flowable流程实例管理接口

一、流程实例的管理接口常见功能：
1.启动一个流程（即创建一个流程实例）
2.本人发起的流程实例
3.本人参与的流程实例
4.挂起/激活流程实例
5.提前终止流程实例（或又叫撤销流程）
6.彻底删除流程实例
7.流程图查看
8.判断流程实例的状态(运行中/已结束）

import org.apache.commons.lang3.StringUtils;
import org.flowable.bpmn.model.BpmnModel;
import org.flowable.common.engine.impl.identity.Authentication;
import org.flowable.engine.*;
import org.flowable.engine.history.HistoricProcessInstance;
import org.flowable.engine.repository.Deployment;
import org.flowable.engine.runtime.Execution;
import org.flowable.engine.runtime.ProcessInstance;
import org.flowable.image.ProcessDiagramGenerator;
import org.flowable.task.api.Task;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;

import javax.servlet.http.HttpServletResponse;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class ActivitiUtils {
    private static final Logger logger = LoggerFactory.getLogger(ActivitiUtils.class);

    private ProcessEngine processEngine;
    private RuntimeService runtimeService;
    private TaskService taskService;
    private RepositoryService repositoryService;

    @Autowired
    public ActivitiUtils(ProcessEngine processEngine, RepositoryService repositoryService,RuntimeService runtimeService, TaskService taskService) {
        this.processEngine = processEngine;
        this.repositoryService = repositoryService;
        this.runtimeService = runtimeService;
        this.taskService = taskService;
    }

    /**
     * 启动流程
     *
     * @param processKey 流程定义key
     * @param params
     * @return
     */
    public ProcessInstance startFlow(String processKey, Map<String, Object> params) {
        //启动前必须开启,这样才能取得流程发起人
        String userId = params.get("AuthenticatedUserId").toString();
        //设置流程实例的发起人是当前用户
        Authentication.setAuthenticatedUserId(userId);
        // 取得业务id
        String businessKey = params.get("businessKey").toString();
        if (StringUtils.isEmpty(processKey)) {
            logger.error("错误：流程定义未找到！");
        }
        if (null == params) {
            params = new HashMap<>();
        }
        Deployment deployment = repositoryService.createDeploymentQuery().processDefinitionKey(processKey).singleResult();
        if (deployment == null) {
            logger.error("错误：启动流程实例:" + processKey);
        }
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(processKey, businessKey, params);// 同时设置业务的id到流程实例中的BUSINESS_KEY_
        logger.info("成功：启动流程实例：" + processInstance.getProcessDefinitionName() + ":" + processInstance.getId());
        Authentication.setAuthenticatedUserId(null); // 这个方法最终使用一个ThreadLocal类型的变量进行存储，也就是与当前的线程绑定，所以流程实例启动完毕之后，需要设置为null，防止多线程的时候出问题。
        return processInstance;
    }

    /**
     * 终止流程实例
     *
     * @param processInstanceId
     */
    public void deleteProcessInstanceById(String processInstanceId) {
        // ""这个参数本来可以写删除原因
        runtimeService.deleteProcessInstance(processInstanceId,"");
    }

    /**
     * 我发起的流程实例列表
     *
     * @param userId
     * @return  流程实例列表
     */
    public List<HistoricProcessInstance> getMyStartProcint(String userId) {
        List<HistoricProcessInstance> list = processEngine.getHistoryService()
                .createHistoricProcessInstanceQuery()
                .startedBy(userId)
                .orderByProcessInstanceStartTime()
                .asc()
                .list();
        return list;
    }

    /**
     * 挂起流程实例
     *
     * @param processInstanceId 当前流程实例id
     */
    public void handUpProcessInstance(String processInstanceId) {
        runtimeService.suspendProcessInstanceById(processInstanceId);
    }

    /**
     * 恢复（唤醒）被挂起的流程实例
     *
     * @param processInstanceId  流程实例id
     */
    public void activateProcessInstance(String processInstanceId) {
        runtimeService.activateProcessInstanceById(processInstanceId);
    }

    /**
     * 判断流程实例在运行中存不存在
     *
     * @param processInstanceId  流程实例
     * @return true表示存在,false表示不存在
     */
    public Boolean isExistProcIntRunning(String processInstanceId){
        ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();
        if (processInstance == null) {
            return false;
        } else  {
            return true;
        }
    }

    /**
     * 查询历史实例中流程实例是否存在
     *
     * @param processInstanceId 流程实例
     * @return true表示存在,false表示不存在
     */
    public Boolean isExistProcHistory(String processInstanceId){
        HistoricProcessInstance historicProcessInstance = processEngine.getHistoryService()
                .createHistoricProcessInstanceQuery()
                .processInstanceId(processInstanceId)
                .singleResult();
        if (historicProcessInstance == null) {
            return false;
        } else {
            return true;
        }
    }


    /**
     * 生成流程图
     * 通过传入流程启动id去查询当前流执行节点
     * 返回流程图 到期节点 标红显示
     *
     * @param response
     * @param processId  任务ID
     * @throws Exception
     */
    public void genProcessDiagram(HttpServletResponse response, String processId) throws Exception {
        ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId(processId).singleResult();
        //流程走完的不显示图
        if (processInstance == null) {
            return;
        }
        Task task = taskService.createTaskQuery().processInstanceId(processInstance.getId()).singleResult();
        //使用流程实例ID，查询正在执行的执行对象表，返回流程实例对象
        String processInstanceId = task.getProcessInstanceId();
        List<Execution> executions = runtimeService.createExecutionQuery().processInstanceId(processInstanceId).list();

        //得到正在执行的Activity的Id
        List<String> activityIds = new ArrayList<>();
        List<String> flows = new ArrayList<>();
        for (Execution exe : executions) {
            List<String> activeActivityIds = runtimeService.getActiveActivityIds(exe.getId());
            activityIds.addAll(activeActivityIds);
        }

        //获取流程图
        BpmnModel bpmnModel = repositoryService.getBpmnModel(processInstance.getProcessDefinitionId());
        ProcessEngineConfiguration processEngineConfiguration = processEngine.getProcessEngineConfiguration();
        ProcessDiagramGenerator processDiagramGenerator = processEngineConfiguration.getProcessDiagramGenerator();
        InputStream in = processDiagramGenerator.generateDiagram(bpmnModel, "png", activityIds, flows, processEngineConfiguration.getActivityFontName(), processEngineConfiguration.getLabelFontName(), processEngineConfiguration.getAnnotationFontName(), processEngineConfiguration.getClassLoader(), 1.0, false);
        OutputStream out = null;
        byte[] buf = new byte[1024];
        int legth = 0;
        try {
            out = response.getOutputStream();
            while ((legth = in.read(buf)) != -1) {
                out.write(buf, 0, legth);
            }
        } finally {
            if (in != null) {
                in.close();
            }
            if (out != null) {
                out.close();
            }
        }
    }



}