Activiti工作流节点的自由跳转

àì夳堔傛蜴生んèń 2022-08-21 04:54 409阅读 0赞

最近在搞openwebflow的工作流节点自由跳转功能，在网上看了一些资料，感觉不是很好，总结原因如下：

*  直接手动调用SqlSession的操作，感觉会漏掉一些重要的初始化操作（如：启动新节点之后加载其用户授权策略，等）；
 *  只有往前（往已执行过的节点）跳转的功能，没有往后节点（往还没有执行的节点）跳转的功能；
 *  新任务不是追加到已有执行路径上，而是覆盖老任务；

那么就自己动手吧！操作流程其实也简单，大概如下：

1.  按照目标节点（activity）定义创建一个新的任务（task），这个创建过程必须和正常流程到了某个节点的时候完全一样（如：不应该忽略用户授权策略的加载，任务名称表达式的计算，等）；
2.  删除掉当前任务（task）；

**注意：直接删除当前节点会报错，因为它还在流程之中，所以要先解除任务与当前执行execution的关联；**

以上操作如何安全的实现呢？看了一下源码，经过多次痛苦的尝试，积累了不少教训：

*  直接SqlSession操作数据库是不行的，这种方法容易擦枪走火！
 *  直接taskService.saveTask也是不行的，因为它实际上仅仅是针对DbSqlSession的操作！不commit一切操作都白搭！

那么怎么办呢？我想说的是，Activiti的封装做得很厚，想完全看懂是太难的。目前我还没想完全看懂，直接吐槽一下，与后人分享其中的痛苦：

*  太多的Command！一个saveTask()总会包装成SaveTask操作，关键代码总是藏得很深！
 *  太多的事件！
 *  太多的AtomicOperation！
 *  太多的Listener！
 *  太多的CommandInterceptor！隐隐约约感觉Activiti将各种CommandInterceptor组成一个chain，然后在执行核心代码的时候会一层一层的剥洋葱！
 *  还有就是栈式Context！看看下面这段代码就明白有多坑爹了：

**\[java\]**  [view plain][]  [copy][view plain]

[print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **public** **static** **void** setCommandContext(CommandContext commandContext) \{  
2.    getStack(commandContextThreadLocal).push(commandContext);  
3.  \}

总之，代码看得那是相当郁闷！debug的时候，调用栈极其深，而且大部分都会落在如下两段代码中：

代码1：

**\[java\]**  [view plain][]  [copy][view plain]

[print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **public** <T> T execute(CommandConfig config, Command<T> command) \{  
2.    **if** (!log.isDebugEnabled()) \{  
3.      // do nothing here if we cannot log  
4.      **return** next.execute(config, command);  
5.    \}  
6.    log.debug("\\n");  
7.    log.debug("--- starting \{\} --------------------------------------------------------", command.getClass().getSimpleName());  
8.    **try** \{  
9.    
10.     **return** next.execute(config, command);  
11.   
12.   \} **finally** \{  
13.     log.debug("--- \{\} finished --------------------------------------------------------", command.getClass().getSimpleName());  
14.     log.debug("\\n");  
15.   \}  
16. \}

代码2：

**\[java\]**  [view plain][]  [copy][view plain]

[print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **try** \{  
2.    // Push on stack  
3.    Context.setCommandContext(context);  
4.    Context.setProcessEngineConfiguration(processEngineConfiguration);  
5.      
6.    **return** next.execute(config, command);  
7.      
8.  \} **catch** (Exception e) \{  
9.        
10.   context.exception(e);  
11.     
12. \} **finally** \{  
13.   **try** \{  
14.       **if** (!contextReused) \{  
15.           context.close();  
16.       \}  
17.   \} **finally** \{  
18.       // Pop from stack  
19.       Context.removeCommandContext();  
20.       Context.removeProcessEngineConfiguration();  
21.   \}  
22. \}

看到那么多的next没？足够让人疯掉的\*\_\*

由于时间关系，我没有细细的去理解每个类，但最终还是找出了一个极妙、极安全的方法，那就是：**自己写Command！然后扔给CommandExecutor()了事！**

最终形成的代码如下所示：

**\[java\]**  [view plain][]  [copy][view plain]

[print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **package** org.openwebflow.ctrl;  
2.    
3.  **import** org.activiti.engine.ProcessEngine;  
4.  **import** org.activiti.engine.TaskService;  
5.  **import** org.activiti.engine.impl.RuntimeServiceImpl;  
6.  **import** org.activiti.engine.impl.interceptor.Command;  
7.  **import** org.activiti.engine.impl.interceptor.CommandContext;  
8.  **import** org.activiti.engine.impl.persistence.entity.ExecutionEntity;  
9.  **import** org.activiti.engine.impl.persistence.entity.TaskEntity;  
10. **import** org.activiti.engine.impl.pvm.process.ActivityImpl;  
11. **import** org.openwebflow.util.ActivityUtils;  
12.   
13. **public** **class** TaskFlowControlService  
14. \{  
15.     ProcessEngine \_processEngine;  
16.   
17.     **private** String \_processId;  
18.   
19.     **public** TaskFlowControlService(ProcessEngine processEngine, String processId)  
20.     \{  
21.         \_processEngine = processEngine;  
22.         \_processId = processId;  
23.     \}  
24.   
25.     /\*\* 
26.      \* 跳转至指定活动节点 
27.      \*  
28.      \* @param targetTaskDefinitionKey 
29.      \* @throws Exception 
30.      \*/  
31.     **public** **void** jump(String targetTaskDefinitionKey) **throws** Exception  
32.     \{  
33.         TaskEntity currentTask = (TaskEntity) \_processEngine.getTaskService().createTaskQuery()  
34.                 .processInstanceId(\_processId).singleResult();  
35.         jump(currentTask, targetTaskDefinitionKey);  
36.     \}  
37.   
38.     /\*\* 
39.      \*  
40.      \* @param currentTaskEntity 
41.      \*            当前任务节点 
42.      \* @param targetTaskDefinitionKey 
43.      \*            目标任务节点（在模型定义里面的节点名称） 
44.      \* @throws Exception 
45.      \*/  
46.     **private** **void** jump(**final** TaskEntity currentTaskEntity, String targetTaskDefinitionKey) **throws** Exception  
47.     \{  
48.         **final** ActivityImpl activity = ActivityUtils.getActivity(\_processEngine,  
49.             currentTaskEntity.getProcessDefinitionId(), targetTaskDefinitionKey);  
50.   
51.         **final** ExecutionEntity execution = (ExecutionEntity) \_processEngine.getRuntimeService().createExecutionQuery()  
52.                 .executionId(currentTaskEntity.getExecutionId()).singleResult();  
53.   
54.         **final** TaskService taskService = \_processEngine.getTaskService();  
55.   
56.         //包装一个Command对象  
57.         ((RuntimeServiceImpl) \_processEngine.getRuntimeService()).getCommandExecutor().execute(  
58.             **new** Command<java.lang.Void>()  
59.             \{  
60.                 @Override  
61.                 **public** Void execute(CommandContext commandContext)  
62.                 \{  
63.                     //创建新任务  
64.                     execution.setActivity(activity);  
65.                     execution.executeActivity(activity);  
66.   
67.                     //删除当前的任务  
68.                     //不能删除当前正在执行的任务，所以要先清除掉关联  
69.                     currentTaskEntity.setExecutionId(**null**);  
70.                     taskService.saveTask(currentTaskEntity);  
71.                     taskService.deleteTask(currentTaskEntity.getId(), **true**);  
72.   
73.                     **return** **null**;  
74.                 \}  
75.             \});  
76.     \}  
77. \}

最后写了一个测试类，代码如下：

**\[java\]**  [view plain][]  [copy][view plain]

[print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  @Test  
2.  **public** **void** testTaskSequence() **throws** Exception  
3.  \{  
4.      //\_processDef对应于vacationRequest流程，参见https://github.com/bluejoe2008/openwebflow/blob/master/models/test.bpmn  
5.      ProcessInstance instance = \_processEngine.getRuntimeService().startProcessInstanceByKey(\_processDef.getKey());  
6.      String instanceId = instance.getId();  
7.    
8.      TaskService taskService = \_processEngine.getTaskService();  
9.      Task task1 = taskService.createTaskQuery().singleResult();  
10.     Assert.assertEquals("step2", task1.getTaskDefinitionKey());  
11.   
12.     Map<String, Object> vars = **new** HashMap<String, Object>();  
13.     vars.put("vacationApproved", **false**);  
14.     vars.put("numberOfDays", 10);  
15.     vars.put("managerMotivation", "get sick");  
16.   
17.     String taskId = taskService.createTaskQuery().taskCandidateUser("kermit").singleResult().getId();  
18.     taskService.complete(taskId, vars);  
19.     Task task2 = taskService.createTaskQuery().singleResult();  
20.     Assert.assertEquals("adjustVacationRequestTask", task2.getTaskDefinitionKey());  
21.   
22.     TaskFlowControlService tfcs = **new** TaskFlowControlService(\_processEngine, instanceId);  
23.   
24.     //跳回至 step2  
25.     tfcs.jump("step2");  
26.     Task task3 = taskService.createTaskQuery().singleResult();  
27.     Assert.assertEquals("step2", task3.getTaskDefinitionKey());  
28.   
29.     //确认权限都拷贝过来了  
30.     //management可以访问该task  
31.     Assert.assertEquals(1, taskService.createTaskQuery().taskCandidateGroup("management").count());  
32.     //engineering不可以访问该task  
33.     Assert.assertEquals(0, taskService.createTaskQuery().taskCandidateGroup("engineering").count());  
34.   
35.     //确认历史轨迹里已保存  
36.     List<HistoricActivityInstance> activities = \_processEngine.getHistoryService()  
37.             .createHistoricActivityInstanceQuery().processInstanceId(instanceId).list();  
38.     Assert.assertEquals(5, activities.size());  
39.     Assert.assertEquals("step1", activities.get(0).getActivityId());  
40.     Assert.assertEquals("step2", activities.get(1).getActivityId());  
41.     Assert.assertEquals("requestApprovedDecision", activities.get(2).getActivityId());  
42.     Assert.assertEquals("adjustVacationRequestTask", activities.get(3).getActivityId());  
43.     Assert.assertEquals("step2", activities.get(4).getActivityId());  
44.   
45.     //测试一下往前跳  
46.     tfcs.jump("adjustVacationRequestTask");  
47.     Task task4 = taskService.createTaskQuery().singleResult();  
48.     Assert.assertEquals("adjustVacationRequestTask", task4.getTaskDefinitionKey());  
49.   
50.     activities = \_processEngine.getHistoryService().createHistoricActivityInstanceQuery()  
51.             .processInstanceId(instanceId).list();  
52.     Assert.assertEquals(6, activities.size());  
53.     Assert.assertEquals("adjustVacationRequestTask", activities.get(5).getActivityId());  
54.     \_processEngine.getRuntimeService().deleteProcessInstance(instanceId, "test");  
55. \}

[view plain]: http://blog.csdn.net/bluejoe2000/article/details/41778737#
[CODE]: https://code.csdn.net/assets/CODE_ico.png
[CODE_CODE]: https://code.csdn.net/snippets/544525
[ico_fork.svg]: https://code.csdn.net/assets/ico_fork.svg
[ico_fork.svg 1]: https://code.csdn.net/snippets/544525/fork

发表评论取消回复

表情：

评论列表（有 0 条评论，409人围观）

还没有评论，来说两句吧...

相关阅读

相关 activity多实例节点任意跳转

前言上一篇我们简单演示了单实例节点跳转的过程，在实际业务场景中，多实例节点的跳转也是一种常见的跳转场景，举例来说，当前的节点配置的是会签，即多个实例任务的节点，需要从当

比眉伴天荒/ 2023年02月22日 05:17/ 0 赞/ 41 阅读

相关 activity任意节点跳转

前言在实际业务中，总会碰到一些特殊的需求，比如要实现任意两个审批节点之间的跳转，举例来说，某个审批流程有3级审批，来了这么个需求，一级审批完结之后在满足特定的条件下，可

Love The Way You Lie/ 2023年02月21日 06:07/ 0 赞/ 16 阅读

相关工作流 Flowable 节点自由跳转

Flowable6已经实现了流程节点间的跳转，本次就初探一下相关的API。相关的示例代码在Flowable的开源代码中可以找到，具体的位置如下： \modules

た入场券/ 2022年11月18日 13:45/ 0 赞/ 315 阅读

相关 activiti 中国式自由流任意节点的跳转

工作流目前只能支持按照预先设置好的线，判断线的预制条件才能按照模板进行跳转。假设一个场景 a提交到 b b提交到c c提交到d d在一直提交下去。但是退回如何控制呢。假如d

我会带着你远行/ 2022年11月11日 15:58/ 0 赞/ 263 阅读

相关 Flowable自由跳转

Flowable6已经实现了流程节点间的跳转，本次就初探一下相关的API。相关的示例代码在Flowable的开源代码中可以找到，具体的位置如下： \modules

傷城~/ 2022年10月19日 13:58/ 0 赞/ 201 阅读

相关 Activiti实现自由流（任意节点的相互跳转）

/ 流程转向操作 @param taskId 当前任务ID @param activi

柔光的暖阳◎/ 2022年10月07日 09:58/ 0 赞/ 419 阅读

相关 Flowable 自由跳转

Flowable6已经实现了流程节点间的跳转，本次就初探一下相关的API。相关的示例代码在Flowable的开源代码中可以找到，具体的位置如下： \modules

谁借莪１个温暖的怀抱￠/ 2022年09月03日 08:27/ 0 赞/ 129 阅读

相关 Activiti工作流节点的自由跳转

最近在搞openwebflow的工作流节点自由跳转功能，在网上看了一些资料，感觉不是很好，总结原因如下：直接手动调用SqlSession的操作，感觉会漏掉一些重要的初

àì夳堔傛蜴生んèń/ 2022年08月21日 04:54/ 0 赞/ 410 阅读

相关 activiti工作流获取下一节点实例

第一个方法getTaskDefinitionList用于包装下面两个方法： / @author: Longjun @Des

缺乏、安全感/ 2022年07月29日 08:48/ 0 赞/ 298 阅读

相关 Activiti+Springboot跳转到任意节点

[参考链接：Activiti工作流几种驳回方式的实现与比较][Activiti] 1.TaskFlowControlService 方法类 package co

以你之姓@/ 2022年05月16日 08:44/ 0 赞/ 214 阅读