1 个人任务

1.1 分配任务负责人

1.1.1 固定分配

  • 在进行业务流程建模的时候指定固定的任务负责人。

固定分配.png

  • 在properties视图中，添加Assignee项为任务负责人。

由于固定分配方式，任务只管一步一步执行任务，执行到每一个任务将按照BPMN的配置去分配任务负责人。

1.1.2 表达式分配

1.1.2.1 UEL表达式

  • Activiti使用UEL表达式，UEL是JavaEE规范的一部分，URL（Unified Expression Language）即统一表达式语言，Activiti支持两种UEL表达式：UEL-value和UEL-method。
  • UEL-value定义如下：
    • assignee这个变量是Activiti的一个流程变量。

UEL-value.png

  • user这个变量也是Activiti的一个流程变量，user.assignee表示通过调用user的getter方法获取值。

另外一种UEL-value.png

  • UEL-method定义如下：
    • holidayBean是Spring容器中的一个Bean，下图UEL-method的含义是调用该Bean的一个getHolidayId()方法。

UEL-method.png

1.1.2.2 使用流程变量分配任务

  • 定义任务分配流程变量：

UEL-value.png

  • 设置流程变量：在启动流程实例的时候设置流程变量
  1. package com.sunxiaping;
  3. import org.activiti.engine.ProcessEngine;
  4. import org.activiti.engine.ProcessEngineConfiguration;
  5. import org.activiti.engine.RuntimeService;
  6. import org.activiti.engine.runtime.ProcessInstance;
  7. import org.junit.Test;
  9. import java.util.HashMap;
  10. import java.util.Map;
  12. /**
  13.  * @author <a href="mailto:1900919313@qq.com">weiwei.xu</a>
  14.  * @version 1.0
  15.  * 2020-08-01 14:35
  16.  */
  17. public class ActivitiStartProcessInstanceTest {
  19.     /**
  20.      * act_hi_actinst 活动实例
  21.      * act_hi_identitylink 参与者信息
  22.      * act_hi_procinst 流程实例
  23.      * act_hi_taskinst 任务实例
  24.      * act_ru_execution 执行表
  25.      * act_ru_identitylink 参与者信息
  26.      * act_ru_task   任务表
  27.      */
  28.     @Test
  29.     public void test() {
  30.         //创建ProcessEngineConfiguration对象
  31.         ProcessEngineConfiguration configuration = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti-cfg.xml");
  32.         ProcessEngine processEngine = configuration.buildProcessEngine();
  33.         //获取RuntimeService对象
  34.         RuntimeService runtimeService = processEngine.getRuntimeService();
  36.         //设置流程变量
  37.         Map<String, Object> variables = new HashMap<>();
  38.         variables.put("assignee0", "张三");
  39.         variables.put("assignee1", "李四");
  40.         variables.put("assignee2", "王五");
  42.         //根据流程定义的key启动流程实例
  43.         ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("holiday", variables);
  44.         //获取流程实例的相关信息
  45.         String processDefinitionId = processInstance.getProcessDefinitionId();
  46.         System.out.println("流程定义的id = " + processDefinitionId);
  47.         String deploymentId = processInstance.getDeploymentId();
  48.         System.out.println("流程部署的id = " + deploymentId);
  49.         String id = processInstance.getId();
  50.         System.out.println("流程实例的id = " + id);
  51.         String activityId = processInstance.getActivityId();
  52.         System.out.println("当前活动的id = " + activityId);
  54.     }
  55. }

1.1.2.3 注意事项

  • 由于使用了表达式分配，必须保证在任务执行过程中表达式执行成功，比如某个任务使用了表达式${order.price > 100 && order.price <250}，当执行该任务时必须保证order在流程变量中存在，否则Activiti将抛出异常。

1.1.3 监听器分配

  • 任务监听器是发生对应的任务相关事件时执行自定义的Java逻辑或表达式。
  • 任务相关事件包括：
    • Event：
      • Create：任务创建后触发。
      • Assignment：任务分配后触发。
      • Delete：任务完成后触发。
      • All：所有事件发生都触发。

监听器分配.png

  • 自定义一个任务监听器类，然后此类必须实现org.activiti.engine.delegate.TaskListener接口：
  1. package com.sunxiaping.task;
  3. import org.activiti.engine.delegate.DelegateTask;
  4. import org.activiti.engine.delegate.TaskListener;
  6. /**
  7.  * @author <a href="mailto:1900919313@qq.com">weiwei.xu</a>
  8.  * @version 1.0
  9.  * 2020-08-05 15:44
  10.  */
  11. public class SelfTaskListener implements TaskListener {
  12.     @Override
  13.     public void notify(DelegateTask delegateTask) {
  14.         //指定任务的负责人
  15.         delegateTask.setAssignee("张三");
  16.     }
  17. }

在实际开发中，一般也不使用监听器分配方式，太麻烦了。

2 流程变量

2.1 什么是流程变量？

  • 流程变量在Activiti中是一个非常重要的角色，流程运转有时需要靠流程变量，业务系统和Activiti结合时少不了流程变量，流程变量就是Activiti在管理工作流时根据管理需要而设置的变量。
  • 比如在请假流程流转时如果请假天数>3天则有总经理审批，否则由人事直接审批，请假天数就可以设置流程变量，在流程流转时使用。

注意：虽然流程变量中可以存储业务数据，可以通过Activiti的API查询流程变量从而实现查询业务数据，但是不建议这么使用，因为业务数据查询由业务系统负责，Activiti设置流程变量是为了流程执行需要而创建的。

2.2 流程变量类型

流程变量类型.png

注意：

  • 如果将POJO存储到流程变量中，必须实现序列化接口Serializable，为了防止由于新增字段无法反序列化。

2.3 流程变量的作用域

  • 流程变量的作用域范围可以是一个流程实例（ProcessInstance）、一个任务（Task）或一个执行实例（Execution）。
  • 流程变量的作用域范围的默认值是流程实例，作用域范围最大，可以称为global变量。
  • 流程变量的作用域范围如果仅仅针对一个任务或一个执行实例，那么作用域范围没有流程实例大，可以称为local变量。
  • global变量中变量名不允许重复，设置相同名称的变量，后设置的值会覆盖前设置的变量值。
  • local变量由于在不同的任务或不同的执行实例中，作用域互不影响，变量名可以相同没有影响。local变量名也可以和global变量名相同，没有影响。

2.4 流程变量的使用方法

  • ①设置流程变量。
  • ②通过UEL表达式使用流程变量。
    • Activiti7进阶之个人任务和流程变量 - 图8可以在assignee处设置UEL表达式，表达值的值就是任务的负责人。例如：${assignee}，assignee就是一个流程变量的名称。

在assignee处设置UEL表达式.png

  • Activiti7进阶之个人任务和流程变量 - 图10可以在连线上设置UEL表达式，决定流程的走向。例如：${holidayNum>=3}和${holidayNum<3}中holidayNum就是一个流程变量名称，UEL表达式的结果类型为boolean类型，如果UEL表达式的值是true，则总经理审批，否则直接人事存档。

在连线上设置UEL表达式.png

2.5 使用global变量控制流程

2.5.1 需求

  • 员工创建请假流程申请单，由部门经理审批，部门经理审批通过后请假3天以下的由人事经理直接审批，3天及3天以上的由总经理审批，总经理审批通过再通过人事经理存档。

使用global变量控制流程的需求.png

2.5.2 画流程定义

  • 请假大于等于3天的连线条件：

请假大于等于3天的连线条件.png

  • 请假小于3天的连线条件：

请假小于3天的连线条件.png

本人在画BPMN文件的时候将填写请假申请单的assignee设置为张三，部门经理审批的assignee设置为李四，总经理审批的assignee设置为王五，人事经理存档设置为赵六。

2.5.3 设置global流程变量

2.5.3.1 准备工作

  • 导入相关jar包的Maven坐标：
  1. <properties>
  2.     <activiti.version>7.0.0.GA</activiti.version>
  3. </properties>
  5. <dependencies>
  6.     <dependency>
  7.         <groupId>org.activiti</groupId>
  8.         <artifactId>activiti-engine</artifactId>
  9.         <version>7.0.0.GA</version>
  10.     </dependency>
  11.     <dependency>
  12.         <groupId>org.activiti</groupId>
  13.         <artifactId>activiti-spring</artifactId>
  14.         <version>${activiti.version}</version>
  15.     </dependency>
  16.     <dependency>
  17.         <groupId>org.activiti</groupId>
  18.         <artifactId>activiti-bpmn-model</artifactId>
  19.         <version>${activiti.version}</version>
  20.     </dependency>
  21.     <dependency>
  22.         <groupId>org.activiti</groupId>
  23.         <artifactId>activiti-bpmn-converter</artifactId>
  24.         <version>${activiti.version}</version>
  25.     </dependency>
  26.     <dependency>
  27.         <groupId>org.activiti</groupId>
  28.         <artifactId>activiti-json-converter</artifactId>
  29.         <version>${activiti.version}</version>
  30.     </dependency>
  31.     <dependency>
  32.         <groupId>org.activiti</groupId>
  33.         <artifactId>activiti-bpmn-layout</artifactId>
  34.         <version>${activiti.version}</version>
  35.     </dependency>
  36.     <dependency>
  37.         <groupId>org.activiti.cloud</groupId>
  38.         <artifactId>activiti-cloud-services-api</artifactId>
  39.         <version>7-201802-EA</version>
  40.     </dependency>
  41.     <dependency>
  42.         <groupId>mysql</groupId>
  43.         <artifactId>mysql-connector-java</artifactId>
  44.         <version>8.0.19</version>
  45.     </dependency>
  46.     <dependency>
  47.         <groupId>junit</groupId>
  48.         <artifactId>junit</artifactId>
  49.         <version>4.12</version>
  50.     </dependency>
  51.     <!-- log start -->
  52.     <dependency>
  53.         <groupId>org.apache.logging.log4j</groupId>
  54.         <artifactId>log4j-core</artifactId>
  55.         <version>2.13.3</version>
  56.     </dependency>
  57.     <dependency>
  58.         <groupId>org.apache.logging.log4j</groupId>
  59.         <artifactId>log4j-api</artifactId>
  60.         <version>2.13.3</version>
  61.     </dependency>
  62.     <dependency>
  63.         <groupId>org.slf4j</groupId>
  64.         <artifactId>slf4j-api</artifactId>
  65.         <version>1.7.30</version>
  66.     </dependency>
  67.     <dependency>
  68.         <groupId>org.apache.logging.log4j</groupId>
  69.         <artifactId>log4j-slf4j-impl</artifactId>
  70.         <version>2.13.3</version>
  71.     </dependency>
  72.     <!-- log end -->
  73.     <dependency>
  74.         <groupId>org.mybatis</groupId>
  75.         <artifactId>mybatis</artifactId>
  76.         <version>3.4.5</version>
  77.     </dependency>
  78.     <dependency>
  79.         <groupId>commons-dbcp</groupId>
  80.         <artifactId>commons-dbcp</artifactId>
  81.         <version>1.4</version>
  82.     </dependency>
  83. </dependencies>
  85. <dependencyManagement>
  86.     <dependencies>
  87.         <dependency>
  88.             <groupId>org.activiti.cloud.dependencies</groupId>
  89.             <artifactId>activiti-cloud-dependencies</artifactId>
  90.             <version>7.0.0.GA</version>
  91.             <scope>import</scope>
  92.             <type>pom</type>
  93.         </dependency>
  94.     </dependencies>
  95. </dependencyManagement>
  • 日志文件(log4j2.xml)
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!--日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL -->
  3. <!--Configuration后面的status用于设置log4j2自身内部的信息输出，可以不设置，当设置成trace时，可以看到log4j2内部各种详细输出-->
  4. <configuration status="INFO">
  5.     <!--先定义所有的appender-->
  6.     <appenders>
  7.         <!--输出日志信息到控制台-->
  8.         <console name="Console" target="SYSTEM_OUT">
  9.             <!--控制日志输出的格式-->
  10.             <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
  11.         </console>
  12.     </appenders>
  13.     <!--然后定义logger，只有定义了logger并引入的appender，appender才会生效-->
  14.     <!--root：用于指定项目的根日志，如果没有单独指定Logger，则会使用root作为默认的日志输出-->
  15.     <loggers>
  16.         <root level="INFO">
  17.             <appender-ref ref="Console"/>
  18.         </root>
  19.     </loggers>
  20. </configuration>
  • Activiti的核心配置文件(activiti-cfg.xml)
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.        xmlns:context="http://www.springframework.org/schema/context"
  4.        xmlns="http://www.springframework.org/schema/beans"
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  6.         http://www.springframework.org/schema/beans/spring-beans.xsd
  7.         http://www.springframework.org/schema/context
  8.         http://www.springframework.org/schema/context/spring-context.xsd">
  10.     <!--  配置数据源 -->
  11.     <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
  12.         <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
  13.         <property name="username" value="root"/>
  14.         <property name="url"
  15.                   value="jdbc:mysql://192.168.1.146:3306/activiti?useUnicode=true&amp;characterEncoding=UTF-8&amp;autoReconnect=true&amp;useSSL=false&amp;serverTimezone=GMT%2B8&amp;allowPublicKeyRetrieval=true"/>
  16.         <property name="password" value="123456"/>
  17.         <property name="maxActive" value="3"/>
  18.         <property name="maxIdle" value="1"/>
  19.     </bean>
  21.     <!-- Activiti单独运行的ProcessEngine配置 -->
  22.     <bean id="processEngineConfiguration" class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
  23.         <!-- 数据源 -->
  24.         <property name="dataSource" ref="dataSource"/>
  25.         <!--
  26.             activiti数据库表处理策略
  27.                 false(默认值)：检查数据库的版本和依赖库的版本，如果不匹配就抛出异常
  28.                 true：构建流程引擎时，执行检查，如果需要就执行更新。如果表不存在，就创建。
  29.                 create-drop：构建流程引擎时创建数据库报表，关闭流程引擎时就删除这些表。
  30.                 drop-create：先删除表再创建表。
  31.                 create：构建流程引擎时创建数据库表，关闭流程引擎时不删除这些表
  32.         -->
  33.         <property name="databaseSchemaUpdate" value="true"/>
  34.     </bean>
  35. </beans>
  • 请假实体类(Holiday.java)
  1. package com.sunxiaping.task;
  3. import java.io.Serializable;
  4. import java.util.Date;
  6. /**
  7.  * 请假实体类
  8.  *
  9.  * @author <a href="mailto:1900919313@qq.com">weiwei.xu</a>
  10.  * @version 1.0
  11.  * 2020-08-06 14:30
  12.  */
  13. public class Holiday implements Serializable {
  15.     /**
  16.      * 主键
  17.      */
  18.     private Integer id;
  20.     /**
  21.      * 申请人名字
  22.      */
  23.     private String holidayName;
  25.     /**
  26.      * 开始时间
  27.      */
  28.     private Date beginDate;
  30.     /**
  31.      * 结束时间
  32.      */
  33.     private Date endDate;
  35.     /**
  36.      * 请假天数
  37.      */
  38.     private Float num;
  40.     /**
  41.      * 请假事由
  42.      */
  43.     private String reason;
  45.     /**
  46.      * 请假类型：病假、婚假、丧假等
  47.      */
  48.     private String type;
  51.     public Integer getId() {
  52.         return id;
  53.     }
  55.     public void setId(Integer id) {
  56.         this.id = id;
  57.     }
  59.     public String getHolidayName() {
  60.         return holidayName;
  61.     }
  63.     public void setHolidayName(String holidayName) {
  64.         this.holidayName = holidayName;
  65.     }
  67.     public Date getBeginDate() {
  68.         return beginDate;
  69.     }
  71.     public void setBeginDate(Date beginDate) {
  72.         this.beginDate = beginDate;
  73.     }
  75.     public Date getEndDate() {
  76.         return endDate;
  77.     }
  79.     public void setEndDate(Date endDate) {
  80.         this.endDate = endDate;
  81.     }
  83.     public Float getNum() {
  84.         return num;
  85.     }
  87.     public void setNum(Float num) {
  88.         this.num = num;
  89.     }
  91.     public String getReason() {
  92.         return reason;
  93.     }
  95.     public void setReason(String reason) {
  96.         this.reason = reason;
  97.     }
  99.     public String getType() {
  100.         return type;
  101.     }
  103.     public void setType(String type) {
  104.         this.type = type;
  105.     }
  106. }
  • 将流程定义和对应的图片放入到resources目录下：

在classpath下放入流程定义文件和图片.png

2.5.3.2 启动流程时设置

  • 示例：
  1. package com.sunxiaping.test;
  3. import com.sunxiaping.task.Holiday;
  4. import org.activiti.engine.*;
  5. import org.activiti.engine.repository.Deployment;
  6. import org.activiti.engine.runtime.ProcessInstance;
  7. import org.activiti.engine.task.Task;
  8. import org.junit.After;
  9. import org.junit.Before;
  10. import org.junit.Test;
  12. import java.time.LocalDateTime;
  13. import java.time.ZoneId;
  14. import java.util.Date;
  15. import java.util.HashMap;
  16. import java.util.List;
  17. import java.util.Map;
  19. /**
  20.  * global流程变量测试：启动流程时设置
  21.  *
  22.  * @author <a href="mailto:1900919313@qq.com">weiwei.xu</a>
  23.  * @version 1.0
  24.  * 2020-08-06 14:28
  25.  */
  26. public class ActivitiGlobalVariableStartProcessInstanceTest {
  27.     ProcessEngine processEngine = null;
  29.     @Before
  30.     public void before() {
  31.         ProcessEngineConfiguration configuration = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti-cfg.xml");
  32.         processEngine = configuration.buildProcessEngine();
  33.     }
  35.     @After
  36.     public void after() {
  37.         if (processEngine != null) {
  38.             processEngine.close();
  39.         }
  40.     }
  42.     /**
  43.      * 流程定义部署
  44.      */
  45.     @Test
  46.     public void testDeployment() {
  47.         //获取RepositoryService对象
  48.         RepositoryService repositoryService = processEngine.getRepositoryService();
  49.         //获取Deployment对象
  50.         Deployment deployment = repositoryService.createDeployment()
  51.                 .addClasspathResource("diagram/holiday.bpmn")
  52.                 .addClasspathResource("diagram/holiday.png")
  53.                 .name("请假申请流程")
  54.                 .deploy();
  55.         String id = deployment.getId();
  56.         System.out.println("流程部署的id = " + id);
  57.         String name = deployment.getName();
  58.         System.out.println("流程部署的名称 = " + name);
  59.         String key = deployment.getKey();
  60.         System.out.println("流程部署的key = " + key);
  61.     }
  63.     /**
  64.      * 启动流程的时候给流程变量赋值
  65.      */
  66.     @Test
  67.     public void testStartProcessInstance() {
  68.         //流程定义的key
  69.         String processDefinitionKey = "holiday";
  70.         //获取RuntimeService对象
  71.         RuntimeService runtimeService = processEngine.getRuntimeService();
  73.         //封装global流程变量
  74.         Holiday holiday = new Holiday();
  75.         holiday.setNum(3f);
  76.         holiday.setHolidayName("如花");
  77.         holiday.setId(1);
  78.         holiday.setType("年假");
  79.         holiday.setReason("想男友了");
  80.         holiday.setBeginDate(new Date());
  81.         LocalDateTime endLocalDateTime = LocalDateTime.now().plusDays(3);
  82.         Date endDate = Date.from(endLocalDateTime.atZone(ZoneId.systemDefault()).toInstant());
  83.         holiday.setEndDate(endDate);
  85.         Map<String, Object> variables = new HashMap<>();
  86.         variables.put("holiday", holiday);
  88.         //根据流程定义的key启动流程实例
  89.         ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(processDefinitionKey, variables);
  91.         String id = processInstance.getId();
  92.         System.out.println("流程实例的id = " + id);
  94.         String name = processInstance.getName();
  95.         System.out.println("流程实例的名称 = " + name);
  97.         String processDefinitionId = processInstance.getProcessDefinitionId();
  98.         System.out.println("流程定义的id = " + processDefinitionId);
  99.     }
  101.     /**
  102.      * 测试张三完成任务
  103.      */
  104.     @Test
  105.     public void testZhangSanTask() {
  106.         String assignee = "张三";
  107.         //流程定义的key
  108.         String processDefinitionKey = "holiday";
  109.         //获取TaskService对象
  110.         TaskService taskService = processEngine.getTaskService();
  111.         //获取张三任务的列表
  112.         List<Task> taskList = taskService.createTaskQuery().processDefinitionKey(processDefinitionKey).taskAssignee(assignee).list();
  114.         for (Task task : taskList) {
  115.             //任务的id
  116.             String id = task.getId();
  117.             System.out.println("张三任务的id = " + id);
  118.             taskService.complete(id);
  119.         }
  120.     }
  122.     /**
  123.      * 测试李四完成任务
  124.      */
  125.     @Test
  126.     public void testLiSiTask() {
  127.         String assignee = "李四";
  128.         //流程定义的key
  129.         String processDefinitionKey = "holiday";
  130.         //获取TaskService对象
  131.         TaskService taskService = processEngine.getTaskService();
  132.         //获取李四任务的列表
  133.         List<Task> taskList = taskService.createTaskQuery().processDefinitionKey(processDefinitionKey).taskAssignee(assignee).list();
  135.         for (Task task : taskList) {
  136.             //任务的id
  137.             String id = task.getId();
  138.             System.out.println("李四任务的id = " + id);
  139.             taskService.complete(id);
  140.         }
  141.     }
  143.     /**
  144.      * 测试王五和赵六的任务，查看到底是王五还是赵六有任务
  145.      */
  146.     @Test
  147.     public void testWangWuTask() {
  148.         String assignee = "王五";
  149.         //流程定义的key
  150.         String processDefinitionKey = "holiday";
  151.         //获取TaskService对象
  152.         TaskService taskService = processEngine.getTaskService();
  153.         //获取王五任务的列表
  154.         List<Task> taskList = taskService.createTaskQuery().processDefinitionKey(processDefinitionKey).taskAssignee(assignee).list();
  156.         for (Task task : taskList) {
  157.             //任务的id
  158.             String id = task.getId();
  159.             System.out.println("王五任务的id = " + id);
  160.         }
  162.         assignee = "赵六";
  163.         taskService = processEngine.getTaskService();
  164.         //获取赵六任务的列表
  165.         taskList = taskService.createTaskQuery().taskAssignee(assignee).list();
  167.         for (Task task : taskList) {
  168.             //任务的id
  169.             String id = task.getId();
  170.             System.out.println("赵六任务的id = " + id);
  171.         }
  172.     }
  173. }

2.5.3.3 完成任务时设置

  • 示例：
  1. package com.sunxiaping.test;
  3. import com.sunxiaping.task.Holiday;
  4. import org.activiti.engine.*;
  5. import org.activiti.engine.repository.Deployment;
  6. import org.activiti.engine.runtime.ProcessInstance;
  7. import org.activiti.engine.task.Task;
  8. import org.junit.After;
  9. import org.junit.Before;
  10. import org.junit.Test;
  12. import java.time.LocalDateTime;
  13. import java.time.ZoneId;
  14. import java.util.Date;
  15. import java.util.HashMap;
  16. import java.util.List;
  17. import java.util.Map;
  19. /**
  20.  * global流程变量测试：完成任务时设置
  21.  *
  22.  * @author <a href="mailto:1900919313@qq.com">weiwei.xu</a>
  23.  * @version 1.0
  24.  * 2020-08-06 14:28
  25.  */
  26. public class ActivitiGlobalVariableCompleteTaskTest {
  27.     ProcessEngine processEngine = null;
  29.     @Before
  30.     public void before() {
  31.         ProcessEngineConfiguration configuration = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti-cfg.xml");
  32.         processEngine = configuration.buildProcessEngine();
  33.     }
  35.     @After
  36.     public void after() {
  37.         if (processEngine != null) {
  38.             processEngine.close();
  39.         }
  40.     }
  42.     /**
  43.      * 流程定义部署
  44.      */
  45.     @Test
  46.     public void testDeployment() {
  47.         //获取RepositoryService对象
  48.         RepositoryService repositoryService = processEngine.getRepositoryService();
  49.         //获取Deployment对象
  50.         Deployment deployment = repositoryService.createDeployment()
  51.                 .addClasspathResource("diagram/holiday.bpmn")
  52.                 .addClasspathResource("diagram/holiday.png")
  53.                 .name("请假申请流程")
  54.                 .deploy();
  55.         String id = deployment.getId();
  56.         System.out.println("流程部署的id = " + id);
  57.         String name = deployment.getName();
  58.         System.out.println("流程部署的名称 = " + name);
  59.         String key = deployment.getKey();
  60.         System.out.println("流程部署的key = " + key);
  61.     }
  63.     /**
  64.      * 启动流程
  65.      */
  66.     @Test
  67.     public void testStartProcessInstance() {
  68.         //流程定义的key
  69.         String processDefinitionKey = "holiday";
  70.         //获取RuntimeService对象
  71.         RuntimeService runtimeService = processEngine.getRuntimeService();
  73.         //根据流程定义的key启动流程实例
  74.         ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(processDefinitionKey);
  76.         String id = processInstance.getId();
  77.         System.out.println("流程实例的id = " + id);
  79.         String name = processInstance.getName();
  80.         System.out.println("流程实例的名称 = " + name);
  82.         String processDefinitionId = processInstance.getProcessDefinitionId();
  83.         System.out.println("流程定义的id = " + processDefinitionId);
  84.     }
  86.     /**
  87.      * 测试张三完成任务，张三完成任务的时候给global变量赋值
  88.      */
  89.     @Test
  90.     public void testZhangSanTask() {
  91.         String assignee = "张三";
  92.         //流程定义的key
  93.         String processDefinitionKey = "holiday";
  94.         //获取TaskService对象
  95.         TaskService taskService = processEngine.getTaskService();
  96.         //获取张三任务的列表
  97.         List<Task> taskList = taskService.createTaskQuery().processDefinitionKey(processDefinitionKey).taskAssignee(assignee).list();
  99.         for (Task task : taskList) {
  100.             //任务的id
  101.             String id = task.getId();
  102.             System.out.println("张三任务的id = " + id);
  104.             //封装global流程变量
  105.             Holiday holiday = new Holiday();
  106.             holiday.setNum(3f);
  107.             holiday.setHolidayName("如花");
  108.             holiday.setId(1);
  109.             holiday.setType("年假");
  110.             holiday.setReason("想男友了");
  111.             holiday.setBeginDate(new Date());
  112.             LocalDateTime endLocalDateTime = LocalDateTime.now().plusDays(3);
  113.             Date endDate = Date.from(endLocalDateTime.atZone(ZoneId.systemDefault()).toInstant());
  114.             holiday.setEndDate(endDate);
  116.             Map<String, Object> variables = new HashMap<>();
  117.             variables.put("holiday", holiday);
  119.             taskService.complete(id, variables);
  120.         }
  121.     }
  123.     /**
  124.      * 测试李四完成任务
  125.      */
  126.     @Test
  127.     public void testLiSiTask() {
  128.         String assignee = "李四";
  129.         //流程定义的key
  130.         String processDefinitionKey = "holiday";
  131.         //获取TaskService对象
  132.         TaskService taskService = processEngine.getTaskService();
  133.         //获取李四任务的列表
  134.         List<Task> taskList = taskService.createTaskQuery().processDefinitionKey(processDefinitionKey).taskAssignee(assignee).list();
  136.         for (Task task : taskList) {
  137.             //任务的id
  138.             String id = task.getId();
  139.             System.out.println("李四任务的id = " + id);
  140.             taskService.complete(id);
  141.         }
  142.     }
  144.     /**
  145.      * 测试王五和赵六的任务，查看到底是王五还是赵六有任务
  146.      */
  147.     @Test
  148.     public void testWangWuTask() {
  149.         String assignee = "王五";
  150.         //流程定义的key
  151.         String processDefinitionKey = "holiday";
  152.         //获取TaskService对象
  153.         TaskService taskService = processEngine.getTaskService();
  154.         //获取王五任务的列表
  155.         List<Task> taskList = taskService.createTaskQuery().processDefinitionKey(processDefinitionKey).taskAssignee(assignee).list();
  157.         for (Task task : taskList) {
  158.             //任务的id
  159.             String id = task.getId();
  160.             System.out.println("王五任务的id = " + id);
  161.         }
  163.         assignee = "赵六";
  164.         taskService = processEngine.getTaskService();
  165.         //获取赵六任务的列表
  166.         taskList = taskService.createTaskQuery().taskAssignee(assignee).list();
  168.         for (Task task : taskList) {
  169.             //任务的id
  170.             String id = task.getId();
  171.             System.out.println("赵六任务的id = " + id);
  172.         }
  173.     }
  174. }

2.5.3.4 通过当前流程实例设置

  • 通过流程实例的id设置全局流程变量，该流程实例必须没有执行完毕。
  • 示例：
  1. package com.sunxiaping.test;
  3. import com.sunxiaping.task.Holiday;
  4. import org.activiti.engine.*;
  5. import org.activiti.engine.repository.Deployment;
  6. import org.activiti.engine.runtime.ProcessInstance;
  7. import org.activiti.engine.task.Task;
  8. import org.junit.After;
  9. import org.junit.Before;
  10. import org.junit.Test;
  12. import java.time.LocalDateTime;
  13. import java.time.ZoneId;
  14. import java.util.Date;
  15. import java.util.HashMap;
  16. import java.util.List;
  17. import java.util.Map;
  19. /**
  20.  * global流程变量测试：通过当前流程实例设置
  21.  *
  22.  * @author <a href="mailto:1900919313@qq.com">weiwei.xu</a>
  23.  * @version 1.0
  24.  * 2020-08-06 14:28
  25.  */
  26. public class ActivitiGlobalVariableCurrentExecutionIdTest {
  27.     ProcessEngine processEngine = null;
  29.     @Before
  30.     public void before() {
  31.         ProcessEngineConfiguration configuration = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti-cfg.xml");
  32.         processEngine = configuration.buildProcessEngine();
  33.     }
  35.     @After
  36.     public void after() {
  37.         if (processEngine != null) {
  38.             processEngine.close();
  39.         }
  40.     }
  42.     /**
  43.      * 流程定义部署
  44.      */
  45.     @Test
  46.     public void testDeployment() {
  47.         //获取RepositoryService对象
  48.         RepositoryService repositoryService = processEngine.getRepositoryService();
  49.         //获取Deployment对象
  50.         Deployment deployment = repositoryService.createDeployment()
  51.                 .addClasspathResource("diagram/holiday.bpmn")
  52.                 .addClasspathResource("diagram/holiday.png")
  53.                 .name("请假申请流程")
  54.                 .deploy();
  55.         String id = deployment.getId();
  56.         System.out.println("流程部署的id = " + id);
  57.         String name = deployment.getName();
  58.         System.out.println("流程部署的名称 = " + name);
  59.         String key = deployment.getKey();
  60.         System.out.println("流程部署的key = " + key);
  61.     }
  63.     /**
  64.      * 启动流程
  65.      */
  66.     @Test
  67.     public void testStartProcessInstance() {
  68.         //流程定义的key
  69.         String processDefinitionKey = "holiday";
  70.         //获取RuntimeService对象
  71.         RuntimeService runtimeService = processEngine.getRuntimeService();
  73.         //根据流程定义的key启动流程实例
  74.         ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(processDefinitionKey);
  76.         String id = processInstance.getId();
  77.         System.out.println("流程实例的id = " + id);
  79.         String name = processInstance.getName();
  80.         System.out.println("流程实例的名称 = " + name);
  82.         String processDefinitionId = processInstance.getProcessDefinitionId();
  83.         System.out.println("流程定义的id = " + processDefinitionId);
  84.     }
  87.     /**
  88.      * 通过流程实例的id设置流程变量，该流程必须没有执行完毕
  89.      */
  90.     @Test
  91.     public void testSetVariable(){
  92.         String executionId = "2501";
  94.         //封装global流程变量
  95.         Holiday holiday = new Holiday();
  96.         holiday.setNum(3f);
  97.         holiday.setHolidayName("如花");
  98.         holiday.setId(1);
  99.         holiday.setType("年假");
  100.         holiday.setReason("想男友了");
  101.         holiday.setBeginDate(new Date());
  102.         LocalDateTime endLocalDateTime = LocalDateTime.now().plusDays(3);
  103.         Date endDate = Date.from(endLocalDateTime.atZone(ZoneId.systemDefault()).toInstant());
  104.         holiday.setEndDate(endDate);
  106.         Map<String, Object> variables = new HashMap<>();
  107.         variables.put("holiday", holiday);
  109.         //获取RuntimeService对象
  110.         RuntimeService runtimeService = processEngine.getRuntimeService();
  112.         //设置流程变量
  113.         runtimeService.setVariables(executionId,variables);
  114.     }
  118.     /**
  119.      * 测试张三完成任务
  120.      */
  121.     @Test
  122.     public void testZhangSanTask() {
  123.         String assignee = "张三";
  124.         //流程定义的key
  125.         String processDefinitionKey = "holiday";
  126.         //获取TaskService对象
  127.         TaskService taskService = processEngine.getTaskService();
  128.         //获取张三任务的列表
  129.         List<Task> taskList = taskService.createTaskQuery().processDefinitionKey(processDefinitionKey).taskAssignee(assignee).list();
  131.         for (Task task : taskList) {
  132.             //任务的id
  133.             String id = task.getId();
  134.             System.out.println("张三任务的id = " + id);
  136.             taskService.complete(id);
  137.         }
  138.     }
  140.     /**
  141.      * 测试李四完成任务
  142.      */
  143.     @Test
  144.     public void testLiSiTask() {
  145.         String assignee = "李四";
  146.         //流程定义的key
  147.         String processDefinitionKey = "holiday";
  148.         //获取TaskService对象
  149.         TaskService taskService = processEngine.getTaskService();
  150.         //获取李四任务的列表
  151.         List<Task> taskList = taskService.createTaskQuery().processDefinitionKey(processDefinitionKey).taskAssignee(assignee).list();
  153.         for (Task task : taskList) {
  154.             //任务的id
  155.             String id = task.getId();
  156.             System.out.println("李四任务的id = " + id);
  157.             taskService.complete(id);
  158.         }
  159.     }
  161.     /**
  162.      * 测试王五和赵六的任务，查看到底是王五还是赵六有任务
  163.      */
  164.     @Test
  165.     public void testWangWuTask() {
  166.         String assignee = "王五";
  167.         //流程定义的key
  168.         String processDefinitionKey = "holiday";
  169.         //获取TaskService对象
  170.         TaskService taskService = processEngine.getTaskService();
  171.         //获取王五任务的列表
  172.         List<Task> taskList = taskService.createTaskQuery().processDefinitionKey(processDefinitionKey).taskAssignee(assignee).list();
  174.         for (Task task : taskList) {
  175.             //任务的id
  176.             String id = task.getId();
  177.             System.out.println("王五任务的id = " + id);
  178.         }
  180.         assignee = "赵六";
  181.         taskService = processEngine.getTaskService();
  182.         //获取赵六任务的列表
  183.         taskList = taskService.createTaskQuery().taskAssignee(assignee).list();
  185.         for (Task task : taskList) {
  186.             //任务的id
  187.             String id = task.getId();
  188.             System.out.println("赵六任务的id = " + id);
  189.         }
  190.     }
  191. }

2.5.3.5 通过当前任务设置

  • 该任务必须待办任务，act_ru_task表中存在。如果该任务已经结束，就会报错。
  • 示例：
  1. package com.sunxiaping.test;
  3. import com.sunxiaping.task.Holiday;
  4. import org.activiti.engine.*;
  5. import org.activiti.engine.repository.Deployment;
  6. import org.activiti.engine.runtime.ProcessInstance;
  7. import org.activiti.engine.task.Task;
  8. import org.junit.After;
  9. import org.junit.Before;
  10. import org.junit.Test;
  12. import java.time.LocalDateTime;
  13. import java.time.ZoneId;
  14. import java.util.Date;
  15. import java.util.HashMap;
  16. import java.util.List;
  17. import java.util.Map;
  19. /**
  20.  * global流程变量测试：通过当前流程实例设置
  21.  *
  22.  * @author <a href="mailto:1900919313@qq.com">weiwei.xu</a>
  23.  * @version 1.0
  24.  * 2020-08-06 14:28
  25.  */
  26. public class ActivitiGlobalVariableCurrentTaskIdTest {
  27.     ProcessEngine processEngine = null;
  29.     @Before
  30.     public void before() {
  31.         ProcessEngineConfiguration configuration = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti-cfg.xml");
  32.         processEngine = configuration.buildProcessEngine();
  33.     }
  35.     @After
  36.     public void after() {
  37.         if (processEngine != null) {
  38.             processEngine.close();
  39.         }
  40.     }
  43.     /**
  44.      * 流程定义部署
  45.      */
  46.     @Test
  47.     public void testDeployment() {
  48.         //获取RepositoryService对象
  49.         RepositoryService repositoryService = processEngine.getRepositoryService();
  50.         //获取Deployment对象
  51.         Deployment deployment = repositoryService.createDeployment()
  52.                 .addClasspathResource("diagram/holiday.bpmn")
  53.                 .addClasspathResource("diagram/holiday.png")
  54.                 .name("请假申请流程")
  55.                 .deploy();
  56.         String id = deployment.getId();
  57.         System.out.println("流程部署的id = " + id);
  58.         String name = deployment.getName();
  59.         System.out.println("流程部署的名称 = " + name);
  60.         String key = deployment.getKey();
  61.         System.out.println("流程部署的key = " + key);
  62.     }
  64.     /**
  65.      * 启动流程
  66.      */
  67.     @Test
  68.     public void testStartProcessInstance() {
  69.         //流程定义的key
  70.         String processDefinitionKey = "holiday";
  71.         //获取RuntimeService对象
  72.         RuntimeService runtimeService = processEngine.getRuntimeService();
  74.         //根据流程定义的key启动流程实例
  75.         ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(processDefinitionKey);
  77.         String id = processInstance.getId();
  78.         System.out.println("流程实例的id = " + id);
  80.         String name = processInstance.getName();
  81.         System.out.println("流程实例的名称 = " + name);
  83.         String processDefinitionId = processInstance.getProcessDefinitionId();
  84.         System.out.println("流程定义的id = " + processDefinitionId);
  85.     }
  88.     /**
  89.      * 测试张三完成任务
  90.      */
  91.     @Test
  92.     public void testZhangSanTask() {
  93.         String assignee = "张三";
  94.         //流程定义的key
  95.         String processDefinitionKey = "holiday";
  96.         //获取TaskService对象
  97.         TaskService taskService = processEngine.getTaskService();
  98.         //获取张三任务的列表
  99.         List<Task> taskList = taskService.createTaskQuery().processDefinitionKey(processDefinitionKey).taskAssignee(assignee).list();
  101.         for (Task task : taskList) {
  102.             //任务的id
  103.             String id = task.getId();
  105.             //封装global流程变量
  106.             Holiday holiday = new Holiday();
  107.             holiday.setNum(3f);
  108.             holiday.setHolidayName("如花");
  109.             holiday.setId(1);
  110.             holiday.setType("年假");
  111.             holiday.setReason("想男友了");
  112.             holiday.setBeginDate(new Date());
  113.             LocalDateTime endLocalDateTime = LocalDateTime.now().plusDays(3);
  114.             Date endDate = Date.from(endLocalDateTime.atZone(ZoneId.systemDefault()).toInstant());
  115.             holiday.setEndDate(endDate);
  117.             Map<String, Object> variables = new HashMap<>();
  118.             variables.put("holiday", holiday);
  121.             taskService.setVariables(id,variables);
  123.             System.out.println("张三任务的id = " + id);
  125.             taskService.complete(id);
  126.         }
  127.     }
  129.     /**
  130.      * 测试李四完成任务
  131.      */
  132.     @Test
  133.     public void testLiSiTask() {
  134.         String assignee = "李四";
  135.         //流程定义的key
  136.         String processDefinitionKey = "holiday";
  137.         //获取TaskService对象
  138.         TaskService taskService = processEngine.getTaskService();
  139.         //获取李四任务的列表
  140.         List<Task> taskList = taskService.createTaskQuery().processDefinitionKey(processDefinitionKey).taskAssignee(assignee).list();
  142.         for (Task task : taskList) {
  143.             //任务的id
  144.             String id = task.getId();
  145.             System.out.println("李四任务的id = " + id);
  146.             taskService.complete(id);
  147.         }
  148.     }
  150.     /**
  151.      * 测试王五和赵六的任务，查看到底是王五还是赵六有任务
  152.      */
  153.     @Test
  154.     public void testWangWuTask() {
  155.         String assignee = "王五";
  156.         //流程定义的key
  157.         String processDefinitionKey = "holiday";
  158.         //获取TaskService对象
  159.         TaskService taskService = processEngine.getTaskService();
  160.         //获取王五任务的列表
  161.         List<Task> taskList = taskService.createTaskQuery().processDefinitionKey(processDefinitionKey).taskAssignee(assignee).list();
  163.         for (Task task : taskList) {
  164.             //任务的id
  165.             String id = task.getId();
  166.             System.out.println("王五任务的id = " + id);
  167.         }
  169.         assignee = "赵六";
  170.         taskService = processEngine.getTaskService();
  171.         //获取赵六任务的列表
  172.         taskList = taskService.createTaskQuery().taskAssignee(assignee).list();
  174.         for (Task task : taskList) {
  175.             //任务的id
  176.             String id = task.getId();
  177.             System.out.println("赵六任务的id = " + id);
  178.         }
  179.     }
  181. }

2.5.4 注意事项

  • 如果UEL表达式中流程变量名不存在则报错。
  • 如果UEL表达式中流程变量值为null，流程不按UEL表达式去执行，而流程结束。
  • 如果UEL表达式都不符合条件，流程结束。
  • 如果连接不设置条件，会走flow序号小的那条线。

2.5.5 操作的数据库表

  • 设置流程变量会在当前执行流程变量表(act_ru_variable)插入记录，同时也会在历史流程变量表(act_hi_varinst)中也插入记录。

2.6 设置Local流程变量(实际开发中一般不用)

2.6.1 完成任务前设置

  • 在任务完成前设置Local流程变量，当前运行的Local流程变量只能在该任务结束前使用，任务结束该变量无法在当前流程实例使用，可以通过查询历史任务查询。
  • 示例：
  1. /**
  2.      * 测试张三完成任务
  3.      */
  4. @Test
  5. public void testZhangSanTask() {
  6.     String assignee = "张三";
  7.     //流程定义的key
  8.     String processDefinitionKey = "holiday";
  9.     //获取TaskService对象
  10.     TaskService taskService = processEngine.getTaskService();
  11.     //获取张三任务的列表
  12.     List<Task> taskList = taskService.createTaskQuery().processDefinitionKey(processDefinitionKey).taskAssignee(assignee).list();
  14.     for (Task task : taskList) {
  15.         //任务的id
  16.         String id = task.getId();
  17.         System.out.println("张三任务的id = " + id);
  19.         //封装global流程变量
  20.         Holiday holiday = new Holiday();
  21.         holiday.setNum(3f);
  22.         holiday.setHolidayName("如花");
  23.         holiday.setId(1);
  24.         holiday.setType("年假");
  25.         holiday.setReason("想男友了");
  26.         holiday.setBeginDate(new Date());
  27.         LocalDateTime endLocalDateTime = LocalDateTime.now().plusDays(3);
  28.         Date endDate = Date.from(endLocalDateTime.atZone(ZoneId.systemDefault()).toInstant());
  29.         holiday.setEndDate(endDate);
  31.         Map<String, Object> variables = new HashMap<>();
  32.         variables.put("holiday", holiday);
  34.         taskService.setVariablesLocal(id,variables);
  36.         taskService.complete(id);
  37.     }
  38. }

2.6.2 通过当前任务设置

  • 示例：
  1. /**
  2.      * 测试张三完成任务
  3.      */
  4. @Test
  5. public void testZhangSanTask() {
  6.     String assignee = "张三";
  7.     //流程定义的key
  8.     String processDefinitionKey = "holiday";
  9.     //获取TaskService对象
  10.     TaskService taskService = processEngine.getTaskService();
  11.     //获取张三任务的列表
  12.     List<Task> taskList = taskService.createTaskQuery().processDefinitionKey(processDefinitionKey).taskAssignee(assignee).list();
  14.     for (Task task : taskList) {
  15.         //任务的id
  16.         String id = task.getId();
  18.         //封装global流程变量
  19.         Holiday holiday = new Holiday();
  20.         holiday.setNum(3f);
  21.         holiday.setHolidayName("如花");
  22.         holiday.setId(1);
  23.         holiday.setType("年假");
  24.         holiday.setReason("想男友了");
  25.         holiday.setBeginDate(new Date());
  26.         LocalDateTime endLocalDateTime = LocalDateTime.now().plusDays(3);
  27.         Date endDate = Date.from(endLocalDateTime.atZone(ZoneId.systemDefault()).toInstant());
  28.         holiday.setEndDate(endDate);
  30.         Map<String, Object> variables = new HashMap<>();
  31.         variables.put("holiday", holiday);
  34.         taskService.setVariables(id,variables);
  36.         System.out.println("张三任务的id = " + id);
  38.         taskService.complete(id);
  39.     }
  40. }