转：http://blog.csdn.net/rosten/article/details/38300267
package com.famousPro.process.service.impl;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.activiti.engine.FormService;
import org.activiti.engine.HistoryService;
import org.activiti.engine.RepositoryService;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.history.HistoricActivityInstance;
import org.activiti.engine.impl.RepositoryServiceImpl;
import org.activiti.engine.impl.persistence.entity.ProcessDefinitionEntity;
import org.activiti.engine.impl.persistence.entity.TaskEntity;
import org.activiti.engine.impl.pvm.PvmTransition;
import org.activiti.engine.impl.pvm.process.ActivityImpl;
import org.activiti.engine.impl.pvm.process.ProcessDefinitionImpl;
import org.activiti.engine.impl.pvm.process.TransitionImpl;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import com.famousPro.common.service.impl.BaseServiceImp;
import com.famousPro.common.util.IDGenerator;
import com.famousPro.common.util.StringUtil;
import com.famousPro.process.service.ProcessCoreService;
import com.famousPro.process.service.ProcessOtherService;
/**
* 流程操作核心类<br>
* 此核心类主要处理：流程通过、驳回、会签、转办、中止、挂起等核心操作<br>
*
* @author wangfuwei
*
*/
public class ProcessCoreServiceImpl extends BaseServiceImp implements
ProcessCoreService {
protected RepositoryService repositoryService;
protected RuntimeService runtimeService;
protected TaskService taskService;
protected FormService formService;
protected HistoryService historyService;
protected ProcessOtherService processOtherService;
/**
* 根据当前任务ID，查询可以驳回的任务节点
*
* @param taskId
* 当前任务ID
*/
public List<ActivityImpl> findBackAvtivity(String taskId) throws Exception {
List<ActivityImpl> rtnList = null;
if (processOtherService.isJointTask(taskId)) {// 会签任务节点，不允许驳回
rtnList = new ArrayList<ActivityImpl>();
} else {
rtnList = iteratorBackActivity(taskId, findActivitiImpl(taskId,
null), new ArrayList<ActivityImpl>(),
new ArrayList<ActivityImpl>());
}
return reverList(rtnList);
}
/**
* 审批通过(驳回直接跳回功能需后续扩展)
*
* @param taskId
* 当前任务ID
* @param variables
* 流程存储参数
* @throws Exception
*/
public void passProcess(String taskId, Map<String, Object> variables)
throws Exception {
List<Task> tasks = taskService.createTaskQuery().parentTaskId(taskId)
.taskDescription("jointProcess").list();
for (Task task : tasks) {// 级联结束本节点发起的会签任务
commitProcess(task.getId(), null, null);
}
commitProcess(taskId, variables, null);
}
/**
* 驳回流程
*
* @param taskId
* 当前任务ID
* @param activityId
* 驳回节点ID
* @param variables
* 流程存储参数
* @throws Exception
*/
public void backProcess(String taskId, String activityId,
Map<String, Object> variables) throws Exception {
if (StringUtil.isNull(activityId)) {
throw new Exception("驳回目标节点ID为空！");
}
// 查询本节点发起的会签任务，并结束
List<Task> tasks = taskService.createTaskQuery().parentTaskId(taskId)
.taskDescription("jointProcess").list();
for (Task task : tasks) {
commitProcess(task.getId(), null, null);
}
// 查找所有并行任务节点，同时驳回
List<Task> taskList = findTaskListByKey(findProcessInstanceByTaskId(
taskId).getId(), findTaskById(taskId).getTaskDefinitionKey());
for (Task task : taskList) {
commitProcess(task.getId(), variables, activityId);
}
}
/**
* 取回流程
*
* @param taskId
* 当前任务ID
* @param activityId
* 取回节点ID
* @throws Exception
*/
public void callBackProcess(String taskId, String activityId)
throws Exception {
if (StringUtil.isNull(activityId)) {
throw new Exception("目标节点ID为空！");
}
// 查找所有并行任务节点，同时取回
List<Task> taskList = findTaskListByKey(findProcessInstanceByTaskId(
taskId).getId(), findTaskById(taskId).getTaskDefinitionKey());
for (Task task : taskList) {
commitProcess(task.getId(), null, activityId);
}
}
/**
* 中止流程(特权人直接审批通过等)
*
* @param taskId
*/
public void endProcess(String taskId) throws Exception {
ActivityImpl endActivity = findActivitiImpl(taskId, "end");
commitProcess(taskId, null, endActivity.getId());
}
/**
* 会签操作
*
* @param taskId
* 当前任务ID
* @param userCodes
* 会签人账号集合
* @throws Exception
*/
public void jointProcess(String taskId, List<String> userCodes)
throws Exception {
for (String userCode : userCodes) {
TaskEntity task = (TaskEntity) taskService.newTask(IDGenerator
.generateID());
task.setAssignee(userCode);
task.setName(findTaskById(taskId).getName() + "-会签");
task.setProcessDefinitionId(findProcessDefinitionEntityByTaskId(
taskId).getId());
task.setProcessInstanceId(findProcessInstanceByTaskId(taskId)
.getId());
task.setParentTaskId(taskId);
task.setDescription("jointProcess");
taskService.saveTask(task);
}
}
/**
* 转办流程
*
* @param taskId
* 当前任务节点ID
* @param userCode
* 被转办人Code
*/
public void transferAssignee(String taskId, String userCode) {
taskService.setAssignee(taskId, userCode);
}
/**
* ***************************************************************************************************************************************************<br>
* ************************************************以下为流程会签操作核心逻辑******************************************************************************<br>
* ***************************************************************************************************************************************************<br>
*/
/**
* ***************************************************************************************************************************************************<br>
* ************************************************以上为流程会签操作核心逻辑******************************************************************************<br>
* ***************************************************************************************************************************************************<br>
*/
/**
* ***************************************************************************************************************************************************<br>
* ************************************************以下为流程转向操作核心逻辑******************************************************************************<br>
* ***************************************************************************************************************************************************<br>
*/
/**
* @param taskId
* 当前任务ID
* @param variables
* 流程变量
* @param activityId
* 流程转向执行任务节点ID<br>
* 此参数为空，默认为提交操作
* @throws Exception
*/
private void commitProcess(String taskId, Map<String, Object> variables,
String activityId) throws Exception {
if (variables == null) {
variables = new HashMap<String, Object>();
}
// 跳转节点为空，默认提交操作
if (StringUtil.isNull(activityId)) {
taskService.complete(taskId, variables);
} else {// 流程转向操作
turnTransition(taskId, activityId, variables);
}
}
/**
* 清空指定活动节点流向
*
* @param activityImpl
* 活动节点
* @return 节点流向集合
*/
private List<PvmTransition> clearTransition(ActivityImpl activityImpl) {
// 存储当前节点所有流向临时变量
List<PvmTransition> oriPvmTransitionList = new ArrayList<PvmTransition>();
// 获取当前节点所有流向，存储到临时变量，然后清空
List<PvmTransition> pvmTransitionList = activityImpl
.getOutgoingTransitions();
for (PvmTransition pvmTransition : pvmTransitionList) {
oriPvmTransitionList.add(pvmTransition);
}
pvmTransitionList.clear();
return oriPvmTransitionList;
}
/**
* 还原指定活动节点流向
*
* @param activityImpl
* 活动节点
* @param oriPvmTransitionList
* 原有节点流向集合
*/
private void restoreTransition(ActivityImpl activityImpl,
List<PvmTransition> oriPvmTransitionList) {
// 清空现有流向
List<PvmTransition> pvmTransitionList = activityImpl
.getOutgoingTransitions();
pvmTransitionList.clear();
// 还原以前流向
for (PvmTransition pvmTransition : oriPvmTransitionList) {
pvmTransitionList.add(pvmTransition);
}
}
/**
* 流程转向操作
*
* @param taskId
* 当前任务ID
* @param activityId
* 目标节点任务ID
* @param variables
* 流程变量
* @throws Exception
*/
private void turnTransition(String taskId, String activityId,
Map<String, Object> variables) throws Exception {
// 当前节点
ActivityImpl currActivity = findActivitiImpl(taskId, null);
// 清空当前流向
List<PvmTransition> oriPvmTransitionList = clearTransition(currActivity);
// 创建新流向
TransitionImpl newTransition = currActivity.createOutgoingTransition();
// 目标节点
ActivityImpl pointActivity = findActivitiImpl(taskId, activityId);
// 设置新流向的目标节点
newTransition.setDestination(pointActivity);
// 执行转向任务
taskService.complete(taskId, variables);
// 删除目标节点新流入
pointActivity.getIncomingTransitions().remove(newTransition);
// 还原以前流向
restoreTransition(currActivity, oriPvmTransitionList);
}
/**
* ***************************************************************************************************************************************************<br>
* ************************************************以上为流程转向操作核心逻辑******************************************************************************<br>
* ***************************************************************************************************************************************************<br>
*/
/**
* ***************************************************************************************************************************************************<br>
* ************************************************以下为查询流程驳回节点核心逻辑***************************************************************************<br>
* ***************************************************************************************************************************************************<br>
*/
/**
* 迭代循环流程树结构，查询当前节点可驳回的任务节点
*
* @param taskId
* 当前任务ID
* @param currActivity
* 当前活动节点
* @param rtnList
* 存储回退节点集合
* @param tempList
* 临时存储节点集合（存储一次迭代过程中的同级userTask节点）
* @return 回退节点集合
*/
private List<ActivityImpl> iteratorBackActivity(String taskId,
ActivityImpl currActivity, List<ActivityImpl> rtnList,
List<ActivityImpl> tempList) throws Exception {
// 查询流程定义，生成流程树结构
ProcessInstance processInstance = findProcessInstanceByTaskId(taskId);
// 当前节点的流入来源
List<PvmTransition> incomingTransitions = currActivity
.getIncomingTransitions();
// 条件分支节点集合，userTask节点遍历完毕，迭代遍历此集合，查询条件分支对应的userTask节点
List<ActivityImpl> exclusiveGateways = new ArrayList<ActivityImpl>();
// 并行节点集合，userTask节点遍历完毕，迭代遍历此集合，查询并行节点对应的userTask节点
List<ActivityImpl> parallelGateways = new ArrayList<ActivityImpl>();
// 遍历当前节点所有流入路径
for (PvmTransition pvmTransition : incomingTransitions) {
TransitionImpl transitionImpl = (TransitionImpl) pvmTransition;
ActivityImpl activityImpl = transitionImpl.getSource();
String type = (String) activityImpl.getProperty("type");
/**
* 并行节点配置要求：<br>
* 必须成对出现，且要求分别配置节点ID为:XXX_start(开始)，XXX_end(结束)
*/
if ("parallelGateway".equals(type)) {// 并行路线
String gatewayId = activityImpl.getId();
String gatewayType = gatewayId.substring(gatewayId
.lastIndexOf("_") + 1);
if ("START".equals(gatewayType.toUpperCase())) {// 并行起点，停止递归
return rtnList;
} else {// 并行终点，临时存储此节点，本次循环结束，迭代集合，查询对应的userTask节点
parallelGateways.add(activityImpl);
}
} else if ("startEvent".equals(type)) {// 开始节点，停止递归
return rtnList;
} else if ("userTask".equals(type)) {// 用户任务
tempList.add(activityImpl);
} else if ("exclusiveGateway".equals(type)) {// 分支路线，临时存储此节点，本次循环结束，迭代集合，查询对应的userTask节点
currActivity = transitionImpl.getSource();
exclusiveGateways.add(currActivity);
}
}
/**
* 迭代条件分支集合，查询对应的userTask节点
*/
for (ActivityImpl activityImpl : exclusiveGateways) {
iteratorBackActivity(taskId, activityImpl, rtnList, tempList);
}
/**
* 迭代并行集合，查询对应的userTask节点
*/
for (ActivityImpl activityImpl : parallelGateways) {
iteratorBackActivity(taskId, activityImpl, rtnList, tempList);
}
/**
* 根据同级userTask集合，过滤最近发生的节点
*/
currActivity = filterNewestActivity(processInstance, tempList);
if (currActivity != null) {
// 查询当前节点的流向是否为并行终点，并获取并行起点ID
String id = findParallelGatewayId(currActivity);
if (StringUtil.isNull(id)) {// 并行起点ID为空，此节点流向不是并行终点，符合驳回条件，存储此节点
rtnList.add(currActivity);
} else {// 根据并行起点ID查询当前节点，然后迭代查询其对应的userTask任务节点
currActivity = findActivitiImpl(taskId, id);
}
// 清空本次迭代临时集合
tempList.clear();
// 执行下次迭代
iteratorBackActivity(taskId, currActivity, rtnList, tempList);
}
return rtnList;
}
/**
* 反向排序list集合，便于驳回节点按顺序显示
*
* @param list
* @return
*/
private List<ActivityImpl> reverList(List<ActivityImpl> list) {
List<ActivityImpl> rtnList = new ArrayList<ActivityImpl>();
// 由于迭代出现重复数据，排除重复
for (int i = list.size(); i > 0; i--) {
if (!rtnList.contains(list.get(i - 1)))
rtnList.add(list.get(i - 1));
}
return rtnList;
}
/**
* 根据当前节点，查询输出流向是否为并行终点，如果为并行终点，则拼装对应的并行起点ID
*
* @param activityImpl
* 当前节点
* @return
*/
private String findParallelGatewayId(ActivityImpl activityImpl) {
List<PvmTransition> incomingTransitions = activityImpl
.getOutgoingTransitions();
for (PvmTransition pvmTransition : incomingTransitions) {
TransitionImpl transitionImpl = (TransitionImpl) pvmTransition;
activityImpl = transitionImpl.getDestination();
String type = (String) activityImpl.getProperty("type");
if ("parallelGateway".equals(type)) {// 并行路线
String gatewayId = activityImpl.getId();
String gatewayType = gatewayId.substring(gatewayId
.lastIndexOf("_") + 1);
if ("END".equals(gatewayType.toUpperCase())) {
return gatewayId.substring(0, gatewayId.lastIndexOf("_"))
+ "_start";
}
}
}
return null;
}
/**
* 根据流入任务集合，查询最近一次的流入任务节点
*
* @param processInstance
* 流程实例
* @param tempList
* 流入任务集合
* @return
*/
private ActivityImpl filterNewestActivity(ProcessInstance processInstance,
List<ActivityImpl> tempList) {
while (tempList.size() > 0) {
ActivityImpl activity_1 = tempList.get(0);
HistoricActivityInstance activityInstance_1 = findHistoricUserTask(
processInstance, activity_1.getId());
if (activityInstance_1 == null) {
tempList.remove(activity_1);
continue;
}
if (tempList.size() > 1) {
ActivityImpl activity_2 = tempList.get(1);
HistoricActivityInstance activityInstance_2 = findHistoricUserTask(
processInstance, activity_2.getId());
if (activityInstance_2 == null) {
tempList.remove(activity_2);
continue;
}
if (activityInstance_1.getEndTime().before(
activityInstance_2.getEndTime())) {
tempList.remove(activity_1);
} else {
tempList.remove(activity_2);
}
} else {
break;
}
}
if (tempList.size() > 0) {
return tempList.get(0);
}
return null;
}
/**
* 查询指定任务节点的最新记录
*
* @param processInstance
* 流程实例
* @param activityId
* @return
*/
private HistoricActivityInstance findHistoricUserTask(
ProcessInstance processInstance, String activityId) {
HistoricActivityInstance rtnVal = null;
// 查询当前流程实例审批结束的历史节点
List<HistoricActivityInstance> historicActivityInstances = historyService
.createHistoricActivityInstanceQuery().activityType("userTask")
.processInstanceId(processInstance.getId()).activityId(
activityId).finished()
.orderByHistoricActivityInstanceEndTime().desc().list();
if (historicActivityInstances.size() > 0) {
rtnVal = historicActivityInstances.get(0);
}
return rtnVal;
}
/**
* *******************************************************************************************************<br>
* ********************************以上为查询流程驳回节点核心逻辑***********************************************<br>
* ********************************************************************************************************<br>
*/
/**
* ********************************************************************************<br>
* **********************以下为activiti 核心service
* set方法***************************<br>
* *********************************************************************************<br>
*/
public void setFormService(FormService formService) {
this.formService = formService;
}
public void setHistoryService(HistoryService historyService) {
this.historyService = historyService;
}
public void setRepositoryService(RepositoryService repositoryService) {
this.repositoryService = repositoryService;
}
public void setRuntimeService(RuntimeService runtimeService) {
this.runtimeService = runtimeService;
}
public void setTaskService(TaskService taskService) {
this.taskService = taskService;
}
/**
* ********************************************************************************<br>
* **********************以上为activiti 核心service
* set方法***************************<br>
* *********************************************************************************<br>
*/
/**
* ********************************************************************************<br>
* **********************以下为根据 任务节点ID 获取流程各对象查询方法**********************<br>
* *********************************************************************************<br>
*/
public void setProcessOtherService(ProcessOtherService processOtherService) {
this.processOtherService = processOtherService;
}
/**
* 根据任务ID获得任务实例
*
* @param taskId
* 任务ID
* @return
* @throws Exception
*/
private TaskEntity findTaskById(String taskId) throws Exception {
TaskEntity task = (TaskEntity) taskService.createTaskQuery().taskId(
taskId).singleResult();
if (task == null) {
throw new Exception("任务实例未找到!");
}
return task;
}
/**
* 根据流程实例ID和任务key值查询所有同级任务集合
*
* @param processInstanceId
* @param key
* @return
*/
private List<Task> findTaskListByKey(String processInstanceId, String key) {
return taskService.createTaskQuery().processInstanceId(
processInstanceId).taskDefinitionKey(key).list();
}
/**
* 根据任务ID获取对应的流程实例
*
* @param taskId
* 任务ID
* @return
* @throws Exception
*/
private ProcessInstance findProcessInstanceByTaskId(String taskId)
throws Exception {
// 找到流程实例
ProcessInstance processInstance = runtimeService
.createProcessInstanceQuery().processInstanceId(
findTaskById(taskId).getProcessInstanceId())
.singleResult();
if (processInstance == null) {
throw new Exception("流程实例未找到!");
}
return processInstance;
}
/**
* 根据任务ID获取流程定义
*
* @param taskId
* 任务ID
* @return
* @throws Exception
*/
private ProcessDefinitionEntity findProcessDefinitionEntityByTaskId(
String taskId) throws Exception {
// 取得流程定义
ProcessDefinitionEntity processDefinition = (ProcessDefinitionEntity) ((RepositoryServiceImpl) repositoryService)
.getDeployedProcessDefinition(findTaskById(taskId)
.getProcessDefinitionId());
if (processDefinition == null) {
throw new Exception("流程定义未找到!");
}
return processDefinition;
}
/**
* 根据任务ID和节点ID获取活动节点 <br>
*
* @param taskId
* 任务ID
* @param activityId
* 活动节点ID <br>
* 如果为null或""，则默认查询当前活动节点 <br>
* 如果为"end"，则查询结束节点 <br>
*
* @return
* @throws Exception
*/
private ActivityImpl findActivitiImpl(String taskId, String activityId)
throws Exception {
// 取得流程定义
ProcessDefinitionEntity processDefinition = findProcessDefinitionEntityByTaskId(taskId);
// 获取当前活动节点ID
if (StringUtil.isNull(activityId)) {
activityId = findTaskById(taskId).getTaskDefinitionKey();
}
// 根据流程定义，获取该流程实例的结束节点
if (activityId.toUpperCase().equals("END")) {
for (ActivityImpl activityImpl : processDefinition.getActivities()) {
List<PvmTransition> pvmTransitionList = activityImpl
.getOutgoingTransitions();
if (pvmTransitionList.isEmpty()) {
return activityImpl;
}
}
}
// 根据节点ID，获取对应的活动节点
ActivityImpl activityImpl = ((ProcessDefinitionImpl) processDefinition)
.findActivity(activityId);
return activityImpl;
}
/**
* ********************************************************************************<br>
* **********************以上为根据 任务节点ID 获取流程各对象查询方法**********************<br>
* *********************************************************************************<br>
*/
}
相关推荐
总的来说，实现Activiti-5.4中的会签功能涉及到流程设计、配置、监听器使用以及代码实现等多个方面。通过理解和掌握这些知识点，你可以灵活地构建适应各种业务场景的并发签名流程，提高企业的协作效率。
这种方式使得流程可以根据业务需求灵活扩展，而无需修改核心流程逻辑。 5. **流程图**： `voterProcess.png` 文件是流程图，显示了整个会签投票过程的可视化表示。通过此图，可以清晰地看到各个步骤、会签任务的...
流程发布后，你可以通过Activiti提供的管理界面或API进行监控和控制，包括查看流程实例、跟踪流程执行路径、干预正在进行的任务等。此外，还可以对已发布的流程进行升级或回滚，以适应业务变化。 ### 6. 源码分析 ...
总结来说，"Activiti多实例任务实现会签"是通过Activiti引擎和BPMN 2.0的多实例任务特性，构建出一个需要多人同时审批的业务流程，以满足企业中的并行决策需求。开发者需要了解BPMN 2.0的语法，以及如何利用Activiti...
5.9 版本是 Activiti 的一个重要里程碑，它包含了一系列改进和增强，旨在提供更稳定、高效和易用的流程管理体验。 首先，我们要了解 Activiti 的核心概念。Activiti 是基于 BPMN 2.0（Business Process Model and ...
在用activiti的时候经常遇到取会签人员的问题，这个文档解决怎么获取会签人员。
【标题】"activiti5.9 请假流程例子 eclipse项目" 在企业级应用开发中，工作流管理系统（Workflow Management System）扮演着至关重要的角色，它能够自动化和管理业务流程，提高工作效率。Activiti 是一个开源的...
Activiti6-流程跟踪监控图-节点-流程线高亮显示-支持通过、不通过、驳回、退回 支持内容： 已完成节点高亮显示、当前执行中节点红色显示 支持一个节点多条流出线，包括通过、不通过、驳回、退回，按照已执行操作正确...
标题中的“activiti5.9的编辑组件activiti-modeler”指的是Activiti工作流引擎的一个重要组成部分——Activiti Modeler。Activiti是一个开源的业务流程管理（BPM）和工作流系统，它允许开发者和业务分析师创建、部署...
这个"activiti流程图查看demo"是一个示例项目，旨在帮助用户理解如何在Activiti中查看和操作流程图。在本篇文章中，我们将深入探讨Activiti的核心概念、流程图的查看方法以及如何利用diagram-viewer工具来实现这一...
### Activiti 5.9 PostgreSQL 安装指南详解 #### 一、概述 Activiti是一款开源的工作流引擎，用于快速开发业务流程应用。其官方提供的示例通常基于H2数据库，但对于生产环境或特定需求场景，用户可能更倾向于使用...
这个简单的Activiti请假流程项目是一个基础的实践，可以帮助开发者了解Activiti的核心概念和基本操作。通过实践，可以深入理解如何使用Activiti构建和管理业务流程，并为进一步的复杂流程设计和优化打下基础。
在IT行业中，Activiti是一个非常流行的开源工作流引擎，它被广泛用于企业级应用中来管理业务流程。本文将深入探讨如何在Activiti 6.0版本中实现流程图片的自定义颜色功能，以增强流程图的可读性和美观性。 首先，...
忙活了一个星期左右，查找各种资料，终于将Activiti的流程设计器分离出来，与SpringMVC,spring整合了起来，先把工程分享出来，等有时间了在慢慢讲解具体的整合步骤。工程下载之后直接可以运行，只需要改一下数据库...
在本案例中，我们聚焦于"activiti5.9 表创建"，这涉及到在Activiti 5.9版本中如何创建和管理数据库表，以及如何进行相关的操作如删除和升级。 首先，让我们深入理解"create"。在Activiti中，当你首次部署或安装时，...
Activiti5.9 API.chm
流程跟踪任务节点和线高亮显示是Activiti流程跟踪功能的重要组成部分，能够标记流程所走过的节点和线为红色，未走过的节点和线不标记，支持驳回和子流程。 Activiti流程跟踪任务节点和线高亮显示的实现原理是基于...
总之，Activiti流程图的部署和操作涉及到流程定义的生命周期管理，包括创建、部署、查询和更新等步骤。正确地部署和操作流程图能够确保业务流程在系统中按照预期执行，从而提升企业的运营效率和自动化水平。熟悉并...
1. **BPMN 2.0支持**：Activiti 5.9全面支持BPMN 2.0标准，这意味着你可以利用各种流程元素，如用户任务、服务任务、并发分支、事件、网关等，构建复杂的工作流程。BPMN 2.0的标准化使得流程定义可以在不同工具和...