jbpm自由流，流程回退，以及assignment-handler 和handler的使用

1 ： 实现自由流无非就是新建一个transition让它指向我们的目标节点，流转到目标节点以后我们必要的需要将这个新的transition给删除，以免影响其他的业务流

 1 package com.testbase.service;
 2 
 3 import java.util.List;
 4 
 5 import org.jbpm.api.Execution;
 6 import org.jbpm.api.ExecutionService;
 7 import org.jbpm.api.RepositoryService;
 8 import org.jbpm.api.TaskService;
 9 import org.jbpm.api.model.Transition;
10 import org.jbpm.api.task.Task;
11 import org.jbpm.pvm.internal.model.ActivityImpl;
12 import org.jbpm.pvm.internal.model.ProcessDefinitionImpl;
13 import org.jbpm.pvm.internal.model.TransitionImpl;
14 import org.springframework.beans.factory.annotation.Autowired;
15 import org.springframework.stereotype.Service;
16 
17 @Service
18 public class FreeDomFlowService {
19 
20     @Autowired
21     TaskService taskService;
22     @Autowired
23     ExecutionService executionService;
24 
25     @Autowired
26     RepositoryService repositoryService;
27 
28     public void createFreedom(String taskId, String endDom) {
29         Task task = taskService.getTask(taskId);
30         String activityName = task.getActivityName();
31         Execution execution = executionService.findExecutionById(task.getExecutionId());
32         ProcessDefinitionImpl processDefinitionImpl = (ProcessDefinitionImpl) repositoryService
33                 .createProcessDefinitionQuery().processDefinitionId(execution.getProcessDefinitionId()).uniqueResult();
34 
35         // 寻找一个活跃在给定activityName执行
36         //execution.findActiveExecutionIn(activityName);
37         // 递归搜索给定的活动元素,包括这个活动和所有子活动(当前活动节点名称)
38         ActivityImpl activityImpl = processDefinitionImpl.findActivity(activityName);
39         // 目标节点名称
40         ActivityImpl goleActivityImpl = processDefinitionImpl.findActivity(endDom);
41 
42         TransitionImpl transitionImpl = activityImpl.createOutgoingTransition();
43         transitionImpl.setName("新的teansition");
44         transitionImpl.setDestination(goleActivityImpl);
45         activityImpl.addOutgoingTransition(transitionImpl);
46 
47         // 完成任务
48         taskService.completeTask(task.getId(), transitionImpl.getName());
49         // 删除创建的流转路线，这个一般都会删除一下，防止影响原本流程定义
50         this.removeOutTransition(processDefinitionImpl, activityName, endDom);
51 
52     }
53 
54     // 删除自由流
55     public void removeOutTransition(ProcessDefinitionImpl pd, String sourceName, String destName) {
56 
57         ActivityImpl sourceActivity = pd.findActivity(sourceName);
58         @SuppressWarnings("unchecked")
59         List<Transition> trans = (List<Transition>) sourceActivity.getOutgoingTransitions();
60         for (Transition tran : trans) {
61             if (destName.equals(tran.getDestination().getName())) {
62                 trans.remove(tran);
63                 break;
64             }
65         }
66     }
67 
68 }

其实这个是一个工具类，我们在使用他的时候给他一个taskID和目标节点的名字我们就可以实现自由流了freeDomFlowService.createFreedom("90003", "主任审批");

 

2 ： 流程回退的实现有很多种方法，其中一种我们可以decision标签来判断，当它达到某一个条件的时候我们可以使他回退到原来的节点，当让想流转到哪里由开发者自行决定

 

 

3 ： assigment-handler实在task标签下常用的一个标签器class属性去指向一个类，这个类必须是实现AssignmentHandler接口，而且要重写assign方法，方法的参数我们可以获取我们想要的数据，在里边我们可以动态指定执行者，获取流程变量，更新流程变量，

1    <task g="148,149,92,52" name="填写表单">
2          <assignment-handler class="com.testbase.service.StartTaskUser">
3          </assignment-handler>
4       <transition g="-30,-14" name="提交到科长" to="科长审批"/>
5    </task>

 

 1 package com.testbase.service;
 2 
 3 import org.jbpm.api.model.OpenExecution;
 4 import org.jbpm.api.task.Assignable;
 5 import org.jbpm.api.task.AssignmentHandler;
 6 
 7 public class StartTaskUser implements AssignmentHandler {
 8 
 9     /**
10      * 
11      */
12     private static final long serialVersionUID = 1L;
13 
14     public void assign(Assignable assignable, OpenExecution execution) throws Exception {
15         // TODO Auto-generated method stub
16         String userName = execution.getVariable("userName").toString();
17         assignable.setAssignee(userName);
18         System.out.println("设置启动用户为 ————》" + userName);
19         execution.setVariable("code", 100);
20     }
21 
22 }

 

4 ： handler标签是出现在decision标签下的，class指向的类也要实现特定的接口DecisionHandler重写decide方法，既然handler是出现在decision标签下的那么自然是服务与decision节点的，在重写的decide方法里我们可以获取数据也可以设置数据，其主要目的就是使用代码的方式判断流程的流转，让程序更加的灵活

1    <decision g="331,321,48,48" name="exclusive1">
2    <handler class="com.testbase.service.HandlerService" />
3       <transition g="516,351:-52,-22" name="审批通过" to="主任审批"/>
4       <transition g="195,341:-52,-22" name="驳回" to="填写表单"/>
5    </decision>

 

 1 package com.testbase.service;
 2 
 3 import org.jbpm.api.jpdl.DecisionHandler;
 4 import org.jbpm.api.model.OpenExecution;
 5 
 6 public class HandlerService implements DecisionHandler {
 7 
 8     /**
 9      * 
10      */
11     private static final long serialVersionUID = 1L;
12 
13     public String decide(OpenExecution execution) {
14         boolean isInto = (Boolean) execution.getVariable("isInto");
15         System.out.println(isInto);
16         if (isInto)
17             return "审批通过";
18         else
19             return "驳回";
20     }
21 
22 }

 

转载于:https://www.cnblogs.com/holdouts/articles/5815466.html