Activiti工做流引擎使用詳解（一）

1、IDEA安裝activiti插件

在插件庫中查找actiBPM，安裝該插件，若是找不到該插件，請到插件庫中下載該包手動安裝，插件地址

http://plugins.jetbrains.com/plugin/7429-actibpm 安裝後重啓IDEA

2、activiti基礎環境搭建

2.1 actiBPM插件使用示例

將須要用到的activiti包引入到工程中

<dependency>
    <groupId>org.activiti</groupId>
    <artifactId>activiti-engine</artifactId>
    <version>5.17.0</version>
</dependency>

resources目錄下建立diagrams文件夾

右鍵new，點擊BpmnFeil,而後取個名

鼠標左鍵拖拽StartEvent到界面上，一樣再弄幾個其餘圖標

 

 鼠標放到圖標中心會變成黑白扇形，拖拽連線到另外一個圖標進行畫圖

 

 

生成png文件

右鍵點擊hello.bpmn，選擇Diagrams

點擊箭頭指的圖標，選擇生成位置便可

2.2 初始化activiti表結構

2.2.1 經過代碼建立工做流使用的表

public class TestActiviti {
    /**
     * 使用代碼建立工做流使用的23張表
     */
    @Test
    public void createTable(){
        //建立引擎配置類
        ProcessEngineConfiguration configuration = ProcessEngineConfiguration.createStandaloneProcessEngineConfiguration();
        configuration.setJdbcDriver("com.mysql.jdbc.Driver");
        configuration.setJdbcUrl("jdbc:mysql://192.168.27.14:3306/activiti");
        configuration.setJdbcUsername("root");
        configuration.setJdbcPassword("root");

        //不自動建立表，須要表存在 DB_SCHEMA_UPDATE_FALSE = "false";
        //先刪除表，再建立表 DB_SCHEMA_UPDATE_CREATE_DROP = "create-drop";
        //若是表不存在，先建立表 DB_SCHEMA_UPDATE_TRUE = "true";
        configuration.setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);
        //建立工做流核心對象
        ProcessEngine processEngine = configuration.buildProcessEngine();
        System.out.println(processEngine);
    }
}

2.2.2 經過配置文件方式配置數據庫等，resourses目錄下添加activiti.cfg.xml配置文件，再經過代碼初始化工做流使用的表

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">

    <bean id="processEngineConfiguration" class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
        <!-- 鏈接數據的配置 -->
        <property name="jdbcDriver" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://192.168.27.14:3306/activiti?characterEncoding=utf8"/>
        <property name="jdbcUsername" value="root"/>
        <property name="jdbcPassword" value="root"/>
        <!--  不自動建立表，須要表存在 "false";
              先刪除表，再建立表  "create-drop";
              若是表不存在，先建立表"true";
        -->
        <property name="databaseSchemaUpdate" value="true"/>
    </bean>
</beans>

@Test
public void createTable2(){
    ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cfg.xml")
            .buildProcessEngine();
}

 2.2.3 那麼，能不能再給力一點？前面看到了兩種建立ProcessEngine（流程引擎）的方式，而這裏要簡化不少，調用ProcessEngines的getDefaultProceeEngine方法時會自動加載classpath下名爲activiti.cfg.xml文件。

@Test
public void createTable3(){
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
}

3、activiti核心api講解

3.1ProcessEngine

在Activiti中最核心的類，其餘的類都是由他而來，由工做流引擎能夠建立各個Service，這些Service是調用工做流23張表的服務

@Test
public void getService(){
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

    //管理流程定義
    RepositoryService repositoryService = processEngine.getRepositoryService();
    //執行管理，包括啓動、推動、刪除流程實例等
    RuntimeService runtimeService = processEngine.getRuntimeService();
    //任務管理
    TaskService taskService = processEngine.getTaskService();
    //歷史管理（執行完的數據的管理
    HistoryService historyService = processEngine.getHistoryService();
    //組織機構管理
    IdentityService identityService = processEngine.getIdentityService();
    //可選服務，任務表單管理
    FormService formService = processEngine.getFormService();
    
    ManagementService managementService = processEngine.getManagementService();
}

3.2 RepositoryService

是Activiti的倉庫服務類。所謂的倉庫指流程定義文檔的兩個文件：bpmn文件和流程圖片。

@Test
public void testRespositoryService(){
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    RepositoryService repositoryService = processEngine.getRepositoryService();
    //可產生DeploymentBuilder用來定義流程部署的相關參數
    DeploymentBuilder deployment = repositoryService.createDeployment();
    //刪除流程定義
    repositoryService.deleteDeployment("deploymentId");
}

3.3 RuntimeService

是activiti的流程執行服務類。能夠從這個服務類中獲取不少關於流程執行相關的信息。

3.4 TaskService

是activiti的任務服務類。能夠從這個類中獲取任務的信息。

3.5 HistoryService

是activiti的查詢歷史信息的類。在一個流程執行完成後，這個對象爲咱們提供查詢歷史信息。

3.6 ProcessDefinition

流程定義類。能夠從這裏得到資源文件等。

3.7 ProcessInstance

表明流程定義的執行實例。如小明請了一天的假，就必須發出一個流程實例的申請。一個流程實例包括了全部的運行節點。咱們能夠利用這個對象來了解當前流程實例的進度等信息。流程實例就表示一個流程從開始到結束的最大的流程分支，即一個流程中流程實例只有一個。

3.8 Execution

Activiti用這個對象去描述流程執行的每個節點。在沒有併發的狀況下，Execution就是同ProcessInstance。流程按照流程定義的規則執行一次的過程，就能夠表示執行對象Execution。

4、一個簡單的HelloWorld程序示例

4.1 利用插件建立流程圖

 

4.2 部署流程定義

/**
 * 部署流程定義
 */
@Test
public void deploymentProcessDefinition(){

    //獲取流程定義與部署相關Service
    Deployment deployment = processEngine.getRepositoryService()
            .createDeployment()     //建立一個部署對象
            .name("helloworld入門程序")
            .addClasspathResource("diagrams/helloworld.bpmn")//加載資源文件
            .deploy();//完成部署
    System.out.println(deployment.getId());
    System.out.println(deployment.getName());
}

4.3 啓動流程實例

/**
 * 啓動流程實例
 */
@Test
public void startProcessInstance(){
    //獲取與正在執行的流程示例和執行對象相關的Service
    ProcessInstance processInstance = processEngine.getRuntimeService()
            //使用流程定義的key啓動實例，key對應bpmn文件中id的屬性值，默認按照最新版本流程啓動
            .startProcessInstanceByKey("helloworld");
    System.out.println(processInstance.getId());
    System.out.println(processInstance.getProcessDefinitionId());
}

4.4 查看個人我的任務

/**
 * 查詢當前的我的任務
 */
@Test
public void findPersonalTask(){
    //與正在執行的任務相關的Service
    List<Task> list = processEngine.getTaskService()
            .createTaskQuery()  //建立查詢任務對象
            .taskAssignee("王五")     //指定我的任務查詢，指定辦理人
            .list();
    if(list != null && list.size() > 0){
        for(Task task : list){
            System.out.println(task.getId());
            System.out.println(task.getName());
            System.out.println(task.getCreateTime());
            System.out.println(task.getAssignee());
            System.out.println(task.getProcessInstanceId());
            System.out.println(task.getExecutionId());
            System.out.println(task.getProcessDefinitionId());
        }
    }
}

4.5 完成個人我的任務

/**
 * 完成個人任務
 */
@Test
public void completePersonalTask(){
    processEngine.getTaskService()
            .complete("7502");
}

5、管理流程定義

5.1 部署流程定義

經過classpath部署流程定義

/**部署流程定義（從classpath）*/
@Test
public void deploymentProcessDefinition_classpath(){
    Deployment deployment = processEngine.getRepositoryService()//與流程定義和部署對象相關的Service
            .createDeployment()//建立一個部署對象
            .name("流程定義")//添加部署的名稱
            .addClasspathResource("diagrams/helloworld.bpmn")//從classpath的資源中加載，一次只能加載一個文件
            .addClasspathResource("diagrams/helloworld.png")//從classpath的資源中加載，一次只能加載一個文件
            .deploy();//完成部署
    System.out.println("部署ID："+deployment.getId());//
    System.out.println("部署名稱："+deployment.getName());//
}

經過zip文件部署流程定義

/**部署流程定義（從zip）*/
@Test
public void deploymentProcessDefinition_zip(){
    InputStream in = this.getClass().getClassLoader().getResourceAsStream("diagrams/helloworld.zip");
    ZipInputStream zipInputStream = new ZipInputStream(in);
    Deployment deployment = processEngine.getRepositoryService()//與流程定義和部署對象相關的Service
            .createDeployment()//建立一個部署對象
            .name("流程定義")//添加部署的名稱
            .addZipInputStream(zipInputStream)//指定zip格式的文件完成部署
            .deploy();//完成部署
    System.out.println("部署ID："+deployment.getId());//
    System.out.println("部署名稱："+deployment.getName());//
}

 這一步在數據庫中將操做三張表：

a) act_re_deployment（部署對象表）

　　存放流程定義的顯示名和部署時間，每部署一次增長一條記錄

b) act_re_procdef（流程定義表）

　　存放流程定義的屬性信息，部署每一個新的流程定義都會在這張表中增長一條記錄。

注意：當流程定義的key相同的狀況下，使用的是版本升級

c) act_ge_bytearray（資源文件表）

　　存儲流程定義相關的部署信息。即流程定義文檔的存放地。每部署一次就會增長兩條記錄，一條是關於bpmn規則文件的，一條是圖片的（若是部署時只指定了bpmn一個文件，activiti會在部署時解析bpmn文件內容自動生成流程圖）。兩個文件不是很大，都是以二進制形式存儲在數據庫中。

5.2 查看流程定義

/**查詢流程定義*/
@Test
public void findProcessDefinition(){
    List<ProcessDefinition> list = processEngine.getRepositoryService()//與流程定義和部署對象相關的Service
            .createProcessDefinitionQuery()//建立一個流程定義的查詢
            /**指定查詢條件,where條件*/
//                        .deploymentId(deploymentId)//使用部署對象ID查詢
//                        .processDefinitionId(processDefinitionId)//使用流程定義ID查詢
//                        .processDefinitionKey(processDefinitionKey)//使用流程定義的key查詢
//                        .processDefinitionNameLike(processDefinitionNameLike)//使用流程定義的名稱模糊查詢

            /**排序*/
            .orderByProcessDefinitionVersion().asc()//按照版本的升序排列
//                        .orderByProcessDefinitionName().desc()//按照流程定義的名稱降序排列

            /**返回的結果集*/
            .list();//返回一個集合列表，封裝流程定義
//                        .singleResult();//返回唯一結果集
//                        .count();//返回結果集數量
//                        .listPage(firstResult, maxResults);//分頁查詢
    if(list!=null && list.size()>0){
        for(ProcessDefinition pd:list){
            System.out.println("流程定義ID:"+pd.getId());//流程定義的key+版本+隨機生成數
            System.out.println("流程定義的名稱:"+pd.getName());//對應helloworld.bpmn文件中的name屬性值
            System.out.println("流程定義的key:"+pd.getKey());//對應helloworld.bpmn文件中的id屬性值
            System.out.println("流程定義的版本:"+pd.getVersion());//當流程定義的key值相同的相同下，版本升級，默認1
            System.out.println("資源名稱bpmn文件:"+pd.getResourceName());
            System.out.println("資源名稱png文件:"+pd.getDiagramResourceName());
            System.out.println("部署對象ID："+pd.getDeploymentId());
            System.out.println("#########################################################");
        }
    }
}

結果：

再部署一次運行結果爲：

　　能夠看到流程定義的key值相同的狀況下，版本是從1開始逐次升級的，流程定義的Id是【key：版本：生成ID】。由運行結果能夠看出：Key和Name的值爲：bpmn文件process節點的id和name的屬性值。key屬性被用來區別不一樣的流程定義，帶有特定key的流程定義第一次部署時，version爲1。以後每次部署都會在當前最高版本號上加1，Id的值的生成規則爲:{processDefinitionKey}:{processDefinitionVersion}:{generated-id}, 這裏的generated-id是一個自動生成的惟一的數字，重複部署一次，deploymentId的值以必定的形式變化，規則act_ge_property表生成。

5.3 刪除流程定義

/**刪除流程定義*/
@Test
public void deleteProcessDefinition(){
    //使用部署ID，完成刪除
    String deploymentId = "601";
    /**
     * 不帶級聯的刪除
     *    只能刪除沒有啓動的流程，若是流程啓動，就會拋出異常
     */
//        processEngine.getRepositoryService()//
//                        .deleteDeployment(deploymentId);

    /**
     * 級聯刪除
     *       無論流程是否啓動，都能能夠刪除
     */
    processEngine.getRepositoryService()//
            .deleteDeployment(deploymentId, true);
    System.out.println("刪除成功！");
}

　　若是該流程定義下沒有正在運行的流程，則能夠用普通刪除。若是是有關聯的信息，用級聯刪除。項目開發中使用級聯刪除的狀況比較多，刪除操做通常只開放給超級管理員使用。

5.4 獲取流程定義文檔的資源

 查詢出流程定義文檔。主要查的是圖片，用於顯示流程用。

/**查看流程圖
 * @throws IOException */
@Test
public void viewPic() throws IOException {
    /**將生成圖片放到文件夾下*/
    String deploymentId = "801";
    //獲取圖片資源名稱
    List<String> list = processEngine.getRepositoryService()//
            .getDeploymentResourceNames(deploymentId);
    //定義圖片資源的名稱
    String resourceName = "";
    if(list!=null && list.size()>0){
        for(String name:list){
            if(name.indexOf(".png")>=0){
                resourceName = name;
            }
        }
    }
    //獲取圖片的輸入流
    InputStream in = processEngine.getRepositoryService()//
            .getResourceAsStream(deploymentId, resourceName);
    //將圖片生成到D盤的目錄下
    File file = new File("D:/"+resourceName);
    //將輸入流的圖片寫到D盤下
    FileUtils.copyInputStreamToFile(in, file);
}

　　deploymentId爲流程部署ID，resourceName爲act_ge_bytearray表中NAME_列的值，使用repositoryService的getDeploymentResourceNames方法能夠獲取指定部署下得全部文件的名稱，使用repositoryService的getResourceAsStream方法傳入部署ID和資源圖片名稱能夠獲取部署下指定名稱文件的輸入流，最後的有關IO流的操做，使用FileUtils工具的copyInputStreamToFile方法完成流程流程到文件的拷貝，將資源文件以流的形式輸出到指定文件夾下。

5.5 查詢最新版本的流程定義

/***附加功能：查詢最新版本的流程定義*/
@Test
public void findLastVersionProcessDefinition(){
    List<ProcessDefinition> list = processEngine.getRepositoryService()//
            .createProcessDefinitionQuery()//
            .orderByProcessDefinitionVersion().asc()//使用流程定義的版本升序排列
            .list();
    /**
     * Map<String,ProcessDefinition>
     map集合的key：流程定義的key
     map集合的value：流程定義的對象
     map集合的特色：當map集合key值相同的狀況下，後一次的值將替換前一次的值
     */
    Map<String, ProcessDefinition> map = new LinkedHashMap<String, ProcessDefinition>();
    if(list!=null && list.size()>0){
        for(ProcessDefinition pd:list){
            map.put(pd.getKey(), pd);
        }
    }
    List<ProcessDefinition> pdList = new ArrayList<ProcessDefinition>(map.values());
    if(pdList!=null && pdList.size()>0){
        for(ProcessDefinition pd:pdList){
            System.out.println("流程定義ID:"+pd.getId());//流程定義的key+版本+隨機生成數
            System.out.println("流程定義的名稱:"+pd.getName());//對應helloworld.bpmn文件中的name屬性值
            System.out.println("流程定義的key:"+pd.getKey());//對應helloworld.bpmn文件中的id屬性值
            System.out.println("流程定義的版本:"+pd.getVersion());//當流程定義的key值相同的相同下，版本升級，默認1
            System.out.println("資源名稱bpmn文件:"+pd.getResourceName());
            System.out.println("資源名稱png文件:"+pd.getDiagramResourceName());
            System.out.println("部署對象ID："+pd.getDeploymentId());
            System.out.println("#########################################################");
        }
    }
}

5.6 刪除流程定義

/**附加功能：刪除流程定義（刪除key相同的全部不一樣版本的流程定義）*/
@Test
public void deleteProcessDefinitionByKey(){
    //流程定義的key
    String processDefinitionKey = "helloworld";
    //先使用流程定義的key查詢流程定義，查詢出全部的版本
    List<ProcessDefinition> list = processEngine.getRepositoryService()//
            .createProcessDefinitionQuery()//
            .processDefinitionKey(processDefinitionKey)//使用流程定義的key查詢
            .list();
    //遍歷，獲取每一個流程定義的部署ID
    if(list!=null && list.size()>0){
        for(ProcessDefinition pd:list){
            //獲取部署ID
            String deploymentId = pd.getDeploymentId();
            processEngine.getRepositoryService()//
                    .deleteDeployment(deploymentId, true);
        }
    }
}

 6、流程實例、任務的執行

涉及到的表

6.1 啓動流程實例

    /**
     * 啓動流程實例
     */
    @Test
    public void startProcessInstance(){
        //獲取與正在執行的流程示例和執行對象相關的Service
        ProcessInstance processInstance = processEngine.getRuntimeService()
                //使用流程定義的key啓動實例，key對應bpmn文件中id的屬性值，默認按照最新版本流程啓動
                .startProcessInstanceByKey("helloworld");
        System.out.println(processInstance.getId());
        System.out.println(processInstance.getProcessDefinitionId());
    }

　　經過流程定義的key啓動流程實例，這時打開數據庫act_ru_execution表，ID_表示執行對象ID，PROC_INST_ID_表示流程實例ID，若是是單例流程（沒有分支和聚合），那麼流程實例ID和執行對象ID是相同的。

一個流程流程實例只有一個，執行對象能夠存在多個。

 6.2 查詢個人我的任務

/**查詢當前人的我的任務*/
    @Test
    public void findMyPersonalTask(){
        String assignee = "張三";
        List<Task> list = processEngine.getTaskService()//與正在執行的任務管理相關的Service
                .createTaskQuery()//建立任務查詢對象
                /**查詢條件（where部分）*/
                .taskAssignee(assignee)//指定我的任務查詢，指定辦理人
//                        .taskCandidateUser(candidateUser)//組任務的辦理人查詢
//                        .processDefinitionId(processDefinitionId)//使用流程定義ID查詢
//                        .processInstanceId(processInstanceId)//使用流程實例ID查詢
//                        .executionId(executionId)//使用執行對象ID查詢
                /**排序*/
                .orderByTaskCreateTime().asc()//使用建立時間的升序排列
                /**返回結果集*/
//                        .singleResult()//返回唯一結果集
//                        .count()//返回結果集的數量
//                        .listPage(firstResult, maxResults);//分頁查詢
                .list();//返回列表
        if(list!=null && list.size()>0){
            for(Task task:list){
                System.out.println("任務ID:"+task.getId());
                System.out.println("任務名稱:"+task.getName());
                System.out.println("任務的建立時間:"+task.getCreateTime());
                System.out.println("任務的辦理人:"+task.getAssignee());
                System.out.println("流程實例ID："+task.getProcessInstanceId());
                System.out.println("執行對象ID:"+task.getExecutionId());
                System.out.println("流程定義ID:"+task.getProcessDefinitionId());
                System.out.println("########################################################");
            }
        }
    }

　　由於是任務查詢，因此從processEngine中應該獲得TaskService，使用TaskService獲取到任務查詢對象TaskQuery，爲查詢對象添加查詢過濾條件，使用taskAssignee指定任務的辦理者（即查詢指定用戶的代辦任務），同時能夠添加分頁排序等過濾條件，調用list方法執行查詢，返回辦理者爲指定用戶的任務列表，任務ID、名稱、辦理人、建立時間能夠從act_ru_task表中查到。在這種狀況下，ProcessInstance至關於Execution， 若是assignee屬性爲部門經理，結果爲空。由於如今流程只到了」填寫請假申請」階段，後面的任務尚未執行，即在數據庫中沒有部門經理能夠辦理的任務，因此查詢不到。 一個Task節點和Execution節點是1對1的狀況，在task對象中使用Execution_來表示他們之間的關係任務ID在數據庫表act_ru_task中對應「ID_」列。

　　在activiti任務中，主要分爲兩大類查詢任務（我的任務和組任務）：

1.確切指定了辦理者的任務，這個任務將成爲指定者的私有任務，即我的任務。

2.沒法指定具體的某一我的來辦理的任務，能夠把任務分配給幾我的或者一到 多個小組，讓這個範圍內的用戶能夠選擇性（若有空餘時間時）來辦理這類任務，即組任務。

 6.3 辦理任務

    /**完成個人任務*/
    @Test
    public void completeMyPersonalTask(){
        //任務ID
        String taskId = "1202";
        processEngine.getTaskService()//與正在執行的任務管理相關的Service
                .complete(taskId);
        System.out.println("完成任務：任務ID："+taskId);
    }

　　是辦理任務，因此從ProcessEngine獲得的是TaskService。當執行完這段代碼，再以員工的身份去執行查詢的時候，會發現這個時候已經沒有數據了，由於正在執行的任務中沒有數據。對於執行完的任務，activiti將從act_ru_task表中刪除該任務，下一個任務會被插入進來。以」部門經理」的身份進行查詢，能夠查到結果。由於流程執行到部門經理審批這個節點了。再執行辦理任務代碼，執行完之後以」部門經理」身份進行查詢，沒有結果。重複這個步驟直到流程執行完。

6.4 查詢流程狀態（判斷流程是正在執行仍是結束）

    /**查詢流程狀態（判斷流程正在執行，仍是結束）*/
    @Test
    public void isProcessEnd(){
        String processInstanceId = "1001";
        ProcessInstance pi = processEngine.getRuntimeService()//表示正在執行的流程實例和執行對象
                .createProcessInstanceQuery()//建立流程實例查詢
                .processInstanceId(processInstanceId)//使用流程實例ID查詢
                .singleResult();
        if(pi==null){
            System.out.println("流程已經結束");
        }
        else{
            System.out.println("流程沒有結束");
        }
    }

       在流程執行的過程當中，建立的流程實例ID在整個過程當中都不會變，當流程結束後，流程實例將會在正在執行的執行對象表中（act_ru_execution）被刪除。

　　由於是查詢流程實例，因此先獲取runtimeService，建立流程實例查詢對象，設置實例ID過濾參數，因爲一個流程實例ID只對應一個實例，使用singleResult執行查詢返回一個惟一的結果，若是結果數量大於1，則拋出異常，判斷指定ID的實例是否存在，若是結果爲空，則表明流程結束，實例在正在執行的執行對象表中已被刪除，轉換成歷史數據。

6.5 查詢歷史任務

/**查詢歷史任務*/
@Test
public void findHistoryTask(){
    String taskAssignee = "張三";
    List<HistoricTaskInstance> list = processEngine.getHistoryService()//與歷史數據（歷史表）相關的Service
            .createHistoricTaskInstanceQuery()//建立歷史任務實例查詢
            .taskAssignee(taskAssignee)//指定歷史任務的辦理人
            .list();
    if(list!=null && list.size()>0){
        for(HistoricTaskInstance hti:list){
            System.out.println(hti.getId()+"    "+hti.getName()+"    "+hti.getProcessInstanceId()+"   "+hti.getStartTime()+"   "+hti.getEndTime()+"   "+hti.getDurationInMillis());
            System.out.println("################################");
        }
    }
}

6.6 查詢歷史流程實例

/**查詢歷史流程實例*/
@Test
public void findHistoryProcessInstance(){
    String processInstanceId = "1001";
    HistoricProcessInstance hpi = processEngine.getHistoryService()//與歷史數據（歷史表）相關的Service
            .createHistoricProcessInstanceQuery()//建立歷史流程實例查詢
            .processInstanceId(processInstanceId)//使用流程實例ID查詢
            .singleResult();
    System.out.println(hpi.getId()+"    "+hpi.getProcessDefinitionId()+"    "+hpi.getStartTime()+"    "+hpi.getEndTime()+"     "+hpi.getDurationInMillis());
}

7、流程變量

流程變量涉及到的表

7.1模擬獲取流程變量的場景

/**模擬設置和獲取流程變量的場景 */
@Test
public void setAndGetVariables(){
    RuntimeService runtimeService = processEngine.getRuntimeService();
    TaskService taskService = processEngine.getTaskService();

    //使用執行對象ID設置
    runtimeService.setVariable(executionId, variableName, value);（設置一個）
    runtimeService.setVariables(executionId, variables);

    //使用任務ID設置
    taskService.setVariable(taskId, variableName, value);（設置一個）
    taskService.setVariables(taskId, variables);

    //啓動流程實例的同時設置
    runtimeService.startProcessInstanceByKey(processDefinitionKey, variables);

    //完成任務的同時設置
    taskService.complete(taskId, variables);

    /**獲取流程變量*/
    //使用執行對象ID和流程變量的名稱，獲取流程變量的值
    runtimeService.getVariable(executionId, variableName);
    //使用執行對象ID，獲取全部的流程變量，將流程變量放置到Map集合中，map集合的key就是流程變量的名稱，map集合的value就是流程變量的值
    runtimeService.getVariables(executionId);
    //使用執行對象ID，獲取流程變量的值，經過設置流程變量的名稱存放到集合中，獲取指定流程變量名稱的流程變量的值，值存放到Map集合中
    runtimeService.getVariables(executionId, variableNames);

    //使用任務ID和流程變量的名稱，獲取流程變量的值
    taskService.getVariable(taskId, variableName);
    //使用任務ID，獲取全部的流程變量，將流程變量放置到Map集合中，map集合的key就是流程變量的名稱，map集合的value就是流程變量的值
    taskService.getVariables(taskId);
    //使用任務ID，獲取流程變量的值，經過設置流程變量的名稱存放到集合中，獲取指定流程變量名稱的流程變量的值，值存放到Map集合中
    taskService.getVariables(taskId, variableNames);
}

7.2 設置流程變量

/**設置流程變量 */
@Test
public void setVariables(){
    TaskService taskService = processEngine.getTaskService();
    //任務ID
    String taskId = "50004";
    //1、設置流程變量，使用基本數據類型
    taskService.setVariableLocal(taskId,"請假天數",3);//local與當前task綁定，下一個task不可見
    taskService.setVariable(taskId,"請假日期",new Date());
    taskService.setVariable(taskId,"請假緣由","回家探親");
    //二：設置流程變量，使用javabean類型
    /**
     * 當一個javabean（實現序列號）放置到流程變量中，要求javabean的屬性不能再發生變化
     *    * 若是發生變化，再獲取的時候，拋出異常
     *
     * 解決方案：在Person對象中添加：
     *         private static final long serialVersionUID = 6757393795687480331L;
     *      同時實現Serializable 
     * */
    Person p = new Person();
    p.setId(20);
    p.setName("翠花");
    taskService.setVariable(taskId, "人員信息(添加固定版本)", p);

    System.out.println("流程變量設置成功");
}

流程變量支持的類型：

　　從圖中能夠看出包括了大部分封裝類型和Date、String和實現了Serializable接口的類的類型。流程變量的獲取針對流程實例（即1個流程），每一個流程實例獲取的流程變量時不一樣的，使用基本類型獲取流程變量，在taskService中使用任務ID，流程變量的名稱，獲取流程變量的值。Javabean類型設置獲取流程變量，除了須要這個javabean實現了Serializable接口外，還要求流程變量對象的屬性不能發生變化，不然拋出異常。解決方案，固定序列化ID。

setVariable和setVariableLocal的區別：

setVariable：設置流程變量的時候，流程變量名稱相同的時候，後一次的值替換前一次的值，並且能夠看到TASK_ID的字段不會存聽任務ID的值

setVariableLocal：

1. 設置流程變量的時候，針對當前活動的節點設置流程變量，若是一個流程中存在2個活動節點，對每一個活動節點都設置流程變量，即便流程變量的名稱相同，後一次的版本的值也不會替換前一次版本的值，它會使用不一樣的任務ID做爲標識，存放2個流程變量值，並且能夠看到TASK_ID的字段會存聽任務ID的值

例如act_hi_varinst 表的數據：不一樣的任務節點，即便流程變量名稱相同，存放的值也是不一樣的。

如圖：

2. 使用setVariableLocal說明流程變量綁定了當前的任務，當流程繼續執行時，下個任務獲取不到這個流程變量（由於正在執行的流程變量中沒有這個數據），全部查詢正在執行的任務時不能查詢到咱們須要的數據，此時須要查詢歷史的流程變量。

7.3 獲取流程變量

/**獲取流程變量 */
@Test
public void getVariables(){
    TaskService taskService = processEngine.getTaskService();
    //任務ID
    String taskId = "55002";
    /**一：獲取流程變量，使用基本數據類型*/
    Integer days = (Integer) taskService.getVariable(taskId, "請假天數");
    Date date = (Date) taskService.getVariable(taskId, "請假日期");
    String resean = (String) taskService.getVariable(taskId, "請假緣由");
    System.out.println("請假天數："+days);
    System.out.println("請假日期："+date);
    System.out.println("請假緣由："+resean);
    /**二：獲取流程變量，使用javabean類型*/
    Person p = (Person)taskService.getVariable(taskId, "人員信息(添加固定版本)");
    System.out.println(p.getId()+"        "+p.getName());
}

7.4 查詢歷史流程變量

/**查詢流程變量的歷史表*/
@Test
public void findHistoryProcessVariables(){
    List<HistoricVariableInstance> list = processEngine.getHistoryService()//
            .createHistoricVariableInstanceQuery()//建立一個歷史的流程變量查詢對象
            .variableName("請假天數")
            .list();
    if(list!=null && list.size()>0){
        for(HistoricVariableInstance hvi:list){
            System.out.println(hvi.getId()+"   "+hvi.getProcessInstanceId()+"   "+hvi.getVariableName()+"   "+hvi.getVariableTypeName()+"    "+hvi.getValue());
            System.out.println("###############################################");
        }
    }
}

 　　歷史的流程變量查詢，指定流程變量的名稱，查詢act_hi_varinst表（也能夠針對，流程實例ID，執行對象ID，任務ID查詢）