程序博客网 > tekla软件多少钱

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

来源：互联网 发布：tekla软件多少钱 编辑：程序博客网 时间：2024/04/29 10:42
 http://geekwang.javaeye.com/blog/201267

本篇文章，我们将从业务流程的设计开始，通过带领大家完成一个完整工作流的程序设计，来学习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代码 复制代码

 

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代码 复制代码

 

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代码 复制代码

 

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代码 复制代码

Java代码 复制代码
  1.    JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();  

从jBPM配置环境中获取jBPM上下文实例，jbpmContext是对jbpm持久层操作API及上下文环境的封装，它根据jBPM的配置文件生成。

Java代码 复制代码

Java代码 复制代码
  1. GraphSession graphSession = jbpmContext.getGraphSession();  

生成对流程图操作的持久层会话

Java代码 复制代码

Java代码 复制代码
  1. ProcessDefinition pdf  = graphSession.findLatestProcessDefinition("simple");  

从数据库获取命名为“simple”的流程定义。

2. 新建流程实例，并存入数据库持久化

Java代码 复制代码

Java代码 复制代码
  1. ProcessInstance pi = pdf.createProcessInstance();  

根据流程定义生成实例。

Java代码 复制代码

 

Java代码 复制代码
  1. pi.getContextInstance().createVariable("initiator", user);   
  2. pi.signal();  


设置实例的上下文变量，激活实例执行进程。

Java代码 复制代码

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()，其本质是要释放数据库的操作连接。

  • FirstFlow样例代码.rar (85.9 KB)
  • 下载次数: 31
tekla软件多少钱 tekla软件多少钱
原创粉丝点击
热门IT博客
能写日记的软件能写日记的软件
宝宝学字软件宝宝学字软件
软件疲劳强度测试
python scatter 气泡
团购软件
网络宣传部是干什么的
手机晒密软件
域名的dns怎么设置
福建三千万美元知乎
网络层ddos
江苏软件考试网
淘宝网雪纺吊带衫
淘宝神笔好不好
巧克力知乎
男生基本款衬衫 知乎
淘宝网韩都衣舍旗舰店
淘宝号怎么变三心
沙沙网络跑路了
linux snmp配置文件
网络大电影报价单
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 校园的贴花高手林逸 校园的贴身校花高手 校园的贴身高手林逸 我的校花贴身高手林逸 校花的贴身手 我的校花贴身高手 校花的的贴身高手 和校花同居的大盗 校花的 贴身狂少 校花的贴身狂龙 和校花在一起的日子 校花的贴身少狂 贴身校花的 校花的 贴身高手手游 贴身高手txt全集下载 校园之贴身高手 贴身高手 校园贴身保镖 校园贴身高手林逸全集 贴身高手鱼人二代 校园贴身保镖林逸 校园贴花高手全文阅读林逸 xhdtsgs 贴身高手txt 校园贴身高手 校花门 校花门事件 重回我爸校草 重回我爸当校草 校草贷 私董会 各大学校训 郑州校训通 河南校训通手机版 校信通校信通校信通 校信通怎么 校信通公司 校讯通怎么收费 开通校讯通 校讯通注册 校信通作用

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里