Activiti6.0版本流程撤回、跳转、回退等操作

package com.sn.cloud.activiti6.controller;

import java.math.BigDecimal;
import java.util.HashMap;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.activiti.bpmn.model.FlowNode;
import org.activiti.engine.ManagementService;
import org.activiti.engine.RepositoryService;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.task.Task;
import org.apache.commons.lang.StringUtils;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;

import com.google.gson.Gson;
import com.sn.cloud.aa.user.User;
import com.sn.cloud.ac.taskinfo.TaskInfo;
import com.sn.cloud.ac.taskinfo.TaskStatus;
import com.sn.cloud.activiti6.cmd.DeleteTaskCmd;
import com.sn.cloud.activiti6.cmd.SetFLowNodeAndGoCmd;
import com.sn.cloud.bill.dto.BillDataDto;
import com.sn.cloud.core.AppContext;
import com.sn.cloud.dao.sql.SqlHelper;
import com.sn.cloud.util.ResultMessage;

@Controller
@RequestMapping("/activiti")
public class ActivitiWithdrawController extends ActivitiController {

	/**
	 * 撤回审批信息
	 * 
	 * @param bill
	 * @param request
	 * @param response
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	@RequestMapping("/withdraw")
	public void jump(@RequestBody BillDataDto bill, HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		User user = AppContext.getCurrentUser();
		String data = bill.getData();
		Gson gson = new Gson();
		Map<String, Object> map = new HashMap<String, Object>();
		map = gson.fromJson(data, map.getClass());
		String businesskey = map.get("id").toString();
		try {
			BigDecimal bd = new BigDecimal((double) map.get("id"));
			businesskey = bd.toPlainString();
		} catch (Exception e) {
		}
		Task task = getTask(businesskey);
		String startuser = SqlHelper.selectOne("slactstartuser", businesskey);
		if (startuser.equals(user.getId().toString())) {
			deleteactiviti(businesskey);
			Map<String, Object> paramMap = new HashMap<String, Object>();
			paramMap.put("billnum", bill.getBillnum());
			paramMap.put("id", businesskey);
			RuntimeService runtimeService = processEngine.getRuntimeService();
			// 删除流程
			runtimeService.deleteProcessInstance(task.getProcessInstanceId(),
					"撤回删除");
			SqlHelper.delete("deletetaskinfo", paramMap);
			renderJson(response, ResultMessage.success());
		} else {
			// 获取目标节点定义
			String taskDefKey = null;
			map = new HashMap<String, Object>();
			map.put("businesskey", businesskey);
			map.put("assignee", user.getId());
			try {
				taskDefKey = SqlHelper.selectFirst("selecttaskkey", map);
			} catch (Exception e) {
				e.printStackTrace();
			}
			if (StringUtils.isNotBlank(taskDefKey)) {
				String taskId = task.getId();
				RepositoryService repositoryService = processEngine
						.getRepositoryService();
				// 当前任务
				TaskService taskService = processEngine.getTaskService();
				ManagementService managementService = processEngine
						.getManagementService();
				Task currentTask = taskService.createTaskQuery().taskId(taskId)
						.singleResult();
				// 获取流程定义
				org.activiti.bpmn.model.Process process = repositoryService
						.getBpmnModel(currentTask.getProcessDefinitionId())
						.getMainProcess();
				FlowNode targetNode = (FlowNode) process
						.getFlowElement(taskDefKey);
				// 删除当前运行任务
				String executionEntityId = managementService
						.executeCommand(new DeleteTaskCmd(currentTask.getId()));
				// 流程执行到来源节点
				managementService.executeCommand(new SetFLowNodeAndGoCmd(
						targetNode, executionEntityId));
				TaskInfo total = new TaskInfo();
				total.setBilltype(bill.getBillnum());
				total.setTaskstatus(TaskStatus.withdraw);
				total.setBusinessKey(businesskey);
				activitimessage(null, total, task);
				renderJson(response, ResultMessage.success());
			} else {
				renderJson(response, ResultMessage.error("当前流程节点为空，请检查."));
			}
		}
	}
}
------------------
//删除当前运行时任务命令，并返回当前任务的执行对象id
//这里继承了NeedsActiveTaskCmd，主要时很多跳转业务场景下，要求不能时挂起任务。可以直接继承Command即可
package com.sn.cloud.activiti6.cmd;

import org.activiti.engine.impl.cmd.NeedsActiveTaskCmd;
import org.activiti.engine.impl.interceptor.CommandContext;
import org.activiti.engine.impl.persistence.entity.ExecutionEntity;
import org.activiti.engine.impl.persistence.entity.TaskEntity;
import org.activiti.engine.impl.persistence.entity.TaskEntityManagerImpl;


@SuppressWarnings("serial")
public class DeleteTaskCmd extends NeedsActiveTaskCmd<String> {
    public DeleteTaskCmd(String taskId){
        super(taskId);
    }
    public String execute(CommandContext commandContext, TaskEntity currentTask){
        //获取所需服务
        TaskEntityManagerImpl taskEntityManager = (TaskEntityManagerImpl)commandContext.getTaskEntityManager();
        //获取当前任务的来源任务及来源节点信息
        ExecutionEntity executionEntity = currentTask.getExecution();
        //删除当前任务,来源任务
        taskEntityManager.deleteTask(currentTask, "撤回审批", false, false);
        return executionEntity.getId();
    }
    public String getSuspendedTaskException() {
        return "挂起的任务不能跳转";
    }
}

------------------
//根据提供节点和执行对象id，进行跳转命令
package com.sn.cloud.activiti6.cmd;

import java.util.List;

import org.activiti.bpmn.model.FlowNode;
import org.activiti.bpmn.model.SequenceFlow;
import org.activiti.engine.ActivitiException;
import org.activiti.engine.impl.interceptor.Command;
import org.activiti.engine.impl.interceptor.CommandContext;
import org.activiti.engine.impl.persistence.entity.ExecutionEntity;


//根据提供节点和执行对象id，进行跳转命令
	public class SetFLowNodeAndGoCmd implements Command<Void> {
		private FlowNode flowElement;
		private String executionId;

		public SetFLowNodeAndGoCmd(FlowNode flowElement, String executionId) {
			this.flowElement = flowElement;
			this.executionId = executionId;
		}

		public Void execute(CommandContext commandContext) {
			// 获取目标节点的来源连线
			List<SequenceFlow> flows = flowElement.getIncomingFlows();
			if (flows == null || flows.size() < 1) {
				throw new ActivitiException("回退错误，目标节点没有来源连线");
			}
			// 随便选一条连线来执行，当前执行计划为，从连线流转到目标节点，实现跳转
			ExecutionEntity executionEntity = commandContext
					.getExecutionEntityManager().findById(executionId);
			executionEntity.setCurrentFlowElement(flows.get(0));
			commandContext.getAgenda().planTakeOutgoingSequenceFlowsOperation(
					executionEntity, true);
			return null;
		}
	}

这段代码参照了这篇文章,点击打开链接，选的是第三个方法，但是实际操作中发现了一些问题，所以做了些修改在此留下笔记为以后做参考