activiti 选人的实现

最新推荐文章于 2023-02-27 21:10:21 发布
最新推荐文章于 2023-02-27 21:10:21 发布
阅读量759 收藏
点赞数
文章标签： activiti 选人 提交
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/crackajack123/article/details/84490741
版权
activiti默认是不带有选人的功能的，它默认的是在调用complete 方法的时候自动根据下一个节点的 assignee属性或者candidate属性 设置下一节点的候选人或者 assginee。

由于项目的原因我们需要实现在上一个节点提交的时候设置就要从几个候选审批人员中选择一个或者几个审批人员，下面的代码写了个Junit 的demo。 



package test.java.org.activiti.designer.test;

import static org.junit.Assert.*;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.io.FileInputStream;

import org.activiti.bpmn.model.BpmnModel;
import org.activiti.bpmn.model.FlowElement;
import org.activiti.bpmn.model.Process;
import org.activiti.bpmn.model.SequenceFlow;
import org.activiti.engine.IdentityService;
import org.activiti.engine.RepositoryService;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.impl.persistence.entity.TaskEntity;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.activiti.engine.test.ActivitiRule;
import org.junit.Rule;
import org.junit.Test;

public class ProcessTest {

	private String filename = "E:\\workspace4.3\\kft-activiti-demo-no-maven\\resources\\diagrams\\test2.bpmn";

	@Rule
	public ActivitiRule activitiRule = new ActivitiRule();
	static RuntimeService runtimeService;
	static TaskService taskService;
	static IdentityService identityService;

	static RepositoryService repositoryService;


	//流程定义编号
	private String processDefinitionId ;
	//任务编号
	//private String taskId;
	//流程实例号
	private String processInstanceId;
	@Test
	public void mainTest() throws Exception {

		repositoryService = activitiRule.getRepositoryService();	
		runtimeService = activitiRule.getRuntimeService();
		taskService = activitiRule.getTaskService();

		ProcessTest ptm = new ProcessTest();
		//这里有个问题，runtimeService.startProcessInstanceByKey 这个方法直接就把流程流转到任务用户去了，没经过选人的操作
		//这里就变通一下处理，提交到一个无所谓的人，然后在调用方法修改这个人。
		String taskId;
		//返回的usertask的id
		taskId = ptm.startProcess();
		//**********流程启动成功
		//流程在第一个审批人哪里
		//taskId = ptm.getNextNodeId(1,"feng");
		//选人
		List<String> userList= ptm.getNextTaskUserByTaskId(taskId);
		//设置审批人
		ptm.setApproveUser(taskId, "feng");

		taskId = ptm.getNextNodeId(1,"feng");

		//第一个审批人提交流程  feng 为当前节点审批人，xiaozhang 为设置的下一节点审批人
		ptm.completeByAssignee("feng","xiaozhang");
		//************第一个人审批成功



		taskId = ptm.getNextNodeId(1,"xiaozhang");
		//选人
		userList= ptm.getNextTaskUserByTaskId(taskId);
		//第一个审批人提交流程
		ptm.completeByAssignee("xiaozhang","xiaoming");

		ptm.getNextNodeId(1,"xiaoming");

		//第二个审批人提交流程
		ptm.completeByAssignee("xiaoming","xiangwang");
		//************第二个人审批成功


	}
	//启动流程
	public String startProcess() throws Exception {

		repositoryService.createDeployment().addInputStream("test2.bpmn20.xml",new FileInputStream(filename)).deploy();
 		Map<String, Object> variableMap = new HashMap<String, Object>();
		variableMap.put("name", "Activiti");


		//启动流程
		ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("test2", variableMap);

		processDefinitionId = processInstance.getProcessDefinitionId();
		processInstance.getId();
		List<TaskEntity> tList =  ((org.activiti.engine.impl.persistence.entity.ExecutionEntity) processInstance).getTasks();

		this.setProcessInstanceId( processInstance.getId() );

		this.setProcessDefinitionId(processDefinitionId);

		if(tList.size()!=1) {
			System.err.println("start节点的输出路由不能有多个");
		}
		return tList.get(0).getId();

	}

	public void queryProcessInstance() {
		List<ProcessInstance> instanceList = runtimeService
				.createProcessInstanceQuery().processDefinitionKey("test")
				.list();
		//查询 流程实例
		for (ProcessInstance queryProcessInstance : instanceList) {
			queryProcessInstance.getActivityId();

			System.out.print("-----queryProcessInstance:"+queryProcessInstance.getActivityId());

			assertEquals(false, queryProcessInstance.isEnded());
			System.out.println("id " + queryProcessInstance.getId()
					+ ", ended=" + queryProcessInstance.isEnded()+",ProcessDefinitionId="+queryProcessInstance.getProcessDefinitionId());
		}
	}
	//根据assignee来查询用户
	public void queryTask(String assignee) {
		//startProcessInstance();

		// taskService.createTaskQuery().taskCandidateGroup("sales").singleResult();

		Task task= taskService.createTaskQuery().taskAssignee(assignee).singleResult();


		System.out.println("审批人为【"+assignee+"】的任务有：任务编号为【" + task.getId() + "】"+ task.getTaskDefinitionKey());

	}
	/**
	 * 
	 * @param queryType  查询类型1 根据 assignee 查询  2 根据candidateuser查询
	 * @param str
	 */
	public String getNextNodeId(int queryType,String str) {


		Task task = null;
		if(queryType==1) {
			task = taskService.createTaskQuery().taskAssignee(str).singleResult();
		}else if(queryType==2){
			task = taskService.createTaskQuery().taskCandidateUser(str).singleResult();

		}else if(queryType==3){
			task = taskService.createTaskQuery().taskCandidateGroup(str).singleResult();

		}

		List<FlowElement> list = getNextNode(task.getId());


		if(task==null) {
			return null;
		}


		for(FlowElement e :list) {
			//((org.activiti.bpmn.model.UserTask) e)
		}

		return task.getId();

	}
	/**
	 * 获取流程的下一个节点 且要经过规则引擎判断后的节点
	 * @param taskId
	 * @return
	 */
	private List<FlowElement> getNextNode(String taskId) {

		Task task = null;
		task = taskService.createTaskQuery().taskId(taskId).singleResult();
		if(task==null) {
			return null;
		}
		List<FlowElement> list = new ArrayList<FlowElement>();

		ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId(task.getProcessInstanceId()).singleResult();

		//当前活动节点
		String activitiId = processInstance.getActivityId();

		System.out.println("当前节点是【"+activitiId+"】");

		//pmmnModel 遍历节点需要它
    	BpmnModel bpmnModel =  repositoryService.getBpmnModel(task.getProcessDefinitionId());

    	List<Process> processList = bpmnModel.getProcesses();

		//循环多个物理流程
		for(Process process:processList) {

			//返回该流程的所有任务，事件
 			Collection<FlowElement> cColl = process.getFlowElements();
 			//遍历节点
			for(FlowElement f :cColl) {


				//如果改节点是当前节点 者 输出该节点的下一个节点
				if(f.getId().equals(activitiId)) {

					List<SequenceFlow>  sequenceFlowList = new ArrayList<SequenceFlow>();
					//通过反射来判断是哪种类型
					if(f instanceof org.activiti.bpmn.model.StartEvent) {
						//开始事件的输出路由
						sequenceFlowList	= ((org.activiti.bpmn.model.StartEvent) f).getOutgoingFlows();
					}else if(f instanceof org.activiti.bpmn.model.UserTask) {

						sequenceFlowList	= ((org.activiti.bpmn.model.UserTask) f).getOutgoingFlows();


						for(SequenceFlow sf :sequenceFlowList)  {

							String targetRef = sf.getTargetRef();
							FlowElement ref = process.getFlowElement(targetRef);

						//	nextActivitiIdList.add(ref.getId());

							list.add(ref);
						}

					}else if(f instanceof org.activiti.bpmn.model.SequenceFlow) {


					}else if(f instanceof org.activiti.bpmn.model.EndEvent) {
						sequenceFlowList	= ((org.activiti.bpmn.model.EndEvent) f).getOutgoingFlows();
					}
					break;
				} 

			}

		}	
		return list;
	} 
	//流程流转到下一步
	public void completeByAssignee(String assignee,String nextUser) throws Exception {

		HashMap<String,Object> map = new HashMap<String,Object>();

		map.put("nextUser", nextUser);
		Task task = taskService.createTaskQuery().taskAssignee(assignee).singleResult();
		taskService.complete(task.getId(),map);
		System.out.println("完成任务 编号为【" + task.getId() + "】,名称为【"+task.getName()+"】的任务");
	}
	/**
	 * 设置某个节点的审批人员
	 * @param taskId
	 * @param user
	 */
	public void setApproveUser(String taskId,String user) {
		Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
		task.setAssignee(user);
		taskService.saveTask(task);
	}

	/**
	 * 取下一个节点的审批人
	 * @param taskId
	 * @return
	 */
	public List<String> getNextTaskUserByTaskId(String taskId) {
		List<String> list = new ArrayList<String>();

		List<FlowElement> fList = getNextNode(taskId);


		for(FlowElement u:fList){

			String str =  ((org.activiti.bpmn.model.UserTask) u).getAssignee(); 
			list.add(str);
		}
		return list ;
	}

	/**
	 * 找当前节点的候选审批人  供流程实例start后调用
	 * @param taskId
	 * @return
	 */
	public List<String> getThisTaskUser(String taskId) {
		List<String> list = new ArrayList<String>();
		Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
		String taskUser = task.getAssignee();

		//*****************************根据taskUser的配置到自己的表里面去找数据

		list.add(taskUser);
		return list ;
	}
	public String getProcessDefinitionId() {
		return processDefinitionId;
	}

	public void setProcessDefinitionId(String processDefinitionId) {
		this.processDefinitionId = processDefinitionId;
	}

	public String getProcessInstanceId() {
		return processInstanceId;
	}

	public void setProcessInstanceId(String processInstanceId) {
		this.processInstanceId = processInstanceId;
	}
}


另外再绘制流程图的时候除了首节点，其余每个节点要设置listener ，可以设置一个公共的listener 传递不同的参数代码如： 

package org.activiti.ext;


import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.sql.DataSource;

import org.activiti.engine.delegate.DelegateExecution;
import org.activiti.engine.delegate.DelegateTask;
import org.activiti.engine.delegate.ExecutionListener;
import org.activiti.engine.delegate.TaskListener;
import org.apache.ibatis.annotations.Delete;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class TaskUserQuery implements TaskListener{


	  /**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	private static Logger logger = LoggerFactory.getLogger(TaskUserQuery.class);

	protected DataSource dataSource;



	private org.activiti.engine.impl.el.FixedValue orgLevel ;
	private org.activiti.engine.impl.el.FixedValue dutyNo ;
	public DataSource getDataSource() {
		return dataSource;
	}
	public void setDataSource(DataSource dataSource) {
		this.dataSource = dataSource;
	}
	/**
	 * 审批过程中找人的方法
	 * @param str 组名
	 * @return
	 * @throws SQLException
	 */
	public String getTaskUser(String str) throws SQLException {
		logger.debug("-------------------自定义找人----------------------------getTaskUser");

		Connection conn = dataSource.getConnection();

		Statement state = conn.createStatement();
		String queryTaskUserSql = "select id_ from act_id_user aiu where exists (select 1 from act_id_membership aim where aim.user_id_ = aiu.id_ and  aim.group_id_='"+str+"' )";

		ResultSet rs = state.executeQuery(queryTaskUserSql);
		rs.next();
		logger.debug("-------------------自定义找人----------------------------：返回的人是"+rs.getString(1));

		conn.close();
		state.close();
		return rs.getString(1);

	} 

	public List<String> getTaskUserList(String str) throws SQLException {
		logger.debug("-------------------自定义找人----------------------------getTaskUserList");
		List<String> taskUser = new ArrayList<String>();

		Connection conn = dataSource.getConnection();

		Statement state = conn.createStatement();
		String queryTaskUserSql = "select id_ from act_id_user aiu where exists (select 1 from act_id_membership aim where aim.user_id_ = aiu.id_ and  aim.group_id_='"+str+"' )";

		ResultSet rs = state.executeQuery(queryTaskUserSql);
		while(rs.next()) {
			taskUser.add(rs.getString(1));
		}
		logger.debug("------------------- 自定义找人----------------------------：返回的人是"+taskUser.toString());

		conn.close();
		state.close();
		return taskUser;

	} 
	@Override
	public void notify(DelegateTask delegateTask) {


		Map<String,Object> map = delegateTask.getVariables();
		String taskId = delegateTask.getId();

		System.out.println("in taskUserQuer class variable is:"+map.toString());
		System.out.println("in taskUserQuer class taskid is:"+taskId);
		System.out.println("in taskUserQuer class orgLevel is:"+orgLevel.getExpressionText());



		String id = delegateTask.getId();
		String s = delegateTask.getAssignee();
		//根据流程变量的内容设置下一个节点的审批人
		delegateTask.setAssignee(map.get("nextUser").toString());

		Map<String,Object> m1 = delegateTask.getExecution().getVariables();
		Map<String,Object> m2 = delegateTask.getVariablesLocal();



//		logger.debug("-----------------------------------------id is:"+id);
//	//	logger.debug("-----------------------------------------arg is:"+dutyNo.getExpressionText());
//		delegateTask.setAssignee(dutyNo.getExpressionText());

		// TODO Auto-generated method stub
//		logger.debug("----------------------设置选人 开始--------------------------");
//		delegateTask.setAssignee("admin");  
//		logger.debug("----------------------设置选人 结束--------------------------");
	}

}



整个选人过程的其实比较简单 是：提交流程的时候将下一审批人作为流程变量提交到流程引擎，流程引擎会调用如上代码块的notify 方法（当然需要在usertask上配置 配置下图） ，在notify方法内delegateTask.setAssignee设置下一个节点的审批人

[img]http://dl2.iteye.com/upload/attachment/0090/3471/2dd96ad5-41b2-35e9-866a-e4c9fc76456a.jpg[/img]
crackajack123
关注
Activiti选人页面的实现
泽宇的博客
09-11 5666
Activiti会签、选人页面的实现 Activiti 1、背景 Activiti默认是不带有选人的功能的，它默认的是在调用complete方法的时候自动根据下一个节点的 assignee属性设置下一节点的候选人，也可设置candidate属性或者角色，提交到下一步，流程引擎自动解析为公有任务，需要具体执行人去认领。  但是并不是所有的业务逻辑都符合Activit规定的标准情况
Activiti流程设计器实现自定义勾选办理人、候选人、候选组
weixin_33728268的博客
10-18 4469
为什么80%的码农都做不了架构师？>>> ...
activit实现选人效果
07-22
实现了activiti对业务中的人员进行设定
Activiti指定组用户
W_DongQiang的博客
07-26 2781
方式一：定义流程时指定组任务候选人（该方式不够灵活，使用较少） 方式二：使用流程变量指定组任务候选人 流程图代码 &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:xsi="http://www....
activiti 候选人：（候选组）流程设计：
qi95719的博客
03-26 1万+
候选人：可以设置多个执行，但是真正执行的只有1个，只要有人签收之后，其他人的代签收任务将会没有这些任务：即只要有人签收任务，其他人的任务就直接被删除（隐式的删除） 流程设计 人事部审批节点候选人：zzz,xxx 部署流程后：流程定义ID：候选人:1:85004 查询节点执行人(包括候选人和候选组)：act_hi_identitylink 启动流程：      publ
activiti-选择代理人候选人候选组.rar
02-26
activiti-选择代理人候选人候选组。扩展activiti流程设计器，更改人员和角色组的输入为选择方式。可自定义人员和角色数据接口地址，且可分页。使用简单，直接替换两个文件即可
activitiDemo.rar
09-20
** activiti ** 是一个开源的工作流引擎，广泛用于企业应用中的业务流程管理（BPM）。在本示例中，"activitiDemo.rar" 提供了一个...通过学习和实践，你可以掌握如何利用 Activiti 实现灵活、高效的企业业务流程管理。
activiti 动态分配任务候选人
DQchat的博客
08-20 8999
任务候选人是有权限对该任务进行操作的用户， 可以使用TaskService.addCandidateUser() 或 addCandidateGroup()实现， 可以在bpmn中进行配置， 可以使用监听器方式（需要继承TaskListener） 可以使用JUEL表达式实现，使用${}来引用,和EL表达式一样 下面我们使用JUEL表达式实现： 1. 在bpmn中...
activiti获取下一步审批人员及表单信息
bingliang514csdn的博客
02-27 2007
activiti获取下一步审批人员及表单信息
activiti6 根据当前节点获取下一个审批节点
weixin_45818332的博客
12-06 1958
直接上代码废话不多说
ACTIVITI如何获取下一步节点
08-09
NULL 博文链接：https://chun521521.iteye.com/blog/2182997
Activiti流程编辑器针对自定义用户角色表优化改造
weixin_34307464的博客
04-15 984
本文目的： 针对自定义的用户、角色表，对Activiti的在线流程设计器进行优化改造，使之能直接在图形界面上完成对节点办理人、候选人、候选组的配置，不需要先去查数据库中的用户ID、角色ID等信息再填入。 先上一张实现效果图： image.png 1、页面改造 image.png...
Activiti工作流进阶（十二）————工作流提供的用户角色
时光匆匆独白 将颠沛磨成卡带
07-07 4136
工作流提供的用户角色 一、设置用户角色 这个【部门经理】相当于一个用户角色，一个角色可以对应多个人，比如有三个人：张三、李四是部门经理，王五是总经理， 那我们可以把这三个人录入的我们自己的用户表中，那么工作流也给我们提供了至少三张表：用户表，角色表，用户角色关联表 那我们就可以把部门经理这个角色与张三、李四关联起来，那具体怎么做呢？
Acticti工作流(二)：设置审批人的三种方式
热门推荐
changpx
04-25 1万+
1，写死审批人，见上篇文章，Activiti工作流的使用（一） 2，通过el表达式设置，${user} 启动流程实例，并设置第一个节点审批人 @Test public void ActivitiStartInstance(){ //获取RuntimrService 对象 RuntimeService runtimeService = processEngine.getRuntimeService(); //创建流程实例 流程定义的key.
activiti简单的方式设置流程下一个节点的处理人
qq_39830452的博客
06-28 6344
activiti简单粗暴的方式设置流程下一个节点的处理人 activiti 6.0 简单的流程图`` /** * 设置下一个节点的审核人 * @param processId:流程实例ID * @param Assignee:审核人ID * */ public void setFirstTaskAssignee(String processId,String Assignee){ TaskService taskService =
Activiti6修改自定义选择代理人，候选人，候选组（左右结构）
lishangqing的博客
08-06 2646
Activiti6修改自定义选择代理人，候选人，候选组（左右结构）html代码js代码 html代码 <div class="modal" ng-controller="KisBpmAssignmentPopupCtrl"> <div style="width:60%;height:80%;" class="modal-dialog"> <div class="modal-content"> <div class="modal-header"
activiti流程设计器-人员选择
qq_35147356的博客
02-26 461
效果图： 代理人选择 候选人选择： 候选组选择： 下载地址：下载地址 下载后有了两个文件 和 直接替换即可实现 修改url参数可修改人员和角色的数据请求地址 参考
Activiti工作流--组任务分配--之十一
夜空中最亮的星
10-13 1866
将组任务分配给某些人有三个途径 在流程设计当中指定处理任务的某些人 (注意:添加处理人员不是在assignee选项 而是 cadidateUsers) 在流程设计的时候用流程变量的方式指定某些任务处理人,然后在前面的流程处理完的时候用流程变量指定某些具体的人传入到下一个流程 . 在流程设计的时候给流程任务添加一个监听器 ,在业务代码里面指定某些处理人 注意: 查询任务方式的不一样(只能通过...
Activiti工作流(一)：简单使用
changpx
04-19 1094
可以看到填写请假单任务已完成，当前流程进入领导审批节点，完成当前节点任务，该流程结束。将test.bpmn改名test.xml,然后右键选择。将test.xml重新改为test.bpmn。Idea 安装activit插件。根据流程编号KEY_启动流程实例。同样设置领导审批人节点 审批人。生成图片并保存在项目资源路径下。根据任务id完成当前待办任务。设置填写请假单节点审批人。创建test.bpmn。判断当前流程是否已结束。画一个简单的请假流程。
activiti7 实现抄送
最新发布
02-27
在 Activiti 7 中实现抄送功能可以通过以下步骤： 1. 定义流程模型：使用 Activiti 7 的模型设计器创建流程模型，包括任务节点和用户任务节点。 2. 添加抄送人属性：在用户任务节点中添加一个自定义属性，用于指定...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值