JBPM建一个简单的范例

一，开发环境的搭建

1，版本：

l        eclipse-SDK- 3.2.2 -win32＋MyEclipse_5.5.1GA_E3.2.2_Installer

l        jbpm-starters-kit- 3.1.4

2，搭建：

l        eclipse-SDK- 3.2.2 -win32解压到D:/ eclipse

l        MyEclipse_ 5.5.1 GA_E3.2.2_Installer安装到D:/ eclipse

l        把jbpm-starters-kit- 3.1.4 解压到D：/ jbpm-starters-kit-3.1.4下面，并把根目录下面的“jbpm”文件夹改名字为“jbpm.3”

l        在D:/eclipse/links下面新建“jbpm.link”文件，输入“path= D:/ /jbpm-starters-kit- 3.1.4 // jbpm-designer//jbpm-gpd-feature”（导入流程设计图像插件）

l        启动elipse之后，菜单栏上“Window—preferences”发现有“JBoss jBPM”，选择里面的“Runtime Locations”

l        点击“add”；name栏输入“jb pm3.1.4 （也可随意）”，点击“Search”找到并选择“D:/jbpm-starters-kit-3.1.4/ jbpm .3 ”

l        点击“OK”之后，要在“jb pm3.1.4 ”前面的勾打上，  

二、建立jbpm－web工程：

1，菜单栏“File——project”，选择“JBoss jBPM——Process Project”选择“next”，“Project name”栏输入名字，然后“next，Finish”；

2，选择新建工程，右键选择“Myelipse——Add Web Project Capabilities”，新建一个发布目录，如“web”；

3，src/main/config 下面是数据流链接等配置文件

4，src/main/jpdl 下面是流程文件

5，src/main/java 是程序运行需要的文件

 

6，建立一个新的流程：

在 目录src/main/jpdl  上右键，新建选择“other——JBoss jBPM”选择“Process Definition”,输入流程名字即可（注意暂时先记住这个流程名字，后面测试的时候，方便检查）

三、流程的运转

1，往数据库中导入流程配置文件，在src/main/java/action下面新建一个java文件，运行junit即可。（可检查表“jbpm_processdefinition”）如下：

 

3，流程的流转：以“processdefinition.xml”为例

 

Swinlane 加载权限的元素；user（shoul）是内部的方法，shouli是可以看见shouli这个流程节点的人员；

 

流程节点以“start-state”开始，以“end-state”结束；“action”是进入节点的时，程序发生的事件，里面可以有结合业务逻辑代码；“controller”中的“vaiable”是节点的变量，在启动流程的时候，可以把变量赋值，以方便使用；“transition”是从“name”转到下一个节点“to”；

4，java文件：

        

 

5，action文件

 

6，流程处理java

7，package com.sample.bean;

8，  

9，import java.util.ArrayList;

10，            import java.util.Iterator;

11，            import java.util.List;

12，             

13，             

14，            import org.apache.commons.logging.Log;

15，            import org.apache.commons.logging.LogFactory;

16，            import org.hibernate.Session;

17，            import org.hibernate.Transaction;

18，             

19，            import org.jbpm.JbpmContext;

20，            import org.jbpm.context.def.VariableAccess;

21，            import org.jbpm.db.GraphSession;

22，            import org.jbpm.db.TaskMgmtSession;

23，            import org.jbpm.graph.def.ProcessDefinition;

24，            import org.jbpm.graph.exe.ProcessInstance;

25，            import org.jbpm.taskmgmt.def.TaskController;

26，            import org.jbpm.taskmgmt.exe.TaskInstance;

27，             

28，            public class TaskBean {

29，             

30，                     JbpmContext jbpmContext;

31，                     GraphSession graphSession;

32，                     TaskMgmtSession taskMgmtSession;

33，                   List taskFormParameters;

34，                   public TaskBean(){

35，                            this.jbpmContext = JbpmContext.getCurrentJbpmContext();

36，                            this.graphSession = jbpmContext.getGraphSession();

37，                            this.taskMgmtSession = jbpmContext.getTaskMgmtSession();

38，                           

39，                     }

40，             //根据节点id，查询本节点所以的任务

41，                   public  List getTaskList(String actorId){

42，                      List list=null;

43，                      Session session= jbpmContext.getSessionFactory().openSession();

44，                      try{                 

45，                             TaskMgmtSession taskMgmtSession =new TaskMgmtSession(session);

46，                             list=taskMgmtSession.findTaskInstances(actorId);

47，                          Iterator it = list.iterator();

48，                          while(it.hasNext()){

49，                            TaskInstance taskInstance = (TaskInstance)it.next();

50，                            taskInstance.getVariable("name");

51，                            taskInstance.getVariable("content");

52，                            taskInstance.getActorId();

53，                            taskInstance.getVariable("address");

54，                            taskInstance.getTask().getTaskNode().getName();

55，                          }

56，                      }catch(Exception e){

57，                             e.printStackTrace(); 

58，                      }finally{

59，                             session.close();

60，                      }

61，                      return list;

62，                   }

63，                   //创建任务

64，                   public  String createTask(String name,String address,String content){             

65，                          StringBuffer message=new StringBuffer();

66，                          //读取节点信息，注意此处的“ceshi”跟processdefinition.xml中的名字要一样的

67，                       ProcessDefinition processDefinition =graphSession.findLatestProcessDefinition("ceshi");

68，                       ProcessInstance pi =processDefinition.createProcessInstance();    

69，                       Session session = jbpmContext.getSession();

70，                       Transaction tran = session.beginTransaction();

71，                       try{

72，                          TaskInstance taskInstance = pi.getTaskMgmtInstance().createStartTaskInstance();

73，                          message.append(taskInstance.getName());

74，                          TaskController taskController=taskInstance.getTask().getTaskController();

75，                          if(taskController!=null){

76，                                 List list = taskController.getVariableAccesses();

77，                                 Iterator iter = list.iterator();

78，                                 while(iter.hasNext()){

79，                                        Object value=null;

80，                                        VariableAccess variableAccess = (VariableAccess)iter.next();

81，                                         

82，                                        String mappedName = variableAccess.getMappedName();

83，                                        if("name".equalsIgnoreCase(mappedName)){

84，                                               value=name;

85，                                               taskInstance.setVariable(mappedName, value);

86，                                        }else if("address".equalsIgnoreCase(mappedName)){

87，                                               value=address;

88，                                               taskInstance.setVariable(mappedName, value);

89，                                        }else if("content".equalsIgnoreCase(mappedName)){

90，                                               value=content;

91，                                               taskInstance.setVariable(mappedName, value);

92，                                        }

93，                                 }

94，                          }

95，                          //保存节点信息

96，                       jbpmContext.save(taskInstance);

97，                       //结束本节点的信息，同时创建下一个节点的开始

98，                       taskInstance.end();

99，                       message.append("，同时发送给"+taskInstance.getContextInstance().getVariable("actorId"));

100，                   tran.commit();

101，                   }catch(Exception e){

102，                         e.printStackTrace();

103，                         tran.rollback();

104，                   }finally{

105，                         if(session!=null){

106，                                session.close();

107，                         }

108，                   }

109，                   return message.toString();

110，               }

111，              

112，               //更新本节点的变量的信息，并结束本节点的；同时创建下一个节点的初始化的任务，可参考表“jbpm_token”中的“start_,end_”两个字段的信息

113，               public  String updateTask(long id,String name,String address,String content){

114，                      String message=null;

115，                      //数据库链接

116，                      Session session = jbpmContext.getSession();

117，                   Transaction tran = session.beginTransaction();

118，                   try{

119，                        

120，                      TaskInstance taskInstance = taskMgmtSession.loadTaskInstance(id);

121，                      TaskController taskController=taskInstance.getTask().getTaskController();

122，                      if(taskController!=null){

123，                             List list = taskController.getVariableAccesses();

124，                             Iterator iter = list.iterator();

125，                             while(iter.hasNext()){

126，                                    Object value=null;

127，                                    VariableAccess variableAccess = (VariableAccess)iter.next();

128，                                    String mappedName = variableAccess.getMappedName();

129，                                    if("name".equalsIgnoreCase(mappedName)){

130，                                           value=name;

131，                                           taskInstance.setVariable(mappedName, value);

132，                                    }else if("address".equalsIgnoreCase(mappedName)){

133，                                           value=address;

134，                                           taskInstance.setVariable(mappedName, value);

135，                                    }else if("content".equalsIgnoreCase(mappedName)){

136，                                           value=content;

137，                                           taskInstance.setVariable(mappedName, value);

138，                                    }

139，                             }

140，                      }

141，                     

142，                   jbpmContext.save(taskInstance);

143，                   taskInstance.end();

144，                   tran.commit();

145，                   ProcessInstance processInstance = taskInstance.getTaskMgmtInstance().getProcessInstance();

146，                   if(processInstance.hasEnded()){

147，                          message="流程结束!";

148，                   }else{

149，                          message="任务由："+taskInstance.getActorId()+"发给："+taskInstance.getContextInstance().getVariable("actorId");

150，                   }

151，                   }catch(Exception e){

152，                         e.printStackTrace();

153，                       tran.rollback();   

154，                   }finally{

155，                         if(session!=null){

156，                                session.close();

157，                         }

158，                   }

159，                   return message;

160，              

161，               }

162，                private static final Log log = LogFactory.getLog(TaskBean.class);

163，        }