Activiti工作流基礎學習筆記

阿新 • • 發佈：2018-11-28

一、瞭解工作流

工作流(Workflow)，就是“業務過程的部分或整體在計算機應用環境下的自動化”，它主要解決的是“使在多個參與者之間按照某種預定義的規則傳遞文件、資訊或任務的過程自動進行，從而實現某個預期的業務目標，或者促使此目標的實現”。工作流管理系統(Workflow Management System, WfMS)是一個軟體系統，它完成工作量的定義和管理，並按照在系統中預先定義好的工作流邏輯進行工作流例項的執行。工作流管理系統不是企業的業務系統，而是為企業的業務系統的執行提供了一個軟體的支撐環境。

常見的工作流框架 Activity5.13、JBPM4.4、OSWorkFlow、WorkFlow 工作流框架底層需要有資料庫提供支援，activiti5.13版本，有23張表。JBPM4.4框架底層有資料庫支援，18張表。JBPM底層使用hibernate操作資料庫。Activiti框架底層使用的mybatis操作資料庫。

二、初始化表結構

###1.使用Activiti框架提供的建表語句下載的Activiti框架的包中 /activiti-x.xx/database/ceate/ 目錄中提供各種資料庫的建表語句。

2.使用Activiti框架自動建表

2.1 不使用配置檔案

    @Test
    public void test1() {
        //    建立一個流程引擎配置物件
        ProcessEngineConfiguration configuration = ProcessEngineConfiguration.createStandaloneProcessEngineConfiguration();

        //    設定資料來源資訊
        configuration.setJdbcDriver("com.mysql.jdbc.Driver" 
);
        configuration.setJdbcUrl("jdbc:mysql://localhost:3306/activiti");
        configuration.setJdbcUsername("root");
        configuration.setJdbcPassword("");

        //    設定自動建表
        configuration.setDatabaseSchemaUpdate("true");

        //    建立一個流程引擎物件，在建立流程引擎物件中會自動建表
        ProcessEngine processEngine = configuration.buildProcessEngine();
    }
複製程式碼

2.2 使用自定義配置檔案

actitviti-context.xml (名字隨意)

	<!-- 配置流程引擎配置物件 -->
	<bean id="processEngineConfiguration"
		class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
		<property name="jdbcDriver" value="com.mysql.jdbc.Driver" />
		<property name="jdbcUrl" value="jdbc:mysql:///activiti" />
		<property name="jdbcUsername" value="root" />
		<property name="jdbcPassword" value="" />
		<property name="databaseSchemaUpdate" value="true" />
	</bean>
複製程式碼

Test.java

    @Test
    /**
     * 使用框架提供的自動建表（提供配置檔案）
     */
    public void test2() {
        String resource = "actitviti-context.xml";//配置檔名稱
        String beanName = "processEngineConfiguration";//配置id值
        //載入配置檔案
        ProcessEngineConfiguration configuration = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource(resource, beanName);
       //建立流程引擎物件
        ProcessEngine processEngine = configuration.buildProcessEngine();
    }
複製程式碼

3.3 使用Activiti框架提供的預設配置檔案

要求配置檔名稱必須為activiti-context.xml或者activiti.cfg.xml。
配置流程引擎配置物件的id必須為 processEngineConfiguration 建立流程引擎物件的id必須為processEngine activiti-context.xml

	<!-- 配置流程引擎配置物件 -->
	<bean id="processEngineConfiguration"
		class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
		<property name="jdbcDriver" value="com.mysql.jdbc.Driver" />
		<property name="jdbcUrl" value="jdbc:mysql:///activiti" />
		<!--<property name="jdbcUrl" value="jdbc:mysql:///activiti_web" />-->
		<property name="jdbcUsername" value="root" />
		<property name="jdbcPassword" value="" />
		<property name="databaseSchemaUpdate" value="true" />
	</bean>

	<!-- 配置一個流程引擎工廠bean，用於建立流程引擎物件 -->
	<bean id="processEngine" class="org.activiti.spring.ProcessEngineFactoryBean">
		<!-- 通過set方法注入流程引擎配置物件 -->
		<property name="processEngineConfiguration" ref="processEngineConfiguration" />
	</bean>
複製程式碼

Test.java

    @Test
    /**
     * 使用框架提供的自動建表（使用預設配置檔案）
     */
    public void test() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    }
複製程式碼

三、瞭解Activiti框架中的二十三張表

Activiti的後臺是有資料庫的支援，所有的表都以ACT_開頭。第二部分是表示表的用途的兩個字母標識。用途也和服務的API對應。

ACT_RE_*: 'RE'表示repository。這個字首的表包含了流程定義和流程靜態資源（圖片，規則，等等）。

ACT_RU_*: 'RU'表示runtime。這些執行時的表，包含流程例項，任務，變數，非同步任務，等執行中的資料。 Activiti只在流程例項執行過程中儲存這些資料，在流程結束時就會刪除這些記錄。這樣執行時表可以一直很小速度很快。

ACT_ID_*: 'ID'表示identity。這些表包含身份資訊，比如使用者，組等等。

ACT_HI_*: 'HI'表示history。這些表包含歷史資料，比如歷史流程例項，變數，任務等等。

ACT_GE_*: 通用資料，用於不同場景下。

四、Activiti框架的基本使用

1.部署流程定義

1.1 使用Eclipse或Idea的BPMN編輯外掛繪製流程圖，並匯出 流程圖.bpmn和 流程圖.png。（外掛的安裝及使用自行百度）

2.2 使用Java程式碼部署流程流程定義 Test.java

    @Test
    /**
     * 部署流程定義
     * 操作的資料表：
     *      act_re_deloyment（部署表） 部署一次 插入一條記錄
     *      act_re_procdef 可以認為是部署表的擴充套件表 流程定義表
     *      act_ge_bytearray:流程定義檔案被序列化存在資料表中
     */
    public void test() {
        //使用預設配置檔案建立流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        // 獲得一個部署構建器物件，用於載入流程定義檔案（test.bpmn test.png）完成流程定義的部署
        DeploymentBuilder builder = processEngine.getRepositoryService().createDeployment();
        //   載入流程定義檔案
        builder.addClasspathResource("/process/test.bpmn");
        builder.addClasspathResource("/process/test.png");
        //    部署流程定義
        Deployment deployment = builder.deploy();
    }
複製程式碼

2. 查詢流程定義列表

    /**
     * 查詢流程定義列表
     */
    @Test
    public void test() {
        //使用預設配置檔案建立流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //    流程定義查詢物件，用於查詢act_re_procdef
        ProcessDefinitionQuery query = processEngine.getRepositoryService().createProcessDefinitionQuery();
        //新增過濾條件
        query.processDefinitionKey("myProcess_1");
        //    新增排序條件
        query.orderByProcessDefinitionVersion().desc();
        //新增分頁查詢
        query.listPage(0, 10);
        List<ProcessDefinition> list = query.list();
        for (ProcessDefinition pd : list) {
            System.out.println(pd.getId());
        }
    }
複製程式碼

3.啟動流程例項

流程例項是根據一個流程定義具體的一次執行過程就是一個流程例項,一個流程定義對應多個流程例項(一對多關係)。

    /**
     * 根據流程定義 啟動一個流程例項
     * 根據流程定義的一次具體執行過程，就是一個流程例項
     */
    @Test
    public void test() {
        //使用預設配置檔案建立流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        String processDefinitionId = "myProcess_1:7:1004";//流程定義id可在act_re_procdef表中查詢到
        ProcessInstance processInstance = processEngine.getRuntimeService().startProcessInstanceById(processDefinitionId);
        System.out.println(processInstance.getId());
    }
複製程式碼

4.查詢個人任務列表

    /**
     * 查詢個人任務列表
     */
    @Test
    public void test() {
        //使用預設配置檔案建立流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //建立任務查詢
        TaskQuery taskQuery = processEngine.getTaskService().createTaskQuery();
      //新增查詢條件 辦理人為王五
        String assignee = "王五";
        taskQuery.taskAssignee(assignee);
        List<Task> list = taskQuery.list();//查詢所有
        for (Task task : list) {
            System.out.println(task.getId() + "——" + task.getName());
        }
    }
複製程式碼

5.辦理任務

    /**
     * 辦理業務
     */
    @Test
    public void test() {
        //使用預設配置檔案建立流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        String taskId = "602";//任務id可在act_ru_task表中查詢到
        processEngine.getTaskService().complete(taskId);//傳入任務id辦理業務
        System.out.println("辦理成功");
    }
複製程式碼

五、Activiti提供的Service物件

在以上的程式碼中有很多Servie，接下來說明一下這些Service的區別。

RepositoryService----操作靜態的資源（流程定義，bpmn、png） RuntimeService-----操作流程例項（啟動流程例項、查詢流程例項、結束流程例項） TaskService-----操作任務（查詢任務、辦理任務） HistoryService----操作歷史資料

六、Activiti框架提供的物件(和表有對應關係)

Deployment-----act_re_deployment ProcessDefinition----act_re_procdef ProcessInstance-----act_ru_execution Task-----act_ru_task

七、使用Activiti框架提供的網頁版流程設計器

1.將Activiti的包中activiti-explorer.war複製到tomcat的/webapps目錄中。 2.啟動Tomcat，訪問 http://lcoalhost:8080/activiti-explorer 3.登入。登入賬號和密碼為：kermit

八、使用Activiti框架的API操作流程

1.部署流程定義的兩種方法

1.1 讀取單個的流程定義檔案

    @Test
    public void test() {
        //使用預設配置檔案建立流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //建立流程部署物件
        DeploymentBuilder deploymentBuilder = processEngine.getRepositoryService().createDeployment();

        //讀取單個的流程定義檔案
        deploymentBuilder.addClasspathResource("/process/test.bpmn");
        deploymentBuilder.addClasspathResource("/process/test.png");
        Deployment deployment = deploymentBuilder.deploy();//部署流程
複製程式碼

1.2 讀取ZIP壓縮檔案將test.bpmn和test.png放到同一個zip壓縮包中。

    @Test
    public void test() {
        //使用預設配置檔案建立流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //建立流程部署物件
        DeploymentBuilder deploymentBuilder = processEngine.getRepositoryService().createDeployment();

        //讀取ZIP壓縮檔案
        //讀取資原始檔
        ZipInputStream zipInputStream = new ZipInputStream(this.getClass().getClassLoader().getResourceAsStream("/process/process.zip"));
        deploymentBuilder.addZipInputStream(zipInputStream);
        deploymentBuilder.name("請假流程部署");//設定流程定義名稱
        Deployment deployment1 = deploymentBuilder.deploy();//部署流程
    }
複製程式碼

2.查詢流程部署列表（act_re_deployment表）

    @Test
    public void test() {
        //使用預設配置檔案建立流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //部署查詢物件，查詢act_re_deployment 部署表
        DeploymentQuery deploymentQuery = processEngine.getRepositoryService().createDeploymentQuery();
        List<Deployment> list = deploymentQuery.list();
        for (Deployment deployment : list) {
            String id = deployment.getId();
            System.out.println(id);
        }
    }
複製程式碼

3.刪除部署資訊

    @Test
    public void test() {
        //使用預設配置檔案建立流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        String deloymentId = "7504"; //流程部署id  在act_re_deployment表中
        //deleteDeployment有兩個引數 第一個刪除 部署的內容的id，第二個是否級聯刪除，預設為false
        processEngine.getRepositoryService().deleteDeployment(deloymentId, true);
    }
複製程式碼

4.刪除流程定義（通過刪除部署資訊達到刪除流程定義的目的）

    @Test
    public void test() {
        //使用預設配置檔案建立流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        String deloymentId = "1001";
        //deleteDeployment有兩個引數 第一個刪除 部署的內容的id，第二個是否級聯刪除，預設為false
        processEngine.getRepositoryService().deleteDeployment(deloymentId, true);
    }
複製程式碼

5.查詢流程定義列表

    @Test
    public void test() {
        //使用預設配置檔案建立流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //流程定義查詢物件，查詢表act_re_procdef
        ProcessDefinitionQuery processDefinitionQuery = processEngine.getRepositoryService().createProcessDefinitionQuery();
        List<ProcessDefinition> list = processDefinitionQuery.list();
        for (ProcessDefinition pd : list) {
            System.out.println(pd.getName() + "———" + pd.getId());
        }
    }
複製程式碼

6.查詢一次部署對應的流程定義檔案和對應的輸入流（bpmn，png）

 @Test
    public void test() throws IOException {
        //使用預設配置檔案建立流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        String deploymentId = "901";
        List<String> list = processEngine.getRepositoryService().getDeploymentResourceNames(deploymentId);
        for (String name : list) {
            System.out.println(name);
            InputStream inputStream = processEngine.getRepositoryService().getResourceAsStream(deploymentId, name);
            //將檔案儲存到本地磁碟
         org.apache.commons.io.FileUtils.copyInputStreamToFile(inputStream, new File("d:\\" + name));
            inputStream.close();
        }
    }
複製程式碼

7.獲得png檔案的輸入流

    @Test
    public void test() throws IOException {
        //使用預設配置檔案建立流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        String processDefinitionId = "myProcess_1:6:904";
        InputStream PngInputStream = processEngine.getRepositoryService().getProcessDiagram(processDefinitionId);
        FileUtils.copyInputStreamToFile(PngInputStream, new File("d:\\my.png"));
    }
複製程式碼

8.啟動流程例項的兩種方法

8.1 方式一：根據流程定義的id啟動

@Test
    public void test() {
        //使用預設配置檔案建立流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //方式一：根據流程定義的id啟動
       String processDefinitionId = "myProcess_1:6:904";
        ProcessInstance processInstance = processEngine.getRuntimeService().startProcessInstanceById(processDefinitionId);
        System.out.println(processInstance.getId());
}
複製程式碼

8.2 方式二：根據流程定義的key啟動（自動選擇最新版本的流程定義啟動流程例項）

    @Test
    public void test() {
        //使用預設配置檔案建立流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //方式二：根據流程定義的key啟動（自動選擇最新版本的流程定義啟動流程例項）
        String processDefinitionKey = "myProcess_1";
        ProcessInstance processInstance = processEngine.getRuntimeService().startProcessInstanceByKey(processDefinitionKey);
        System.out.println(processInstance.getId());
    }
複製程式碼

9.查詢流程例項列表，查詢act_ru_execution表

    @Test
    public void test() {
        //使用預設配置檔案建立流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //流程例項查詢物件，查詢act_ru_execution表
        ProcessInstanceQuery query = processEngine.getRuntimeService().createProcessInstanceQuery();
        query.processDefinitionKey("myProcess_1");
        query.orderByProcessDefinitionId().desc();
        query.listPage(0, 3);
        List<ProcessInstance> list = query.list();
        for (ProcessInstance pi : list) {
            System.out.println(pi.getId() + "--" + pi.getActivityId());
        }
    }
複製程式碼

10.結束流程例項

操作的表：act_re_excution,act_ru_task

    @Test
    public void test() {
        //使用預設配置檔案建立流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        String processInstanceId = "1601";
        processEngine.getRuntimeService().deleteProcessInstance(processInstanceId, "不想要了");
    }
複製程式碼

11.查詢任務列表

    @Test
    public void test() {
        //使用預設配置檔案建立流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //任務查詢物件，查詢任務表 act_ru_task表
        TaskQuery query = processEngine.getTaskService().createTaskQuery();
        //按照辦理人進行過濾
        String assignee = "李四";
        query.taskAssignee(assignee);
        query.orderByTaskCreateTime().desc();
        List<Task> list = query.list();
        for (Task task : list) {
            System.out.println(task.getId());
        }
    }
複製程式碼

12.辦理任務

    @Test
    public void test() {
        //使用預設配置檔案建立流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        String taskId = "1404";
        processEngine.getTaskService().complete(taskId);
    }
複製程式碼

13.直接將流程向下執行一步

    @Test
    public void test() {
        //使用預設配置檔案建立流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        String executionId = "1401"; //流程例項id
        processEngine.getRuntimeService().signal(executionId);
    }
複製程式碼

14.查詢最新版本的流程定義列表

    @Test
    public void test() {
        //使用預設配置檔案建立流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        ProcessDefinitionQuery query = processEngine.getRepositoryService().createProcessDefinitionQuery();
        query.orderByProcessDefinitionVersion().asc();
        List<ProcessDefinition> list = query.list();
        Map<String, ProcessDefinition> map = new HashMap<>();
        for (ProcessDefinition pd : list) {
            map.put(pd.getKey(),pd);
        }
        System.out.println(map);
    }
複製程式碼

15.流程的修改

流程的修改：新增新的流程版本，如果已經在執行的流程，按照原來的流程繼續執行。新的流程按照最新版本進行執行。

16.歷史資料查詢

16.1 查詢歷史流程例項列表查詢歷史流程例項列表 act_hi_procinst

    @Test
    public void test() {
        //使用預設配置檔案建立流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        HistoricProcessInstanceQuery query = processEngine.getHistoryService().createHistoricProcessInstanceQuery();
        List<HistoricProcessInstance> list = query.list();
        for (HistoricProcessInstance hi : list) {
            System.out.println(hi.getId());
        }
    }
複製程式碼

16.2 查詢歷史活動資料查詢歷史活動資料 act_hi_actinst 包括任務和事件

    @Test
    public void test() {
        //使用預設配置檔案建立流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        HistoricActivityInstanceQuery query = processEngine.getHistoryService().createHistoricActivityInstanceQuery();
        //按照流程例項排序
        query.orderByProcessInstanceId().desc();
        query.orderByHistoricActivityInstanceEndTime().asc();
        List<HistoricActivityInstance> list = query.list();
        for (HistoricActivityInstance hi : list) {
            System.out.println(hi.getActivityId() + "——" + hi.getActivityName() + "——" + hi.getActivityType());
        }
    }
複製程式碼

16.3 查詢歷史任務資料查詢歷史任務資料 act_hi_taskinst 單純的只有任務

    @Test
    public void test() {
        //使用預設配置檔案建立流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        HistoricTaskInstanceQuery query = processEngine.getHistoryService().createHistoricTaskInstanceQuery();
        query.orderByProcessInstanceId().asc();
        query.orderByHistoricTaskInstanceEndTime().asc();
        List<HistoricTaskInstance> list = query.list();
        for (HistoricTaskInstance hi:list){
            System.out.println(hi.getAssignee()+"——"+hi.getName()+"——"+hi.getStartTime());
        }
    }
複製程式碼

九、流程變數

在流程執行或者任務執行的過程中，用於設定和獲取變數，使用流程變數在流程傳遞的過程中傳遞業務引數。

對應的表： act_ru_variable：正在執行的流程變量表 act_hi_varinst：流程變數歷史表
流程變數圖解

1.設定流程變數

1.1 在啟動流程例項時設定

    @Test
    public void test() {
        //使用預設配置檔案建立流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        String processDefinitionKey = "variable";
        Map<String, Object> variables = new HashMap<>();
        variables.put("key1", "value1");
        variables.put("key2", 200);
        ProcessInstance processInstance = processEngine.getRuntimeService().startProcessInstanceByKey(processDefinitionKey, variables);
        System.out.println(processInstance.getId());
    }
複製程式碼

1.2 在辦理任務時設定流程變數

    @Test
    public void test() {
        //使用預設配置檔案建立流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        String taskId = "1206";
        Map<String, Object> variables = new HashMap<>();
        variables.put("user", new User(1, "小王"));
        processEngine.getTaskService().complete(taskId, variables);
    }
複製程式碼

1.3 使用RuntimeService的方法設定

    @Test
    public void test() {
        //使用預設配置檔案建立流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        String excutionId = "601";//流程例項Id
        String variableName = "key3";
        String value = "value3";
        processEngine.getRuntimeService().setVariable(excutionId, variableName, value);
    }
複製程式碼

1.4 使用TaskService的方法設定

    @Test
    public void test() {
        //使用預設配置檔案建立流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        String taskId = "704";
        Map<String, Object> variables = new HashMap<>();
        variables.put("key4", 400);
        variables.put("k5", "v5");
        processEngine.getTaskService().setVariables(taskId, variables);
    }
複製程式碼

### 2.流程變數支援的型別 >Jdk中提供的資料型別（String、Integer、List 、Map…）自定義的實體類（要求實現序列化介面），在variable表中只存bytearray_id 例項化內容存在bytearray表中。

3.獲取流程變數

3.1 使用RuntimeService的方法獲取

    @Test
    public void test() {
        //使用預設配置檔案建立流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        String executionId = "1201";
        Map<String, Object> variables = processEngine.getRuntimeService().getVariables(executionId);
        System.out.println(variables);
        Set<String> set = variables.keySet();//key2 key1 user
        for (String key : set) {
            Object val = variables.get(key);
            System.out.println(key + "=" + val);
        }

        //根據一個key獲得一個value
        Object value = processEngine.getRuntimeService().getVariable(executionId, "user");
        System.out.println(value);

        Collection<String> variableNames = new ArrayList<>();
        variableNames.add("key2");
        variableNames.add("user");
        Map<String, Object> map = processEngine.getRuntimeService().getVariables(executionId, variableNames);
        System.out.println(map);
複製程式碼

3.2 使用TaskService的方法獲取

    @Test
    public void test() {
        //使用預設配置檔案建立流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        String taskId = "1305";
        Map<String, Object> variables = processEngine.getTaskService().getVariables(taskId);
    }
複製程式碼

# 十、任務的型別 ### 1.個人任務 >由某一個負責辦理，在任務表中通過assignee欄位記錄。

2.公共任務（組任務）

當前的任務可以由多個人其中的某一個人辦理，可以在設計流程圖時指定多個辦理人。Candidate Users 候選使用者

2.1 查詢公共任務列表

    @Test
    public void test() {
        //使用預設配置檔案建立流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskQuery query = processEngine.getTaskService().createTaskQuery();
        //    根據候選人過濾
        String candidateUser = "李四";
        query.taskCandidateUser(candidateUser);
        List<Task> list = query.list();
        for (Task task:list){
            System.out.println(task.getName());
        }
    }
複製程式碼

2.2 拾取公共任務（將公共任務變為個人任務）

    @Test
    public void test(){
        //使用預設配置檔案建立流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        String taskId="1602";
        String userId="王五";
        processEngine.getTaskService().claim(taskId,userId);
    }
複製程式碼

2.3 退回任務（將個人任務重新變為公共任務）

    @Test
    public void test(){
        //使用預設配置檔案建立流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        String taskId="1602";
        processEngine.getTaskService().setAssignee(taskId,null);
    }
複製程式碼

### 3.接受任務 >接收任務不是由某個人負責辦理，通過signal方法讓流程執行的![接收任務圖示.png](https://upload-images.jianshu.io/upload_images/12984595-184194b84034837a.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240) ``` /** * 處理接收任務 */ @Test public void test() { //使用預設配置檔案建立流程引擎 ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine(); String excutionId = "2501"; processEngine.getRuntimeService().signal(excutionId); } ```

十一、監聽器（Listener）

1.執行監聽器

監聽流程例項的事件

第一步：按照框架的規則編寫監聽器類

import org.activiti.engine.delegate.DelegateExecution;
import org.activiti.engine.delegate.ExecutionListener;

/**
 * @author Hiseico
 * @create 2018-06-07 16:41
 * @desc 自定義執行監聽器
 **/
public class MyExcutionListener implements ExecutionListener {
    //當監聽事件發生時執行此方法
    @Override
    public void notify(DelegateExecution delegateExecution) throws Exception {
        System.out.println("自定義的監聽器執行。。。2");
    }
}
複製程式碼

第二步：設計流程圖，註冊監聽器類

第三步：啟動流程例項，Activiti框架通過反射呼叫監聽器類

2.任務監聽器

監聽任務事件

第一步：按照activiti框架的規則編寫一個任務監聽器類

import org.activiti.engine.delegate.DelegateTask;
import org.activiti.engine.delegate.TaskListener;

import java.util.Set;

/**
 * @author Hiseico
 * @create 2018-06-07 17:10
 * @desc 自定義任務監聽器
 **/
public class MyTaskListener implements TaskListener {
    /**
     * 監聽任務事件
     *
     * @param delegateTask
     */
    @Override
    public void notify(DelegateTask delegateTask) {
        //任務辦理人
        String assignee = delegateTask.getAssignee();
        //任務名稱
        String eventName = delegateTask.getEventName();
        //事件名稱
        String name = delegateTask.getName();
        //流程例項Id
        String processInstanceId = delegateTask.getProcessInstanceId();
        //獲取當前流程例項範圍內的所有流程變數的名字
        Set<String> variableNames = delegateTask.getVariableNames();
        for (String key : variableNames) {
            Object value = delegateTask.getVariable(key);
            System.out.println(key + " = " + value);
        }
        System.out.println("一個["+name+"]任務被建立了，由["+assignee+"]負責辦理");
    }
}

複製程式碼

第二步：註冊監聽類

第三步：辦理任務，由框架通過反射呼叫監聽器類

十二、閘道器

1.排他閘道器（ExclusiveGateway）

用來在流程中實現決策。當流程執行到排他閘道器，所有資料就會被執行一遍，滿足條件的就會讓流程繼續執行。需要注意的是：排他閘道器只會選擇一條滿足條件的執行。

第一步：設計流程圖，使用排他閘道器

第二步：執行流程，由框架根據設定的流程變數選擇執行其中的一個分支，在分支的線上設定引數：Condition:#{bxje>200}

第三步：辦理業務

    /**
     * 辦理任務，設定流程變數
     */
    @Test
    public void test() {
        String taskId = "802";
        Map<String, Object> variables = new HashMap<>();
        variables.put("bxje",600);//排他閘道器會自動判斷 bxje 變數的值，選擇執行分支
        processEngine.getTaskService().complete(taskId,variables);
    }
複製程式碼

### 2.並行閘道器（ParallelGateway） > 它允許將流程分成多條分支，也可以把多條分支匯聚成一條。

分支：經過並行閘道器的所有流，都會並行執行

匯聚：等所有流都到達並行閘道器之後，流程才會通過並行閘道器。

並行閘道器，沒有條件判斷。流程通過閘道器之後，有幾條分支，就會有幾個執行物件同時執行。需要注意的是：並行閘道器一定是成對出現的，有分支也有匯聚。

十三、Spring整合Activiti

第一步：提供spring配置檔案，配置資料來源、事務管理器、流程引擎配置物件、流程引擎物件 appplicationContext.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="ds" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql:///activiti"/>
        <property name="username" value="root"/>
        <property name="password" value=""/>
    </bean>

    <!--事務管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="ds"/>
    </bean>

    <!--配置一個Spring提供的物件，用於建立一個流程引擎配置物件-->
    <bean id="processEngineConfiguration" class="org.activiti.spring.SpringProcessEngineConfiguration">
        <property name="transactionManager" ref="transactionManager"/>
        <property name="dataSource" ref="ds"/>
        <!--自動建表的配置-->
        <property name="databaseSchemaUpdate" value="true"/>
    </bean>

    <!--建立流程引擎物件-->
    <bean id="processEngine" class="org.activiti.spring.ProcessEngineFactoryBean">
        <property name="processEngineConfiguration" ref="processEngineConfiguration"/>
    </bean>
</beans>
複製程式碼

第二步：在Java程式中讀取spring配置檔案，建立spring工廠，獲取流程引擎物件

public class SpringActivitiTest {
    @Test
    public void test() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring/applicationContext.xml");
       ProcessEngine processEngine = (ProcessEngine) applicationContext.getBean("processEngine");
        DeploymentBuilder deploymentBuilder = processEngine.getRepositoryService().createDeployment();
        deploymentBuilder.addClasspathResource("spring/variable.bpmn");
        Deployment deployment = deploymentBuilder.deploy();
    }
}
複製程式碼

到此Activiti框架的基礎筆記就先整理到這裡，本筆記用作學習完Activiti框架後複習使用，不適用於Activiti框架入門教程，不喜勿噴。

轉載請註明出處及作者。

掘金個人主頁

Create By Hiseico