实现activiti的回退_徐川江的博客_新浪博客

不使用连线指向回退节点，需求：用户可以选择想要回退的节点。

参见如下代码：

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import org.activiti.engine.ActivitiException;

import org.activiti.engine.HistoryService;

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.ProcessEngineImpl;

import org.activiti.engine.impl.RepositoryServiceImpl;

import org.activiti.engine.impl.db.DbSqlSession;

import org.activiti.engine.impl.db.DbSqlSessionFactory;

import org.activiti.engine.impl.db.ListQueryParameterObject;

import org.activiti.engine.impl.persistence.entity.ExecutionEntity;

import org.activiti.engine.impl.persistence.entity.HistoricTaskInstanceEntity;

import org.activiti.engine.impl.persistence.entity.IdentityLinkEntity;

import org.activiti.engine.impl.persistence.entity.ProcessDefinitionEntity;

import org.activiti.engine.impl.persistence.entity.TaskEntity;

import org.activiti.engine.impl.pvm.process.ActivityImpl;

import org.apache.ibatis.session.SqlSession;

import org.apache.ibatis.session.SqlSessionFactory;

public class DbTaskReturn {  

public static ProcessEngineImpl processEngine = (ProcessEngineImpl)framework.Services.processEngine;

public static RepositoryService repositoryService = framework.Services.repositoryService;

public static TaskService taskService = framework.Services.taskService;

public static HistoryService historyService = framework.Services.historyService;

public static RuntimeService runtimeService = framework.Services.runtimeService;

public static IdentityService identityService = framework.Services.identityService;

    public static final int I_NO_OPERATION = 0;  

  

    public static final int I_DONE = 1;  

  

    public static final int I_TASK_NOT_FOUND = 2;  

  

    public static final int I_ROLLBACK = 3;  

  

   

    public static int dbBackTo(String currentTaskId, String backToTaskId){  

        int result = DbTaskReturn.I_NO_OPERATION;

        //获取selSession

        SqlSession sqlSession = getSqlSession();  

        

        TaskEntity currentTaskEntity = getCurrentTaskEntity(currentTaskId);  

        HistoricTaskInstanceEntity backToHistoricTaskInstanceEntity = getHistoryTaskEntity(backToTaskId);  

        

        if (currentTaskEntity == null || backToHistoricTaskInstanceEntity == null){  

            return DbTaskReturn.I_TASK_NOT_FOUND;  

        }

        //获取当前任务流程定义ID

        String processDefinitionId = currentTaskEntity.getProcessDefinitionId();

        //获取当前任务执行ID

        String executionId = currentTaskEntity.getExecutionId();  

        //获取当前任务实体ID

        String currentTaskEntityId = currentTaskEntity.getId();  

        //获取历史任务实例实体ID

        String backToHistoricTaskInstanceEntityId = backToHistoricTaskInstanceEntity.getId();  

        //获取历史任务定义KEY

        String backToTaskDefinitionKey = backToHistoricTaskInstanceEntity.getTaskDefinitionKey();  

        //获取历史处理人

        String backToAssignee = backToHistoricTaskInstanceEntity.getAssignee();  

        boolean success = false;  

        try{  

            // 1. 第一步 完成历史TASK覆盖当前TASK  

            StepOne_use_hi_taskinst_to_change_ru_task(sqlSession, currentTaskEntity, backToHistoricTaskInstanceEntity);  

            // 2. 修改当前任务参与人列表 

            StepTwo_change_ru_identitylink(sqlSession, currentTaskEntityId, backToHistoricTaskInstanceEntityId,  

                backToAssignee);  

            // 3.修改流程记录节点 把ru_execution的ACT_ID_ 改为hi_taskinst.TASK_DEF_KEY_  

            StepThree_change_ru_execution(sqlSession, executionId, processDefinitionId, backToTaskDefinitionKey);  

            success = true;  

        }  

        catch (Exception e){  

            throw new ActivitiException("dbBackTo Exception", e);  

        }  

        finally{  

            if (success){  

                sqlSession.commit();  

                result = DbTaskReturn.I_DONE;  

            }  

            else{  

                sqlSession.rollback();  

                result = DbTaskReturn.I_ROLLBACK;  

            }  

            sqlSession.close();  

        }  

        return result;  

    }  

  

    private static void StepThree_change_ru_execution(SqlSession sqlSession, String executionId,  

            String processDefinitionId, String backToTaskDefinitionKey) throws Exception{  

        List currentExecutionEntityList = sqlSession.selectList("selectExecution", executionId);  

        if (currentExecutionEntityList.size() > 0){  

            ActivityImpl activity = getActivitiImp(processDefinitionId, backToTaskDefinitionKey);  

            Iterator execution = currentExecutionEntityList.iterator();  

            while (execution.hasNext()){  

                ExecutionEntity e = execution.next();  

                e.setActivity(activity);  

                p(sqlSession.update("updateExecution", e));  

            }  

        }  

    }  

    public static void p(Object o){  

        System.out.println(o);  

    } 

    private static void StepTwo_change_ru_identitylink(SqlSession sqlSession, String currentTaskEntityId,  

            String backToHistoricTaskInstanceEntityId, String backToAssignee) throws Exception{  

        ListQueryParameterObject para = new ListQueryParameterObject();  

        para.setParameter(currentTaskEntityId);  

        List currentTaskIdentityLinkEntityList = sqlSession.selectList("selectIdentityLinksByTask",  

            para);  

        if (currentTaskIdentityLinkEntityList.size() > 0){  

            Iterator identityLinkEntityList = currentTaskIdentityLinkEntityList.iterator();  

            IdentityLinkEntity identityLinkEntity;  

            TaskEntity tmpTaskEntity;  

            tmpTaskEntity = new TaskEntity();  

            tmpTaskEntity.setId(backToHistoricTaskInstanceEntityId);  

            while (identityLinkEntityList.hasNext()){  

                identityLinkEntity = identityLinkEntityList.next();  

                identityLinkEntity.setTask(tmpTaskEntity);  

                identityLinkEntity.setUserId(backToAssignee);  

                Map parameters = new HashMap();  

                parameters.put("id", identityLinkEntity.getId());  

                sqlSession.delete("deleteIdentityLink", parameters);  

                sqlSession.insert("insertIdentityLink", identityLinkEntity);  

            }  

        }  

    }  

  

    private static void StepOne_use_hi_taskinst_to_change_ru_task(SqlSession sqlSession, TaskEntity currentTaskEntity,  

            HistoricTaskInstanceEntity backToHistoricTaskInstanceEntity) throws Exception{  

        sqlSession.delete("deleteTask", currentTaskEntity);  

        currentTaskEntity.setName(backToHistoricTaskInstanceEntity.getName());  

        currentTaskEntity.setTaskDefinitionKey(backToHistoricTaskInstanceEntity.getTaskDefinitionKey());  

        currentTaskEntity.setId(backToHistoricTaskInstanceEntity.getId());  

        sqlSession.insert("insertTask", currentTaskEntity);  

    }  

  

  

    private static ActivityImpl getActivitiImp(String processDefinitionId, String taskDefinitionKey){  

        ProcessDefinitionEntity processDefinition = (ProcessDefinitionEntity) ((RepositoryServiceImpl) repositoryService)  

                .getDeployedProcessDefinition(processDefinitionId);  

        List activitiList = processDefinition.getActivities();  

        boolean b;  

        Object activityId;  

        for (ActivityImpl activity : activitiList){  

            activityId = activity.getId();  

            b = activityId.toString().equals(taskDefinitionKey);  

            if (b){  

                return activity;  

            }  

        }  

        return null;  

    }  

    

   

    private static TaskEntity getCurrentTaskEntity(String currentTaskId){  

        return (TaskEntity) taskService.createTaskQuery().taskId(currentTaskId).singleResult();  

    }  

    

   

    private static HistoricTaskInstanceEntity getHistoryTaskEntity(String backToTaskId){  

        return (HistoricTaskInstanceEntity) historyService.createHistoricTaskInstanceQuery()  

                .taskId(backToTaskId).singleResult();  

    }  

  

   

    private static SqlSession getSqlSession(){  

        DbSqlSessionFactory dbSqlSessionFactory = (DbSqlSessionFactory) processEngine.getProcessEngineConfiguration()  

                .getSessionFactories().get(DbSqlSession.class);  

        SqlSessionFactory sqlSessionFactory = dbSqlSessionFactory.getSqlSessionFactory();  

        return sqlSessionFactory.openSession();  

    }  

}