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>