摘要：介紹什么是是由軟件在年月日發(fā)布的業(yè)務(wù)流程管理框架，它是覆蓋了業(yè)務(wù)流程管理工作流服務(wù)協(xié)作等領(lǐng)域的一個(gè)開源的靈活的易擴(kuò)展的可執(zhí)行流程語(yǔ)言框架。第二部分是表示表的用途的兩個(gè)字母標(biāo)識(shí)。

Activiti5是由Alfresco軟件在2010年5月17日發(fā)布的業(yè)務(wù)流程管理（BPM）框架，它是覆蓋了業(yè)務(wù)流程管理、工作流、服務(wù)協(xié)作等領(lǐng)域的一個(gè)開源的、靈活的、易擴(kuò)展的可執(zhí)行流程語(yǔ)言框架。Activiti基于Apache許可的開源BPM平臺(tái)，創(chuàng)始人Tom Baeyens是JBoss jBPM的項(xiàng)目架構(gòu)師，它特色是提供了eclipse插件，開發(fā)人員可以通過(guò)插件直接繪畫出業(yè)務(wù)
流程圖。.

我們即將學(xué)習(xí)的是一個(gè)業(yè)務(wù)流程管理框架， 常見(jiàn)開源工作流引擎框架 ： OSWorkFlow、jBPM（jboss business process management），Activiti工作流（是對(duì)jBPM升級(jí)）。一般我們稱作為工作流框架..

那我們?yōu)槭裁匆獙W(xué)習(xí)業(yè)務(wù)流程管理框架呢？？？學(xué)習(xí)它干嘛？？？工作流（Workflow），就是“業(yè)務(wù)過(guò)程的部分或整體在計(jì)算機(jī)應(yīng)用環(huán)境下的自動(dòng)化”

我們來(lái)提出一個(gè)常見(jiàn)的需求來(lái)更好地理解：

我們?cè)趯W(xué)生時(shí)代，肯定會(huì)遇到請(qǐng)假寫請(qǐng)假條的情況，如果學(xué)校的請(qǐng)假抓得非常嚴(yán)，就需要經(jīng)過(guò)多層的同意才能確定能不能請(qǐng)假..

班主任->任課老師->教學(xué)總監(jiān)->校長(zhǎng)這么一個(gè)流程，首先我們先明確一點(diǎn)：我們作為一個(gè)學(xué)生，不可能直接跳過(guò)老師，去找校長(zhǎng)申請(qǐng)請(qǐng)假的【校長(zhǎng)是你隨便找的嗎？？】

因此我們請(qǐng)假的流程是一步一步的，并不能做跳躍

也就是說(shuō)，當(dāng)班主任沒(méi)有批準(zhǔn)請(qǐng)假的時(shí)候，即使你去找任課老師了，任課老師會(huì)讓你回去找班主任的，作為任課老師了，只關(guān)注班主任有沒(méi)有批準(zhǔn)你請(qǐng)假，同理，作為校長(zhǎng)，只關(guān)注教學(xué)總監(jiān)有沒(méi)有批準(zhǔn)你請(qǐng)假！

進(jìn)一步說(shuō)：當(dāng)教學(xué)總監(jiān)還沒(méi)有批準(zhǔn)你請(qǐng)假時(shí)，你請(qǐng)假的請(qǐng)求是不會(huì)出現(xiàn)在校長(zhǎng)的范圍里的。

其實(shí)是非常好理解的，就是一步步往下執(zhí)行，當(dāng)還沒(méi)有執(zhí)行到自己處理的點(diǎn)子上時(shí)，是不會(huì)有對(duì)應(yīng)的處理請(qǐng)求的。分工有序

對(duì)上面的請(qǐng)假流程進(jìn)行分析，如果我們沒(méi)有使用框架，而把這么一個(gè)請(qǐng)假流程寫到我們的網(wǎng)站中，我們會(huì)怎么做呢？？

我們需要維護(hù)一個(gè)變量，來(lái)不斷傳遞過(guò)去給下一個(gè)處理者...如果一切正常，需求不會(huì)變，并沒(méi)有條件的處理。這是我們非常希望看到的...但是，如果有條件判斷【請(qǐng)假三天以下、請(qǐng)假三天以上的處理方式不一樣】，需求會(huì)變【不需要校長(zhǎng)批準(zhǔn)了，教學(xué)總監(jiān)批準(zhǔn)完，你就能夠請(qǐng)假了】，那么我們的代碼就會(huì)變得亂

基于這么一個(gè)原因，我們是需要學(xué)習(xí)一個(gè)框架來(lái)幫我們完成工作流的...

采用工作流管理系統(tǒng)的優(yōu)點(diǎn)

1、提高系統(tǒng)的柔性，適應(yīng)業(yè)務(wù)流程的變化

2、實(shí)現(xiàn)更好的業(yè)務(wù)過(guò)程控制，提高顧客服務(wù)質(zhì)量

3、降低系統(tǒng)開發(fā)和維護(hù)成本

首先我們來(lái)梳理一下Activiti的開發(fā)步驟：

我們要用到一個(gè)工作流，首先就要把這個(gè)工作流定義出來(lái)【也就是工作流的步驟的怎么樣的】，Activiti支持以“圖”的方式來(lái)定義工作流

定義完工作流，就要部署到起來(lái)【我們可以聯(lián)想到Tomcat，我們光下載了Tomcat是沒(méi)有用的，要把它部署起來(lái)】

隨后我們就執(zhí)行該工作流，該工作流就隨著我們定義的步驟來(lái)一一執(zhí)行！

業(yè)務(wù)流程建模與標(biāo)注（Business Process Model and Notation，BPMN) ，描述流程的基本符號(hào)，包括這些圖元如何組合成一個(gè)業(yè)務(wù)流程圖（Business Process Diagram）

BPMN這個(gè)就是我們所謂把工作流定義出來(lái)的流程圖..

我們?cè)?strong>執(zhí)行工作流步驟的時(shí)候會(huì)涉及到很多數(shù)據(jù)【執(zhí)行該流程的人是誰(shuí)、所需要的參數(shù)是什么、包括想查看之前流程執(zhí)行的記錄等等】，因此我們會(huì)需要用到數(shù)據(jù)庫(kù)的表來(lái)保存數(shù)據(jù)...

由于我們使用的是Activiti框架，這個(gè)框架會(huì)自動(dòng)幫我們把對(duì)應(yīng)的數(shù)據(jù)庫(kù)表創(chuàng)建起來(lái)，它涉及的表有23個(gè)，但是常用的并不是很多，因此也不用很慌...

下面就列舉一下表的情況

Activiti的后臺(tái)是有數(shù)據(jù)庫(kù)的支持，所有的表都以ACT_開頭。 第二部分是表示表的用途的兩個(gè)字母標(biāo)識(shí)。 用途也和服務(wù)的API對(duì)應(yīng)。
ACT_RE_*: "RE"表示repository。 這個(gè)前綴的表包含了流程定義和流程靜態(tài)資源 （圖片，規(guī)則，等等）。
ACT_RU_*: "RU"表示runtime。 這些運(yùn)行時(shí)的表，包含流程實(shí)例，任務(wù)，變量，異步任務(wù)，等運(yùn)行中的數(shù)據(jù)。 Activiti只在流程實(shí)例執(zhí)行過(guò)程中保存這些數(shù)據(jù)， 在流程結(jié)束時(shí)就會(huì)刪除這些記錄。 這樣運(yùn)行時(shí)表可以一直很小速度很快。
ACT_ID_*: "ID"表示identity。 這些表包含身份信息，比如用戶，組等等。
ACT_HI_*: "HI"表示history。 這些表包含歷史數(shù)據(jù)，比如歷史流程實(shí)例， 變量，任務(wù)等等。
ACT_GE_*: 通用數(shù)據(jù)， 用于不同場(chǎng)景下，如存放資源文件。

我這里使用的Intellij idea來(lái)使用Activiti，首先，我們得下載插件來(lái)使用Activiti【因?yàn)槎x流程圖需要用到插件】

詳情可以看這篇博文：http://blog.sina.com.cn/s/blog_4b3196670102woix.html

Activiti插件中文亂碼問(wèn)題：

http://www.cnblogs.com/mymelody/p/6049291.html

流程之前的連線是通過(guò)圖中的藍(lán)色小點(diǎn)點(diǎn)拖動(dòng)來(lái)進(jìn)行連接的...

導(dǎo)入對(duì)應(yīng)的jar包

activation-1.1.jar

activiti-bpmn-converter-5.13.jar

activiti-bpmn-layout-5.13.jar

activiti-bpmn-model-5.13.jar

activiti-common-rest-5.13.jar

activiti-engine-5.13.jar

activiti-json-converter-5.13.jar

activiti-rest-5.13.jar

activiti-simple-workflow-5.13.jar

activiti-spring-5.13.jar

aopalliance-1.0.jar

commons-dbcp-1.4.jar

commons-email-1.2.jar

commons-fileupload-1.2.2.jar

commons-io-2.0.1.jar

commons-lang-2.4.jar

commons-pool-1.5.4.jar

h2-1.3.170.jar

hamcrest-core-1.3.jar

jackson-core-asl-1.9.9.jar

jackson-mapper-asl-1.9.9.jar

javaGeom-0.11.0.jar

jcl-over-slf4j-1.7.2.jar

jgraphx-1.10.4.2.jar

joda-time-2.1.jar

junit-4.11.jar

log4j-1.2.17.jar

mail-1.4.1.jar

mybatis-3.2.2.jar

mysql-connector-java.jar

org.restlet.ext.fileupload-2.0.15.jar

org.restlet.ext.jackson-2.0.15.jar

org.restlet.ext.servlet-2.0.15.jar

org.restlet-2.0.15.jar

slf4j-api-1.7.2.jar

slf4j-log4j12-1.7.2.jar

spring-aop-3.1.2.RELEASE.jar

spring-asm-3.1.2.RELEASE.jar

spring-beans-3.1.2.RELEASE.jar

spring-context-3.1.2.RELEASE.jar

spring-core-3.1.2.RELEASE.jar

spring-expression-3.1.2.RELEASE.jar

spring-jdbc-3.1.2.RELEASE.jar

spring-orm-3.1.2.RELEASE.jar

spring-tx-3.1.2.RELEASE.jar

上面已經(jīng)說(shuō)過(guò)了，我們要想使用Activiti就需要有數(shù)據(jù)庫(kù)的支持，雖然Activiti是自動(dòng)幫我們創(chuàng)建對(duì)應(yīng)的數(shù)據(jù)庫(kù)表，但是我們是需要配置數(shù)據(jù)庫(kù)的信息的。我們配置數(shù)據(jù)庫(kù)的信息，接著拿到Activiti最重要的API------Activiti引擎

Activiti提供使用代碼的方式來(lái)配置數(shù)據(jù)庫(kù)的信息：

    @Test
    public void createActivitiEngine(){

/*        *1.通過(guò)代碼形式創(chuàng)建
         *  - 取得ProcessEngineConfiguration對(duì)象
         *  - 設(shè)置數(shù)據(jù)庫(kù)連接屬性
         *  - 設(shè)置創(chuàng)建表的策略 （當(dāng)沒(méi)有表時(shí)，自動(dòng)創(chuàng)建表）
         *  - 通過(guò)ProcessEngineConfiguration對(duì)象創(chuàng)建 ProcessEngine 對(duì)象*/

         //取得ProcessEngineConfiguration對(duì)象
         ProcessEngineConfiguration engineConfiguration=ProcessEngineConfiguration.
         createStandaloneProcessEngineConfiguration();
         //設(shè)置數(shù)據(jù)庫(kù)連接屬性
         engineConfiguration.setJdbcDriver("com.mysql.jdbc.Driver");
         engineConfiguration.setJdbcUrl("jdbc:mysql://localhost:3306/activitiDB?createDatabaseIfNotExist=true"
         + "&useUnicode=true&characterEncoding=utf8");
         engineConfiguration.setJdbcUsername("root");
         engineConfiguration.setJdbcPassword("root");


         // 設(shè)置創(chuàng)建表的策略 （當(dāng)沒(méi)有表時(shí)，自動(dòng)創(chuàng)建表）
         //          public static final java.lang.String DB_SCHEMA_UPDATE_FALSE = "false";//不會(huì)自動(dòng)創(chuàng)建表，沒(méi)有表，則拋異常
         //          public static final java.lang.String DB_SCHEMA_UPDATE_CREATE_DROP = "create-drop";//先刪除，再創(chuàng)建表
         //          public static final java.lang.String DB_SCHEMA_UPDATE_TRUE = "true";//假如沒(méi)有表，則自動(dòng)創(chuàng)建
         engineConfiguration.setDatabaseSchemaUpdate("true");
         //通過(guò)ProcessEngineConfiguration對(duì)象創(chuàng)建 ProcessEngine 對(duì)象
        ProcessEngine processEngine = engineConfiguration.buildProcessEngine();
         System.out.println("流程引擎創(chuàng)建成功!");
        
    }

Activiti也可以通過(guò)配置文件來(lái)配置數(shù)據(jù)庫(kù)的信息，加載配置文件從而得到工作流引擎

        /**2. 通過(guò)加載 activiti.cfg.xml 獲取 流程引擎 和自動(dòng)創(chuàng)建數(shù)據(jù)庫(kù)及表
         * 
         
        ProcessEngineConfiguration engineConfiguration=
                ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cfg.xml");
            //從類加載路徑中查找資源  activiti.cfg.xm文件名可以自定義
        ProcessEngine processEngine = engineConfiguration.buildProcessEngine();
        System.out.println("使用配置文件Activiti.cfg.xml獲取流程引擎");
        */

activiti.cfg.xml

上面的那種加載配置文件方式，配置文件的名字是可以自定義的，如果我們配置文件的名字默認(rèn)就是activiti.cfg.xml的話，也是放在類路徑下，我們就可以使用默認(rèn)的方式來(lái)進(jìn)行加載了！

    @Test
    public void createActivitiEngine(){
        /**
         * 3. 通過(guò)ProcessEngines 來(lái)獲取默認(rèn)的流程引擎
         */
        //  默認(rèn)會(huì)加載類路徑下的 activiti.cfg.xml
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        System.out.println("通過(guò)ProcessEngines 來(lái)獲取流程引擎");
    }

定義工作流就需要我們剛才下載的插件了，我們是使用圖形的方式來(lái)定義工作流的....

在每個(gè)流程中，我們都可以指定對(duì)應(yīng)的處理人是誰(shuí)，交由誰(shuí)處理

我們上面已經(jīng)定義了工作流了，工作流引擎我們也已經(jīng)拿到了，接下來(lái)就是把工作流部署到工作流引擎中了

    @Test
    public void deploy() {

        //獲取倉(cāng)庫(kù)服務(wù) ：管理流程定義
        RepositoryService repositoryService = processEngine.getRepositoryService();
        Deployment deploy = repositoryService.createDeployment()//創(chuàng)建一個(gè)部署的構(gòu)建器
                .addClasspathResource("LeaveActiviti.bpmn")//從類路徑中添加資源,一次只能添加一個(gè)資源
                .name("請(qǐng)求單流程")//設(shè)置部署的名稱
                .category("辦公類別")//設(shè)置部署的類別
                .deploy();

        System.out.println("部署的id"+deploy.getId());
        System.out.println("部署的名稱"+deploy.getName());
    }

相對(duì)應(yīng)的數(shù)據(jù)庫(kù)表就會(huì)插入數(shù)據(jù)、涉及到的數(shù)據(jù)庫(kù)表后面會(huì)詳細(xì)說(shuō)明。現(xiàn)在我們只要了解到，我們工作流引擎執(zhí)行操作會(huì)有數(shù)據(jù)庫(kù)表記錄

指定指定工作流就是我們定義時(shí)工作流程表的id

    @Test
    public void startProcess(){

        //指定執(zhí)行我們剛才部署的工作流程
        String processDefiKey="leaveBill";
        //取運(yùn)行時(shí)服務(wù)
        RuntimeService runtimeService = processEngine.getRuntimeService();
        //取得流程實(shí)例
        ProcessInstance pi = runtimeService.startProcessInstanceByKey(processDefiKey);//通過(guò)流程定義的key 來(lái)執(zhí)行流程
        System.out.println("流程實(shí)例id:"+pi.getId());//流程實(shí)例id
        System.out.println("流程定義id:"+pi.getProcessDefinitionId());//輸出流程定義的id
    }

剛才我們已經(jīng)開始了工作流了，隨后工作流應(yīng)該去到了申請(qǐng)請(qǐng)假的流程，申請(qǐng)請(qǐng)假的處理人是鐘福成，我們可以查詢出對(duì)應(yīng)的信息：

    //查詢?nèi)蝿?wù)
    @Test
    public void queryTask(){
        //任務(wù)的辦理人
        String assignee="鐘福成";
        //取得任務(wù)服務(wù)
        TaskService taskService = processEngine.getTaskService();
        //創(chuàng)建一個(gè)任務(wù)查詢對(duì)象
        TaskQuery taskQuery = taskService.createTaskQuery();
        //辦理人的任務(wù)列表
        List list = taskQuery.taskAssignee(assignee)//指定辦理人
                .list();
        //遍歷任務(wù)列表
        if(list!=null&&list.size()>0){
            for(Task task:list){
                System.out.println("任務(wù)的辦理人："+task.getAssignee());
                System.out.println("任務(wù)的id："+task.getId());
                System.out.println("任務(wù)的名稱："+task.getName());
            }
        }
    }

我們現(xiàn)在處理流程去到“申請(qǐng)請(qǐng)假”中，處理人是鐘福成...接著就是鐘福成去處理任務(wù)，根據(jù)任務(wù)的id使得流程繼續(xù)往下走

任務(wù)的id剛才我們已經(jīng)查詢出來(lái)了【上面】，我們?nèi)绻窃趙eb端操作數(shù)據(jù)的話，那么只要傳遞過(guò)去就行了！

    //完成任務(wù)
    @Test
    public void compileTask(){
        String taskId="304";
        //taskId：任務(wù)id
        processEngine.getTaskService().complete(taskId);
        System.out.println("當(dāng)前任務(wù)執(zhí)行完畢");
    }

當(dāng)我們處理完該任務(wù)的時(shí)候，就到了批準(zhǔn)【班主任】任務(wù)了，我們查詢一下是不是如我們想象的效果：

我們按照定義的工作流程圖一步一步往下走，最終把流程走完

管理流程定義主要涉及到以下的4張表：

-- 流程部署相關(guān)的表
SELECT * FROM act_ge_bytearray # 通用字節(jié)資源表

SELECT * FROM act_ge_property # 通用屬性表，可以生成部署id

SELECT * FROM act_re_deployment  #部署表

SELECT * FROM act_re_procdef    # 流程定義表

在Eclipse中Activiti插件會(huì)自動(dòng)生成一個(gè)BPMN與之對(duì)應(yīng)的PNG圖片，是需要通過(guò)加載PNG圖片的

    @Test
    public void deploy() {

        //獲取倉(cāng)庫(kù)服務(wù) ：管理流程定義
        RepositoryService repositoryService = processEngine.getRepositoryService();
        Deployment deploy = repositoryService.createDeployment()//創(chuàng)建一個(gè)部署的構(gòu)建器
                .addClasspathResource("LeaveActiviti.bpmn")//從類路徑中添加資源,一次只能添加一個(gè)資源
                .name("請(qǐng)求單流程")//設(shè)置部署的名稱
                .category("辦公類別")//設(shè)置部署的類別
                .deploy();

        System.out.println("部署的id"+deploy.getId());
        System.out.println("部署的名稱"+deploy.getName());
    }

而我們的Intellij idea插件不會(huì)自動(dòng)生成PNG圖片，但是我們?cè)诩虞dBPMN文件的時(shí)候，好像會(huì)自動(dòng)插入PNG圖片，數(shù)據(jù)庫(kù)是有對(duì)應(yīng)的記錄的【我們是沒(méi)有手動(dòng)加載PNG圖片資源的】

我們查看一下

    //查看bpmn 資源圖片
    @Test
    public void viewImage() throws Exception{
        String deploymentId="201";
        String imageName=null;
        //取得某個(gè)部署的資源的名稱  deploymentId
        List resourceNames = processEngine.getRepositoryService().getDeploymentResourceNames(deploymentId);
        // buybill.bpmn  buybill.png
        if(resourceNames!=null&&resourceNames.size()>0){
            for(String temp :resourceNames){
                if(temp.indexOf(".png")>0){
                    imageName=temp;
                }
            }
        }

        /**
         * 讀取資源
         * deploymentId:部署的id
         * resourceName：資源的文件名
         */
        InputStream resourceAsStream = processEngine.getRepositoryService()
                .getResourceAsStream(deploymentId, imageName);

        //把文件輸入流寫入到文件中
        File file=new File("d:/"+imageName);
        FileUtils.copyInputStreamToFile(resourceAsStream, file);
    }

可惜的是，查看出來(lái)的圖片的中文數(shù)據(jù)會(huì)亂碼...

我們當(dāng)時(shí)候查詢流程定義是通過(guò)我們?cè)O(shè)置流程圖的id來(lái)查看的....其實(shí)我們可以通過(guò)其他的屬性來(lái)查詢...并且可以查詢出更加詳細(xì)的數(shù)據(jù)

    //查看流程定義
    @Test
    public void queryProcessDefination(){
        String processDefiKey="buyBill";//流程定義key
        //獲取流程定義列表
        List list = processEngine.getRepositoryService().createProcessDefinitionQuery()
        //查詢 ，好比where
//        .processDefinitionId(proDefiId) //流程定義id
         // 流程定義id  ： buyBill:2:704   組成 ： proDefikey（流程定義key）+version(版本)+自動(dòng)生成id
        .processDefinitionKey(processDefiKey)//流程定義key 由bpmn 的 process 的  id屬性決定
//        .processDefinitionName(name)//流程定義名稱  由bpmn 的 process 的  name屬性決定
//        .processDefinitionVersion(version)//流程定義的版本
        .latestVersion()//最新版本
        
        //排序
        .orderByProcessDefinitionVersion().desc()//按版本的降序排序
        
        //結(jié)果
//        .count()//統(tǒng)計(jì)結(jié)果
//        .listPage(arg0, arg1)//分頁(yè)查詢
        .list();
        
        
        //遍歷結(jié)果
        if(list!=null&&list.size()>0){
            for(ProcessDefinition temp:list){
                System.out.print("流程定義的id: "+temp.getId());
                System.out.print("流程定義的key: "+temp.getKey());
                System.out.print("流程定義的版本: "+temp.getVersion());
                System.out.print("流程定義部署的id: "+temp.getDeploymentId());
                System.out.println("流程定義的名稱: "+temp.getName());
            }
        }
    }

我們還可以加載的是ZIP類型的資源數(shù)據(jù)

    //部署流程定義,資源來(lái)自zip格式
    @Test
    public void deployProcessDefiByZip(){
        InputStream in=getClass().getClassLoader().getResourceAsStream("BuyBill.zip");
        Deployment deploy = processEngine.getRepositoryService()
                .createDeployment()
                .name("采購(gòu)流程")
                .addZipInputStream(new ZipInputStream(in))
                .deploy();
        
        System.out.println("部署名稱:"+deploy.getName());
        System.out.println("部署id:"+deploy.getId());
    }

    //刪除流程定義
    @Test
    public void deleteProcessDefi(){
        //通過(guò)部署id來(lái)刪除流程定義
        String deploymentId="101";
        processEngine.getRepositoryService().deleteDeployment(deploymentId);
    }

再次查詢的時(shí)候，已經(jīng)沒(méi)有101這個(gè)流程定義的數(shù)據(jù)了。

流程實(shí)例與任務(wù)執(zhí)行的常用表有以下幾個(gè)：

-- 流程實(shí)例與任務(wù)

SELECT * FROM act_ru_execution  # 流程執(zhí)行對(duì)象信息
SELECT * FROM act_ru_task   # 正在運(yùn)行的任務(wù)表

SELECT * FROM act_hi_procinst # 歷史流程實(shí)例表
SELECT * FROM act_hi_taskinst  # 歷史流程任務(wù)表

這里就簡(jiǎn)單簡(jiǎn)述一下流程實(shí)例與流程對(duì)象的區(qū)別：

（1）如果是單例流程，執(zhí)行對(duì)象ID就是流程實(shí)例ID

（2）如果一個(gè)流程有分支和聚合，那么執(zhí)行對(duì)象ID和流程實(shí)例ID就不相同

（3）一個(gè)流程中，流程實(shí)例只有1個(gè)，執(zhí)行對(duì)象可以存在多個(gè)。

    @Test
    public void startProcess(){
        String processDefiKey="leaveActiviti";//bpmn 的 process id屬性
        ProcessInstance pi = processEngine.getRuntimeService()
                .startProcessInstanceByKey(processDefiKey);

        System.out.println("流程執(zhí)行對(duì)象的id："+pi.getId());//Execution 對(duì)象
        System.out.println("流程實(shí)例的id："+pi.getProcessInstanceId());//ProcessInstance 對(duì)象
        System.out.println("流程定義的id："+pi.getProcessDefinitionId());//默認(rèn)執(zhí)行的是最新版本的流程定義
    }

//查詢正在運(yùn)行任務(wù) 
    @Test
    public void queryTask(){
        //取得任務(wù)服務(wù)
        TaskService taskService = processEngine.getTaskService();
        //創(chuàng)建一個(gè)任務(wù)查詢對(duì)象
        TaskQuery taskQuery = taskService.createTaskQuery();
        //辦理人的任務(wù)列表
        List list = taskQuery.list();
        //遍歷任務(wù)列表
        if(list!=null&&list.size()>0){
            for(Task task:list){
                System.out.println("任務(wù)的辦理人："+task.getAssignee());
                System.out.println("任務(wù)的id："+task.getId());
                System.out.println("任務(wù)的名稱："+task.getName());
                
            }
        }
        
    }

查詢SELECT * FROM act_ru_task 表

有的時(shí)候，我們需要判斷它是在該流程，還是該流程已經(jīng)結(jié)束了。我們可以根據(jù)獲取出來(lái)的對(duì)象是否為空來(lái)進(jìn)行判斷

    //獲取流程實(shí)例的狀態(tài)
    @Test
    public void getProcessInstanceState(){
        String processInstanceId="605";
        ProcessInstance pi = processEngine.getRuntimeService()
                .createProcessInstanceQuery()
                .processInstanceId(processInstanceId)
                .singleResult();//返回的數(shù)據(jù)要么是單行，要么是空 ，其他情況報(bào)錯(cuò)
        //判斷流程實(shí)例的狀態(tài)
        if(pi!=null){
            System.out.println("該流程實(shí)例"+processInstanceId+"正在運(yùn)行...  "+"當(dāng)前活動(dòng)的任務(wù):"+pi.getActivityId());
        }else{
            System.out.println("當(dāng)前的流程實(shí)例"+processInstanceId+" 已經(jīng)結(jié)束！");
        }

    }

    //查看歷史執(zhí)行流程實(shí)例信息
    @Test
    public void queryHistoryProcInst(){
        List list = processEngine.getHistoryService()
        .createHistoricProcessInstanceQuery()
        .list();
        if(list!=null&&list.size()>0){
            for(HistoricProcessInstance temp:list){
                System.out.println("歷史流程實(shí)例id:"+temp.getId());
                System.out.println("歷史流程定義的id:"+temp.getProcessDefinitionId());
                System.out.println("歷史流程實(shí)例開始時(shí)間--結(jié)束時(shí)間:"+temp.getStartTime()+"-->"+temp.getEndTime());
            }
        }
    }

查詢表：

    @Test
    public void queryHistoryTask(){
        String processInstanceId="605";
        List list = processEngine.getHistoryService()
                .createHistoricTaskInstanceQuery()
                .processInstanceId(processInstanceId)
                .list();
        if(list!=null&&list.size()>0){
            for(HistoricTaskInstance temp:list){
                System.out.print("歷史流程實(shí)例任務(wù)id:"+temp.getId());
                System.out.print("歷史流程定義的id:"+temp.getProcessDefinitionId());
                System.out.print("歷史流程實(shí)例任務(wù)名稱:"+temp.getName());
                System.out.println("歷史流程實(shí)例任務(wù)處理人:"+temp.getAssignee());
            }
        }
    }

給予對(duì)應(yīng)的實(shí)例id就可以查詢出執(zhí)行到哪個(gè)任務(wù)了...

根據(jù)任務(wù)的id，就可以把該任務(wù)執(zhí)行了。

    @Test
    public void compileTask(){
        String taskId="608";
        //taskId：任務(wù)id
        processEngine.getTaskService().complete(taskId);
        System.out.println("當(dāng)前任務(wù)執(zhí)行完畢");
    }

流程變量涉及到的數(shù)據(jù)庫(kù)表：

act_ru_variable：正在執(zhí)行的流程變量表
act_hi_varinst：流程變量歷史表

流程變量在工作流中扮演著一個(gè)非常重要的角色。例如：請(qǐng)假流程中有請(qǐng)假天數(shù)、請(qǐng)假原因等一些參數(shù)都為流程變量的范圍。流程變量的作用域范圍是只對(duì)應(yīng)一個(gè)流程實(shí)例。也就是說(shuō)各個(gè)流程實(shí)例的流程變量是不相互影響的。流程實(shí)例結(jié)束完成以后流程變量還保存在數(shù)據(jù)庫(kù)中（存放到流程變量的歷史表中）。

我們有兩種服務(wù)可以設(shè)置流程變量，TaskService【任務(wù)服務(wù)】和RuntimeService【運(yùn)行時(shí)服務(wù)】

場(chǎng)景

在流程開始的時(shí)候設(shè)置流程變量

在完成某個(gè)任務(wù)的時(shí)候設(shè)置流程變量

使用TaskService設(shè)置服務(wù)

使用RuntimeService設(shè)置服務(wù)

作用：

傳遞業(yè)務(wù)參數(shù)

動(dòng)態(tài)指定代理人【我們快速入門的例子是固定在流程定義圖上寫上代理人的】

指定連接【決定流程往哪邊走】

如果我們使用JavaBean來(lái)作為流程的變量，那么我們需要將JavaBean實(shí)現(xiàn)Serializable接口。

Javabean類型設(shè)置獲取流程變量，除了需要這個(gè)javabean實(shí)現(xiàn)了Serializable接口外，還要求流程變量對(duì)象的屬性不能發(fā)生變化，否則拋出異常。解決方案，固定序列化ID

//模擬流程變量設(shè)置
    @Test
    public void  getAndSetProcessVariable(){
        //有兩種服務(wù)可以設(shè)置流程變量
//        TaskService taskService = processEngine.getTaskService();
//        RuntimeService runtimeService = processEngine.getRuntimeService();
        
        /**1.通過(guò) runtimeService 來(lái)設(shè)置流程變量
         * executionId: 執(zhí)行對(duì)象
         * variableName：變量名
         * values：變量值
         */
//        runtimeService.setVariable(executionId, variableName, values);
//        runtimeService.setVariableLocal(executionId, variableName, values);
        //設(shè)置本執(zhí)行對(duì)象的變量 ，該變量的作用域只在當(dāng)前的execution對(duì)象
//        runtimeService.setVariables(executionId, variables); 
          //可以設(shè)置多個(gè)變量  放在 Map  Map
        
        /**2. 通過(guò)TaskService來(lái)設(shè)置流程變量
         * taskId：任務(wù)id
         */
//        taskService.setVariable(taskId, variableName, values);
//        taskService.setVariableLocal(taskId, variableName, values);
////        設(shè)置本執(zhí)行對(duì)象的變量 ，該變量的作用域只在當(dāng)前的execution對(duì)象
//        taskService.setVariables(taskId, variables); //設(shè)置的是Map
        
        /**3. 當(dāng)流程開始執(zhí)行的時(shí)候，設(shè)置變量參數(shù)
         * processDefiKey: 流程定義的key
         * variables： 設(shè)置多個(gè)變量  Map
         */
//        processEngine.getRuntimeService()
//        .startProcessInstanceByKey(processDefiKey, variables)
        
        /**4. 當(dāng)任務(wù)完成時(shí)候，可以設(shè)置流程變量
         * taskId:任務(wù)id
         * variables： 設(shè)置多個(gè)變量  Map
         */
//        processEngine.getTaskService().complete(taskId, variables);
        
        
        /** 5. 通過(guò)RuntimeService取變量值
         * exxcutionId： 執(zhí)行對(duì)象
         * 
         */
//        runtimeService.getVariable(executionId, variableName);//取變量
//        runtimeService.getVariableLocal(executionId, variableName);//取本執(zhí)行對(duì)象的某個(gè)變量
//        runtimeService.getVariables(variablesName);//取當(dāng)前執(zhí)行對(duì)象的所有變量
        /** 6. 通過(guò)TaskService取變量值
         * TaskId： 執(zhí)行對(duì)象
         * 
         */
//        taskService.getVariable(taskId, variableName);//取變量
//        taskService.getVariableLocal(taskId, variableName);//取本執(zhí)行對(duì)象的某個(gè)變量
//        taskService.getVariables(taskId);//取當(dāng)前執(zhí)行對(duì)象的所有變量
    }

    //設(shè)置流程變量值
    @Test
    public void setVariable(){
        String taskId="1804";//任務(wù)id
        //采用TaskService來(lái)設(shè)置流程變量
        
        //1. 第一次設(shè)置流程變量
//        TaskService taskService = processEngine.getTaskService();
//        taskService.setVariable(taskId, "cost", 1000);//設(shè)置單一的變量，作用域在整個(gè)流程實(shí)例
//        taskService.setVariable(taskId, "申請(qǐng)時(shí)間", new Date());
//        taskService.setVariableLocal(taskId, "申請(qǐng)人", "何某某");//該變量只有在本任務(wù)中是有效的
        
        
        //2. 在不同的任務(wù)中設(shè)置變量
//        TaskService taskService = processEngine.getTaskService();
//        taskService.setVariable(taskId, "cost", 5000);//設(shè)置單一的變量，作用域在整個(gè)流程實(shí)例
//        taskService.setVariable(taskId, "申請(qǐng)時(shí)間", new Date());
//        taskService.setVariableLocal(taskId, "申請(qǐng)人", "李某某");//該變量只有在本任務(wù)中是有效的
        
        /**
         * 3. 變量支持的類型
         * - 簡(jiǎn)單的類型 ：String 、boolean、Integer、double、date 
         * - 自定義對(duì)象bean  
         */
        TaskService taskService = processEngine.getTaskService();
        //傳遞的一個(gè)自定義bean對(duì)象
        AppayBillBean appayBillBean=new AppayBillBean();
        appayBillBean.setId(1);
        appayBillBean.setCost(300);
        appayBillBean.setDate(new Date());
        appayBillBean.setAppayPerson("何某某");
        taskService.setVariable(taskId, "appayBillBean", appayBillBean);
        
        
        System.out.println("設(shè)置成功！");

    }

    
    //查詢流程變量
    @Test
    public void getVariable(){
        String taskId="1804";//任務(wù)id
//        TaskService taskService = processEngine.getTaskService();
//        Integer cost=(Integer) taskService.getVariable(taskId, "cost");//取變量
//        Date date=(Date) taskService.getVariable(taskId, "申請(qǐng)時(shí)間");//取本任務(wù)中的變量
////        Date date=(Date) taskService.getVariableLocal(taskId, "申請(qǐng)時(shí)間");//取本任務(wù)中的變量
//        String appayPerson=(String) taskService.getVariableLocal(taskId, "申請(qǐng)人");//取本任務(wù)中的變量
////        String appayPerson=(String) taskService.getVariable(taskId, "申請(qǐng)人");//取本任務(wù)中的變量
//        
//        System.out.println("金額:"+cost);
//        System.out.println("申請(qǐng)時(shí)間:"+date);
//        System.out.println("申請(qǐng)人:"+appayPerson);
        
        
        //讀取實(shí)現(xiàn)序列化的對(duì)象變量數(shù)據(jù)
        TaskService taskService = processEngine.getTaskService();
        AppayBillBean appayBillBean=(AppayBillBean) taskService.getVariable(taskId, "appayBillBean");
        System.out.println(appayBillBean.getCost());
        System.out.println(appayBillBean.getAppayPerson());
        
    }

public class AppayBillBean  implements Serializable{
    private Integer id;
    private Integer cost;//金額
    private String appayPerson;//申請(qǐng)人
    private Date date;//申請(qǐng)日期
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public Integer getCost() {
        return cost;
    }
    public void setCost(Integer cost) {
        this.cost = cost;
    }
    public String getAppayPerson() {
        return appayPerson;
    }
    public void setAppayPerson(String appayPerson) {
        this.appayPerson = appayPerson;
    }
    public Date getDate() {
        return date;
    }
    public void setDate(Date date) {
        this.date = date;
    }
    

}

上面我們已將學(xué)過(guò)了流程變量了，可以在【任務(wù)服務(wù)、運(yùn)行時(shí)服務(wù)、流程開始、完成某個(gè)任務(wù)時(shí)設(shè)置流程變量】，而我們的連接就是流程變量的實(shí)際應(yīng)用了....

我們并不是所有的流程都是按一條的路徑來(lái)走的，我們有的時(shí)候會(huì)根據(jù)條件來(lái)走不同的路。當(dāng)然了，最終該流程是會(huì)一步步走完....

例子：

重要的信息交由老板來(lái)處理，不重要的信息交由經(jīng)理來(lái)處理

表達(dá)式的結(jié)果必須是布爾型

#{variable=="value"}

${variable==value}

我在任務(wù)完成時(shí)設(shè)置流程變量為不重要，那么跳到下一個(gè)流程時(shí)就是經(jīng)理來(lái)進(jìn)行處理

當(dāng)我設(shè)置為重要的時(shí)候，那么就是交由老板來(lái)處理

上面我們使用連線的時(shí)候用了兩個(gè)條件 : 要么條件是“重要”，要么條件是“不重要”....如果有另一種情況呢？？？就是用戶把條件輸入錯(cuò)了，寫成“不知道重不重要”，那么我們的流程怎么走？？？豈不是奔潰了？？？

因此，我們要有一條默認(rèn)的路來(lái)走，就是當(dāng)該變量不符合任何的條件時(shí)，我們也有一條默認(rèn)的路

值得注意的是：如果是在Eclipse中使用插件的BPMN流程圖，如果使用了排他網(wǎng)關(guān)，那么在Idea下是解析不了的...

解決：

我們只要重新定義BPMN流程圖的排他網(wǎng)關(guān)就行了，idea中的Activiti插件是不用制定默認(rèn)流程的，只要我們不設(shè)置條件，那就是默認(rèn)的連接線

public class ExclusiveGetWay {
    private ProcessEngine processEngine = ProcessEngines
            .getDefaultProcessEngine();

    // 部署流程定義，資源來(lái)在bpmn格式
    @Test
    public void deployProcessDefi() {
        Deployment deploy = processEngine.getRepositoryService()
                .createDeployment().name("排他網(wǎng)關(guān)流程")
                .addClasspathResource("ExclusiveGateway.bpmn")
                .deploy();

        System.out.println("部署名稱:" + deploy.getName());
        System.out.println("部署id:" + deploy.getId());
    }

    // 執(zhí)行流程，開始跑流程
    @Test
    public void startProcess() {
        String processDefiKey = "bankBill";// bpmn 的 process id屬性
        ProcessInstance pi = processEngine.getRuntimeService()
                .startProcessInstanceByKey(processDefiKey);

        System.out.println("流程執(zhí)行對(duì)象的id：" + pi.getId());// Execution 對(duì)象
        System.out.println("流程實(shí)例的id：" + pi.getProcessInstanceId());// ProcessInstance
                                                                    // 對(duì)象
        System.out.println("流程定義的id：" + pi.getProcessDefinitionId());// 默認(rèn)執(zhí)行的是最新版本的流程定義
    }

    // 查詢正在運(yùn)行任務(wù)
    @Test
    public void queryTask() {
        // 取得任務(wù)服務(wù)
        TaskService taskService = processEngine.getTaskService();
        // 創(chuàng)建一個(gè)任務(wù)查詢對(duì)象
        TaskQuery taskQuery = taskService.createTaskQuery();
        // 辦理人的任務(wù)列表
        List list = taskQuery.list();
        // 遍歷任務(wù)列表
        if (list != null && list.size() > 0) {
            for (Task task : list) {
                System.out.println("任務(wù)的辦理人：" + task.getAssignee());
                System.out.println("任務(wù)的id：" + task.getId());
                System.out.println("任務(wù)的名稱：" + task.getName());
            }
        }

    }

    // 完成任務(wù)
    @Test
    public void compileTask() {
        String taskId = "2404";
        Map params=new HashMap();
        params.put("visitor", 6);
        // taskId：任務(wù)id
        processEngine.getTaskService().complete(taskId, params);
//        processEngine.getTaskService().complete(taskId);
        System.out.println("當(dāng)前任務(wù)執(zhí)行完畢");
    }
    
}

我們指定的值并不是VIP也不是后臺(tái)，那么就會(huì)自動(dòng)去普通窗口中處理

并行網(wǎng)關(guān):

等待活動(dòng):

用戶任務(wù):

使用流程變量指定處理人:

我們?cè)诳焖偃腴T的例子中，是在定義流程圖中硬性指定處理人，其實(shí)這么干是不夠靈活的，我們學(xué)了流程變量之后，我們是可以靈活地指定處理人的....

    @Test
    public void deployProcessDefi() {
        Deployment deploy = processEngine.getRepositoryService()
                .createDeployment().name("用戶任務(wù)指定流程")
                .addClasspathResource("AppayBill.bpmn")
                .deploy();

        System.out.println("部署名稱:" + deploy.getName());
        System.out.println("部署id:" + deploy.getId());
    }

    // 執(zhí)行流程，開始跑流程
    @Test
    public void startProcess() {
        String processDefiKey = "appayBill";// bpmn 的 process id屬性
        Map params=new HashMap();
        params.put("userID", "王某某");
        ProcessInstance pi = processEngine.getRuntimeService()
                .startProcessInstanceByKey(processDefiKey, params);

        System.out.println("流程執(zhí)行對(duì)象的id：" + pi.getId());// Execution 對(duì)象
        System.out.println("流程實(shí)例的id：" + pi.getProcessInstanceId());// ProcessInstance
        // 對(duì)象
        System.out.println("流程定義的id：" + pi.getProcessDefinitionId());// 默認(rèn)執(zhí)行的是最新版本的流程定義
    }

    // 查詢正在運(yùn)行任務(wù)
    @Test
    public void queryTask() {
        String assignee="王某某";//指定任務(wù)處理人
        // 取得任務(wù)服務(wù)
        TaskService taskService = processEngine.getTaskService();
        // 創(chuàng)建一個(gè)任務(wù)查詢對(duì)象
        TaskQuery taskQuery = taskService.createTaskQuery();
        // 辦理人的任務(wù)列表
        List list = taskQuery
                .taskAssignee(assignee)
                .list();
        // 遍歷任務(wù)列表
        if (list != null && list.size() > 0) {
            for (Task task : list) {
                System.out.println("任務(wù)的辦理人：" + task.getAssignee());
                System.out.println("任務(wù)的id：" + task.getId());
                System.out.println("任務(wù)的名稱：" + task.getName());
            }
        }

    }

使用類指定:

組任務(wù):

直接指定辦理人

使用流程變量

使用類

如果一個(gè)業(yè)務(wù)需要多方面角色進(jìn)行處理的話，那么我們最好就是用工作流框架。因?yàn)槿绻渲幸粋€(gè)環(huán)節(jié)的需求發(fā)生了變化的話，我們要是沒(méi)有用到工作流。那就需要修改很多的代碼。十分麻煩。

Activiti工作流框架快速入門:

定義工作流，使用插件來(lái)把我們的流程圖畫出來(lái)。這個(gè)流程圖就是我們定義的工作流。

工作流引擎是工作流的核心，能夠讓我們定義出來(lái)的工作流部署起來(lái)。

由于我們使用工作流的時(shí)候是有很多數(shù)據(jù)產(chǎn)生的，因此Activiti是將數(shù)據(jù)保存到數(shù)據(jù)庫(kù)表中的。這些數(shù)據(jù)庫(kù)表由Actitviti創(chuàng)建，由Activiti維護(hù)。

部署完的工作流是需要手動(dòng)去執(zhí)行該工作流的。

根據(jù)由誰(shuí)處理當(dāng)前任務(wù)，我們就可以查詢出具體的任務(wù)信息。

根據(jù)任務(wù)的id，我們就可以執(zhí)行任務(wù)了。

流程定義涉及到了四張數(shù)據(jù)庫(kù)表

我們可以通過(guò)API把我們的流程定義圖讀取出來(lái)

可以根據(jù)查詢最新版本的流程定義

刪除流程定義

部署流程定義的時(shí)候也可以是ZIP文件

流程在運(yùn)行中，涉及到兩個(gè)對(duì)象，四張數(shù)據(jù)庫(kù)表:

流程實(shí)例

流程任務(wù)

流程實(shí)例可以有多個(gè)，流程對(duì)象只能有一個(gè)。

如果流程沒(méi)有分支的話，那么流程實(shí)例就等于流程對(duì)象

基于這么兩個(gè)對(duì)象，我們就可以做很多事情了

獲取流程實(shí)例和任務(wù)的歷史信息

判斷流程實(shí)例是否為空來(lái)判斷流程是否結(jié)束了

查看正在運(yùn)行服務(wù)的詳細(xì)信息

通過(guò)流程實(shí)例來(lái)開啟流程

流程變量:它涉及到了兩張表。流程變量實(shí)際上就是我們的條件。

流程變量的作用域只在流程實(shí)例中。

我們可以在流程開始的時(shí)候設(shè)置流程變量，在任務(wù)完成的時(shí)候設(shè)置流程變量。

運(yùn)行時(shí)服務(wù)和流程任務(wù)都可以設(shè)置流程變量。

通過(guò)連線我們可以在其中設(shè)置條件，根據(jù)不同的條件流程走不同的分支

如果沒(méi)有設(shè)置默認(rèn)的條件，當(dāng)條件不吻合的時(shí)候，那么流程就走不下去了，因此需要排他網(wǎng)關(guān)來(lái)設(shè)置一條默認(rèn)的路徑。

如果文章有錯(cuò)的地方歡迎指正，大家互相交流。習(xí)慣在微信看技術(shù)文章，想要獲取更多的Java資源的同學(xué)，可以關(guān)注微信公眾號(hào):Java3y