jbpm - 工作流的基本操作

刪除流程實例：

Jbpm流程引擎

定義：

jbpm，全稱是Java Business Process Management（業務流程管理），他是覆蓋了業務流程管理，工作流管理，服務協作等領域的一個開源的，靈活的，易擴展的可執行的流程語言框架

作用：

jbpm的流程框架非常靈活，使用起來也非常安全，降低開發的風險，同時jbpm擁有自己的圖形化開發工具，非常方便隨時了解和掌握運行的進程

Jbpm的開發步驟：

1、 引入jbpm 4.4 jar

2、 引入jbpm.cfg.xml、jbpm.hibernate.cfg.xml核心配置文件如圖：

Jbpm.cfg.xml 配置：

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

<jbpm-configuration>

  <import resource="jbpm.default.cfg.xml" />
  <import resource="jbpm.businesscalendar.cfg.xml" />
  <import resource="jbpm.tx.hibernate.cfg.xml" />
  <import resource="jbpm.jpdl.cfg.xml" />
  <import resource="jbpm.bpmn.cfg.xml" />
  <import resource="jbpm.identity.cfg.xml" />

  <!-- Job executor is excluded for running the example test cases. -->
  <!-- To enable timers and messages in production use, this should be included. -->
  <!--
  <import resource="jbpm.jobexecutor.cfg.xml" />
  -->

</jbpm-configuration>

Jbpm.hibernate.cfg.xml 配置：

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

<!DOCTYPE hibernate-configuration PUBLIC
          "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
          "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
  <session-factory>
  
     <property name="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>
     <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
     <property name="hibernate.connection.url">jdbc:mysql:///jbpm</property>
     <property name="hibernate.connection.username">root</property>
     <property name="hibernate.connection.password">123456</property>
     <property name="hibernate.hbm2ddl.auto">update</property>
     <property name="hibernate.format_sql">true</property>
     <property name="hibernate.show_sql">true</property>
     
     <mapping resource="jbpm.repository.hbm.xml" />
     <mapping resource="jbpm.execution.hbm.xml" />
     <mapping resource="jbpm.history.hbm.xml" />
     <mapping resource="jbpm.task.hbm.xml" />
     <mapping resource="jbpm.identity.hbm.xml" />
     
  </session-factory>
</hibernate-configuration>

Log4j.properties 配置：

### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.err
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### direct messages to file mylog.log ###
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=c:/mylog.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### set log levels - for more verbose logging change 'info' to 'debug' ###

log4j.rootLogger=info, stdout

3、 創建表結構 （有18張表）

4、    /**
5、     * 使用jbpm 方式創建表結構  18張表
6、     */
7、    public void createTable()
8、    {
9、           org.jbpm.api.Configuration.getProcessEngine();
         }

流程引擎的使用步驟：

1 、部署流程實例：

1、    public void deploy()
2、        {
3、            //通過Configuration 類構建流程引擎對象
4、            ProcessEngine processEngine = Configuration.getProcessEngine();
5、            
6、            //獲取RepositoryService 接口服務
7、            RepositoryService repositoryService = processEngine.getRepositoryService();
8、            
9、            //發布的方式：零散發布
10、            repositoryService.createDeployment()
11、                .addResourceFromClasspath("jbpm_test.jpdl.xml")
12、                .addResourceFromClasspath("jbpm_test.png")
13、                .deploy();14、        }

其他發布方式：

2、 啟動流程實例： 

public void startProcessInstanceByKey()
    {
        //通過Configuration 類構建流程引擎對象
        ProcessEngine processEngine = Configuration.getProcessEngine();
        
        //獲取ExecutionService 對象
        ExecutionService executionService = processEngine.getExecutionService();
        
        executionService.startProcessInstanceByKey("jbpm_test");  //key 默認為流程文件名稱
    }

3、查詢個人任務 

ProcessEngine processEngine = Configuration.getProcessEngine();
        
        TaskService taskService = processEngine.getTaskService();
        
        List<Task> list =  taskService.findPersonalTasks("員工");
        for(Task t:list)
        {
            System.out.println("任務編號："+t.getId());
            System.out.println("任務名稱："+t.getName());
        } 

4、 辦理個人任務

public void personalComplete()
    {
        ProcessEngine processEngine = Configuration.getProcessEngine();
        
        TaskService taskService = processEngine.getTaskService();
        
        taskService.completeTask("50002");  //任務id
    }

流程變量設置：

public void taskComplete()
    {
        TaskService taskService = Configuration.getProcessEngine().getTaskService();
        Map<String, User> userMap = new HashMap<String, User>();
        User user = new User();
        user.setDay(2);
        user.setName("小明");
        userMap.put("user", user);
        //辦理業務並設置流程變量
        taskService.setVariables("240002", userMap);
        taskService.completeTask("240002");
    }

流程引擎ProcessEngine 的六大服務接口：

流程引擎processEngine 對象的獲取：通過Configuration 類的構建如：

ProcessEngine processEngine = Configuration.getProcessEngine();

1、  RepositoryService 接口（流程資源服務）：

RepositoryService  service= processEngine.getRepositoryService()

作用：提供對流程的部署、刪除、查詢和流程圖的查看操作。

常用方法 如下圖：

部署流程實例：同【1】

查看流程實例：

public void processDefinitionInstanse()
    {
        ProcessEngine processEngine = Configuration.getProcessEngine();
        
        RepositoryService repositoryService = processEngine.getRepositoryService();
        //獲取查看流程實例的query對象
        ProcessDefinitionQuery processDefinitionQuery = repositoryService.createProcessDefinitionQuery();
        List<ProcessDefinition> list = processDefinitionQuery.list();
        for(ProcessDefinition p:list)
        {
            System.out.println("流程對應的id:"+p.getId());
            System.out.println("流程對應的名稱："+p.getName());
            System.out.println("流程對應的key"+p.getKey());
            System.out.println("版本："+p.getVersion());
            System.out.println(p.getDeploymentId());
        }
    }

ProcessDefinitionQuery常用方法：

ProcessDefinition常用方法：

刪除流程實例：

public void deleteProcessDefinfition()
    {
        ProcessEngine processEngine = Configuration.getProcessEngine();
        RepositoryService repositoryService = processEngine.getRepositoryService();
        
        /**
         * 刪除方式一   
         * deleteDeployment(java.lang.String deploymentId) 
         * 只能刪除沒有運行的流程實例。
         */
        repositoryService.deleteDeployment("40001");
        
        /**
         * 刪除方式二
         * deleteDeploymentCascade(java.lang.String deploymentId) 
         * 刪除部署、包含的流程定義、相關流程實例及其歷史信息
         */
        //repositoryService.deleteDeploymentCascade("40001"); //強制刪除
    }

2、 ExecutionService 接口（流程執行服務接口）：

ExecutionService execution = processEngine.getExecutionService()

作用：提供啟動流程服務實例、推動、刪除、等操作。

啟動流程實例：如：【2】

推動流程:

public void signalExecutionById()
    {
        /**
         * 讓流程向后執行一步
         * signalExecutionById(java.lang.String executionId, java.lang.String signalName)  
         * signaName： 下一個節點 transition 的 name
         */
        
        ExecutionService executionService = Configuration.getProcessEngine().getExecutionService();
        executionService.signalExecutionById("60001", "to 部門負責人");
    }

3、 TaskService 接口（人工任務服務）：

TaskService taskService = processEngine.getTaskService()

作用：提供對任務的創建、提交、查詢、刪除等操作。

常用方法 如下圖：

查詢任務（TaskQuery）：

public void personalTaskList()
    {
        ProcessEngine processEngine = Configuration.getProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        
        //獲取任務查詢對象
        TaskQuery taskQuery =  taskService.createTaskQuery();
        //根據操作人查詢任務列表
        List<Task> list = taskQuery.assignee("員工").list();
        
        //查詢所有的任務列表
        //List<Task> list = taskQuery.list();
        for(Task t:list)
        {
            System.out.println("任務編號："+t.getId());
            System.out.println("任務名稱："+t.getName());
        }
    }

TaskQuery常用方法：

辦理任務：

public void completeTask()
    {
        ProcessEngine processEngine = Configuration.getProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        taskService.completeTask("80002");
    }

4、 HistoryService接口（流程歷史服務）：

HistoryService history = processEngine.getHistoryService();

作用：提供對歷史任務的關聯操作、對歷史庫中歷史流程實例、歷史活動實例等、等記錄的查詢操作。

5、 ManagementService 接口：

ManagementService mservice= processEngine.getManagementService()

6、IdentityService 接口：

       IdentityService identitySerivce = processEngine.getIdentityService()

作用：身份認證服務接口。提供對流程用戶、用戶組管理。

流程圖的組成：

1、 活動 Activity /節點 node

2、 流轉Transition /連線（單向箭頭）

3、 事件

流轉（transition）

1、 一般情況下一個活動可以指定一個或多個transition

開始活動（start）中只能有一個transition

結束活動（end）中沒有transition

其他活動可以有一個或多個

2、 如果自有一個transition ，則可以不指定名稱，如果有多個，則要分別指定唯一的名稱

活動（activity）

1、 開始活動

代表流程的開始邊界，一個流程有且自能有一個start活動，開始活動自能自定一個transition。在流程實例啟動后，會自動的使用這個唯一的transition,到下一個活動

2、 End/end-error/end-cancel（結束活動）

帶表流程的結束邊界，可以有多個，也可以沒有，如果有多個，則到達任一個活動，整個流程結束，如果沒有，則到達最后一個transition活動，流程就結束

3、 State狀態活動

作用：等待。可以使用signal 使其結束等待，並向后執行一步

判斷活動（decision）

為其指定一個實現類：DecisionHandler

    private static final long serialVersionUID = 1L;

    @Override
    public String decide(OpenExecution execution) {
        
        System.out.println("decide");
        User user = (User) execution.getVariable("user");
        int day = user.getDay();
        System.out.println("請假天數："+day);
        if(day > 3)
        {
            return "to 總經理審批";
        }
        
        return "to end1";
    }

測試：

public void test()
    {
        //發布流程實例
        ProcessEngine processEngine = Configuration.getProcessEngine();
        processEngine.getRepositoryService()
            .createDeployment()
            .addResourceFromClasspath("com/jbpm_decision/jbpm_decision.jpdl.xml")
            .addResourceFromClasspath("com/jbpm_decision/jbpm_decision.png")
            .deploy();
        Map<String, User> map = new HashMap<String, User>();
        User user = new User();
        user.setDay(2);
        user.setName("張三");
        map.put("user", user);
        
        //啟動流程實例
        ProcessInstance p = processEngine.getExecutionService().startProcessInstanceByKey("jbpm_decision",map);
        
        String taskId = processEngine.getTaskService()
            .createTaskQuery()
            .processInstanceId(p.getId())
            .uniqueResult()
            .getId();
        
        System.out.println(taskId);
        //辦理業務
        processEngine.getTaskService().completeTask(taskId);
    }

分支（fork）/聚合（join）活動：

流程圖：

從圖中：可以看出兩條分支（發貨、匯款）是同時進行的。並且只有當兩條分支都到達join活動，流程才會繼續向后執行，

測試：

@Test
    public void test()
    {
        //獲取流程引擎
        ProcessEngine processEngine = Configuration.getProcessEngine();
        
        //發布流程實例
        processEngine.getRepositoryService()
            .createDeployment()
            .addResourceFromClasspath("com/jbpm_forjion/jbpm_forjion.jpdl.xml")
            .addResourceFromClasspath("com/jbpm_forjion/jbpm_forjion.png")
            .deploy();
        
        //啟動流程實例
           processEngine.getExecutionService().startProcessInstanceByKey("jbpm_forjion");
    }
    
    //查看個人任務
    @Test
    public void taskQueryPersonel()
    {
        ProcessEngine processEngine = Configuration.getProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        List<Task> list = taskService.createTaskQuery().list();
        for(Task t:list)
        {
            System.out.println("任務id:"+t.getId());
            System.out.println("任務名稱："+t.getName());
            System.out.println("任務操作人："+t.getAssignee());
        }
        
        
    }
    
    @Test
    public void taskComplete()
    {
        //獲取流程引擎
        ProcessEngine processEngine = Configuration.getProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        taskService.completeTask("20001");
    }

自定義活動（custion）

流程圖：

實現 ExternalActivityBehaviour 接口：

//到達這個活動是執行方法
    @Override
    public void execute(ActivityExecution aActivityExecution) throws Exception {        
        System.out.println("xxxxxxxxxxxxxxxx  execute  xxxxxxxxxxxxxxxxxx");
        //默認是執行完這個方法是 離開
        //aActivityExecution.takeDefaultTransition();
        //aActivityExecution.waitForSignal();

    }

    //調用signal 方法離開當前節點執行的方法（如果在execute() 方法中離開則不執行該方法）
    @Override
    public void signal(ActivityExecution arg0, String arg1, Map<String, ?> arg2) throws Exception {
        System.out.println("xxxxxxxxxxxxxxxxxx   signal   xxxxxxxxxxxxxxxxxxxxxx");
    }

測試：

@Test
    public void test()
    {
        //發布流程實例
        ProcessEngine processEngine = Configuration.getProcessEngine();
        processEngine.getRepositoryService()
            .createDeployment()
            .addResourceFromClasspath("com/jbpm_custom/jbpm_custom.jpdl.xml")
            .addResourceFromClasspath("com/jbpm_custom/jbpm_custom.png")
            .deploy();
        //啟動流程實例
        ExecutionService executionService = processEngine.getExecutionService();
        ProcessInstance p = executionService.startProcessInstanceByKey("jbpm_custom");
        System.out.println(p.getId());
    }
    
    @Test
    public void signal()
    {
        //發布流程實例
        ProcessEngine processEngine = Configuration.getProcessEngine();
        ExecutionService executionService = processEngine.getExecutionService();
        executionService.signalExecutionById("jbpm_custom.30008");
    }

事件：

1、 在根元素或節點元素中，使用<on event=””> 元素指定事件，其中event屬性代表事件的類型

2、 在<on>中用子元素<enent-listener class=”EventListenerImpl”/> 指定處理類，要求指定的類要實現EventListener接口

事件的類型

1、 <on>元素在根元素<process> 中，可以指定enent為start、end。表示流程的開始於結束。

2、 <on>元素在節點元素中，可以指定event為start、end.表示節點的進入與離開

3、 在start 節點中只有end事件，在end 節點中只有start事件

配置：

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

<process name="jbpm_event" xmlns="http://jbpm.org/4.4/jpdl">
   
   <!-- 流程實例啟動事件 -->
   <on event="start">
      <event-listener class="com.jbpm_event.EventListenerImpl"></event-listener>
   </on>
   <!-- 流程實例離開事件 -->
   <on event="end">
      <event-listener class="com.jbpm_event.EventListenerImpl"></event-listener>
   </on>
   
   <start name="start1" g="566,125,48,48">
      <transition name="to task1" to="task1" g="-63,-25"/>
   </start>
   
   <end name="end1" g="564,498,48,48"/>
   <task name="task1" g="577,294,92,52" assignee="員工">
      <transition name="to end1" to="end1" g="-62,-25"/>
      
       <!-- 進入活動事件 -->
       <on event="start">
          <event-listener class="com.jbpm_event.EventListenerImpl"></event-listener>
       </on>
       <!-- 離開活動事件 -->
       <on event="end">
          <event-listener class="com.jbpm_event.EventListenerImpl"></event-listener>
       </on>
   </task>
</process>