[关闭]
@ruoli 2016-09-07T10:06:27.000000Z 字数 8101 阅读 3451

Activiti选人页面的实现

Activiti

1、背景

Activiti默认是不带有选人的功能的，它默认的是在调用complete方法的时候自动根据下一个节点的 assignee属性设置下一节点的候选人，也可设置candidate属性或者角色，提交到下一步，流程引擎自动解析为公有任务，需要具体执行人去认领。
但是并不是所有的业务逻辑都符合Activit规定的标准情况，适用于这种操作，用户提交时需要从几个候选人中选择一个，然后发送到下一个环节，被选择的审批人，在下一环节拥有待办，目前Activiti工作流暂不支持原生支持，需要自己扩展。

2、扩展步骤

1、实现原理

1、目前Activiti人员解析逻辑

Activiti自带了23张表，其中有四张组织人员相关表：
1) act_id_group用户组信息表
2) act_id_info用户扩展信息表
3) act_id_membership用户与用户组对应信息表
4) act_id_user用户信息表
原生的Activiti人员解析，需要依赖Activiti内置的四张组织信息表，也提供了一些列的AIP让我们去操作这些表，插入和获取信息。
Activiti本身自带了简易的人员管理功能，角色配置，原生的做法是将人员和角色信息配置到工作流表中，工作流就可以自动解析环节处理时的角色，转换为为处理人，我们具体业务实现不用处理，但是这直接导致了三个问题：
第一：就是工作流自带的人员角色表过于简单，不一定能应对复杂的业务逻辑需求。
第二：需要维护两套人员角色信息，加重了程序设计的复杂性。
第三：不便于扩展，业务程序对工作流人员解析这块完全没有控制权，无法做到选人等业务需求。

2、如何使用自己的选人逻辑

首先我们无需管这四张表，也不 用往这些表中插入任何数据，这样就可以使Actriviti基于角色的选人失效，因为根据角色无法解析到人员。
实现我们自己的选人，同样依赖与流程图的属性配置，具体的逻辑是：
流程图配置好审批角色后，业务逻辑程序在提交下一步之前，提前获取到下一步的审批环节和审批角色，手工解析为多个人员，展示给用户，让其选择一个或多个，再以流程参数的形式设置到流程中，提交下一步，下一步审批环节识别到流程参数，绑定审批人员。

2、具体实现

1、编写流程定义工具类

用户获取流程定义相关信息，ActDefinitionService.java示例为：

  1. package modules.act.service;
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. import java.util.Set;
  7. import org.activiti.engine.RepositoryService;
  8. import org.activiti.engine.TaskService;
  9. import org.activiti.engine.delegate.Expression;
  10. import org.activiti.engine.impl.RepositoryServiceImpl;
  11. import org.activiti.engine.impl.bpmn.behavior.MultiInstanceActivityBehavior;
  12. import org.activiti.engine.impl.bpmn.behavior.NoneStartEventActivityBehavior;
  13. import org.activiti.engine.impl.bpmn.behavior.UserTaskActivityBehavior;
  14. import org.activiti.engine.impl.persistence.entity.ProcessDefinitionEntity;
  15. import org.activiti.engine.impl.pvm.PvmActivity;
  16. import org.activiti.engine.impl.pvm.PvmTransition;
  17. import org.activiti.engine.impl.pvm.delegate.ActivityBehavior;
  18. import org.activiti.engine.impl.pvm.process.ActivityImpl;
  19. import org.activiti.engine.impl.task.TaskDefinition;
  20. import org.activiti.engine.repository.ProcessDefinition;
  21. import org.activiti.engine.task.Task;
  22. import org.springframework.beans.factory.annotation.Autowired;
  23. import org.springframework.stereotype.Service;
  24. import org.springframework.transaction.annotation.Transactional;
  26. import common.utils.StringUtils;
  27. import modules.act.entity.ActTransition;
  28. /**
  29.  * 流程定义Service
  30.  * @author Ruoli
  31.  * 2016.08.23
  32.  */
  33. @Service
  34. @Transactional(readOnly = true)
  35. public class ActDefinitionService {
  36.     @Autowired
  37.     private RepositoryService repositoryService;
  38.     @Autowired
  39.     private TaskService taskService;
  40.     /**
  41.      * 查询任务对应的下一步路由
  42.      * @param taskId
  43.      * @return
  44.      */
  45.     public List<ActTransition> getApprovalInfo(String taskId){
  46.         List<ActTransition> approvalList=new ArrayList<ActTransition>();
  47.         //获取当前环节对象
  48.         ActivityImpl activityImpl=this.getActivity(taskId);
  49.         List<PvmTransition> outTransitions = activityImpl
  50.                         .getOutgoingTransitions();// 获取从某个节点出来的所有线路
  51.         for (PvmTransition tr : outTransitions) {
  52.             ActTransition transition=geTransition(tr);
  53.             //transition.getTaskRoleList();  //获取角色 集合
  54.             approvalList.add(transition);
  56.         }
  57.         return approvalList;
  58.     }
  59.     /**
  60.      * 根据TaskId获取流程定义环节对象
  61.      * @param taskId
  62.      * @return
  63.      */
  64.     public ActivityImpl getActivity(String taskId){
  65.         Task task =taskService.createTaskQuery().taskId(taskId).singleResult();
  66.         if(task!=null){
  67.             ProcessDefinitionEntity def = (ProcessDefinitionEntity) ((RepositoryServiceImpl) repositoryService)
  68.                     .getDeployedProcessDefinition(task.getProcessDefinitionId());
  69.              return  def.findActivity(task.getTaskDefinitionKey());
  70.         }
  71.         return null;
  72.     }
  73.     /**
  74.      * 根据路由Id获取路由对象
  75.      * @param transitionId
  76.      * @return ActTransition
  77.      */
  78.     public ActTransition geTransition(String processDefinitionId,String transitionId){
  79.         if(StringUtils.isNotEmpty(processDefinitionId) && StringUtils.isNotEmpty(transitionId)){
  80.             ProcessDefinitionEntity def = (ProcessDefinitionEntity) ((RepositoryServiceImpl) repositoryService)
  81.             .getDeployedProcessDefinition(processDefinitionId);
  82.             List<ActivityImpl> activityList=def.getActivities();
  83.             for(ActivityImpl activityImpl : activityList){
  84.                 List<PvmTransition> outTransitions=activityImpl.getOutgoingTransitions();
  85.                 for (PvmTransition pvmTransition : outTransitions) {
  86.                     if(transitionId.equals(pvmTransition.getId())){
  88.                         ActTransition actTransition=geTransition(pvmTransition);
  89.                          return actTransition;
  90.                     }
  91.                 }
  92.             }
  93.         }
  94.         return null;
  95.     }
  96.     /**
  97.      * 根据连线对象获取下一步处理信息
  98.      * @param pvmTransition
  99.      * @return ActTransition
  100.      */
  101.     private ActTransition geTransition(PvmTransition pvmTransition){
  102.         PvmActivity nextActivity = pvmTransition.getDestination();
  103.         ActTransition actTransition=new ActTransition();
  104.         actTransition.setId(pvmTransition.getId());
  105.         actTransition.setName(pvmTransition.getProperty("name")+"");
  106.         actTransition.setDescription(pvmTransition.getProperty("documentation")+"");
  107.         actTransition.setCondition(pvmTransition.getProperty("conditionText")+"");
  108.         actTransition.setTaskName(nextActivity.getProperty("name")+"");
  110.         //判断是否是UserTask
  111.         ActivityImpl activity=(ActivityImpl)nextActivity;
  112.         ActivityBehavior activityBehavior = activity.getActivityBehavior();
  113.         if (activityBehavior instanceof UserTaskActivityBehavior || activityBehavior instanceof MultiInstanceActivityBehavior) {
  114.         TaskDefinition taskDefinition=(TaskDefinition)nextActivity.getProperty("taskDefinition");
  116.         if(taskDefinition!=null){
  118.             Set<Expression>  roleSet=taskDefinition.getCandidateGroupIdExpressions();
  119.             //List 用户存放下一步审批角色
  120.             List<String> roleList=new ArrayList<String>();
  121.             for(Expression expression:roleSet){
  122.                 roleList.add(expression.getExpressionText());
  123.             }
  124.             actTransition.setTaskRoleList(roleList);
  125.         }
  126.         }
  127.         return actTransition;
  128.     }
  130.     /**
  131.      * 获取首环节处理角色
  132.      * @return
  133.      */
  134.     public List<String> getFristNodeRole(String procDefKey){
  135.          List<String> roleList=new ArrayList<String>();
  136.          ProcessDefinition processDefinition=repositoryService.createProcessDefinitionQuery().processDefinitionKey(procDefKey)
  137.                                             .orderByProcessDefinitionVersion().desc().list().get(0);
  138.               ProcessDefinitionEntity def = (ProcessDefinitionEntity) ((RepositoryServiceImpl) repositoryService)
  139.                                             .getDeployedProcessDefinition(processDefinition.getId());
  140.               List<ActivityImpl> activityList=def.getActivities();
  141.               for(ActivityImpl activityImpl : activityList){
  142.                   ActivityBehavior activityBehavior = activityImpl.getActivityBehavior();
  143.                   if (activityBehavior instanceof NoneStartEventActivityBehavior) {
  144.                       PvmActivity fristTask=activityImpl.getOutgoingTransitions().get(0).getDestination();
  145.                       TaskDefinition taskDefinition=(TaskDefinition)fristTask.getProperty("taskDefinition");
  146.                       Set<Expression>  roleSet=taskDefinition.getCandidateGroupIdExpressions();
  147.                       for(Expression expression:roleSet){
  148.                         roleList.add(expression.getExpressionText());
  149.                       }
  150.                      break;
  151.                   }
  152.               }
  154.         return roleList;
  155.     }
  156. }

其中依赖实体类ActTransition.java 代码如下：

  1. package modules.act.entity;
  3. import java.util.List;
  4. /**
  5.  * 下一步处理信息，此类主要用于人员或路由选择页面
  6.  * @author Ruoli
  7.  * 2016/08/23
  8.  */
  9. public class ActTransition {
  10.     private String id;//路由ID
  11.     private String name;//路由名称
  12.     private String description;//路由描述
  13.     private String condition;//路由条件
  14.     private String taskName;//下一步环节的名称
  15.     private List<String> taskRoleList; //下一步审批角色集合
  16.     //可根据业务需求新增更多字段
  18.     public String getId() {
  19.         return id;
  20.     }
  21.     public void setId(String id) {
  22.         this.id = id;
  23.     }
  25.     public String getTaskName() {
  26.         return taskName;
  27.     }
  28.     public void setTaskName(String taskName) {
  29.         this.taskName = taskName;
  30.     }
  31.     public List<String> getTaskRoleList() {
  32.         return taskRoleList;
  33.     }
  34.     public void setTaskRoleList(List<String> taskRoleList) {
  35.         this.taskRoleList = taskRoleList;
  36.     }
  37.     public String getName() {
  38.         return name;
  39.     }
  40.     public void setName(String name) {
  41.         this.name = name;
  42.     }
  43.     public String getDescription() {
  44.         return description;
  45.     }
  46.     public void setDescription(String description) {
  47.         this.description = description;
  48.     }
  49.     public String getCondition() {
  50.         return condition;
  51.     }
  52.     public void setCondition(String condition) {
  53.         this.condition = condition;
  54.     }
  55. }

2、编写选环节Controller方法

  1. /**
  2.      * 获取流程审批信息，提供发送时 展示选环节列表
  3.      * @param act
  4.      * @return
  5.      */
  6.     @SuppressWarnings("unchecked")
  7.     protected List<Map<String, Object>> getApprovalTrack(String taskId){
  8.         if(StringUtils.isNotBlank(taskId)){
  9.             //1：获取路由信息
  10.             List<ActTransition> approvalList=actDefinitionService.getApprovalInfo(taskId); //actTaskService.getApprovalInfo(act.getTaskId());
  11.             //2:迭代路由
  12.             if(approvalList!=null){
  13.                 //构建树形Tree-List
  14.                 List<Map<String, Object>> resultList=new ArrayList<Map<String, Object>>();
  16.                 for (ActTransition transition : approvalList) {
  17.                     Map<String, Object> tempMap=new HashMap<String, Object>();
  18.                     tempMap.put("id",transition.getId());
  19.                     tempMap.put("name", transition.getTaskName());
  20.                     tempMap.put("pId",1);
  21.                     //此处还有验证路由条件的控制，暂时没有实现
  22.                     //此处可以自己行增加 路由对应的人员信息，可根据角色进行解析，此示例只需要进行选路由即可
  23.                     resultList.add(tempMap);
  24.                 }
  26.                 Map<String, Object> rootMap=new HashMap<String, Object>();
  27.                 rootMap.put("id","1");
  28.                 if(resultList.size()==0){
  29.                     rootMap.put("name","暂无处理环节");
  30.                 }else{
  31.                     rootMap.put("name","可被选择的处理环节");
  32.                 }
  34.                 rootMap.put("pId","0");
  35.                 rootMap.put("nocheck",true);//设置根节点不可选中
  36.                 resultList.add(rootMap);
  37.                 return resultList;
  38.             }
  39.         }
  40.         return null;            
  42.     }
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注