Spring管理流程部署——Activiti


pom.xml

 <!-- activit jar 包 -->
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-engine</artifactId>
            <version>5.19.0.2</version>
        </dependency>

        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-spring</artifactId>
            <version>5.19.0.2</version>
        </dependency>

        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-bpmn-model</artifactId>
            <version>5.19.0.2</version>
        </dependency>
        <!-- spring整合activiti插件 -->
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-spring</artifactId>
            <version>5.19.0.3</version>
        </dependency>

 

----------

 

spring 管理activiti

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"     
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
                        http://www.springframework.org/schema/beans/spring-beans.xsd 
                        http://www.springframework.org/schema/aop 
                        http://www.springframework.org/schema/aop/spring-aop-4.1.xsd 
                        http://www.springframework.org/schema/beans/spring-beans-4.1.xsd 
                        http://www.springframework.org/schema/context 
                        http://www.springframework.org/schema/context/spring-context-4.1.xsd 
                        http://www.springframework.org/schema/tx 
                        http://www.springframework.org/schema/tx/spring-tx-4.1.xsd">
    
    <bean id="processEngineConfiguration" class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
    
        <!-- 連接數據庫的配置 -->        
        <property name="jdbcDriver" value="oracle.jdbc.driver.OracleDriver"></property>
        <property name="jdbcUrl" value="jdbc:oracle:thin:@10.2.13.100:1521:orcl"></property>
        <property name="jdbcUsername" value="cyqq"></property>
        <property name="jdbcPassword" value="1"></property>
        
        <!-- 沒有表創建表 -->
        <property name="databaseSchemaUpdate" value="true"></property>
    </bean>
                  
    <!-- 創建流程引擎對象 -->
    <bean id="processEngine" class="org.activiti.spring.ProcessEngineFactoryBean">
        <property name="processEngineConfiguration" ref="processEngineConfiguration" />
    </bean>
    
    <!-- 由流程引擎對象,提供的方法,創建項目中使用的Activiti工作流的Service -->
     <bean id="repositoryService" factory-bean="processEngine" factory-method="getRepositoryService" />
    <bean id="runtimeService" factory-bean="processEngine" factory-method="getRuntimeService" />
    <bean id="taskService" factory-bean="processEngine" factory-method="getTaskService" />
    <bean id="historyService" factory-bean="processEngine" factory-method="getHistoryService" />
    <bean id="formService" factory-bean="processEngine" factory-method="getFormService" /> 
    
        <!-- 將Activiti工作流的Service注入WrokflowService中 -->
    <bean id="changeWorkflowService" class="com.chen.workflowservice.impl.ChangeWorkFlowService">
        <property name="repositoryService" ref="repositoryService"></property>
        <property name="runtimeService" ref="runtimeService"></property>
        <property name="taskService" ref="taskService"></property>
        <property name="formService" ref="formService"></property>
        <property name="historyService" ref="historyService"></property>
    </bean>
</beans>

 

ChangeWorkFlowService

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.zip.ZipInputStream;

import javax.servlet.http.HttpServletResponse;

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.history.HistoricProcessInstance;
import org.activiti.engine.history.HistoricTaskInstance;
import org.activiti.engine.impl.RepositoryServiceImpl;
import org.activiti.engine.impl.bpmn.behavior.UserTaskActivityBehavior;
import org.activiti.engine.impl.persistence.entity.ExecutionEntity;
import org.activiti.engine.impl.persistence.entity.ProcessDefinitionEntity;
import org.activiti.engine.impl.pvm.PvmActivity;
import org.activiti.engine.impl.pvm.PvmTransition;
import org.activiti.engine.impl.pvm.process.ActivityImpl;
import org.activiti.engine.impl.task.TaskDefinition;
import org.activiti.engine.repository.Deployment;
import org.activiti.engine.repository.ProcessDefinition;
import org.activiti.engine.runtime.Execution;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;

import com.jfinal.plugin.activerecord.Db;
import com.jfinal.plugin.activerecord.Page;
import com.jfinal.plugin.activerecord.Record;
import com.tcinc.cyqq.model.other.TP_BUSINESS;
import com.tcinc.cyqq.workflowservice.IWorkflowService;

public class ChangeWorkFlowService implements IWorkflowService {
    /** 創建工作流Service */
    public RepositoryService repositoryService;// 流程定義
    public RuntimeService runtimeService;// 運行時
    public TaskService taskService;// 任務
    public FormService formService;// 任務表單
    public 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;
    }

    public void setFormService(FormService formService) {
        this.formService = formService;
    }

    public void setHistoryService(HistoryService historyService) {
        this.historyService = historyService;
    }
    
    /*-------------------------------------方法實現------------------------------------*/
    
    /*----------------------------------------- 接口實現 ----------------------------------------*/

    @Override
    public void deploy(String deployBpmn, String deployPng, String deployName) {
        try {
            repositoryService.createDeployment()
                    // 創建部署對象
                    .name(deployName).addClasspathResource(deployBpmn)
                    .addClasspathResource(deployPng).deploy();// 完成部署
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    @Override
    public void deploy(File file, String deployName) {
        try {
            ZipInputStream zipInputStream = new ZipInputStream(
                    new FileInputStream(file));
            repositoryService.createDeployment().name(deployName)
                    .addZipInputStream(zipInputStream).deploy();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    @Override
    public void delDeployGeneral(String deployId) {
        try {
            // 普通刪除,如果當前規則下有正在執行的流程,則拋異常
            repositoryService.deleteDeployment(deployId);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    @Override
    public void delDeployCascade(String deployId) {
        try {
            // 級聯刪除,會刪除和當前規則相關的所有信息,包括歷史
            repositoryService.deleteDeployment(deployId, true);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    @Override
    public List<Deployment> findDeploymentList() {
        List<Deployment> list = null;
        try {
            list = repositoryService.createDeploymentQuery()
                    .orderByDeploymenTime().asc().list();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return list;
    }

    @Override
    public List<Deployment> findDeploymentList(String deployName) {
        List<Deployment> list = null;
        try {
            list = repositoryService.createDeploymentQuery()
                    .deploymentName(deployName).orderByDeploymenTime().asc()
                    .list();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return list;
    }

    @Override
    public Deployment findDeployment(String deployName) {
        Deployment deployment = null;
        try {
            deployment = repositoryService.createDeploymentQuery()
                    .deploymentName(deployName).orderByDeploymenTime().desc()
                    .singleResult();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return deployment;
    }

    @Override
    public List<ProcessDefinition> findProcessDefinitionList() {
        List<ProcessDefinition> list = null;
        try {
            list = repositoryService.createProcessDefinitionQuery()
                    .orderByProcessDefinitionVersion().asc().list();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return list;
    }

    @Override
    public ProcessDefinition findProcessDefinition(String deployId) {
        ProcessDefinition processDefinition = null;
        try {
            processDefinition = repositoryService
                    .createProcessDefinitionQuery().deploymentId(deployId)
                    .orderByProcessDefinitionVersion().desc().singleResult();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return processDefinition;
    }

    @Override
    public String findProcessKey(String deployName) {
        Deployment deployment = findDeployment(deployName);
        ProcessDefinition pd = findProcessDefinition(deployment.getId());

        return pd.getKey();
    }

    @Override
    public ActivityImpl findTaskNode(String processInstanceId) {
        ExecutionEntity execution = null;
        ProcessDefinitionEntity processDefinitionEntity = null;
        ActivityImpl activity = null;
        try {
            // 獲取流程發布Id信息
            String definitionId = getDefinitionId(processInstanceId);

            processDefinitionEntity = getProcessDefinitionEntity(definitionId);

            execution = getExecutionEntity(processInstanceId);

            // 獲取流程所有節點信息
            List<ActivityImpl> activitiList = processDefinitionEntity
                    .getActivities();

            // 遍歷所有節點信息
            for (ActivityImpl activityImpl : activitiList) {
                // 找到當前節點信息
                if (execution.getActivityId().equals(activityImpl.getId())) {
                    activity = activityImpl;
                }
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return activity;
    }

    @Override
    public ProcessDefinition findProcessDefinitionByPid(String processInstanceId) {
        ProcessDefinitionEntity processDefinitionEntity = null;
        ProcessDefinition processDefinition = null;
        try {
            // 獲取流程發布Id信息
            String definitionId = getDefinitionId(processInstanceId);

            processDefinitionEntity = getProcessDefinitionEntity(definitionId);

            String deploymentId = processDefinitionEntity.getDeploymentId();

            processDefinition = getProcessDefinition(deploymentId);

        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return processDefinition;
    }

    @Override
    public ProcessDefinition findProcessDefinitionByHistory(
            String processInstanceId) {
        ProcessDefinitionEntity processDefinitionEntity = null;
        ProcessDefinition processDefinition = null;
        try {
            // 獲取流程發布Id信息
            String definitionId = getDefinitionIdByHistory(processInstanceId);

            processDefinitionEntity = getProcessDefinitionEntity(definitionId);

            String deploymentId = processDefinitionEntity.getDeploymentId();

            processDefinition = getProcessDefinition(deploymentId);

        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return processDefinition;
    }

    @Override
    public List<Task> findTaskListByRole(String roleId) {
        List<Task> list = taskService.createTaskQuery()
                .taskCandidateUser(roleId).orderByTaskCreateTime().asc().list();

        return list;
    }

    @Override
    public String findCompleteTaskByUser(String userId, String chartId) {
        List<HistoricTaskInstance> list = historyService
                .createHistoricTaskInstanceQuery().taskAssignee(userId).list();
        HistoricProcessInstance hi = null;
        ProcessDefinition pd = null;

        StringBuilder businessIds = new StringBuilder();
        String str = "";
        for (HistoricTaskInstance ti : list) {
            hi = getHistoricProcessInstance(ti.getProcessInstanceId().trim());
            pd = getProcessDefinitionByDe(hi.getProcessDefinitionId().trim());

            if (!pd.getKey().trim().equals(chartId))
                continue;

            str = "'"
                    + hi.getBusinessKey().trim()
                            .replace(pd.getKey().trim() + ".", "") + "',";
            if (!businessIds.toString().contains(str)) {
                businessIds.append(str);
            }
        }

        str = businessIds.toString().trim();
        if (!"".equals(str) && str.endsWith(",")) {
            str = str.substring(0, str.length() - 1);
        }

        return str;
    }

    @Override
    public InputStream findImageInputStream(String deploymentId,
            String imageName) {
        return repositoryService.getResourceAsStream(deploymentId, imageName);
    }

    @Override
    public Page<TP_BUSINESS> findBusiness(int pageNumber, int pageSize,
            String roleId) {
        return null;
    }

    @Override
    public ProcessInstance startProcess(String key) {
        System.out.println("key...................................");
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(key);
        System.out.println(processInstance);
        // 獲取任務對象
        return processInstance;
    }


    @Override
    public Map<String, Object> findCoording(String processInstanceId) {
        // 存放坐標
        Map<String, Object> map = new HashMap<String, Object>();
        // 使用任務ID,查詢任務對象
        Task task = getTask(processInstanceId);

        // 獲取流程定義的ID
        String processDefinitionId = task.getProcessDefinitionId();
        // 獲取流程定義的實體對象,(對應.bpmn文件中的數據)
        ProcessDefinitionEntity processDefinitionEntity = getProcessDefinitionEntity(processDefinitionId);

        // 使用流程實例ID,查詢正在執行的對象表,獲取當前活動對應的流程實例對象
        ProcessInstance pi = getProcessInstance(processInstanceId);

        // 獲取當前活動的ID
        String activityId = pi.getActivityId();
        // 獲取當前活動對象
        ActivityImpl activityImpl = processDefinitionEntity
                .findActivity(activityId);
        // 獲取坐標
        map.put("x", activityImpl.getX());
        map.put("y", activityImpl.getY());
        map.put("width", activityImpl.getWidth());
        map.put("height", activityImpl.getHeight());
        return map;
    }

    @Override
    public List<Map<String, Object>> findCoordings(String deploymentId) {
        List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
        Map<String, Object> map = null;
        ProcessDefinition pd = getProcessDefinition(deploymentId);
        ProcessDefinitionEntity processDefinition = getProcessDefinitionEntity(pd
                .getId());
        List<ActivityImpl> activitiList = processDefinition.getActivities();

        for (ActivityImpl activity : activitiList) {
            map = new HashMap<String, Object>();
            map.put("x", activity.getX());
            map.put("y", activity.getY());
            map.put("width", activity.getWidth());
            map.put("height", activity.getHeight());
            map.put("taskId", activity.getId());
            map.put("taskName", activity.getProperty("name"));
            map.put("processKey", pd.getKey());

            list.add(map);
        }

        return list;
    }

    @Override
    public boolean finishTask(String processInstanceId, String lineName,
            String userId) {
        String taskId = "";
        Map<String, Object> variables = new HashMap<String, Object>();

        // 使用任務ID,查詢任務對象
        Task task = getTask(processInstanceId);

        taskId = task.getId().trim();

        // 拾取辦理人
        taskService.claim(taskId, userId);

        // 設置連線名稱
        variables.put("msg", lineName);

        // 完成任務
        taskService.complete(taskId, variables);

        // 判斷流程是否結束
        ProcessInstance pi = getProcessInstance(processInstanceId);

        if (pi == null) {
            return true;
        }

        return false;
    }

    @Override
    public TaskDefinition getNextTaskDefinition(String processInstanceId,
            String msg) {

        String activityId = "";

        String definitionId = getDefinitionId(processInstanceId);

        ProcessDefinitionEntity processDefinitionEntity = getProcessDefinitionEntity(definitionId);

        ExecutionEntity execution = getExecutionEntity(processInstanceId);

        activityId = execution.getActivityId();

        ActivityImpl activityImpl = processDefinitionEntity
                .findActivity(activityId);// 當前節點

        // 獲取當前節點連線所有集合
        List<PvmTransition> pvmTransitions = activityImpl
                .getOutgoingTransitions();

        for (PvmTransition pvmTransition : pvmTransitions) {
            PvmActivity pa = pvmTransition.getDestination();// 獲取所有的終點節點

            if ("userTask".equals(pa.getProperty("type"))) {
                return ((UserTaskActivityBehavior) ((ActivityImpl) pa)
                        .getActivityBehavior()).getTaskDefinition();
            }
        }

        return null;
    }

    @Override
    public Map<String, String> isEndTask(String processInstanceId, String msg) {

        Map<String, String> map = new HashMap<String, String>();
        map.put("isEnd", "false");

        String activityId = "";

        String definitionId = getDefinitionId(processInstanceId);

        ProcessDefinitionEntity processDefinitionEntity = getProcessDefinitionEntity(definitionId);

        ExecutionEntity execution = getExecutionEntity(processInstanceId);

        activityId = execution.getActivityId();

        ActivityImpl activityImpl = processDefinitionEntity
                .findActivity(activityId);// 當前節點

        // 獲取當前節點連線所有集合
        List<PvmTransition> pvmTransitions = activityImpl
                .getOutgoingTransitions();

        for (PvmTransition pvmTransition : pvmTransitions) {
            PvmActivity pa = pvmTransition.getDestination();// 獲取所有的終點節點
            // 獲取連線名
            String condition = pvmTransition.getProperty("conditionText")
                    .toString().trim().replace("${msg==", "").replace("}", "")
                    .replace("'", "");

            if (msg.equals(condition)) {
                if ("endEvent".equals(pa.getProperty("type"))) {
                    map.put("isEnd", "true");
                    map.put("node", pa.getId().trim());
                    return map;
                }
            }
        }

        return map;
    }

    /*---------------------------------------------------常用方法-----------------------------------------------*/

    /**
     * 根據流程實例 ID,獲取流程定義ID
     * 
     * @param processInstanceId
     *            流程實例ID
     * @return
     */
    public String getDefinitionId(String processInstanceId) {
        String definitionId = "";
        ProcessInstance pi = runtimeService.createProcessInstanceQuery()
                .processInstanceId(processInstanceId).singleResult();
        definitionId = pi.getProcessDefinitionId().trim();

        return definitionId;
    }

    /**
     * 根據流程實例ID,獲取流程定義ID(歷史表)
     * 
     * @param processInstanceId
     * @return
     */
    public String getDefinitionIdByHistory(String processInstanceId) {
        String definitionId = "";
        HistoricProcessInstance pi = historyService
                .createHistoricProcessInstanceQuery()
                .processInstanceId(processInstanceId).singleResult();
        definitionId = pi.getProcessDefinitionId().trim();
        return definitionId;
    }

    /**
     * 根據流程定義ID,獲取流程定義對象實體
     * 
     * @param definitionId
     *            流程定義ID
     * @return
     */
    public ProcessDefinitionEntity getProcessDefinitionEntity(
            String definitionId) {
        ProcessDefinitionEntity processDefinitionEntity = (ProcessDefinitionEntity) ((RepositoryServiceImpl) repositoryService)
                .getDeployedProcessDefinition(definitionId);

        return processDefinitionEntity;
    }

    /**
     * 根據流程部署ID,獲取流程定義對象實體
     * 
     * @param deploymentId
     *            流程部署ID
     * @return
     */
    public ProcessDefinition getProcessDefinition(String deploymentId) {
        ProcessDefinition processDefinition = repositoryService
                .createProcessDefinitionQuery().deploymentId(deploymentId)
                .singleResult();

        return processDefinition;
    }

    /**
     * 根據流程定義ID,獲取流程定義對象實體
     * 
     * @param deploymentId
     *            流程定義ID
     * @return
     */
    public ProcessDefinition getProcessDefinitionByDe(String processDefinitionId) {
        ProcessDefinition processDefinition = repositoryService
                .createProcessDefinitionQuery()
                .processDefinitionId(processDefinitionId).singleResult();

        return processDefinition;
    }

    /**
     * 根據流程實例ID,獲取任務
     * 
     * @param processInstanceId
     *            流程實例ID
     * @return
     */
    public Task getTask(String processInstanceId) {
        Task task = taskService.createTaskQuery()
                .processInstanceId(processInstanceId).singleResult();

        return task;
    }

    /**
     * 根據流程實例ID,獲取運行時對象實體
     * 
     * @param processInstanceId
     *            流程實例ID
     * @return
     */
    public ExecutionEntity getExecutionEntity(String processInstanceId) {
        ExecutionEntity execution = (ExecutionEntity) runtimeService
                .createProcessInstanceQuery()
                .processInstanceId(processInstanceId).singleResult();

        return execution;
    }

    /**
     * 使用流程實例ID,查詢正在執行的對象表,獲取當前活動對應的流程實例對象
     * 
     * @param processInstanceId
     *            流程實例ID
     * @return
     */
    public ProcessInstance getProcessInstance(String processInstanceId) {
        ProcessInstance processInstance = runtimeService
                .createProcessInstanceQuery()
                .processInstanceId(processInstanceId).singleResult();

        return processInstance;
    }

    /**
     * 使用流程實例ID,查詢歷史流程實例
     * 
     * @param processInstanceId
     * @return
     */
    public HistoricProcessInstance getHistoricProcessInstance(
            String processInstanceId) {
        HistoricProcessInstance historicProcessInstance = historyService
                .createHistoricProcessInstanceQuery()
                .processInstanceId(processInstanceId).singleResult();
        return historicProcessInstance;
    }

    /**
     * 通過流程定義的key,級聯刪除流程
     * 
     * @param processKey
     *            流程定義key
     */
    public void deleteDeploy(String processKey) {
        List<ProcessDefinition> pdList = repositoryService// 獲取Service
                .createProcessDefinitionQuery()// 創建流程定義查詢
                .processDefinitionKey(processKey)// 通過key查詢
                .list();// 返回一個集合
        for (ProcessDefinition pd : pdList) {
            repositoryService// 獲取Service
                    .deleteDeployment(pd.getDeploymentId(), true);
        }

    }

    /**
     * 根據流程實例id,得到當前任務
     * @param processInstanceId 流程實例id
     * @return
     */
    public Task findTask(String processInstanceId) {
        return taskService.createTaskQuery().processInstanceId(processInstanceId).singleResult();
    }

    /**
     * 根據流程實例id,得到上一個已完成節點
     * @param processInstanceId
     * @return
     */
    public HistoricActivityInstance findLastTask(String processInstanceId) {
        //得到以完成的上一任務節點
        List<HistoricActivityInstance>  haList=historyService.createHistoricActivityInstanceQuery().processInstanceId(processInstanceId).finished().orderByHistoricActivityInstanceEndTime().desc().list();
        //已完成的上一任務
        HistoricActivityInstance ha = haList.get(0);
        return ha;
    }

    @Override
    public Execution getExecution(String processInstanceId) {
        return runtimeService.createExecutionQuery()
                  .processInstanceId(processInstanceId)
                  .singleResult();
    }
    
    @Override
    public HistoricTaskInstance findLastHistTask(String processInstanceId) {
        List<HistoricTaskInstance> list = historyService.createHistoricTaskInstanceQuery()
                      .processInstanceId(processInstanceId)
                      .orderByHistoricTaskInstanceEndTime()
                      .desc()
                      .list();
        return list.get(0);
    }
    /**
     * 通過流程定義key,得到所有節點數量和節點字符串
     * @param processKey 流程定義key
     * @return
     * @throws Exception
     */
    public Object[] getNodeId(String processKey){
        // 得到流程部署實例(得到部署最新的那一個流程)
        Deployment deployment =repositoryService.createDeploymentQuery().processDefinitionKey(processKey).orderByDeploymenTime().desc().list().get(0);
        // 得到流程定義實例
        ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().deploymentId(deployment.getId()).singleResult();
        //得到流程定義實體
        ProcessDefinitionEntity processDefinitionEntity = (ProcessDefinitionEntity) ((RepositoryServiceImpl) repositoryService)
                .getDeployedProcessDefinition(processDefinition.getId());
        List<ActivityImpl> activitiList = processDefinitionEntity.getActivities();
        // 初始化節點集合
        List<String> nodeList = new ArrayList<String>();
        for (ActivityImpl activity : activitiList) {
            nodeList.add(activity.getId());
        }
        StringBuffer nodeId = new StringBuffer();
        for (String node : nodeList) {
            nodeId.append("'").append(node).append("',");
        }
        Object[] obj = new Object[]{nodeList.size(),nodeId.substring(0, nodeId.length() - 1)};
        return obj;
    }
    
    @Override
    public List<TP_BUSINESS> getApplyList(List<TP_BUSINESS> list, String currentUserId, String currentUserName) {
        if (list != null && list.size() > 0) {
            for (int i = 0; i < list.size(); i++) {
                // 獲取流程實例Id
                String processInstanceId = list.get(i).get("PI_ID");                    
                    // 設置辦理人為當前登錄用戶
                    list.get(i).set("CURRENTUSER", currentUserName);
                    // 判斷流程是否結束,如果結束則標志為完成
                    // 通過流程實例id查找正在執行的對象
                    Execution execution = runtimeService.createExecutionQuery().processInstanceId(processInstanceId)
                            .singleResult();
                    String status = "";
                    if (execution != null) {
                        status = "在辦";
                    } else {
                        status = "完成";
                    }
                    list.get(i).set("AUDIT_STATUS", status);
                }
        }
        return list;
    }

    @Override
    public String getActId(String processInstanceId) {
        String actId = "";
        // 通過流程實例id獲取流程實例對象
        ProcessInstance processInstance = runtimeService.createProcessInstanceQuery()
                .processInstanceId(processInstanceId).singleResult();
        if (processInstance != null) {
            actId = processInstance.getActivityId();
        }
        return actId;
    }
    
    @Override
    public List<TP_BUSINESS> getWaitList(List<TP_BUSINESS> list, String currentUserId, String currentUserName) {
        if(list != null && list.size() > 0) {
            for(int i=0; i<list.size(); i++) {
                //流程實例id
                String pi_id = list.get(i).get("pi_id");    
                    //設置當前辦理人名稱
                    list.get(i).set("CURRENTUSER", currentUserName);
                    //查詢當前流程的歷史任務
                    List<HistoricTaskInstance> hisList = historyService.createHistoricTaskInstanceQuery()
                                  .processInstanceId(pi_id)
                                  .orderByHistoricTaskInstanceEndTime()
                                  .desc()
                                  .list();
                    if(hisList != null && hisList.size() > 0) {
                        //設置上一個環節名稱
                        list.get(i).set("LAST_LINK", hisList.get(0).getName());
                        //設置上個環節提交時間
                        list.get(i).set("LAST_LINK_DATE", hisList.get(0).getEndTime());
                        //得到上個辦理人id
                        String lastAsseId = hisList.get(0).getAssignee();
                        List<Record> userList = Db.find("SELECT REAL_NAME FROM SYS_USER WHERE ID='"+lastAsseId+"'");
                        if(userList != null && userList.size() > 0) {
                            //設置上個辦理人名稱
                            list.get(i).set("LAST_LINK_APPLICANT", userList.get(0).get("real_name"));
                        }
                        
                }
                if(list.get(i).get("AUDIT_STATUS").equals("1")) {
                    list.get(i).set("AUDIT_STATUS", "在辦");
                }else {
                    list.get(i).set("AUDIT_STATUS", "完結");
                }
            }
        }
        return list;
    }
    
    @Override
    public InputStream viewImg(String processInstanceId) {
        InputStream in = null;
        // 獲取流程實例對象
        HistoricProcessInstance  processinstance = historyService.createHistoricProcessInstanceQuery()
                      .processInstanceId(processInstanceId)
                      .singleResult();
        if (processinstance != null) {
            // 獲取流程定義id
            String processDefinitionId = processinstance.getProcessDefinitionId();
            // 獲取流程定義對象
            ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()
                    .processDefinitionId(processDefinitionId).singleResult();
            // 部署id
            String deployId = processDefinition.getDeploymentId();
            // 文件名稱
            String imgName = processDefinition.getDiagramResourceName();
            // 獲取輸入流
            in = repositoryService.getResourceAsStream(deployId, imgName);
        }
        return in;
    }
    
    @Override
    public Execution getCurrentExecution(String processInstanceId) {
        Execution execution = runtimeService.createExecutionQuery()
                                            .processInstanceId(processInstanceId)
                                            .singleResult();
        return execution;
    }
    @Override
    public boolean completeProcess(String processInstanceId,String status,String currentUserId) {
        boolean result = false;
        String elString="${message=='完成'}";
        Map<String,Object> variables = new HashMap<String, Object>();
        Task task = taskService.createTaskQuery()
                               .processInstanceId(processInstanceId)
                               .singleResult();
        if(task != null) {
            //獲取任務id
            String taskId = task.getId();
            //拾取任務
            if(task.getAssignee() == null) {
                //采用當前要用戶拾取任務
                taskService.claim(taskId, currentUserId);
            }    
            //得到下一個節點id            
            String nextActId = this.viewNextAct(processInstanceId, elString);
            //如果下一個節點id是endevent1(結束節點),則根據status判斷是同意還是拒絕用於最后是否保存數據
            if(nextActId.toString().trim().equals("endevent1")) {
                variables.put("message", "完成");
            }else {
                variables.put("message", status);
            }            
            taskService.complete(taskId,variables);
            result = true;
        }
        return result;
    }
    
    @Override
    public String viewNextAct(String processInstanceId, String elString) {
        String nextActId = "";
        //獲取流程實例對象
        ProcessInstance processInstance = runtimeService.createProcessInstanceQuery()
                      .processInstanceId(processInstanceId)
                      .singleResult();
        
        if(processInstance != null) {
            //獲取當前節點id
            String activityId = processInstance.getActivityId();
            //獲取流程定義id
            String processDefinitionId = processInstance.getProcessDefinitionId();
            //獲取流程定義實體對象
            ProcessDefinitionEntity processDefinitionEntity= (ProcessDefinitionEntity)repositoryService.getProcessDefinition(processDefinitionId);
            if(processDefinitionEntity != null) {
                //獲取當前節點對象
                ActivityImpl activityImpl = processDefinitionEntity.findActivity(activityId);
                if(activityImpl != null) {
                    //得到當前節點所有出線信息
                    List<PvmTransition> pvmList = activityImpl.getOutgoingTransitions();
                    if(pvmList != null && pvmList.size() > 1) {
                        for(PvmTransition pvm:pvmList) {
                            //得到連線的表達式
                            String conditionText = (String)pvm.getProperty("conditionText");
                            //看得到的連線名稱和傳遞過來的名稱是否匹配
                            if(elString.equals(conditionText)) {
                                ActivityImpl a = (ActivityImpl)pvm.getDestination();
                                //獲取下一個節點的id
                                nextActId = a.getId();                                
                            }
                        }
                    }
                }
            }
        }
        return nextActId;
    }
    
    @Override
    public boolean revoke(String processInstanceId) {
        // 根據流程實例id獲取任務對象
        Task task = taskService.createTaskQuery().processInstanceId(processInstanceId).singleResult();
        String taskId = task.getId();
        // 結束流程時設置流程變量
        Map<String, Object> variables = new HashMap<String, Object>();
        variables.put("message", "撤銷");
        taskService.complete(taskId, variables);
        // 查看流程是否結束(execution為空則結束)
        Execution execution = runtimeService.createExecutionQuery().processInstanceId(processInstanceId).singleResult();
        if (execution == null) {
            return true;
        } else {
            return false;
        }
    }
    /**
     * 查看流程圖的當前活動節點
     * @param taskId 任務id
     * @return [0]x、[1]y、[2]width、[3]height、[4]流程部署id、[5]資源圖片路徑
     * @throws Exception
     */
    public Object[] showCurrentView(String processInstanceId) throws Exception{
        //無論流程是否走完,得到的都是最后一條記錄(ACT_HI_TASKINST)
        HistoricTaskInstance h = historyService.createHistoricTaskInstanceQuery().processInstanceId(processInstanceId).list().get(0);
        String processDefinitionId = h.getProcessDefinitionId();//得到流程定義id
        //流程定義實體
        ProcessDefinitionEntity pdm = (ProcessDefinitionEntity) repositoryService.getProcessDefinition(processDefinitionId);
        ProcessInstance pi = runtimeService.createProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();
        
        /*因為activiti框架的緩存會話機制,所以我在這個位置將“流程部署id和支援圖片路徑取出來”*/
        ProcessDefinition pd = repositoryService.createProcessDefinitionQuery().processDefinitionId(processDefinitionId.trim()).singleResult();
        String deploymentId = pd.getDeploymentId(); //流程部署id
        String diagramResourceName = pd.getDiagramResourceName(); //流程資源圖片路徑
        /*因為activiti框架的緩存會話機制,所以我在這個位置將“流程部署id和支援圖片路徑取出來”*/
        
        Object[] view = new Object[6];
        view[4] = deploymentId;
        view[5] = diagramResourceName;
        //因為有可能流程已經走完,所有還是判斷哈,免得空指針異常
        if(pi != null){
            ActivityImpl ai = pdm.findActivity(pi.getActivityId());
            //根據活動ID  獲取活動實例
            ActivityImpl activityImpl = pdm.findActivity(pi.getActivityId());
            view[0] = activityImpl.getX();
            view[1] = activityImpl.getY();
            view[2] = activityImpl.getWidth(); //寬度
            view[3] = activityImpl.getHeight(); //高度
        }
        
        return view;
    }
    /**
     * 查看流程圖
     * @param deploymentId 流程部署id
     * @param diagramResourceName 資源圖片名稱
     * @param response 將數據向頁面輸出
     * @throws IOException 
     */
    public void showView(String deploymentId,String diagramResourceName,HttpServletResponse response) throws Exception{
        //調用接口得到流程圖
        InputStream inputStream = repositoryService.getResourceAsStream(deploymentId, diagramResourceName);
        OutputStream out = response.getOutputStream();
        for(int b = -1;(b=inputStream.read())!=-1;){
            out.write(b);
        }
        out.close();
        inputStream.close();
    }
}

 

web.xml

   <!-- 加載Spring容器配置 -->
     <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

<!--     設置Spring容器加載所有的配置文件的路徑 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:activiti-context.xml</param-value>
    </context-param>

 


免責聲明!

本站轉載的文章為個人學習借鑒使用,本站對版權不負任何法律責任。如果侵犯了您的隱私權益,請聯系本站郵箱yoyou2525@163.com刪除。



 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM