`

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

    博客分类：
  • Jbpm
JBPMHibernate 
阅读更多

代码说明：
在借款流程发起后，流程进入了申请单填写阶段。这个阶段是个人工的任务，需要用户的介入。因此，对于要借款的用户而言，首先是获取填写申请单的任务实例：
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. }  
     /**
     * 总经理审批
     * @param pass
     */
    @SuppressWarnings("unchecked")
    protected void approveByPresident(boolean pass){
    	   System.out.println("==FirstFlowProcessTest.approveByPresident()=="); 
           Iterator<TaskInstance> it = pi.getTaskMgmtInstance().getTaskInstances().iterator();
           
           for( ;it.hasNext(); ){           	
	           	TaskInstance ti = it.next();	           	
	           	if(ti.getActorId().equals("President")){
	                List<Transition> transitions = ti.getToken().getNode().getLeavingTransitions();
	                for(Transition t : transitions){
	                	System.out.println("----Transition" + t.getName());
	                }
	                assertEquals("President",ti.getActorId());
	                if(pass){
	                	 ti.end("总经理审批通过");    	
	                }else{
	                	ti.end("总经理驳回");
	                }
	                return;
	           	}
           }
}

代码说明：
此步代码同“部门经理审批”代码相似，不作更多说明。

标准流程测试案例

该案例模拟了标准运行环境中，基于关系型数据库的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. }  
public class FirstFlowProcessDBTest {	
	/*
	 * 初始化jBPM配置
	 * 包含对Hibernate的数据库初始化
	 */
    static JbpmConfiguration jbpmConfiguration = JbpmConfiguration.getInstance();    
    public static void main(String[] args){
    	FirstFlowProcessDBTest test = new FirstFlowProcessDBTest();
    	test.test4000YuanApplication();
    	test.test6000YuanApplication();
    	test.test7000YuanApplication();
    }
    
	public void test4000YuanApplication(){
		ProcessInstance pi = createProcessInstance("linly");
		submitApplication("linly" , 4000);
		approveByManager(true);
		checkTasks(pi);
	}
	public void test6000YuanApplication() {
		ProcessInstance pi = createProcessInstance("linly");
		submitApplication("linly" , 6000);
		approveByManager(true);
		approveByPresident(true);
		checkTasks(pi);
	}	
	public void test7000YuanApplication() {
		ProcessInstance pi = createProcessInstance("linly");
		submitApplication("linly" , 7000);
		approveByManager(true);
		approveByPresident(false);
		checkTasks(pi);
	} 
    /**
     * 生成流程实例 
     */
    protected ProcessInstance createProcessInstance(String user){
        System.out.println("==FirstFlowProcessTest.createProcessInstance()==");
        JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();
        try {
        	 GraphSession graphSession = jbpmContext.getGraphSession();
             /*
              * 从数据库获取指定的流程定义
              */
        	 ProcessDefinition pdf  = graphSession.findLatestProcessDefinition("simple");
        	 //生成流程实例
        	 ProcessInstance pi = pdf.createProcessInstance();
        	 //设置流程发起人
        	 pi.getContextInstance().createVariable("initiator", user);
        	 //触发流程转向
        	 pi.signal();
        	 /*
        	  * 保存流程实例 
        	  */
        	 jbpmContext.save(pi);        	 
        	 return pi;
        }finally{
        	jbpmContext.close();
        }
    }
    
    /**
     * 填写提交申请单
     * @param money
     */
    @SuppressWarnings("unchecked")
    protected void submitApplication(String actorId , int money){
        System.out.println("==FirstFlowProcessTest.submitApplication()=="); 
    	JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();
	    try {  	
            /*
             *根据操作者ID，获取属于该操作者的任务集
             */
	        List<TaskInstance> taskInstances = jbpmContext.getTaskList(actorId);	        
	        for(TaskInstance ti : taskInstances){
		        System.out.println("ti.name = " + ti.getName());
		        System.out.println("ti.actor = " + ti.getActorId());
		        ContextInstance ci = ti.getContextInstance();
		        ci.setVariable("money",new Integer(money));
		        ti.end();
	        }	        
	    }finally{
	    	jbpmContext.close();	
	    }
    }
    
    /**
     * 部门经理审批
     * @param pass
     */
    @SuppressWarnings("unchecked")
    protected void approveByManager(boolean pass){    	
        System.out.println("==FirstFlowProcessTest.approveByManager()==");
    	JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();
    	try{
    		List<TaskInstance> taskInstances = jbpmContext.getTaskList("DepartmentManager");
    		for(TaskInstance ti : taskInstances){    		
				System.out.println("ti.name = " + ti.getName());
				System.out.println("ti.actor = " + ti.getActorId());
			     if(pass){
                	 ti.end("部门经理审批通过");    	
                }else{
                	ti.end("部门经理驳回");
                } 			
    		}
    	}finally{
    		jbpmContext.close();
    	}
    }
    
    /**
     * 总经理审批
     * @param pass
     */
    @SuppressWarnings("unchecked")
    protected void approveByPresident(boolean pass){
    	System.out.println("==FirstFlowProcessTest.approveByPresident()==");    	
    	JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();
    	try{
    		List<TaskInstance> taskInstances = jbpmContext.getTaskList("President");
    		for(TaskInstance ti : taskInstances){
    			System.out.println("ti.name = " + ti.getName());
				System.out.println("ti.actor = " + ti.getActorId());
			     if(pass){
                	 ti.end("总经理审批通过");    	
                }else{
                	ti.end("总经理驳回");
                }
			}
    	}finally{
    		jbpmContext.close();
    	}
    }
    
    /**
     * 打印任务记录
     */
    @SuppressWarnings("unchecked")
	protected void checkTasks(ProcessInstance pi){       
        System.out.println("==FirstFlowProcessTest.checkTasks()==");
        JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();
    	try{    				
	        List<TaskInstance> coll = jbpmContext.getTaskMgmtSession().findTaskInstancesByProcessInstance(pi);	
	        System.out.println("====Process has task:====");	
	        for(TaskInstance ti : coll){	
	               System.out.println("=="+ti.getName()+"==");	
	               System.out.println("=="+ti.getActorId()+"==");	
	               System.out.println("=="+ti.getVariables().toString() +"==");	
	        }	
	        System.out.println("====end====");
    	}finally{
    		jbpmContext.close();
    	}
    }    
}


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

1. 从数据库载入流程定义

Java代码 复制代码

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

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

Java代码 复制代码

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

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

Java代码 复制代码

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

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

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

Java代码 复制代码

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

根据流程定义生成实例。

Java代码 复制代码

 

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


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

Java代码 复制代码

Java代码 复制代码
  1. jbpmContext.save(pi);  
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()，其本质是要释放数据库的操作连接。

分享到：
| Javap
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    jBPM-jPDL学习笔记——流程设计与控制(转载)

    在《jBPM-jPDL学习笔记——流程设计与控制》这篇博文中，作者主要介绍了如何使用jPDL进行流程设计和控制，包括以下几个关键知识点： 1. **jPDL介绍**： jPDL是jBPM的核心组成部分，它定义了流程实例的行为。通过...

    JBPM相关文档大全

    jBPM-jPDL学习笔记——流程设计与控制.doc JBPM4.4之HelloWorld示例.doc jbpm4.4会签实例.doc jbpm4.4安装配置step by step.doc jbpm4自带数据库分析.doc jBPM_4教程PPT.pdf JBPM与SSH架构融合.doc 工作流模型...

    jbpm学习资料,jbpm教程

    通过jBPM-jPDL学习笔记，你可以系统地学习如何使用jPDL设计和实施业务流程，掌握jbpm的核心概念和技术。无论是对于开发人员还是业务分析师，这份资料都将极大地提升你在工作流管理领域的专业技能。

    JPBM实战经验以及相关参考文档

    在安装配置方面，"jBPM-jPDL学习笔记—框架设计简介.doc"和"jBPM-JPDL v3.2环境部署——发布到Tomcat + MySQL.doc"将是你的重要参考资料。这两个文档详细介绍了如何搭建jBPM开发环境，包括下载和安装jBPM工具，配置...

    jbpm实战讲解.pdf

    #### 三、JBPM学习笔记系列 **1.1 Ant构建与数据库环境配置** - 重点介绍了如何使用Ant进行构建和部署，以及如何配置数据库环境，为后续的流程定义和执行打下基础。 **1.2 MyEclipse整合JBPM配置** - 讲述了...

Magicbox
Global site tag (gtag.js) - Google Analytics