JSAAS的Activiti会签开发扩展处理

最新推荐文章于 2024-03-24 16:00:25 发布
最新推荐文章于 2024-03-24 16:00:25 发布
阅读量629 收藏
点赞数
分类专栏： Java SaaS Activiti 文章标签： java 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013604967/article/details/84805996
版权
本文介绍了在流程业务中如何利用Activiti实现中国特色的会签需求。通过配置多实例的人工任务，动态计算参与人员集合，并设定完成条件，以支持并行会签。此外，还详细阐述了会签服务类的实现，包括获取人员集合和判断任务完成的接口，以及处理会签投票结果的方法。最后，展示了实现后的会签效果。
摘要由CSDN通过智能技术生成

1.什么是会签?

 

在流程业务管理中，任务是通常都是由一个人去处理的，而多个人同时处理一个任务，这种任务我们称之为会签任务。这种业务需求很常见，如一个请款单，领导审批环节中，就需要多个部门领导签字。在流程业务中，我们可以把每个领导签字的环节都定义为任务，并且这个会签的人员是不固定的，若固定的我们可以通过Activiti的并行任务或串行任务来处理。会签的引入说明，无非就是为了流程流转至某一环节点，其审批的人员是动态的，并且需要根据会签审批的结果实现流程的不同流转。

2.中国特色的会签需求是什么？

 

      会签需求主要有以下两方面：

  1. 会签的参与人员
  2. 会签审批的顺序
  3. 会签审批的结果
  4. 动态加签

以下我们就是围绕以上的需求进行扩展实现的

3.Activiti对于会签的实现

 

BPMN2的标准中并没有对以上这种情景提供完善的支持，因此要在Activiti中实现会签审批，我们需要结合Activiti提供的流程任务的多实例特性，进行一些必要的扩展，以支持我们的中国特色的会签需求。
会签任务也是一种人工任务，其在activiti的定义中，也是使用UserTask来定义，但在属性上我们需要对这个定义的类型进行特殊的配置，即为多任务实例类型（并行或串行）任何一种。另外需要定义会签的参与人员，再定义会签的完成条件（若不定义，表示其是所有参与人均完成后，流程才往下跳转）。

3.1.多实例的人工任务配置

 

通过在UserTask节点的属性上配置，如下所示：

1.png

其生成的BPMN的配置文件如下所示：

  <userTask id= "sid-78A17A9B-1185-48AA-A1CA-611421251D52" name= "经理会签" >
      <multiInstanceLoopCharacteristics isSequential= "false" activiti:collection= "${counterSignService.getUsers(execution)}" >
        <completionCondition>${counterSignService.isComplete(execution)} </completionCondition>
      </multiInstanceLoopCharacteristics>
    </userTask>

【说明】：

  1. isSequential="false" 表示这是非串行会签，即为并行会签，如三个人参与会签，是三个人同时收到待办，任务实例是同时产生的。
  2. activiti:collection 表示是会签的参与人员集合，用户可以通过定义自身的服务类来获取
  3. completionCondition  表示是任务往下跳转的完成条件，返回true是，表示条件成立，流程会跳至下一审批环节。

我们就是围绕着这几点来实现中国式的流程会签的

3.2 会签任务的人员集合计算处理

 

我们在Spring容器中定义一个会签服务类(counterSignService）里面提供两个api接口，一个是获得任务的人员集合，另一个是判断当前任务是否已经完成了会签的计算，其参考代码如下所示：

package com.redxun.bpm.core.service.sign;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

import javax.annotation.Resource;

import org.activiti.engine.impl.pvm.delegate.ActivityExecution;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import com.redxun.bpm.activiti.util.ProcessHandleHelper;
import com.redxun.bpm.core.entity.BpmDestNode;
import com.redxun.bpm.core.entity.BpmRuPath;
import com.redxun.bpm.core.entity.BpmSignData;
import com.redxun.bpm.core.entity.IExecutionCmd;
import com.redxun.bpm.core.entity.ProcessMessage;
import com.redxun.bpm.core.entity.config.MultiTaskConfig;
import com.redxun.bpm.core.entity.config.TaskVotePrivConfig;
import com.redxun.bpm.core.entity.config.UserTaskConfig;
import com.redxun.bpm.core.identity.service.BpmIdentityCalService;
import com.redxun.bpm.core.manager.BpmNodeSetManager;
import com.redxun.bpm.core.manager.BpmSignDataManager;
import com.redxun.bpm.enums.TaskOptionType;
import com.redxun.org.api.model.IdentityInfo;
import com.redxun.sys.org.entity.OsGroup;
import com.redxun.sys.org.entity.OsRelType;
import com.redxun.sys.org.entity.OsUser;
import com.redxun.sys.org.manager.OsGroupManager;
import com.redxun.sys.org.manager.OsUserManager;

/**
 * 会签配置服务类
 * @author csx
 *
 */
public class CounterSignService {
@Resource
private BpmSignDataManager bpmSignDataManager;
@Resource
private BpmNodeSetManager bpmNodeSetManager;
@Resource
 BpmIdentityCalService bpmIdentityCalService;
@Resource
private OsGroupManager osGroupManager;
@Resource
private OsUserManager osUserManager;

private Log logger=LogFactory.getLog(CounterSignService.class);
/**
  * 获得会签任务中的人员计算集合
  * @param execution
  * @return
  */
public Set<String> getUsers(ActivityExecution execution){
  
  logger.debug("enter the CounterSignService ");
  
  Set<String> userIds=new LinkedHashSet<String>();
  String nodeId=execution.getActivity().getId();
  //1.回退处理通过
  BpmRuPath backRuPath=ProcessHandleHelper.getBackPath();
  if(backRuPath!=null && "YES".equals(backRuPath.getIsMultiple())){
   String uIds=backRuPath.getUserIds();
   userIds.addAll(Arrays.asList(uIds.split("[,]"))); 
   execution.setVariable("signUserIds_"+nodeId,uIds);
   return userIds;
  }

  //2.通过变量来判断是否第一次进入该方法
  String signUserIds=(String)execution.getVariable("signUserIds_"+nodeId);
  
  if(StringUtils.isNotEmpty(signUserIds)){
   String[]uIds=signUserIds.split("[,]");
   userIds.addAll(Arrays.asList(uIds));
   return userIds;
  }
  
  //3.从界面中的提交变量取用户
  IExecutionCmd nextCmd=ProcessHandleHelper.getProcessCmd();
  BpmDestNode bpmDestNode=nextCmd.getNodeUserMap().get(nodeId);

  if(bpmDestNode!=null && StringUtils.isNotEmpty(bpmDestNode.getUserIds())){
   //加至流程变量中，以使后续继续不需要从线程及数据库中获取
   execution.setVariable("signUserIds_"+nodeId,bpmDestNode.getUserIds());
   execution.setVariable("priority_"+nodeId,bpmDestNode.getPriority());
   execution.setVariable("expiretime_"+nodeId, bpmDestNode.getExpireTime());
   
   String[]uIds=bpmDestNode.getUserIds().split("[,]");
   userIds.addAll(Arrays.asList(uIds));
   return userIds;
  }
  
  //4.从数据库中读取节点人员配置获得参与人员列表
  Collection<IdentityInfo> idInfoList=bpmIdentityCalService.calNodeUsersOrGroups(execution.getProcessDefinitionId(), execution.getCurrentActivityId(),execution.getVariables());
  
  for(IdentityInfo identityInfo:idInfoList){
   if(IdentityInfo.IDENTIFY_TYPE_USER.equals(identityInfo.getIdentityType())){
    userIds.add(identityInfo.getIdentityInfoId());
   }else{
    List<OsUser> users= osUserManager.getByGroupIdRelTypeId(identityInfo.getIdentityInfoId(), OsRelType.REL_CAT_GROUP_USER_BELONG_ID);
    for(OsUser u:users){
     userIds.add(u.getUserId());
    }
   }
  }
  if(userIds.size()>0){
   StringBuffer sb=new StringBuffer();
   for(String uId:userIds){
    sb.append(uId).append(",");
   }
   if(sb.length()>0){
    sb.deleteCharAt(sb.length()-1);
   }
   execution.setVariable("signUserIds_"+nodeId,sb.toString());
  }else{
   String name=(String)execution.getActivity().getProperty("name");
   ProcessMessage msg=ProcessHandleHelper.getProcessMessage();
   msg.getErrorMsges().add("会签节点["+name+"]没有设置执行人员，请联系管理员！");
  }
   
  
  
  return userIds;
}

/**
  * 会签是否计算完成
  * @param execution
  * @return
  */
public boolean isComplete(ActivityExecution execution){
  //完成会签的次数
  Integer completeCounter=(Integer)execution.getVariable("nrOfCompletedInstances");
  //总循环次数
  Integer instanceOfNumbers=(Integer)execution.getVariable("nrOfInstances");
  
  String solId=(String)execution.getVariable("solId");
  String nodeId=execution.getActivity().getId();
  UserTaskConfig taskConfig=bpmNodeSetManager.getTaskConfig(solId, nodeId);
  
  //获得任务及其多实例的配置,则任务不进行任何投票的设置及处理，即需要所有投票完成后来才跳至下一步。
  if(taskConfig.getMultiTaskConfig()==null){
   return completeCounter==instanceOfNumbers;
  }

  //获得会签的数据
  List<BpmSignData> bpmSignDatas=bpmSignDataManager.getByInstIdNodeId(execution.getProcessInstanceId(), nodeId);
  MultiTaskConfig multiTask=taskConfig.getMultiTaskConfig();
  //通过票数
  int passCount=0;
  //反对票数
  int refuseCount=0;
  //弃权票数
  int abstainCount=0;
  
  for(BpmSignData data:bpmSignDatas){
   int calCount=1;
   //弃权不作票数统计
   if(TaskOptionType.ABSTAIN.name().equals(data.getVoteStatus())){
    abstainCount++;
    continue;
   }
   String userId=data.getUserId();
   //检查是否有特权的处理
   if(multiTask.getVotePrivConfigs().size()>0){
    //计算用户的用户组
    List<OsGroup> osGroups=osGroupManager.getBelongGroups(userId);
    
    for(TaskVotePrivConfig voteConfig:multiTask.getVotePrivConfigs()){
     //是否在特权里
     boolean isInPriv=false;
     //为用户类型
     if(TaskVotePrivConfig.USER.equals(voteConfig.getIdentityType()) 
       && voteConfig.getIdentityIds().contains(userId)){
      isInPriv=true;
     }else{//为用户组类型
      for(OsGroup osGroup:osGroups){
       if(voteConfig.getIdentityIds().contains(osGroup.getGroupId())){
        isInPriv=true;
        break;
       }
      }
     }
     //若找到特权，则计算其值
     if(isInPriv){
      calCount=voteConfig.getVoteNums();
      break;
     }
    }
   }
   //统计同意票数
   if(TaskOptionType.AGREE.name().equals(data.getVoteStatus())){
    passCount+=calCount;
   }else{//统计反对票数
    refuseCount+=calCount;
   }
  }
  
  logger.debug("==============================passCount:"+passCount
    +" refuseCount:" + refuseCount +" abstainCount:"+abstainCount);
  //是否可以跳出会签
  boolean isNext=false;
  String result=null;
  
  //按投票通过数进行计算
  if(MultiTaskConfig.VOTE_TYPE_PASS.equals(multiTask.getVoteResultType())){
   //计算是否通过
   //按投票数进行统计
   if(MultiTaskConfig.CAL_TYPE_NUMS.equals(multiTask.getCalType())){
    //代表通过
    if(passCount>=multiTask.getVoteValue()){
     isNext=true;
     result="PASS";
    }
   }else{//按百分比进行计算
    int resultPercent=new Double(passCount*100/(passCount+refuseCount+abstainCount)).intValue();
    //代表通过
    if(resultPercent>=multiTask.getVoteValue()){
     isNext=true;
     result="PASS";
    }
   }
  }else{//按投票反对数进行计算
   //计算是否通过
   //按投票数进行统计
   if(MultiTaskConfig.CAL_TYPE_NUMS.equals(multiTask.getCalType())){
    //代表通过
    if(refuseCount>=multiTask.getVoteValue()){
     isNext=true;
     result="REFUSE";
    }
   }else{//按百分比进行计算
    int resultPercent=new Double(refuseCount*100/(passCount+refuseCount+abstainCount)).intValue();
    //代表通过
    if(resultPercent>=multiTask.getVoteValue()){
     isNext=true;
     result="REFUSE";
    }
   }
  }
  
  if((MultiTaskConfig.HANDLE_TYPE_DIRECT.equals(multiTask.getHandleType())&& isNext)//直接处理
    || (MultiTaskConfig.HANDLE_TYPE_WAIT_TO.equals(multiTask.getHandleType()) && completeCounter==instanceOfNumbers)){//等待所有的处理完
   execution.setVariable("voteResult_"+nodeId, result);
   //删除该节点的会签数据
   for(BpmSignData data:bpmSignDatas){
    bpmSignDataManager.deleteObject(data);
   }
   return true;
  }
  
  return false;
  
}
}
 

【说明】
以上的代码的人员计算有几个来源：

  1. 流程回退时获得原来参与的人员
  2. 直接从流程变量中获取
  3. 从界面中的提交变量取用户
  4. 从数据库中读取节点人员配置获得参与人员列表

会签的投票处理结果放至流程变量中去，供后续的分支条件来处理，我们把会签的配置设置管理如下：

task-config.png

我们提供了按票数、百分比的投票处理，同时允许有特权的用户的投票规则以支持灵活的会签结果运算。

实现了以上配置后，流程的会签就比较简单，具体的效果如下视频演示：

 

http://www.redxun.cn/vedio/taskSign.htm

演示效果如：

http://www.redxun.cn:8020/saweb/login.jsp 

mansan2015
关注
专栏目录
Activiti会签
Uself
05-07 2万+
1. 什么是会签 a) 在流程业务管理中，任务是通常都是由一个人去处理的，而多个人同时处理一个任务，这种任务我们称之为会签任务。 2. 会签的种类 a) 按数量通过：达到一定数量的通过表决后，会签通过。 b) 按比例通过：达到一定比例的通过表决后，会签通过。 c) 一票否决：只要有一个表决时否定的，会签通过。 d) 一票通过：只要有一个表决通过的，会签通过.........
工作流activiti 会签 驳回/撤回 问题
weixin_41643546的博客
12-27 6371
工作中用到了activity 进行流程审批。节点用到了会签功能。上线后，发现会签节点驳回/撤回会出现失效，例如会签需要USER1,USER2顺序会签，但是在USER1，用户撤回，并不能撤回到初始节点，而是到了会签下一节点。 所以为了解决这个问题，博主进行可研究。 经研究发现，会签任务是带有子任务的，上图为例： SELECT * FROM ACT_RU_EXECUTION WHERE PROC_INST_ID_ = '2232501'; 正常非会签任务，我们可以认为：PROC_INST_I...
jbpm工作流（会签，串签）
06-13
jbpm的流程部署 流程开始 任务提交 查询已办，待办
web工作流管理系统开发之十八 工作流会签的相关实现
专注于web工作流管理系统开发
04-23 216
在工作流系统中，单步会签，多部门会签，会签百分比，加签，减签等等这些是必备的功能。尤其在办公管理的审批流程中，经常会用到这些。 例如单步会签，在流程的某个环节需要多个人同时办理，不分先后次序的签署意见等。 多部门会签，流程运行到某个环节需要多个部门的人同时办理，各部门不分先后次序的发表审批意见等。 会签百分比，流程运行到某个环节需要多个人协助同时处理，但是只需要80％的人处理过，就可以通过了...
应用jBPM4解决中国特色的流程需求
cpongo5
09-25 145
1. jBPM4的特点\jBPM是JBoss众多开源项目中的一个工作流开源项目，也是目前应用最广泛的工作流项目。在今年的7月10号，JBoss jBPM团队正式发布了jBPM4的正式版。jBPM4完全基于流程虚拟机（PVM）的机制，对核心引擎进行了重新设计，而PVM的引入也使得jBPM4可以支持多流程语言了。除此之外还有很多其它的特点：\流程定义对象的变化\ 在流程定义的对象上，节点类型划分...
工作流会签
QingniuFu的专栏
06-13 981
一、会签概念     会签在工作流应用中非常普遍，就是在同一任务节点，多个人可同时办理。会签的概念看似简单，但客户需求千差万别，以至于会签形式多样化。由于会签是同时办理，自然牵扯到参与者对资源的竞争问题（比如表单的加锁解锁），我会在后面文章细说。 二、一步步走向会签    1、 引擎不支持的年代         n年前，那时公司工作流引擎还没有实现会签功能，但项目不等人，我们只有在...
工作流操作-会签
weixin_43150720的博客
06-10 3837
注：流程引擎 Camunda 会签：内容涉及到多个部门，多个部门直接审批没有顺序，只有当所有部门通过，或者部分通过，此任务才算完成。 流程图 会签任务选择并行多实例。 办理人设置为流程变量assignee,这个变量名也是多实例集合中的元素变量。 多实例的配置： 此时部署流程，完成提交申请是需要如下操作： @Test public void completeTask(){ String taskId = "2f0db62c-aabd-11ea-88e3-000ec6dd34b8"; St
activiti 会签投票统计
03-01
在 Activiti 流程设计中，会签任务允许多个参与者同时处理同一个任务。这通常通过 BPMN 2.0 的并行多实例（Parallel Multi-instance）概念来实现，用以模拟工作流中的“所有人必须同意”或“多数同意”的场景。`...
activiti取会签人员
11-02
在用activiti的时候经常遇到取会签人员的问题，这个文档解决怎么获取会签人员。
Activiti-5.4中实现会签
03-30
在 Activiti-5.4 版本中，会签（Concurrent Signatures）是流程设计中的一个重要特性，允许多个参与者同时对同一任务进行处理，提高了工作效率。下面我们将详细探讨如何在Activiti-5.4中实现会签以及相关的技术细节...
【专题讲解】工作流引擎会签，加签，主持人，组长模式专题讲解.docx
04-11
ccflow工作流，开源工作流引擎
应用工作流解决中国特色的流程需求
02-11
应用工作流解决中国特色的流程需求,应用工作流解决中国特色的流程需求
工作流之会签
xionghaizhi的博客
12-24 1871
首先 配置较 单节点多了几个配置项 相关参数说明 ： nrOfInstances：实例总数 nrOfActiveInstances：当前活动的，比如，还没完成的，实例数量。 对于顺序执行的多实例，值一直为1。 nrOfCompletedInstances：已经完成实例的数目。 原来的这个变量还需要写   相关信息解释： Multi instance： Sequence 设...
工作流引擎会签，加签，主持人，组长模式
yuanhaijie123的博客
03-21 719
概要说明 关键字： ccflow 工作流引擎 会签，加签，主持人，多人处理规则 会签定义： 会签就是多人在一个节点上表达意见，每个人只能在一个节点上填写一个意见。 我们提供两种模式的会签：协作模式的会签与组长模式的会签，我们要根据不同的应用场景设置会签类型。 协作模式下又分为，协作组员是否可以在找其他人进行协作。 组长会签模式，又分为，单组长模式，多组长模式。 如下图就是会签的设置页面。 协作...
会签是什么，何时使用会签，如何设计使用会签
热门推荐
驰骋工作流的博客
04-19 3万+
会签是什么、何时使用会签、如何设计使用会签、在BPM中如何设计会签、使用会签
[AIGC] 工作流中的会签：概念与实现
程序员三木的博客
03-24 521
工作流中的会签是一个十分重要的环节，它可以确保工作流中的操作或者决策已经得到相关人员的认同和批准。下面我们将详细介绍一下会签的概念，以及如何在Flowable工作流引擎中实现会签。
工作流中的会签模式
汪涛的专栏
04-18 8414
工作流中常用的有两种模式的会签：有主持人的会签和无主持人的会签。下图是有主持人的会签：“主持会签”步骤的任务执行人（主持人）可以为“会签”步骤动态指派参与会签的人员，同时主持人也评审会签结果。通过该会签模式可以人工控制需要会签的次数，以及每次参与会签的人员。该会签模式比较简洁，是推荐的常用模式。下图是无主持人的会签模式：无主持人的会签模式，实际上是把会签人员确定和会签评审分
Flowable工作流 实现多实例任务（会签或签）
telescopewang的博客
06-12 5070
Flowable 多实例 会签：${nrOfCompletedInstances==nrOfInstances}或签：${nrOfCompletedInstances>=1}固定集合、变量参数为approverList、approver。
工作流引擎会签，加签，主持人，组长模式专题讲解
slysxy的博客
02-26 1026
第1章: 概要说明 关键字： ccflow 工作流引擎 会签，加签，主持人，多人处理规则 会签定义：会签就是多人在一个节点上表达意见，每个人只能在一个节点上填写一个意见。 我们提供两种模式的会签：协作模式的会签与组长模式的会签，我们要根据不同的应用场景设置会签类型。 协作模式下又分为，协作组员是否可以在找其他人进行协作。 组长会签模式，又分为，单组长模式，多组长模式。 如下图就是会签的设置页面。 ...
activiti 会签
最新发布
07-18
通过Activiti，你可以创建自定义的任务形式，指定参与者的角色，设置截止日期，甚至支持邮件通知提醒参与者处理他们的审批请求。一旦某个会签条件满足，系统会自动将任务推送给下一个审批者，整个过程都在工作流程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值