Activiti工做流基礎學習筆記

時間 2019-11-06

標籤 activiti 基礎學習筆記简体版

原文原文鏈接

1、瞭解工做流

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

常見的工做流框架 Activity5.1三、JBPM4.四、OSWorkFlow、WorkFlow 工做流框架底層須要有數據庫提供支持，activiti5.13版本，有23張表。JBPM4.4框架底層有數據庫支持，18張表。JBPM底層使用hibernate操做數據庫。Activiti框架底層使用的mybatis操做數據庫。mysql

2、初始化表結構

1.使用Activiti框架提供的建表語句

下載的Activiti框架的包中 /activiti-x.xx/database/ceate/ 目錄中提供各類數據庫的建表語句。web

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 (名字隨意)spring

<!-- 配置流程引擎配置對象 -->
	<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.javasql

@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.javaapache

@Test
    /**
     * 使用框架提供的自動建表（使用默認配置文件）
     */
    public void test() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    }
複製代碼

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

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

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

ACT_RU_*: 'RU'表示runtime。這些運行時的表，包含流程實例，任務，變量，異步任務，等運行中的數據。 Activiti只在流程實例執行過程當中保存這些數據，在流程結束時就會刪除這些記錄。這樣運行時表能夠一直很小速度很快。

ACT_ID_*: 'ID'表示identity。這些表包含身份信息，好比用戶，組等等。

ACT_HI_*: 'HI'表示history。這些表包含歷史數據，好比歷史流程實例，變量，任務等等。

ACT_GE_*: 通用數據，用於不一樣場景下。

4、Activiti框架的基本使用

1.部署流程定義

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

2.2 使用Java代碼部署流程流程定義 Test.javamybatis

@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("辦理成功");
    }
複製代碼

5、Activiti提供的Service對象

在以上的代碼中有不少Servie，接下來講明一下這些Service的區別。

RepositoryService----操做靜態的資源（流程定義，bpmn、png） RuntimeService-----操做流程實例（啓動流程實例、查詢流程實例、結束流程實例） TaskService-----操做任務（查詢任務、辦理任務） HistoryService----操做歷史數據

6、Activiti框架提供的對象(和表有對應關係)

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

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

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

8、使用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());
        }
    }
複製代碼

9、流程變量

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

對應的表： 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);
    }
複製代碼

# 10、任務的類型 ### 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); } ```

11、監聽器（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+"]負責辦理");
    }
}

複製代碼

第二步：註冊監聽類

第三步：辦理任務，由框架經過反射調用監聽器類

12、網關

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） > 它容許將流程分紅多條分支，也能夠把多條分支匯聚成一條。

分支：通過並行網關的全部流，都會並行執行

匯聚：等全部流都到達並行網關以後，流程纔會經過並行網關。

並行網關，沒有條件判斷。流程經過網關以後，有幾條分支，就會有幾個執行對象同時執行。須要注意的是：並行網關必定是成對出現的，有分支也有匯聚。

十3、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框架入門教程，不喜勿噴。