CSDN博客

img turkeyzhou

jBPM-jPDL学习笔记——流程设计与控制

发表于2008/10/2 13:22:00  932人阅读

jBPM-jPDL学习笔记——流程设计与控制

背景
本片文章,我们将从业务流程的设计开始,通过带领大家完成一个完整工作流的程序设计,来学习jPDL的使用。

业务流程设计
这里我们实现一个相对简化的公司借款申请流程。流程图如下:


在jPDL中,与流程设计相关的文件有三个:processdefinition.xml、gdp.xml、processimage.jpg。 其中processdefinition.xml是流程定义的描述文件;gpd.xml是对图形界面呈现的XML描述;而 processimage.jpg则是对图形界面的快照。下面我们将展示本样例的流程定义文件。

流程定义描述

processdefinition.xml文件

引用

<?xml version="1.0" encoding="UTF-8"?>

<process-definition   xmlns ="urn:jbpm.org:jpdl-3.2"  name="simple">
   <start-state name="开始">
      <transition name="借款发起" to="填写借款申请">
<action name="Action_StartProcess" class="com.firstflow.action.StartProcessActionHander"></action>
</transition>
   </start-state>
   <task-node name="填写借款申请">
<task name="Task_AssignToInitiator">
<assignment class="com.firstflow.task.NewApplicationAssignmentHandler"></assignment>
</task>
<transition to="部门经理审批" name="提交申请">
<action name="Action_SubmitApply" class="com.firstflow.action.SubmitApplyActionHandler"></action>
</transition>
</task-node>

<task-node name="部门经理审批">
<task name="Task_ManagerApprove">
<assignment class="com.firstflow.task.DepartmentManagerApproveAssignmentHandler"></assignment>
</task>
<transition to="金额判定" name="部门经理审批通过">
<action name="Task_ManagerApproved" class="com.firstflow.action.ManagerApprovedActionHandler"></action>
</transition>
<transition to="结束" name="部门经理驳回">
<action name="Action_ManagerDisapprove" class="com.firstflow.action.ManagerDisapproveActionHandler"></action>
</transition>
</task-node>

<node name="财务拨款">
<action name="Action_AccountantProcess" class="com.firstflow.action.AccountantProcessActoinHandler"></action>
<transition to="结束" name="邮件通知">
<action name="Action_Mail" class="com.firstflow.action.SendMailActionHandler"></action>
</transition>
</node>

<decision name="金额判定">
<handler class="com.firstflow.decision.MoneyCheckDecisionHandler"></handler>
<transition to="总经理审批" name=">5000元总经理审批"></transition>
<transition to="财务拨款" name="<5000元 财务拨款"></transition>
</decision>

<task-node name="总经理审批">
<task name="Task_PresidentApprove">
<assignment class="com.firstflow.task.PresidentApproveAssignmentHandler"></assignment>
</task>
<transition to="财务拨款" name="总经理审批通过">
<action name="Action_PresidentApproved" class="com.firstflow.action.PresidentApprovedActionHandler"></action>
</transition>
<transition to="结束" name="总经理驳回">
<action name="Action_PresidentDisapproved" class="com.firstflow.action.PresidentDisapprovedActionHandler"></action>
</transition>
</task-node>
   <end-state name="结束"></end-state>
</process-definition>


在样例流程中,除了开始和结束结点外,我们定义了三种类型的结点:

任务结点<task-node>
任务结点是一个需要人工参与的结点类型。当流程进入结点时,会生成相应的任务实例(TaskInstatnce),并通过委派接口 AssignmentHandler或jBPM表达式将任务委派给一个或多个特定的角色或参与者。结点自身进入等待状态,直到任务被参与者完成或者跳过, 流程继续。

判定结点<decision>
判定结点的设计目标是根据上下文环境和程序逻辑,判定流程转向。通过指定一个实现DecisionHandlder接口的Java委派类或jBPM表达式,来返回转向(transition)的字符窜类型的名称(可以是中文哦),来达到决定流程方向的功能。

普通结点<node>
普通结点也可以定义相应的处理任务,通过定义相应的ActioinHandler类。同任务结点不同的是,普通结点定义的任务是由流程自动执行的,无须人工干预。

三种结点都可定义结点事件(event):
node-enter,该事件在流程进入结点时触发
node-leave,该事件在流程离开节点是触发
可以在事件上挂接ActioinHandler接口的实现类来完成一些特定的功能。

三种节点都可以定义异步处理方式(async属性):
异步处理意味着每个结点的事务处理是通过消息机制分离的,不再同一线程中统一调用执行。而是由消息监听线程从消息队列中取得消息体来运行相应得程序。
此外我们定义了结点间的转向(transition),用来记录和处理状态的变迁。每个转向中,可以委派一个或多个的ActioinHandler接口实现类,负责处理节点变迁时的上下文状态变更及回调用户定义的处理程序。

流程的程序接口说明

动作处理接口(ActioinHandler)
接口方法:void execute( ExecutionContext executionContext ) throws Exception
该接口是jPDL中最常用的一个回调接口。从它的接口方法可以发现,它仅仅暴露了流程执行上下文变量ExecutionContext。用户程序 通过ExecutionContext来了解流程的执行状态,并通过改变ExecutionContext中的属性值来影响流程的执行。
ActioinHandler接口可以在所有能包含事件(event)、动作(action)元素的地方被回调。

判定处理接口(DecisionHandlder)
接口方法:String decide(ExecutionContext executionContext) throws Exception
判定接口仅适用于判定节点(decision)中。从它的接口方法可以看出,方法要返回一个字符串型的结果,这个结果必须和判定节点拥有的转向(transition)集合中的一条转向名称相匹配。
在DecisionHandlder的接口方法中一样能访问到ExecutionContext变量,这为判定提供了执行上下文的根据。当然,如果有必要,用户也可以在该接口中改变ExecutionContext中的变量值。

委派处理接口(AssignmentHandler)
接口方法:void assign(Assignable assignable, ExecutionContext executionContext) throws Exception;
委派处理接口被用户任务元素(task)的委派(assignment)子元素中,它的职责很明确,就是将任务分配给指定的人员或角色。
在AssignmentHandler接口的方法中,Assignable变量通常指任务实例(TaskInstance)。通过将 ExecutionContext和TaskInstance两个变量都暴露给接口方法,用户就可以根据流程上下文情况,来决定要将指定的任务分配个谁。

流程的部署

用户使用jPDL的流程设计器定义业务流程,当然,你也可以直接用文档编辑器直接编辑processdefinition.xml定义文件。定义文档是可 以直接被ProcessDefinition类载入使用的,但在正式运行的系统中,流程定义信息更多是使用关系型数据库来存储。从流程定义文件将数据导入 流程数据库的过程,我们称之为流程部署。
jPDL的流程部署文件包含processdefinition.xml的定义部分和Java处理器的代码部分,这些文件可以被一起打包成.jpdl的zip格式包而后上传服务器端。这个过程可以在流程设计器界面的“deployment”标签页中操作:

这里我们着重要讲述的是接受部署文件上载的服务器端配置。在jBPM3.2的包中带着一个jPDL的管理控制台web应用,默认名字为jbpm- console。该应用带有接受流程定义包部署的程序,但不是最小化的。实际上完成流程部署功能的,只是jbpm-jpdl.jar核心包中的一个 servlet类:org.jbpm.web.ProcessUploadServlet . 完成这个Servlet的成功部署,需要以下工作:

1. 配置web.xml,将servlet配置成启动时加载,如下:
引用

<web-app>
<servlet>
  <servlet-name>GDP Deployer Servlet</servlet-name>
  <servlet-class>org.jbpm.web.ProcessUploadServlet</servlet-class>
  <load-on-startup>1</load-on-startup>
  </servlet>
 
<servlet-mapping>
  <servlet-name>GDP Deployer Servlet</servlet-name>
  <url-pattern>/upload/*</url-pattern>
  </servlet-mapping>
 
</web-app>


2. 建立流程定义存储数据库表:
Demo中,我们使用的数据库是MySQL的,在E:/Java/tools/jbpm-jpdl-3.2.2/db/目录下有个 jbpm.jpdl.mysql.sql数据库脚本文件。但我们不能直接导入该文件, 会提示有错误, 应为该文件的SQL语句末尾少了分号,在批量执行时,MySQL报错。需要在每一行SQL的末尾添加一个分号,这样就可以用source命令导入了。

3. 配置Hibernate.cfg.xml
由于jBPM的数据库持久化是依靠Hibernate进行的,因此需要配置Hibernate.cfg.xml使其适应我们的MySQL环境
引用

<!-- hibernate dialect -->
    <property name="hibernate.dialect">org.hibernate.dialect.MySQLInnoDBDialect</property>
    <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
    <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/linly</property>
    <property name="hibernate.connection.username">linly</property>
    <property name="hibernate.connection.password">coffee</property>
    <property name="hibernate.cache.provider_class">org.hibernate.cache.HashtableCacheProvider</property>


4. Import需要的jar包
这里的jar包包括三部分:jbpm的核心包;Hibernate及其支撑包;MySQL的JDBC驱动包。


到此,我们的配置工作完成,这是实现jBPM流程部署服务端的最小化应用配置。

流程控制及API使用

样例程序中的Handler接口实现

下面,根据上述的接口分类,列出样例程序中的类名及相应的功能说明,具体可参考源代码。
动作处理接口(ActioinHandler)

这里要提到一个很重要的区别,就是作用于Node上的ActoinHandler和作用于Transition上的ActoinHandler是 有不同的。区别在于,Node上的ActoinHandler在结束业务逻辑处理后,必须调用 executionContext.leaveNode();或executionContext.leaveNode(transition)来保证流 程向下执行;而作用于Transition上的则不需要。

判定处理接口(DecisionHandlder)


委派处理接口(AssignmentHandler)


流程测试剖析

本章节,我们将给大家剖析两个流程测试类。一个是简单的基于内存模型的流程测试FirstFlowProcessTest;一个是更贴近实用的,基于MySQL数据库操作的标准测试案例。通过对这两个测试例程的分析,来直观的学习如何通过Java API操作jPDL。

简单流程测试案例
测试案例类:FirstFlowProcessTest.java
Java代码 复制代码
  1. public class FirstFlowProcessTest extends TestCase {  
  2.     ProcessDefinition pdf ;  
  3.     ProcessInstance pi;         
  4.   
  5.     public void test4000YuanApplication() throws Exception {  
  6.         deployProcessDefinition();  
  7.         createProcessInstance("linly");  
  8.         submitApplication(4000);  
  9.         approveByManager(true);  
  10.         checkTasks();  
  11.     }  
  12.   
  13.     public void test6000YuanApplication() throws Exception {  
  14.         deployProcessDefinition();  
  15.         createProcessInstance("linly");  
  16.         submitApplication(6000);  
  17.         approveByManager(true);  
  18.         approveByPresident(true);  
  19.         checkTasks();  
  20.     }  
  21.       
  22.     public void test7000YuanApplication() throws Exception {  
  23.         deployProcessDefinition();  
  24.         createProcessInstance("linly");  
  25.         submitApplication(7000);  
  26.         approveByManager(true);  
  27.         approveByPresident(false);  
  28.         checkTasks();  
  29.     }  
  30.       
  31.     /** 
  32.      * 部署流程定义 
  33.      * @throws Exception 
  34.      */  
  35.     protected void deployProcessDefinition() throws Exception{  
  36.         System.out.println("==FirstFlowProcessTest.deployProcessDefinition()==");  
  37.         pdf = ProcessDefinition.parseXmlResource("firstflow/processdefinition.xml");  
  38.         assertNotNull("Definition should not be null", pdf);          
  39.     }      
  40.     /** 
  41.      * 生成流程实例  
  42.      */  
  43.     protected void createProcessInstance(String user){  
  44.         System.out.println("==FirstFlowProcessTest.createProcessInstance()==");  
  45.     assertNotNull("Definition should not be null", pdf);  
  46.         //生成实例  
  47.         pi = pdf.createProcessInstance();  
  48.         assertNotNull("processInstance should not be null", pi);  
  49.         //设置流程发起人  
  50.         pi.getContextInstance().createVariable("initiator", user);  
  51.         //触发流程转向  
  52.         pi.signal();  
  53.     }      
  54.     /** 
  55.      * 填写提交申请单 
  56.      * @param money 
  57.      */  
  58.     protected void submitApplication(int money){          
  59.         System.out.println("==FirstFlowProcessTest.submitApplication()==");          
  60.         TaskInstance ti = (TaskInstance)pi.getTaskMgmtInstance().getTaskInstances().iterator() .next() ;          
  61.         System.out.println("ti.actor = " + ti.getActorId());          
  62.         ContextInstance ci = ti.getContextInstance();  
  63.         ci.setVariable("money",new Integer(money));  
  64.         ti.end();         
  65.     }      
  66.     /** 
  67.      * 部门经理审批 
  68.      * @param pass 
  69.      */      
  70.     @SuppressWarnings("unchecked")  
  71.     protected void approveByManager(boolean pass){        
  72.         System.out.println("==FirstFlowProcessTest.approveByManager()==");          
  73.         Iterator<TaskInstance> it = pi.getTaskMgmtInstance().getTaskInstances().iterator();          
  74.         for( ;it.hasNext(); ){            
  75.             TaskInstance ti = it.next();              
  76.             if(ti.getActorId().equals("DepartmentManager")){  
  77.                 List<Transition> transitions = ti.getToken().getNode().getLeavingTransitions();  
  78.                 for(Transition t : transitions){  
  79.                     System.out.println("----Transition" + t.getName());  
  80.                 }  
  81.                 assertEquals("DepartmentManager",ti.getActorId());  
  82.                 if(pass){  
  83.                      ti.end("部门经理审批通过");          
  84.                 }else{  
  85.                     ti.end("部门经理驳回");  
  86.                 }  
  87.                 return;  
  88.             }  
  89.         }          
  90.     }  
  91.       
  92.     /** 
  93.      * 总经理审批 
  94.      * @param pass 
  95.      */  
  96.     @SuppressWarnings("unchecked")  
  97.     protected void approveByPresident(boolean pass){  
  98.            System.out.println("==FirstFlowProcessTest.approveByPresident()==");  
  99.              
  100.            Iterator<TaskInstance> it = pi.getTaskMgmtInstance().getTaskInstances().iterator();  
  101.              
  102.            for( ;it.hasNext(); ){  
  103.               
  104.                 TaskInstance ti = it.next();  
  105.                   
  106.                 if(ti.getActorId().equals("President")){  
  107.                     List<Transition> transitions = ti.getToken().getNode().getLeavingTransitions();  
  108.                     for(Transition t : transitions){  
  109.                         System.out.println("----Transition" + t.getName());  
  110.                     }  
  111.                     assertEquals("President",ti.getActorId());  
  112.                     if(pass){  
  113.                          ti.end("总经理审批通过");       
  114.                     }else{  
  115.                         ti.end("总经理驳回");  
  116.                     }  
  117.                     return;  
  118.                 }  
  119.            }  
  120.     }      
  121.     /** 
  122.      * 打印任务记录 
  123.      */  
  124.     @SuppressWarnings("unchecked")  
  125.     protected void checkTasks(){         
  126.         System.out.println("==FirstFlowProcessTest.checkTasks()==");  
  127.         Collection<TaskInstance> coll = pi.getTaskMgmtInstance().getTaskInstances();  
  128.         System.out.println("====Process has task:====");  
  129.         for(TaskInstance ti : coll){  
  130.                System.out.println("=="+ti.getName()+"==");  
  131.                System.out.println("=="+ti.getActorId()+"==");  
  132.                System.out.println("=="+ti.getVariables().toString() +"==");  
  133.         }  
  134.         System.out.println("====end====");     
  135.     }       


该案例是在没有数据库支持的情况下,对报销流程进行运行测试,测试逻辑如下:

1. 加载流程定义
Java代码 复制代码
  1. ProcessDefinition.parseXmlResource("firstflow/processdefinition.xml")  
代码说明:
在没有数据库存储的情况下,流程定义通过ProcessDefinition类直接从processdefinition.xml文件中解析加载。

2. 实例化流程对象
Java代码 复制代码
  1. //生成实例  
  2.  pi = pdf.createProcessInstance();  
  3. assertNotNull("processInstance should not be null", pi);  
  4. //设置流程发起人  
  5.  pi.getContextInstance().createVariable("initiator", user);  
  6. //触发流程转向  
  7.  pi.signal();  
代码说明:
在获得流程定义的实例后,可以用它生成流程实例,使用如下的语句:
pi = pdf.createProcessInstance();
流程实例拥有自己的ContextInstance环境变量对象。它实际上是一个HashMap,以key-value方式记录了流程的上下文变量值,代码中的
pi.getContextInstance().createVariable("initiator", user);就是向环境变量中添加一个key为initiator的对象。
每个流程实例都拥有自己Token令牌对象,主流程有自己的RootToken,子流程也拥有自己的子Token。父流程的Token和子流程的Token相互关联,形成Token树。
Token对象表示流程运行的当前位置(运行到哪个节点了)。通过对Token对象的signal()方法调用,可以使流程向下运行。代码中的 pi.signal();实际上是间接调用了pi.getRootToken().signal();它使得新建的流程继续向下个节点(即借款申请单填 写)进发。

3. 员工发起借款申请
Java代码 复制代码
  1. /** 
  2.  * 填写提交申请单 
  3.  * @param money 
  4.  */  
  5. protected void submitApplication(int money){  
  6.          System.out.println("==FirstFlowProcessTest.submitApplication()==");  
  7.       
  8.     TaskInstance ti = (TaskInstance)pi.getTaskMgmtInstance().getTaskInstances().iterator() .next()           
  9.     System.out.println("ti.actor = " + ti.getActorId());  
  10.     ContextInstance ci = ti.getContextInstance();  
  11.     ci.setVariable("money",new Integer(money));  
  12.     ti.end();  
代码说明:
在借款流程发起后,流程进入了申请单填写阶段。这个阶段是个人工的任务,需要用户的介入。因此,对于要借款的用户而言,首先是获取填写申请单的任务实例:
     TaskInstance ti = (TaskInstance)pi.getTaskMgmtInstance().getTaskInstances().iterator() .next()        
在这个测试类中,由于没有数据库。对流程实例的引用是依靠了类的全局标量pi。这里通过pi获取全部的任务列表。实际上有且仅有一个任务,就是我们刚刚发起的申请单填写任务。
接下来,我们获取流程的上下文变量,将申请借款的数额记录在上下文变量中ContextInstance ci = ti.getContextInstance();
    ci.setVariable("money",new Integer(money));
最后,我们要结束当前任务,告诉流程继续下行,调用ti.end();这个方法的本质依然是调用了token.signal(),它选择了一个默 认的transition进行转向。这里要说明的是signal方法有多态的实现signal(Transition  transition),是可以指定具体转向参数的。

4. 部门领导审批申请
Java代码 复制代码
  1.      /** 
  2.      * 部门经理审批 
  3.      * @param pass 
  4.      */      
  5.     @SuppressWarnings("unchecked")  
  6.     protected void approveByManager(boolean pass){        
  7.         System.out.println("==FirstFlowProcessTest.approveByManager()==");          
  8.         Iterator<TaskInstance> it = pi.getTaskMgmtInstance().getTaskInstances().iterator();          
  9.         for( ;it.hasNext(); ){            
  10.             TaskInstance ti = it.next();              
  11.             if(ti.getActorId().equals("DepartmentManager")){  
  12.                 List<Transition> transitions = ti.getToken().getNode().getLeavingTransitions();  
  13.                 for(Transition t : transitions){  
  14.                     System.out.println("----Transition" + t.getName());  
  15.                 }  
  16.                 assertEquals("DepartmentManager",ti.getActorId());  
  17.                 if(pass){  
  18.                      ti.end("部门经理审批通过");          
  19.                 }else{  
  20.                     ti.end("部门经理驳回");  
  21.                 }  
  22.                 return;  
  23.             }  
  24.         }   
  25. }  
代码说明:
这里,流程进入了部门经理审批阶段。由于没有数据库支持,我们只能采取遍历任务列表,并比对委派者ID的方式来确定委派给部门经理的任务实例。(在后面的基于数据库的标准案例中,我们会看到如果根据用户的ID来获取分配给指定用户的任务)
ti.getActorId().equals("DepartmentManager") // 比对任务的委派人。
ti.getToken().getNode().getLeavingTransitions();//获取任务在当前节点上的所有转向。
这里我们要特别指出的是ti.end("部门经理审批通过")和ti.end("部门经理驳回")这实际上调用token.signal(transition);来完成任务的转向,从而使流程继续。

5. 总经理审批申请
Java代码 复制代码
  1.      /** 
  2.      * 总经理审批 
  3.      * @param pass 
  4.      */  
  5.     @SuppressWarnings("unchecked")  
  6.     protected void approveByPresident(boolean pass){  
  7.            System.out.println("==FirstFlowProcessTest.approveByPresident()==");   
  8.            Iterator<TaskInstance> it = pi.getTaskMgmtInstance().getTaskInstances().iterator();  
  9.              
  10.            for( ;it.hasNext(); ){                 
  11.                 TaskInstance ti = it.next();                  
  12.                 if(ti.getActorId().equals("President")){  
  13.                     List<Transition> transitions = ti.getToken().getNode().getLeavingTransitions();  
  14.                     for(Transition t : transitions){  
  15.                         System.out.println("----Transition" + t.getName());  
  16.                     }  
  17.                     assertEquals("President",ti.getActorId());  
  18.                     if(pass){  
  19.                          ti.end("总经理审批通过");       
  20.                     }else{  
  21.                         ti.end("总经理驳回");  
  22.                     }  
  23.                     return;  
  24.                 }  
  25.            }  
  26. }  
代码说明:
此步代码同“部门经理审批”代码相似,不作更多说明。

标准流程测试案例

该案例模拟了标准运行环境中,基于关系型数据库的jBPM系统是如何执行流程的。
测试案例类:FirstFlowProcessDBTest.java
Java代码 复制代码
  1. public class FirstFlowProcessDBTest {     
  2.     /* 
  3.      * 初始化jBPM配置 
  4.      * 包含对Hibernate的数据库初始化 
  5.      */  
  6.     static JbpmConfiguration jbpmConfiguration = JbpmConfiguration.getInstance();      
  7.     public static void main(String[] args){  
  8.         FirstFlowProcessDBTest test = new FirstFlowProcessDBTest();  
  9.         test.test4000YuanApplication();  
  10.         test.test6000YuanApplication();  
  11.         test.test7000YuanApplication();  
  12.     }  
  13.       
  14.     public void test4000YuanApplication(){  
  15.         ProcessInstance pi = createProcessInstance("linly");  
  16.         submitApplication("linly" , 4000);  
  17.         approveByManager(true);  
  18.         checkTasks(pi);  
  19.     }  
  20.     public void test6000YuanApplication() {  
  21.         ProcessInstance pi = createProcessInstance("linly");  
  22.         submitApplication("linly" , 6000);  
  23.         approveByManager(true);  
  24.         approveByPresident(true);  
  25.         checkTasks(pi);  
  26.     }     
  27.     public void test7000YuanApplication() {  
  28.         ProcessInstance pi = createProcessInstance("linly");  
  29.         submitApplication("linly" , 7000);  
  30.         approveByManager(true);  
  31.         approveByPresident(false);  
  32.         checkTasks(pi);  
  33.     }   
  34.     /** 
  35.      * 生成流程实例  
  36.      */  
  37.     protected ProcessInstance createProcessInstance(String user){  
  38.         System.out.println("==FirstFlowProcessTest.createProcessInstance()==");  
  39.         JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();  
  40.         try {  
  41.              GraphSession graphSession = jbpmContext.getGraphSession();  
  42.              /* 
  43.               * 从数据库获取指定的流程定义 
  44.               */  
  45.              ProcessDefinition pdf  = graphSession.findLatestProcessDefinition("simple");  
  46.              //生成流程实例  
  47.              ProcessInstance pi = pdf.createProcessInstance();  
  48.              //设置流程发起人  
  49.              pi.getContextInstance().createVariable("initiator", user);  
  50.              //触发流程转向  
  51.              pi.signal();  
  52.              /* 
  53.               * 保存流程实例  
  54.               */  
  55.              jbpmContext.save(pi);             
  56.              return pi;  
  57.         }finally{  
  58.             jbpmContext.close();  
  59.         }  
  60.     }  
  61.       
  62.     /** 
  63.      * 填写提交申请单 
  64.      * @param money 
  65.      */  
  66.     @SuppressWarnings("unchecked")  
  67.     protected void submitApplication(String actorId , int money){  
  68.         System.out.println("==FirstFlowProcessTest.submitApplication()==");   
  69.         JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();  
  70.         try {     
  71.             /* 
  72.              *根据操作者ID,获取属于该操作者的任务集 
  73.              */  
  74.             List<TaskInstance> taskInstances = jbpmContext.getTaskList(actorId);            
  75.             for(TaskInstance ti : taskInstances){  
  76.                 System.out.println("ti.name = " + ti.getName());  
  77.                 System.out.println("ti.actor = " + ti.getActorId());  
  78.                 ContextInstance ci = ti.getContextInstance();  
  79.                 ci.setVariable("money",new Integer(money));  
  80.                 ti.end();  
  81.             }             
  82.         }finally{  
  83.             jbpmContext.close();      
  84.         }  
  85.     }  
  86.       
  87.     /** 
  88.      * 部门经理审批 
  89.      * @param pass 
  90.      */  
  91.     @SuppressWarnings("unchecked")  
  92.     protected void approveByManager(boolean pass){        
  93.         System.out.println("==FirstFlowProcessTest.approveByManager()==");  
  94.         JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();  
  95.         try{  
  96.             List<TaskInstance> taskInstances = jbpmContext.getTaskList("DepartmentManager");  
  97.             for(TaskInstance ti : taskInstances){             
  98.                 System.out.println("ti.name = " + ti.getName());  
  99.                 System.out.println("ti.actor = " + ti.getActorId());  
  100.                  if(pass){  
  101.                      ti.end("部门经理审批通过");          
  102.                 }else{  
  103.                     ti.end("部门经理驳回");  
  104.                 }             
  105.             }  
  106.         }finally{  
  107.             jbpmContext.close();  
  108.         }  
  109.     }  
  110.       
  111.     /** 
  112.      * 总经理审批 
  113.      * @param pass 
  114.      */  
  115.     @SuppressWarnings("unchecked")  
  116.     protected void approveByPresident(boolean pass){  
  117.         System.out.println("==FirstFlowProcessTest.approveByPresident()==");          
  118.         JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();  
  119.         try{  
  120.             List<TaskInstance> taskInstances = jbpmContext.getTaskList("President");  
  121.             for(TaskInstance ti : taskInstances){  
  122.                 System.out.println("ti.name = " + ti.getName());  
  123.                 System.out.println("ti.actor = " + ti.getActorId());  
  124.                  if(pass){  
  125.                      ti.end("总经理审批通过");       
  126.                 }else{  
  127.                     ti.end("总经理驳回");  
  128.                 }  
  129.             }  
  130.         }finally{  
  131.             jbpmContext.close();  
  132.         }  
  133.     }  
  134.       
  135.     /** 
  136.      * 打印任务记录 
  137.      */  
  138.     @SuppressWarnings("unchecked")  
  139.     protected void checkTasks(ProcessInstance pi){         
  140.         System.out.println("==FirstFlowProcessTest.checkTasks()==");  
  141.         JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();  
  142.         try{                      
  143.             List<TaskInstance> coll = jbpmContext.getTaskMgmtSession().findTaskInstancesByProcessInstance(pi);      
  144.             System.out.println("====Process has task:====");      
  145.             for(TaskInstance ti : coll){      
  146.                    System.out.println("=="+ti.getName()+"==");    
  147.                    System.out.println("=="+ti.getActorId()+"==");     
  148.                    System.out.println("=="+ti.getVariables().toString() +"==");   
  149.             }     
  150.             System.out.println("====end====");  
  151.         }finally{  
  152.             jbpmContext.close();  
  153.         }  
  154.     }      
  155. }  

相对于简单流程测试案例,标准流程的业务是相同的。它们的不同点在于:简单流程通过XML载入流程定义,并使用类的全局变量来保存流程实例的引用;而标准流程则是通过数据库载入流程定义,并使用数据库的会话来维护流程的运行。

1. 从数据库载入流程定义
Java代码 复制代码
  1.    JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();  
从jBPM配置环境中获取jBPM上下文实例,jbpmContext是对jbpm持久层操作API及上下文环境的封装,它根据jBPM的配置文件生成。   
Java代码 复制代码
  1. GraphSession graphSession = jbpmContext.getGraphSession();  
生成对流程图操作的持久层会话
Java代码 复制代码
  1. ProcessDefinition pdf  = graphSession.findLatestProcessDefinition("simple");  
从数据库获取命名为“simple”的流程定义。

2. 新建流程实例,并存入数据库持久化
Java代码 复制代码
  1. ProcessInstance pi = pdf.createProcessInstance();  
根据流程定义生成实例。
Java代码 复制代码
  1. pi.getContextInstance().createVariable("initiator", user);  
  2. pi.signal();  

设置实例的上下文变量,激活实例执行进程。
Java代码 复制代码
  1. jbpmContext.save(pi);  

保存实例到数据库,持久化实例。

3. 从数据库获取属于指定操作者的任务集
Java代码 复制代码
  1. JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();  
  2. try{  
  3.         List<TaskInstance> taskInstances = jbpmContext.getTaskList("DepartmentManager");  
  4.         for(TaskInstance ti : taskInstances){  
  5.         System.out.println("ti.name = " + ti.getName());  
  6.         System.out.println("ti.actor = " + ti.getActorId());  
  7.         if(pass){  
  8.                  ti.end("部门经理审批通过");          
  9.          }else{  
  10.                 ti.end("部门经理驳回");  
  11.          }  
  12.     }     
  13. }finally{  
  14.     jbpmContext.close();  
  15. }  
通过JbpmContext对象,从数据库获取指定操作者的任务集合:
Java代码 复制代码
  1. List<TaskInstance> taskInstances = jbpmContext.getTaskList("DepartmentManager");  

注意,在每次的JbpmContext对象使用完毕后,一定要执行jbpmContext.close(),其本质是要释放数据库的操作连接。
0 0

相关博文

我的热门文章

img
取 消
img