关于activiti流程通过、驳回、会签、转办、中止、挂起等核心操作功能的封装

http://blog.csdn.net/aochuanguying/article/details/7594197

[java] view plain copy print ?





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;

/**

* 流程操作核心类

* 此核心类主要处理：流程通过、驳回、会签、转办、中止、挂起等核心操作

*

* @author wangfuwei

*

*/

publicclass 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 findBackAvtivity(String taskId) throws Exception {

List rtnList = null ;

if (processOtherService.isJointTask(taskId)) {// 会签任务节点，不允许驳回

rtnList = new ArrayList ();

} else {

rtnList = iteratorBackActivity(taskId, findActivitiImpl(taskId,

null), new ArrayList (),

new ArrayList ());

}

return reverList(rtnList);

}

/**

* 审批通过(驳回直接跳回功能需后续扩展)

*

* @param taskId

* 当前任务ID

* @param variables

* 流程存储参数

* @throws Exception

*/

publicvoid passProcess(String taskId, Map <string, object> variables)

throws Exception {

List 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

*/

publicvoid backProcess(String taskId, String activityId,

Map <string, object> variables) throws Exception {

if (StringUtil.isNull(activityId)) {

thrownew Exception("驳回目标节点ID为空！");

}

// 查询本节点发起的会签任务，并结束

List tasks = taskService.createTaskQuery().parentTaskId(taskId)

.taskDescription("jointProcess").list();

for (Task task : tasks) {

commitProcess(task.getId(), null, null);

}

// 查找所有并行任务节点，同时驳回

List 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

*/

publicvoid callBackProcess(String taskId, String activityId)

throws Exception {

if (StringUtil.isNull(activityId)) {

thrownew Exception("目标节点ID为空！");

}

// 查找所有并行任务节点，同时取回

List taskList = findTaskListByKey(findProcessInstanceByTaskId(

taskId).getId(), findTaskById(taskId).getTaskDefinitionKey());

for (Task task : taskList) {

commitProcess(task.getId(), null, activityId);

}

}

/**

* 中止流程(特权人直接审批通过等)

*

* @param taskId

*/

publicvoid endProcess(String taskId) throws Exception {

ActivityImpl endActivity = findActivitiImpl(taskId, "end");

commitProcess(taskId, null, endActivity.getId());

}

/**

* 会签操作

*

* @param taskId

* 当前任务ID

* @param userCodes

* 会签人账号集合

* @throws Exception

*/

publicvoid jointProcess(String taskId, List 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

*/

publicvoid transferAssignee(String taskId, String userCode) {

taskService.setAssignee(taskId, userCode);

}

/**

* ***************************************************************************************************************************************************

* ************************************************以下为流程会签操作核心逻辑******************************************************************************

* ***************************************************************************************************************************************************

*/

/**

* ***************************************************************************************************************************************************

* ************************************************以上为流程会签操作核心逻辑******************************************************************************

* ***************************************************************************************************************************************************

*/

/**

* ***************************************************************************************************************************************************

* ************************************************以下为流程转向操作核心逻辑******************************************************************************

* ***************************************************************************************************************************************************

*/

/**

* @param taskId

* 当前任务ID

* @param variables

* 流程变量

* @param activityId

* 流程转向执行任务节点ID

* 此参数为空，默认为提交操作

* @throws Exception

*/

privatevoid 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 clearTransition(ActivityImpl activityImpl) {

// 存储当前节点所有流向临时变量

List oriPvmTransitionList = new ArrayList ();

// 获取当前节点所有流向，存储到临时变量，然后清空

List pvmTransitionList = activityImpl

.getOutgoingTransitions();

for (PvmTransition pvmTransition : pvmTransitionList) {

oriPvmTransitionList.add(pvmTransition);

}

pvmTransitionList.clear();

return oriPvmTransitionList;

}

/**

* 还原指定活动节点流向

*

* @param activityImpl

* 活动节点

* @param oriPvmTransitionList

* 原有节点流向集合

*/

privatevoid restoreTransition(ActivityImpl activityImpl,

List oriPvmTransitionList) {

// 清空现有流向

List pvmTransitionList = activityImpl

.getOutgoingTransitions();

pvmTransitionList.clear();

// 还原以前流向

for (PvmTransition pvmTransition : oriPvmTransitionList) {

pvmTransitionList.add(pvmTransition);

}

}

/**

* 流程转向操作

*

* @param taskId

* 当前任务ID

* @param activityId

* 目标节点任务ID

* @param variables

* 流程变量

* @throws Exception

*/

privatevoid turnTransition(String taskId, String activityId,

Map <string, object> variables) throws Exception {

// 当前节点

ActivityImpl currActivity = findActivitiImpl(taskId, null);

// 清空当前流向

List 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);

}

/**

* ***************************************************************************************************************************************************

* ************************************************以上为流程转向操作核心逻辑******************************************************************************

* ***************************************************************************************************************************************************

*/

/**

* ***************************************************************************************************************************************************

* ************************************************以下为查询流程驳回节点核心逻辑***************************************************************************

* ***************************************************************************************************************************************************

*/

/**

* 迭代循环流程树结构，查询当前节点可驳回的任务节点

*

* @param taskId

* 当前任务ID

* @param currActivity

* 当前活动节点

* @param rtnList

* 存储回退节点集合

* @param tempList

* 临时存储节点集合（存储一次迭代过程中的同级userTask节点）

* @return 回退节点集合

*/

private List iteratorBackActivity(String taskId,

ActivityImpl currActivity, List rtnList,

List tempList) throws Exception {

// 查询流程定义，生成流程树结构

ProcessInstance processInstance = findProcessInstanceByTaskId(taskId);

// 当前节点的流入来源

List incomingTransitions = currActivity

.getIncomingTransitions();

// 条件分支节点集合，userTask节点遍历完毕，迭代遍历此集合，查询条件分支对应的userTask节点

List exclusiveGateways = new ArrayList ();

// 并行节点集合，userTask节点遍历完毕，迭代遍历此集合，查询并行节点对应的userTask节点

List parallelGateways = new ArrayList ();

// 遍历当前节点所有流入路径

for (PvmTransition pvmTransition : incomingTransitions) {

TransitionImpl transitionImpl = (TransitionImpl) pvmTransition;

ActivityImpl activityImpl = transitionImpl.getSource();

String type = (String) activityImpl.getProperty("type");

/**

* 并行节点配置要求：

* 必须成对出现，且要求分别配置节点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);

}

} elseif ("startEvent".equals(type)) {// 开始节点，停止递归

return rtnList;

} elseif ("userTask".equals(type)) {// 用户任务

tempList.add(activityImpl);

} elseif ("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 reverList(List list) {

List rtnList = new ArrayList ();

// 由于迭代出现重复数据，排除重复

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 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";

}

}

}

returnnull;

}

/**

* 根据流入任务集合，查询最近一次的流入任务节点

*

* @param processInstance

* 流程实例

* @param tempList

* 流入任务集合

* @return

*/

private ActivityImpl filterNewestActivity(ProcessInstance processInstance,

List 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);

}

returnnull;

}

/**

* 查询指定任务节点的最新记录

*

* @param processInstance

* 流程实例

* @param activityId

* @return

*/

private HistoricActivityInstance findHistoricUserTask(

ProcessInstance processInstance, String activityId) {

HistoricActivityInstance rtnVal = null;

// 查询当前流程实例审批结束的历史节点

List historicActivityInstances = historyService

.createHistoricActivityInstanceQuery().activityType("userTask")

.processInstanceId(processInstance.getId()).activityId(

activityId).finished()

.orderByHistoricActivityInstanceEndTime().desc().list();

if (historicActivityInstances.size() > 0) {

rtnVal = historicActivityInstances.get(0);

}

return rtnVal;

}

/**

* *******************************************************************************************************

* ********************************以上为查询流程驳回节点核心逻辑***********************************************

* ********************************************************************************************************

*/

/**

* ********************************************************************************

* **********************以下为activiti 核心service

* set方法***************************

* *********************************************************************************

*/

publicvoid setFormService(FormService formService) {

this.formService = formService;

}

publicvoid setHistoryService(HistoryService historyService) {

this.historyService = historyService;

}

publicvoid setRepositoryService(RepositoryService repositoryService) {

this.repositoryService = repositoryService;

}

publicvoid setRuntimeService(RuntimeService runtimeService) {

this.runtimeService = runtimeService;

}

publicvoid setTaskService(TaskService taskService) {

this.taskService = taskService;

}

/**

* ********************************************************************************

* **********************以上为activiti 核心service

* set方法***************************

* *********************************************************************************

*/

/**

* ********************************************************************************

* **********************以下为根据 任务节点ID 获取流程各对象查询方法**********************

* *********************************************************************************

*/

publicvoid 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) {

thrownew Exception("任务实例未找到!");

}

return task;

}

/**

* 根据流程实例ID和任务key值查询所有同级任务集合

*

* @param processInstanceId

* @param key

* @return

*/

private List 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) {

thrownew 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) {

thrownew Exception("流程定义未找到!");

}

return processDefinition;

}

/**

* 根据任务ID和节点ID获取活动节点

*

* @param taskId

* 任务ID

* @param activityId

* 活动节点ID

* 如果为null或""，则默认查询当前活动节点

* 如果为"end"，则查询结束节点

*

* @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 pvmTransitionList = activityImpl

.getOutgoingTransitions();

if (pvmTransitionList.isEmpty()) {

return activityImpl;

}

}

}

// 根据节点ID，获取对应的活动节点

ActivityImpl activityImpl = ((ProcessDefinitionImpl) processDefinition)

.findActivity(activityId);

return activityImpl;

}

/**

* ********************************************************************************

* **********************以上为根据 任务节点ID 获取流程各对象查询方法**********************

* *********************************************************************************

*/

}