xplly'Blog

标签

工作流

字数

14956 字

阅读时间

62 分钟

一、概述

Activiti是一个工作流引擎， activiti可以将业务系统中复杂的业务流程抽取出来，使用专门的建模语言BPMN2.0进行定义，业务流程按照预先定义的流程进行执行，实现了系统的流程由activiti进行管理，减少业务系统由于流程变更进行系统升级改造的工作量，从而提高系统的健壮性，同时也减少了系统开发维护成本。

官方网站

1.1 核心类

ProcessEngine这个类是Activiti5的核心，所有的服务都需要通过ProcessEngine来创建，该类是线程安全的

Activiti5的持久化层采用的是Mybatis，这样移植性好

Activiti5主要包括7个Service，这些Service都是通过ProcessEngine创建

repositoryService（持久化服务）
runtimeService（运行时服务）
formService（表单服务）
identityService（身份信息）
taskService（任务服务）
historyService（历史信息）
managementService（管理定时任务）

1.2 使用流程

部署activiti的环境
环境包括：jar包和数据库（25张表）
业务系统通过spring和activiti整合进行开发。
使用activiti提供流程设计器（和idea或eclipse集成的designer）工具进行流程定义
流程定义生成两个文件：.bpmn和.png（不是必须的）。
将流程定义文件部署到activiti的数据库
SELECT * FROM act_re_deployment #流程定义部署表
一次部署插入一条记录，记录流程定义的部署信息
SELECT * FROM act_re_procdef #流程定义表
一次部署流程定义信息，如果一次部署两个流程定义，插入两条记录
建议：一次部署只部署一个流程定义，这样act_re_deployment和act_re_procdef一对一关系
常用两个方法：单个文件部署和zip文件部署。建议单个文件部署。
启动一个流程实例
业务系统就可以按照流程定义去执行业务流程，执行前需要启动一个流程实例
根据流程定义来启动一个流程实例。
指定一个流程定义的key启动一个流程实例，activiti根据key找最新版本的流程定义。
指定一个流程定义的id启动一个流程实例。
启动一个实例需要指定businesskey（业务标识），businessKey是activiti和业务系统整合时桥梁。
比如：请假流程，businessKey就是请假单id。
启动一个实例还可以指定流程变量，流程变量是全局变量（生命期是整个流程实例，流程实例结束，变量就消失）
查询待办任务
查询个人任务：使用taskService，根据assignee查询该用户当前的待办任务。
查询组任务：使用taskService，根据candidateuser查询候选用户当前的待办组任务。
办理任务
办理个人任务：调用taskService的complete方法完成任务。
如果是组任务，需要先拾取任务，调用taskService的claim方法拾取任务，拾取任务之后组任务就变成了个人任务（该任务就有负责人）。

1.3 表结构

Activiti使用到的表都是ACT_开头的。

ACT_RE_*	‘RE’表示repository(存储)。RepositoryService接口所操作的表。带此前缀的表包含的是静态信息，如，流程定义，流程的资源（图片，规则等）。
ACT_RU_*	‘RU’表示runtime，运行时表-RuntimeService。这是运行时的表存储着流程变量，用户任务，变量，职责（job）等运行时的数据。Activiti只存储实例执行期间的运行时数据，当流程实例结束时，将删除这些记录。这就保证了这些运行时的表小且快。
ACT_ID_*	’ID’表示identity (组织机构)，IdentityService接口所操作的表，用户记录，流程中使用到的用户和组。这些表包含标识的信息，如用户，用户组，等等。
ACT_HI_*:	’HI’表示history，历史数据表，HistoryService，就是这些表包含着流程执行的历史相关数据，如结束的流程实例，变量，任务，等等
ACT_GE_*	全局通用数据及设置(general)，各种情况都使用的数据。

具体表信息

act_ge_bytearray	二进制数据表
act_ge_property	属性数据表存储整个流程引擎级别的数据,初始化表结构时，会默认插入三条记录，
act_hi_actinst	历史节点表
act_hi_attachment	历史附件表
act_hi_comment	历史意见表
act_hi_identitylink	历史流程人员表
act_hi_detail	历史详情表，提供历史变量的查询
act_hi_procinst	历史流程实例表
act_hi_taskinst	历史任务实例表
act_hi_varinst	历史变量表
act_id_group	用户组信息表
act_id_info	用户扩展信息表
act_id_membership	用户与用户组对应信息表
act_id_user	用户信息表
act_re_deployment	部署信息表
act_re_model	流程设计模型部署表
act_re_procdef	流程定义数据表
act_ru_event_subscr throwEvent、catchEvent	时间监听信息表
act_ru_execution	运行时流程执行实例表
act_ru_identitylink	运行时流程人员表，主要存储任务节点与参与者的相关信息
act_ru_job	运行时定时任务数据表
act_ru_task	运行时任务节点表
act_ru_variable	运行时流程变量数据表

流程实例数据存储

表	语句	描述
流程实例执行表	SELECT * FROM act_ru_execution	流程实例执行表，记录当前流程实例的执行情况流程实例执行，如果当前只有一个分支时，一个流程实例只有一条记录且执行表的主键id和流程实例id相同，如果当前有多个分支正在运行则该执行表中有多条记录，存在执行表的主键和流程实例id不相同的记录。不论当前有几个分支总会有一条记录的执行表的主键和流程实例id相同一个流程实例运行完成，此表中与流程实例相关的记录删除。
任务执行表	SELECT * FROM act_ru_task	任务执行表，记录当前执行的任务启动流程实例，流程当前执行到第一个任务结点，此表会插入一条记录表示当前任务的执行情况，如果任务完成则记录删除。
任务参与者	SELECT * FROM act_ru_identitylink	任务参与者，记录当前参与任务的用户或组
流程实例历史表	SELECT * FROM act_hi_procinst	流程实例历史表流程实例启动，会在此表插入一条记录，流程实例运行完成记录也不会删除。
任务历史表	SELECT * FROM act_hi_taskinst	任务历史表，记录所有任务开始一个任务，不仅在act_ru_task表插入记录，也会在历史任务表插入一条记录，任务历史表的主键就是任务id，任务完成此表记录不删除。
活动历史表	SELECT * FROM act_hi_actinst	活动历史表，记录所有活动活动包括任务，所以此表中不仅记录了任务，还记录了流程执行过程的其它活动，比如开始事件、结束事件。
当前流程变量表	SELECT * FROM act_ru_variable	记录当前运行流程实例可使用的流程变量，包括 global和local变量
历史流程变量表	SELECT * FROM act_hi_varinst	记录所有已创建的流程变量，包括 global和local变量字段意义参考当前流程变量表。

流程变量存储

字段	含义
Id	主键
Type	变量类型
Name	变量名称
Execution_id	所属流程实例执行id，global和local变量都存储
Proc_inst_id	所属流程实例id，global和local变量都存储
Task_id	所属任务id，local变量存储
Bytearray	serializable类型变量存储对应act_ge_bytearray表的id
Double	double类型变量值
Long	long类型变量值
Text	text类型变量值

1.4 流程变量

流程变量就是activiti在管理工作流时根据管理需要而设置的变量。使用通过UEL表达式。

比如在请假流程流转时如果请假天数大于3天则由总经理审核，否则由人事直接审核，请假天数就可以设置为流程变量，在流程流转时使用。

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

变量类型

注意：如果将pojo存储到流程变量中，必须实现序列化接口serializable，为了防止由于新增字段无法反序列化，需要生成serialVersionUID。

流程变量作用域

流程变量的作用域默认是一个流程实例(processInstance)，也可以是一个任务(task)或一个执行实例(execution)，这三个作用域流程实例的范围最大，可以称为global变量，任务和执行实例仅仅是针对一个任务和一个执行实例范围，范围没有流程实例大，称为local变量。

global变量中变量名不允许重复，设置相同名称的变量，后设置的值会覆盖前设置的变量值。

Local变量由于在不同的任务或不同的执行实例中，作用域互不影响，变量名可以相同没有影响。

Local变量名也可以和global变量名相同，没有影响。

1.5 组任务

在流程定义中在任务结点的assignee固定设置任务负责人，在流程定义时将参与者固定设置在.bpmn文件中，如果临时任务负责人变更则需要修改流程定义，系统可扩展性差。针对这种情况可以给任务设置多个候选人，可以从候选人中选择参与者来完成任务。即为组任务。

组任务办理流程

查询组任务
指定候选人，查询该候选人当前的待办任务。候选人不能办理任务。
拾取(claim)任务
该组任务的所有候选人都能拾取。
将候选人的组任务，变成个人任务。原来候选人就变成了该任务的负责人。
如果拾取后不想办理任务，需要将已经拾取的个人任务归还到组里边，将个人任务变成了组任务。或者将任务交接
查询个人任务
查询方式同个人任务部分，根据assignee查询用户负责的个人任务。
办理个人任务

组任务相关的数据库表

sql

-- 任务执行表，记录当前执行的任务，由于该任务当前是组任务，所有assignee为空，当拾取任务后该字段就是拾取用户的id
SELECT * FROM act_ru_task 

-- 任务参与者，记录当前参考任务用户或组，当前任务如果设置了候选人，会向该表插入候选人记录，有几个候选就插入几个
-- act_ru_identitylink对应的还有一张历史表act_hi_identitylink，向act_ru_identitylink插入记录的同时也会向历史表插入记录。任务完成
SELECT * FROM act_ru_identitylink

1.6 网关

排他网关

排他网关（也叫异或（XOR）网关，或叫基于数据的排他网关），用来在流程中实现决策。当流程执行到这个网关，所有分支都会判断条件是否为true，如果为true则执行该分支，如果从网关出去的线所有条件都不满足则系统抛出异常。 注意，排他网关只会选择一个为true的分支执行。(即使有两个分支条件都为true，排他网关也会只选择一条分支去执行)

并行网关

并行网关允许将流程分成多条分支，也可以把多条分支汇聚到一起，并行网关的功能是基于进入和外出顺序流的：

fork分支：并行后的所有外出顺序流，为每个顺序流都创建一个并发分支。
join汇聚：所有到达并行网关，在此等待的进入分支，直到所有进入顺序流的分支都到达以后，流程就会通过汇聚网关。

注意，如果同一个并行网关有多个进入和多个外出顺序流，它就同时具有分支和汇聚功能。这时，网关会先汇聚所有进入的顺序流，然后再切分成多个并行分支。

与其他网关的主要区别是，并行网关不会解析条件。即使顺序流中定义了条件，也会被忽略。

并行网关在业务应用中常用于会签任务，会签任务即多个参与者共同办理的任务。

并行网关数据存储

当执行到并行
SELECT * FROM act_ru_task #当前任务表有两个(多个)任务当前执行。
通过流程实例执行表：SELECT * FROM act_ru_execution #流程实例的执行表并行任务执行不分前后，由任务的负责人去执行即可。
当完成并任务中一个任务后
已完成的任务在当前任务表act_ru_task_已被删除。在流程实例执行表：SELECT * FROM act_ru_execution有中多个分支存在且有并行网关的汇聚结点。
有并行网关的汇聚结点
说明有一个分支已经到汇聚，等待其它的分支到达
当所有分支任务都完成，都到达汇聚结点后
流程实例执行表：SELECT * FROM act_ru_execution，执行流程实例不存在，说明流程执行结束。
所有分支到达汇聚结点，并行网关执行完成。

包含网关

包含网关可以看做是排他网关和并行网关的结合体。和排他网关一样，你可以在外出顺序流上定义条件，包含网关会解析它们。但是主要的区别是包含网关可以选择多于一条顺序流，这和并行网关一样。包含网关的功能是基于进入和外出顺序流的：

分支：所有外出顺序流的条件都会被解析，结果为true的顺序流会以并行方式继续执行，会为每个顺序流创建一个分支。
汇聚：所有并行分支到达包含网关，会进入等待状态，直到每个包含流程token的进入顺序流的分支都到达。这是与并行网关的最大不同。换句话说，包含网关只会等待被选中执行了的进入顺序流。在汇聚之后，流程会穿过包含网关继续执行。

如果包含网关设置的条件中，流程变量不存在，报错;

当执行到包含网关：流程实例执行表：SELECT * FROM act_ru_execution

先走到汇聚结点的分支，要等待其它分支走到汇聚。等所有分支走到汇聚，包含网关就执行完成。包含网关执行完成，分支和汇聚就从act_ru_execution删除。

在分支时，需要判断条件，符合条件的分支，将会执行，符合条件的分支最终才进行汇聚。

事件网关EventGateway

事件网关允许根据事件判断流向。网关的每个外出顺序流都要连接到一个中间捕获事件。当流程到达一个基于事件网关，网关会进入等待状态：会暂停执行。与此同时，会为每个外出顺序流创建相对的事件订阅。

事件网关的外出顺序流和普通顺序流不同，这些顺序流不会真的"执行"，相反它们让流程引擎去决定执行到事件网关的流程需要订阅哪些事件。要考虑以下条件：

事件网关必须有两条或以上外出顺序流；
事件网关后，只能使用intermediateCatchEvent类型（activiti不支持基于事件网关后连接ReceiveTask）
连接到事件网关的中间捕获事件必须只有一个入口顺序流。

intermediateCatchEvent支持的事件类型

Message Event: 消息事件
Singal Event：信号事件
Timer Event：定时事件

1.7 数据库支持

支持的数据库和版本

数据库类型	版本	JDBC连接示例	说明
h2	1.3.168	jdbc:h2:tcp://localhost/activiti	默认配置的数据库
mysql	5.1.21	jdbc:mysql://localhost:3306/activiti?autoReconnect=true	使用 mysql-connector-java 驱动测试
oracle	11.2.0.1.0	jdbc:oracle:thin:@localhost:1521:xe
postgres	8.1	jdbc:postgresql://localhost:5432/activiti
db2	DB2 10.1 using db2jcc4	jdbc:db2://localhost:50000/activiti
mssql	2008 using sqljdbc4	jdbc:sqlserver://localhost:1433/activiti

创建mysql的表

使用activiti提供的默认方式来创建mysql的表。

默认方式的要求是在 resources 下创建 activiti.cfg.xml 文件，注意：默认方式目录和文件名不能修改，因为activiti的源码中已经设置，到固定的目录读取固定文件名的文件。

在activiti.cfg.xml中bean的名字叫processEngineConfiguration，名字不可修改

在这里有2中配置方式：一种是单独配置数据源，一种是不单独配置数据源

**直接配置processEngineConfiguration **

processEngineConfiguration 用来创建 ProcessEngine，在创建 ProcessEngine 时会执行数据库的操作。

xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                    http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/contex
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
    <!-- 默认id对应的值 为processEngineConfiguration -->
    <!-- processEngine Activiti的流程引擎 -->
    <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="123456"/>
        <!-- activiti数据库表处理策略 -->
        <property name="databaseSchemaUpdate" value="true"/>
    </bean>
</beans>

配置数据源后，在processEngineConfiguration 引用

xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                    http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/contex
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!-- 这里可以使用 链接池 dbcp-->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <property name="url" value="jdbc:mysql:///activiti" />
        <property name="username" value="root" />
        <property name="password" value="123456" />
        <property name="maxActive" value="3" />
        <property name="maxIdle" value="1" />
    </bean>

    <bean id="processEngineConfiguration"
          class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
        <!-- 引用数据源 上面已经设置好了-->
        <property name="dataSource" ref="dataSource" />
        <!-- activiti数据库表处理策略 -->
        <property name="databaseSchemaUpdate" value="true"/>
    </bean>
</beans>

1.8 流程符号

事件 Event

活动 Activity

活动是工作或任务的一个通用术语。一个活动可以是一个任务，还可以是一个当前流程的子处理流程；其次，你还可以为活动指定不同的类型。常见活动如下：

网关 GateWay

网关用来处理决策，有几种常用网关需要了解：

排他网关 (x)

——只有一条路径会被选择。流程执行到该网关时，按照输出流的顺序逐个计算，当条件的计算结果为true时，继续执行当前网关的输出流；

如果多条线路计算结果都是 true，则会执行第一个值为 true 的线路。如果所有网关计算结果没有true，则引擎会抛出异常。

排他网关需要和条件顺序流结合使用，default 属性指定默认顺序流，当所有的条件不满足时会执行默认顺序流。

并行网关 (+)

——所有路径会被同时选择

拆分 —— 并行执行所有输出顺序流，为每一条顺序流创建一个并行执行线路。

合并 —— 所有从并行网关拆分并执行完成的线路均在此等候，直到所有的线路都执行完成才继续向下执行。

包容网关 (+)

—— 可以同时执行多条线路，也可以在网关上设置条件

拆分 —— 计算每条线路上的表达式，当表达式计算结果为true时，创建一个并行线路并继续执行

合并 —— 所有从并行网关拆分并执行完成的线路均在此等候，直到所有的线路都执行完成才继续向下执行。

事件网关 (+)

—— 专门为中间捕获事件设置的，允许设置多个输出流指向多个不同的中间捕获事件。当流程执行到事件网关后，流程处于等待状态，需要等待抛出事件才能将等待状态转换为活动状态。

流向 Flow

流是连接两个流程节点的连线。常见的流向包含以下几种：

1.9 其他拓展

idea插件

actiBPM插件，是Activiti Designer的IDEA版本

二、整合开发

2.1 与SpringBoot整合

依赖

xml

<dependency>
    <groupId>org.activiti</groupId>
    <artifactId>activiti-spring-boot-starter</artifactId>
    <version>7.0.0.Beta2</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.29</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

配置

为了能够实现Activiti7生成的表放到Mysql数据库中，需要在配置文件application.yml中添加相关的配置

注意：activiti7默认没有开启数据库历史记录，需要手动配置开启

yml

spring:
  datasource:
    url: jdbc:mysql:///activiti?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT
    username: root
    password: 123456
    driver-class-name: com.mysql.jdbc.Driver
  activiti:
    #1.flase：默认值。activiti在启动时，对比数据库表中保存的版本，如果没有表或者版本不匹配，将抛出异常
    #2.true： activiti会对数据库中所有表进行更新操作。如果表不存在，则自动创建
    #3.create_drop： 在activiti启动时创建表，在关闭时删除表（必须手动关闭引擎，才能删除表）
    #4.drop-create： 在activiti启动时删除原来的旧表，然后在创建新表（不需要手动关闭引擎）
    database-schema-update: true
    #检测历史表是否存在 activiti7默认没有开启数据库历史记录 启动数据库历史记录
    db-history-used: true
    #记录历史等级 可配置的历史级别有none, activity, audit, full
    #none：不保存任何的历史数据，因此，在流程执行过程中，这是最高效的。
    #activity：级别高于none，保存流程实例与流程行为，其他数据不保存。
    #audit：除activity级别会保存的数据外，还会保存全部的流程任务及其属性。audit为history的默认值。
    #full：保存历史数据的最高级别，除了会保存audit级别的数据外，还会保存其他全部流程相关的细节数据，包括一些流程参数等。
    history-level: full
    #校验流程文件，默认校验resources下的processes文件夹里的流程文件
    check-process-definitions: false

启动类

java

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ActApplication {
    public static void main(String[] args) {
        SpringApplication.run(ActApplication.class,args);
    }
}

SpringSecurity安全框架整合

Activiti7与SpringBoot整合后，默认情况下，集成了SpringSecurity安全框架，管理相关用户权限配置信息

添加SecurityUtil类

java

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.context.SecurityContextImpl;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.stereotype.Component;

import java.util.Collection;


@Component
public class SecurityUtil {
    private Logger logger = LoggerFactory.getLogger(SecurityUtil.class);

     @Autowired
     @Qualifier("myUserDetailsService")
     private UserDetailsService userDetailsService;
 
    public void logInAs(String username) {
     UserDetails user = userDetailsService.loadUserByUsername(username);

     if (user == null) {
         throw new IllegalStateException("User " + username + " doesn't exist, please provide a valid user");
     }
     logger.info("> Logged in as: " + username);

     SecurityContextHolder.setContext(
             new SecurityContextImpl(
                     new Authentication() {
                         @Override
                         public Collection<? extends GrantedAuthority> getAuthorities() {
                             return user.getAuthorities();
                         }
                         @Override
                         public Object getCredentials() {
                             return user.getPassword();
                         }
                         @Override
                         public Object getDetails() {
                             return user;
                         }
                         @Override
                         public Object getPrincipal() {
                             return user;
                         }
                         @Override
                         public boolean isAuthenticated() {
                             return true;
                         }
                         @Override
                         public void setAuthenticated(boolean isAuthenticated) throws IllegalArgumentException { }
                         @Override
                         public String getName() {
                             return user.getUsername();
                         }
     }));
     org.activiti.engine.impl.identity.Authentication.setAuthenticatedUserId(username);
 }
  }

添加DemoApplicationConfig类

java

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
// 实现SpringSecurity框架的用户权限的配置
@Configuration
public class DemoApplicationConfiguration {
    private Logger logger = LoggerFactory.getLogger(DemoApplicationConfiguration.class);
     @Bean
     public UserDetailsService myUserDetailsService() {
         InMemoryUserDetailsManager inMemoryUserDetailsManager = new InMemoryUserDetailsManager();
         //这里添加用户，后面处理流程时用到的任务负责人，需要添加在这里
         String[][] usersGroupsAndRoles = {
                 {"jack", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"},
                 {"rose", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"},
                 {"tom", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"},
                 {"other", "password", "ROLE_ACTIVITI_USER", "GROUP_otherTeam"},
                 {"system", "password", "ROLE_ACTIVITI_USER"},
                 {"admin", "password", "ROLE_ACTIVITI_ADMIN"},
         };

         for (String[] user : usersGroupsAndRoles) {
             List<String> authoritiesStrings = Arrays.asList(Arrays.copyOfRange(user, 2, user.length));
             logger.info("> Registering new user: " + user[0] + " with the following Authorities[" + authoritiesStrings + "]");
             inMemoryUserDetailsManager.createUser(new User(user[0], passwordEncoder().encode(user[1]),
                     authoritiesStrings.stream().map(s -> new SimpleGrantedAuthority(s)).collect(Collectors.toList())));
         }

         return inMemoryUserDetailsManager;
     }
     @Bean
     public PasswordEncoder passwordEncoder() {
         return new BCryptPasswordEncoder();
     }
}

创建Bpmn文件

Activiti7可以自动部署流程，前提是在resources目录下，创建一个新的目录processes，用来放置bpmn文件。

创建一个简单的Bpmn流程文件，并设置任务的用户组Candidate Groups。

Candidate Groups中的内容与上面DemoApplicationConfiguration类中出现的用户组名称要保持一致，可以填写：activitiTeam 或者 otherTeam。

当不确定到底由谁来负责当前任务的时候，只要是Groups内的用户都可以拾取这个任务

测试

java

import com.itheima.utils.SecurityUtil;
import org.activiti.api.process.model.ProcessInstance;
import org.activiti.api.process.model.builders.ProcessPayloadBuilder;
import org.activiti.api.process.runtime.ProcessRuntime;
import org.activiti.api.runtime.shared.query.Page;
import org.activiti.api.runtime.shared.query.Pageable;
import org.activiti.api.task.model.Task;
import org.activiti.api.task.model.builders.TaskPayloadBuilder;
import org.activiti.api.task.runtime.TaskRuntime;
import org.activiti.engine.repository.ProcessDefinition;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
 public class Actviti7DemoApplicationTests {
     @Autowired
     private ProcessRuntime processRuntime;
     @Autowired
     private TaskRuntime taskRuntime;
     @Autowired
     private SecurityUtil securityUtil;

    @Test
    public void testActBoot(){
        System.out.println(taskRuntime);
    }

    /**
     * 查看流程定义
     */
    @Test
    public void contextLoads() {
        securityUtil.logInAs("system");
        Page<org.activiti.api.process.model.ProcessDefinition> processDefinitionPage =
                processRuntime.processDefinitions(Pageable.of(0, 10));
        System.out.println("可用的流程定义数量：" + processDefinitionPage.getTotalItems());
        for (org.activiti.api.process.model.ProcessDefinition pd : processDefinitionPage.getContent()) {
            System.out.println("流程定义：" + pd);
        }
    }


    /**
     * 启动流程实例
     */
    @Test
    public void testStartProcess() {
        securityUtil.logInAs("system");
        ProcessInstance pi = processRuntime.start(ProcessPayloadBuilder.
                start().
                withProcessDefinitionKey("myProcess").
                build());
        System.out.println("流程实例ID：" + pi.getId());
    }


    /**
     **查询任务，并完成自己的任务
     **/
    @Test
    public void testTask() {
        securityUtil.logInAs("jack");
        Page<Task> taskPage=taskRuntime.tasks(Pageable.of(0,10));
        if (taskPage.getTotalItems()>0){
            for (Task task:taskPage.getContent()){
                taskRuntime.claim(TaskPayloadBuilder.
                        claim().
                        withTaskId(task.getId()).build());
                System.out.println("任务："+task);
                taskRuntime.complete(TaskPayloadBuilder.
                        complete().
                        withTaskId(task.getId()).build());
            }
        }
        Page<Task> taskPage2=taskRuntime.tasks(Pageable.of*(0,10));
        if (taskPage2.getTotalItems()>0){
            System.out.println("任务："+taskPage2.getContent());
        }
    }
}

2.2 与Spring整合

依赖

xml

<dependency>
    <groupId>org.activiti</groupId>
    <artifactId>activiti-engine</artifactId>
    <version>7.0.0.Beta1</version>
</dependency>
<dependency>
    <groupId>org.activiti</groupId>
    <artifactId>activiti-spring</artifactId>
    <version>7.0.0.Beta1</version>
</dependency>
<dependency>
    <groupId>org.activiti</groupId>
    <artifactId>activiti-bpmn-model</artifactId>
    <version>7.0.0.Beta1</version>
</dependency>
<dependency>
    <groupId>org.activiti</groupId>
    <artifactId>activiti-bpmn-converter</artifactId>
    <version>7.0.0.Beta1</version>
</dependency>
<dependency>
    <groupId>org.activiti</groupId>
    <artifactId>activiti-json-converter</artifactId>
    <version>7.0.0.Beta1</version>
</dependency>
<dependency>
    <groupId>org.activiti</groupId>
    <artifactId>activiti-bpmn-layout</artifactId>
    <version>7.0.0.Beta1</version>
</dependency>
<dependency>
    <groupId>org.activiti.cloud</groupId>
    <artifactId>activiti-cloud-services-api</artifactId>
    <version>7.0.0.Beta1</version>
</dependency>
<dependency>
    <groupId>aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.5.4</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.40</version>
</dependency>
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.4.5</version>
</dependency>
<dependency>
    <groupId>commons-dbcp</groupId>
    <artifactId>commons-dbcp</artifactId>
    <version>1.4</version>
</dependency>

配置

在Activiti中核心类的是ProcessEngine流程引擎，与Spring整合就是让Spring来管理ProcessEngine

通过org.activiti.spring.SpringProcessEngineConfiguration 与Spring整合方式来创建ProcessEngine对象。

databaseSchemaUpdate的取值内容：

值	含义
flase	默认值。activiti在启动时，会对比数据库表中保存的版本，如果没有表或者版本不匹配，将抛出异常。（生产环境常用）
true	activiti会对数据库中所有表进行更新操作。如果表不存在，则自动创建。（开发时常用）
create_drop	在activiti启动时创建表，在关闭时删除表（必须手动关闭引擎，才能删除表）。（单元测试常用）
drop-create	在activiti启动时删除原来的旧表，然后在创建新表（不需要手动关闭引擎）。

xml

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!-- 数据源 -->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/activiti"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
        <property name="maxActive" value="3"/>
        <property name="maxIdle" value="1"/>
    </bean>
    <!-- 工作流引擎配置bean -->
    <bean id="processEngineConfiguration" class="org.activiti.spring.SpringProcessEngineConfiguration">
        <!-- 数据源 -->
        <property name="dataSource" ref="dataSource"/>
        <!-- 使用spring事务管理器 -->
        <property name="transactionManager" ref="transactionManager"/>
        <!-- 数据库策略 -->
        <property name="databaseSchemaUpdate" value="drop-create"/>
    </bean>
    <!-- 流程引擎 -->
    <bean id="processEngine" class="org.activiti.spring.ProcessEngineFactoryBean">
        <property name="processEngineConfiguration" ref="processEngineConfiguration"/>
    </bean>
    <!-- 资源服务service -->
    <bean id="repositoryService" factory-bean="processEngine" factory-method="getRepositoryService"/>
    <!-- 流程运行service -->
    <bean id="runtimeService" factory-bean="processEngine"  factory-method="getRuntimeService"/>
    <!-- 任务管理service -->
    <bean id="taskService" factory-bean="processEngine" factory-method="getTaskService"/>
    <!-- 历史管理service -->
    <bean id="historyService" factory-bean="processEngine" factory-method="getHistoryService"/>
    <!-- 事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!-- 通知 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <!-- 传播行为 -->
            <tx:method name="save*" propagation="REQUIRED"/>
            <tx:method name="insert*" propagation="REQUIRED"/>
            <tx:method name="delete*" propagation="REQUIRED"/>
            <tx:method name="update*" propagation="REQUIRED"/>
            <tx:method name="find*" propagation="SUPPORTS" read-only="true"/>
            <tx:method name="get*" propagation="SUPPORTS" read-only="true"/>
        </tx:attributes>
    </tx:advice>
    <!-- 切面，根据具体项目修改切点配置
    <aop:config proxy-target-class="true">
        <aop:advisor advice-ref="txAdvice"
                     pointcut="execution(*com.itheima.service.impl..(..))"/>
    </aop:config>-->
</beans>

测试

java

/**
   测试activiti与spring整合是否成功
**/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:activiti-spring.xml")
 public class ActivitiTest {
     @Autowired
     private RepositoryService repositoryService;
     
     @Test
     public void test01(){
         System.out.println("部署对象:"+repositoryService);
     }
 }

三、流程操作

3.1 流程部署

在设计器中定义的流程部署到activiti数据库中，就是流程定义部署。

通过调用activiti的api将流程定义的bpmn和png两个文件一个一个添加部署到activiti中，也可以将两个文件打成zip包进行部署。

单个文件部署

java

/**
 * 部署流程定义
 */
@Test
public void testDeployment(){
//        1、创建ProcessEngine
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//        2、得到RepositoryService实例
    RepositoryService repositoryService = processEngine.getRepositoryService();
//        3、使用RepositoryService进行部署
    Deployment deployment = repositoryService.createDeployment()
            .addClasspathResource("bpmn/evection.bpmn") // 添加bpmn资源
            .addClasspathResource("bpmn/evection.png")  // 添加png资源
            .name("出差申请流程")
            .deploy();
//        4、输出部署信息
    System.out.println("流程部署id：" + deployment.getId());
    System.out.println("流程部署名称：" + deployment.getName());
}

压缩包部署

将evection.bpmn和evection.png压缩成zip包。

java

@Test
public void deployProcessByZip() {
    // 定义zip输入流
    InputStream inputStream = this
            .getClass()
            .getClassLoader()
            .getResourceAsStream(
                    "bpmn/evection.zip");
    ZipInputStream zipInputStream = new ZipInputStream(inputStream);
    // 获取repositoryService
    RepositoryService repositoryService = processEngine
            .getRepositoryService();
    // 流程部署
    Deployment deployment = repositoryService.createDeployment()
            .addZipInputStream(zipInputStream)
            .deploy();
    System.out.println("流程部署id：" + deployment.getId());
    System.out.println("流程部署名称：" + deployment.getName());
}

操作的表

表明	作用
act_re_deployment	流程定义部署表，每部署一次增加一条记录
act_re_procdef	流程定义表，部署每个新的流程定义都会在这张表中增加一条记录
act_ge_bytearray	流程资源表

act_re_deployment和act_re_procdef一对多关系，一次部署在流程部署表生成一条记录，但一次部署可以部署多个流程定义，每个流程定义在流程定义表生成一条记录。每一个流程定义在act_ge_bytearray会存在两个资源记录，bpmn和png。

建议：一次部署一个流程，这样部署表和流程定义表是一对一有关系，方便读取流程部署及流程定义信息。

3.2 流程定义

流程定义部署在activiti后，就可以在系统中通过activiti去管理该流程的执行，执行流程表示流程的一次执行。

比如部署系统出差流程后，如果某用户要申请出差这时就需要执行这个流程，如果另外一个用户也要申请出差则也需要执行该流程，每个执行互不影响，每个执行是单独的流程实例。

启动流程实例时，指定的businesskey，就会在act_ru_execution #流程实例的执行表中存储businesskey。

Businesskey：业务标识，通常为业务表的主键，业务标识和流程实例一一对应。业务标识来源于业务系统。存储业务标识就是根据业务标识来关联查询业务系统的数据。

比如：出差流程启动一个流程实例，就可以将出差单的id作为业务标识存储到activiti中，将来查询activiti的流程实例信息就可以获取出差单的id从而关联查询业务系统数据库得到出差单信息。

java

@Autowired 
private ProcessRuntime processRuntime;
@Autowired
private TaskRuntime taskRuntime;

3.3 查看流程定义

java

/** * 查看流程定义 */
@Test
public void contextLoads() { 
    securityUtil.logInAs("system");
    Page<ProcessDefinition> processDefinitionPage = processRuntime.processDefinitions(Pageable.of(0, 10)); 
    System.out.println("可用的流程定义数量：" + processDefinitionPage.getTotalItems());
    for (org.activiti.api.process.model.ProcessDefinition pd : processDefinitionPage.getContent()) {
        System.out.println("流程定义：" + pd); 
    } 
}

/**
 * 查询流程定义
 */
@Test
public void queryProcessDefinition(){
    //        获取引擎
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//        repositoryService
    RepositoryService repositoryService = processEngine.getRepositoryService();
//        得到ProcessDefinitionQuery 对象
    ProcessDefinitionQuery processDefinitionQuery = repositoryService.createProcessDefinitionQuery();
//          查询出当前所有的流程定义
//          条件：processDefinitionKey =evection
//          orderByProcessDefinitionVersion 按照版本排序
//        desc倒叙
//        list 返回集合
    List<ProcessDefinition> definitionList = processDefinitionQuery.processDefinitionKey("myEvection")
            .orderByProcessDefinitionVersion()
            .desc()
            .list();
//      输出流程定义信息
    for (ProcessDefinition processDefinition : definitionList) {
        System.out.println("流程定义 id="+processDefinition.getId());
        System.out.println("流程定义 name="+processDefinition.getName());
        System.out.println("流程定义 key="+processDefinition.getKey());
        System.out.println("流程定义 Version="+processDefinition.getVersion());
        System.out.println("流程部署ID ="+processDefinition.getDeploymentId());
    }

}

3.4 流程删除

java

public void deleteDeployment() {
    // 流程部署id
    String deploymentId = "1";

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 通过流程引擎获取repositoryService
    RepositoryService repositoryService = processEngine
            .getRepositoryService();
    //删除流程定义，如果该流程定义已有流程实例启动则删除时出错
    repositoryService.deleteDeployment(deploymentId);
    //设置true 级联删除流程定义，即使该流程有流程实例启动也可以删除，设置为false非级别删除方式，如果流程
    //repositoryService.deleteDeployment(deploymentId, true);
}

  使用repositoryService删除流程定义，历史表信息不会被删除

  如果该流程定义下没有正在运行的流程，则可以用普通删除。

如果该流程定义下存在已经运行的流程，使用普通删除报错，可用级联删除方法将流程及相关记录全部删除。

先删除没有完成流程节点，最后就可以完全删除流程定义信息

项目开发中级联删除操作一般只开放给超级管理员使用.

3.5 流程资源下载

从数据库中把资源文件下载到本地。

解决方案有：

1、jdbc对blob类型，clob类型数据读取出来，保存到文件目录

2、使用activiti的api来实现

使用commons-io.jar 解决IO的操作

引入commons-io依赖包

xml

<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.6</version>
</dependency>

通过流程定义对象获取流程定义资源，获取bpmn和png

java

import org.apache.commons.io.IOUtils;

@Test
    public void deleteDeployment(){
//        获取引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//        获取repositoryService
        RepositoryService repositoryService = processEngine.getRepositoryService();
//        根据部署id 删除部署信息,如果想要级联删除，可以添加第二个参数，true
        repositoryService.deleteDeployment("1");
    }

    public void  queryBpmnFile() throws IOException {
//        1、得到引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//        2、获取repositoryService
        RepositoryService repositoryService = processEngine.getRepositoryService();
//        3、得到查询器：ProcessDefinitionQuery，设置查询条件,得到想要的流程定义
        ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()
                .processDefinitionKey("myEvection")
                .singleResult();
//        4、通过流程定义信息，得到部署ID
        String deploymentId = processDefinition.getDeploymentId();
//        5、通过repositoryService的方法，实现读取图片信息和bpmn信息
//        png图片的流
        InputStream pngInput = repositoryService.getResourceAsStream(deploymentId, processDefinition.getDiagramResourceName());
//        bpmn文件的流
        InputStream bpmnInput = repositoryService.getResourceAsStream(deploymentId, processDefinition.getResourceName());
//        6、构造OutputStream流
        File file_png = new File("d:/evectionflow01.png");
        File file_bpmn = new File("d:/evectionflow01.bpmn");
        FileOutputStream bpmnOut = new FileOutputStream(file_bpmn);
        FileOutputStream pngOut = new FileOutputStream(file_png);
//        7、输入流，输出流的转换
        IOUtils.copy(pngInput,pngOut);
        IOUtils.copy(bpmnInput,bpmnOut);
//        8、关闭流
        pngOut.close();
        bpmnOut.close();
        pngInput.close();
        bpmnInput.close();
    }

说明：

```
  deploymentId为流程部署ID
```

  resource_name为act_ge_bytearray表中NAME_列的值

  使用repositoryService的getDeploymentResourceNames方法可以获取指定部署下得所有文件的名称

  使用repositoryService的getResourceAsStream方法传入部署ID和资源图片名称可以获取部署下指定名称文件的输入流

最后的将输入流中的图片资源进行输出。

3.6 流程历史信息查看

即使流程定义已经删除了，流程执行的历史信息通过前面的分析，依然保存在activiti的act_hi_*相关的表中。所以还是可以查询流程执行的历史信息，可以通过HistoryService来查看相关的历史记录。

java

    /**
     * 查看历史信息
     */
    @Test
    public void findHistoryInfo(){
//      获取引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//        获取HistoryService
        HistoryService historyService = processEngine.getHistoryService();
//        获取 actinst表的查询对象
        HistoricActivityInstanceQuery instanceQuery = historyService.createHistoricActivityInstanceQuery();
//        查询 actinst表，条件：根据 InstanceId 查询
//        instanceQuery.processInstanceId("2501");
//        查询 actinst表，条件：根据 DefinitionId 查询
        instanceQuery.processDefinitionId("myEvection:1:4");
//        增加排序操作,orderByHistoricActivityInstanceStartTime 根据开始时间排序 asc 升序
        instanceQuery.orderByHistoricActivityInstanceStartTime().asc();
//        查询所有内容
        List<HistoricActivityInstance> activityInstanceList = instanceQuery.list();
//        输出
        for (HistoricActivityInstance hi : activityInstanceList) {
            System.out.println(hi.getActivityId());
            System.out.println(hi.getActivityName());
            System.out.println(hi.getProcessDefinitionId());
            System.out.println(hi.getProcessInstanceId());
            System.out.println("<==========================>");
        }
    }

3.7 启动流程实例

java

/** * 启动流程实例 */
// 操作的表
// act_ru_execution #流程实例执行表，记录当前流程实例的执行情况
// 流程实例执行，如果当前只有一个分支时，一个流程实例只有一条记录且执行表的主键id和流程实例id相同，如果当前有多个分支正在运行则该执行表中有多条记录，存在执行表的主键和流程实例id不相同的记录。不论当前有几个分支总会有一条记录的执行表的主键和流程实例id相同 
// act_ru_task #任务执行表，记录当前执行的任务 启动流程实例，流程当前执行到第一个任务结点，此表会插入一条记录表示当前任务的执行情况，如果任务完成则记录删除
// act_ru_identitylink #任务参与者，记录当前参与任务的用户或组  
// act_hi_procinst #流程实例历史表   流程实例启动，会在此表插入一条记录，流程实例运行完成记录也不会删除。
// act_hi_taskinst  #任务历史表，记录所有任务  开始一个任务，不仅在act_ru_task表插入记录，也会在历史任务表插入一条记录，任务历史表的主键就是任务id，任务完成此表记录不删除。
// act_hi_actinst  #活动历史表，记录所有活动   活动包括任务，所以此表中不仅记录了任务，还记录了流程执行过程的其它活动，比如开始事件、结束事件。
@Test
public void testStartProcess() {
    // 方式1
    securityUtil.logInAs("system");
    ProcessInstance pi = processRuntime.start(ProcessPayloadBuilder.start().withProcessDefinitionKey("myProcess").build()); 
    System.out.println("流程实例ID：" + pi.getId()); 
    
    // 方式2
    // 流程定义key 
    String processDefinitionKey = ""; 
    // 获取RunTimeService 
    RuntimeService runtimeService = processEngine.getRuntimeService();
    // 根据流程定义key启动流程 
    // businessKey 可选参数。如果指定businesskey，就会在act_ru_execution #流程实例的执行表中存储businesskey。
    // businesskey 业务标识，通常为业务表的主键，业务标识和流程实例一一对应。业务标识来源于业务系统。存储业务标识就是根据业务标识来关联查询业务系统的数据。
    //启动流程实例时设计流程变量 
    //定义流程变量 
    //Map<String, Object> variables = new HashMap<String, Object>(); 
    //设置流程变量assignee 
    //variables.put("assignee", "张三");
    //ProcessInstance processInstance = runtimeService .startProcessInstanceByKey(processDefinitionKey, variables);
    ProcessInstance processInstance = runtimeService .startProcessInstanceByKey(processDefinitionKey,businessKey);
    System.out .println("流程定义id：" + processInstance.getProcessDefinitionId()); 
    System.out.println("流程实例id：" + processInstance.getId());
    System.out.println("当前活动Id：" + processInstance.getActivityId());
}

3.8 查询流程实例

java

/** * 查询流程实例 */
// 当前活动关联业务系统的key 可用于关联业务的key
@Test 
public void queryProcessInstance() {
    // 流程定义key 
    String processDefinitionKey = "holiday"; 
    // 获取RunTimeService 
    RuntimeService runtimeService = processEngine.getRuntimeService();
    List<ProcessInstance> list = runtimeService .createProcessInstanceQuery() .processDefinitionKey(processDefinitionKey)
        // .list();
        for (ProcessInstance processInstance : list) {
            System.out.println("----------------------------"); 
            System.out.println("流程实例id：" + processInstance.getProcessInstanceId()); 
            System.out.println("所属流程定义id：" + processInstance.getProcessDefinitionId()); 
            System.out.println("是否执行完成：" + processInstance.isEnded());
            System.out.println("是否暂停：" + processInstance.isSuspended()); 
            System.out.println("当前活动标识：" + processInstance.getActivityId()); 
            System.out.println("当前活动关联业务系统的key：" + processInstance.getBusinessKey()); 
        } 
}

3.9 查询并完成自己的任务

java

/** * 查询任务，并完成自己的任务 */
@Test
public void testTask() { 
    securityUtil.logInAs("ryandawsonuk"); 
    Page<Task> taskPage=taskRuntime.tasks(Pageable.of(0,10)); 
    // 任务负责人 
    String assignee = "张三丰"; 
    // 查询任务负责人的待办任务
    List<Task> list = taskService.createTaskQuery()// 
        .processDefinitionKey(processDefinitionKey)// 
        .includeProcessVariables().taskAssignee(assignee).list(); 
    
    if (taskPage.getTotalItems()>0){
        // 任务信息
        for (Task task:taskPage.getContent()){ 
            // 任务拾取 完成前需先执行拾取操作
            taskRuntime.claim(TaskPayloadBuilder.claim().withTaskId(task.getId()).build()); 
            System.out.println("任务："+task);
            // 任务完成
            //根据任务id和任务负责人assignee查询当前任务，如果查到说明该用户有完成该任务的权限，否则没有权限
			Task task = taskService.createTaskQuery().taskId(task.getId()).taskAssignee(assignee).singleResult();
            if(task != null){
                taskService.complete(taskId);
                System.out.println("完成任务！！！");
            }
			// taskRuntime.complete(TaskPayloadBuilder.complete().withTaskId(task.getId()).build()); 
        }
    }
    // 任务查询
    Page<Task> taskPage2=taskRuntime.tasks(Pageable.of(0,10));
    if (taskPage2.getTotalItems()>0){
        System.out.println("任务："+taskPage2.getContent());
    } 
}

3.10 挂起/激活流程

java

// 挂起激活流程定义
// 流程定义为挂起状态该流程定义将不允许启动新的流程实例，同时该流程定义下所有的流程实例将全部挂起暂停执行。
@Test
public void suspendOrActivateProcessDefinition() { 
    // 流程定义id
    String processDefinitionId = ""; 
    RepositoryService repositoryService = processEngine .getRepositoryService();
    // 获得流程定义
    ProcessDefinition processDefinition = repositoryService .createProcessDefinitionQuery() .processDefinitionId(processDefinitionId).singleResult(); 
    //是否暂停 
    boolean suspend = processDefinition.isSuspended(); 
    if(suspend){ 
        //如果暂停则激活，这里将流程定义下的所有流程实例全部激活 
        repositoryService.activateProcessDefinitionById(processDefinitionId, true, null);
        System.out.println("流程定义："+processDefinitionId+"激活"); 
    }else{ 
        //如果激活则挂起，这里将流程定义下的所有流程实例全部挂起 
        repositoryService.suspendProcessDefinitionById(processDefinitionId, true, null);
        System.out.println("流程定义："+processDefinitionId+"挂起");
    } 
}

3.11 挂起激活实例

java

// 挂起激活流程实例  单个
// 操作流程实例对象，该流程实例挂起不再继续执行，完成该流程实例的当前任务将报异常。
@Test 
public void suspendOrActiveProcessInstance() {
    // 流程实例id 
    String processInstanceId = ""; 
    // 获取RunTimeService
    RuntimeService runtimeService = processEngine.getRuntimeService(); 
    //根据流程实例id查询流程实例 
    ProcessInstance processInstance = runtimeService.createProcessInstanceQuery() .processInstanceId(processInstanceId).singleResult();
    boolean suspend = processInstance.isSuspended();
    if(suspend){ 
        //如果暂停则激活 
        runtimeService.activateProcessInstanceById(processInstanceId); 
        System.out.println("流程实例："+processInstanceId+"激活"); 
    }else{ 
        //如果激活则挂起 
        runtimeService.suspendProcessInstanceById(processInstanceId);
        System.out.println("流程实例："+processInstanceId+"挂起");
    } 
}

3.12 查询历史任务

java

// 创建历史任务查询对象
HistoricTaskInstanceQuery historicTaskInstanceQuery = historyService.createHistoricTaskInstanceQuery();
// 查询结果包括 local变量
historicTaskInstanceQuery.includeTaskLocalVariables();
for (HistoricTaskInstance historicTaskInstance : list) {
    System.out.println("==============================");
    System.out.println("任务id：" + historicTaskInstance.getId());
    System.out.println("任务名称：" + historicTaskInstance.getName());
    System.out.println("任务负责人：" + historicTaskInstance.getAssignee());
    System.out.println("任务local变量："+ historicTaskInstance.getTaskLocalVariables());
}

四、任务分配负责人

4.1 固定分配

在流程建模时指定固定的任务负责人（在properties视图中，填写Assignee项为任务负责人。）

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

4.2 表达式分配

UEL表达式：Activiti使用UEL表达式，UEL是java EE6规范的一部分，UEL（Unified Expression Language）即统一表达式语言，activiti支持两个UEL表达式：UEL-value和UEL-method。

java

// UEL-value 
// assignee这个变量是activiti的一个流程变量
${assignee} 
// user.assignee表示通过调用user的getter方法获取值
${user.assignee}

// UEL-method
// serBean是spring容器中的一个bean，表示调用该bean的getUserId()方法。
${userBean.getUserId()} 

// UEL-method与UEL-value结合
// ldapService是spring容器的一个bean，findManagerForEmployee是该bean的一个方法，emp是activiti流程变量，emp作为参数传到ldapService.findManagerForEmployee方法中。
${ldapService.findManagerForEmployee(emp)}

//其他
//表达式支持解析基础类型、bean、list、array和map，也可作为条件判断。
${order.price > 100 && order.price < 250}
//由于使用了表达式分配，必须保证在任务执行过程表达式执行成功，比如：
//某个任务使用了表达式${order.price > 100 && order.price < 250}，当执行该任务时必须保证order在流程变量中存在，否则activiti异常。

4.3 监听器方式

java

//任务监听器是发生对应的任务相关事件时执行自定义java逻辑 或表达式。
// Create：任务创建后触发 Assignment：任务分配后触发 Delete：任务完成后触发 All：所有事件发生都触发 表达式：同分配任务负责人
public class MyTaskListener implements TaskListener {
    @Override
    public void notify(DelegateTask delegateTask) {
		//这里指定任务负责人
		delegateTask.setAssignee("张三");
	}
}
//使用监听器分配方式，按照监听事件去执行监听类的notify方法，方法如果不能正常执行也会影响任务的执行。

五、设置流程变量

流程变量就是 activiti 在管理工作流时根据管理需要而设置的变量。

流程变量的作用域可以是一个流程实例(processInstance)，或一个任务(task)，或一个执行实例 (execution)

5.1 globa变量

流程变量的默认作用域是流程实例。当一个流程变量的作用域为流程实例时，可以称为 global 变量

global 变量中变量名不允许重复，设置相同名称的变量，后设置的值会覆盖前设置的变量值。

java

// 启动流程时设置流程变量 
// 流程变量作用域是一个流程实例，流程变量使用Map存储，同一个流程实例设置变量map中key相同，后者覆盖前者。
@Test 
public void startProcessInstance() { 
    // 流程定义key 
    String processDefinitionKey = "";
    Holiday holiday = new Holiday(); holiday.setNum(3); 
    // 定义流程变量 
    Map<String, Object> variables = new HashMap<String, Object>();
    //变量名是num，变量值是holiday.getNum(),变量名也可以是一个对象 
    variables.put("num", holiday.getNum()); 
    RuntimeService runtimeService = processEngine.getRuntimeService(); 
    ProcessInstance processInstance = runtimeService .startProcessInstanceByKey(processDefinitionKey, variables);
    System.out.println("流程实例id:" + processInstance.getProcessInstanceId()); 
}

// 办理任务时设置流程变量
// 该流程变量在该任务完成后的结点可使用，作用域是整个实例，如果key已存在特替换原本的值
// 需要指定任务id，如果任务id不存在则抛出异常。通过map<key,value>设置流程变量，一次可以设置多个变量。
@Test 
public void completTask() { 
    //任务id 
    String taskId = ""; 
    TaskService taskService = processEngine.getTaskService();
    Holiday holiday = new Holiday(); 
    holiday.setNum(4);
    // 定义流程变量
    Map<String, Object> variables = new HashMap<String, Object>(); 
    //变量名是holiday，变量值是holiday对象 
    variables.put("holiday", holiday);
    
    //通过任务设置流程变量 
    //如果该任务已结束则会报错。也可以通过taskService.getVariable()获取流程变量。
    taskService.setVariable(taskId, "holiday", holiday);
    //一次设置多个值
    //taskService.setVariables(taskId, variables) 
    
    // 办理过程中也可设置流程变量
    taskService.complete(taskId, variables);
}

// 通过当前流程实例设置
// 通过流程实例id设置全局变量，该流程实例必须未执行完成。
// 也可以通过runtimeService.getVariable()获取流程变量
public void setGlobalVariableByExecutionId(){ 
    //当前流程实例执行 id，通常设置为当前执行的流程实例
    String executionId="2601";
    RuntimeService runtimeService = processEngine.getRuntimeService(); 
    Holiday holiday = new Holiday(); 
    holiday.setNum(3);
    //通过流程实例 id设置流程变量 
    runtimeService.setVariable(executionId, "holiday", holiday);
    //一次设置多个值
    //runtimeService.setVariables(executionId, variables)
}

5.2 local变量

任务和执行实例仅仅是针对一个任务和一个执行实例范围，范围没有流程实例大，称为 local 变量。

Local 变量由于在不同的任务或不同的执行实例中，作用域互不影响，变量名可以相同没有影响。Local 变量名也可以和 global 变量名相同，没有影响。

java

// 办理任务时设置local流程变量
// 只能在该任务结束前使用，任务结束该变量无法使用
@Test 
public void completTask() { 
    //任务id
    String taskId = ""; 
    TaskService taskService = processEngine.getTaskService(); 
    // 定义流程变量 
    Map<String, Object> variables = new HashMap<String, Object>();
    Holiday holiday = new Holiday ();
    holiday.setNum(3);
    // 定义流程变量
    Map<String, Object> variables = new HashMap<String, Object>();
    //变量名是holiday，变量值是holiday对象 
    variables.put("holiday", holiday);
    // 设置local变量，作用域为该任务
    taskService.setVariablesLocal(tasked, variables); 
    taskService.complete(taskId); 
}


// 通过当前任务设置
// 任务id必须是当前待办任务id，act_ru_task中存在。
// Local变量在任务结束后无法在当前流程实例执行中使用，如果后续的流程执行需要用到此变量则会报错。
@Test
 public void setLocalVariableByTaskId(){
    //当前待办任务id
    String taskId="1404";
    TaskService taskService = processEngine.getTaskService();
    Holiday holiday = new Holiday (); 
     holiday.setNum(3);
    //通过任务设置流程变量
    taskService.setVariableLocal(taskId, "holiday", holiday);
    //一次设置多个值
    //taskService.setVariablesLocal(taskId,  variables)
}

5.3 流程变量的使用方法

在属性上使用UEL表达式
可以在 assignee 处设置 UEL 表达式，表达式的值为任务的负责人，比如： ${assignee}， assignee 就是一个流程变量名称。
Activiti获取UEL表达式的值，即流程变量assignee的值，将assignee的值作为任务的负责人进行任务分配
在连线上使用UEL表达式
在连线上设置UEL表达式，决定流程走向。
比如：${price<10000} 。price就是一个流程变量名称，uel表达式结果类型为布尔类型。
如果UEL表达式是true，要决定流程执行走向。

注意：
1、如果UEL表达式中流程变量名不存在则报错。
2、如果UEL表达式中流程变量值为空NULL，流程不按UEL表达式去执行，而流程结束。
3、如果UEL表达式都不符合条件，流程结束
4、如果连线不设置条件，会走flow序号小的那条线

六、操作组任务

6.1 查询组任务

指定候选人，查询该候选人当前的待办任务。候选人不能立即办理任务。

java

//根据候选人查询组任务
@Test 
public void findGroupTaskList() {
    // 流程定义key 
    String processDefinitionKey = "holiday4";
    // 任务候选人
    String candidateUser = "zhangsan"; 
    // 创建TaskService 
    TaskService taskService = processEngine.getTaskService(); 
    //查询组任务
    List<Task> list = taskService.createTaskQuery()// 
        .processDefinitionKey(processDefinitionKey)// 
        .taskCandidateUser(candidateUser)//根据候选人查询 
        .list();
    for (Task task : list) { 
        System.out.println("----------------------------");
        System.out.println("流程实例id：" + task.getProcessInstanceId());
        System.out.println("任务id：" + task.getId()); 
        System.out.println("任务负责人：" + task.getAssignee()); 
        System.out.println("任务名称：" + task.getName());
    }
}

6.2 拾取(claim)任务

该组任务的所有候选人都能拾取。

将候选人的组任务，变成个人任务。原来候选人就变成了该任务的负责人。

java

//候选人员拾取组任务后该任务变为自己的个人任务。
@Test 
public void claimTask(){ 
    TaskService taskService = processEngine.getTaskService(); 
    //要拾取的任务id 
    String taskId = "6302";
    //任务候选人id 
    String userId = "lisi";
    //拾取任务 
    //即使该用户不是候选人也能拾取(建议拾取时校验是否有资格) 
    //校验该用户有没有拾取任务的资格 
    Task task = taskService.createTaskQuery()// 
        .taskId(taskId) 
        .taskCandidateUser(userId)//根据候选人查询 
        .singleResult();
    if(task!=null){
        taskService.claim(taskId, userId);
        System.out.println("任务拾取成功"); 
    } 
}

6.3 归还或任务交接

如果拾取后不想办理该任务；需要将已经拾取的个人任务归还到组里边，将个人任务变成了组任务。

java

//如果个人不想办理该组任务，可以归还组任务，归还后该用户不再是该任务的负责人
// 归还组任务，由个人任务变为组任务，还可以进行任务交接 
// 建议归还任务前校验该用户是否是该任务的负责人
// 也可以通过setAssignee方法将任务委托给其它用户负责，注意被委托的用户可以不是候选人（建议不要这样使用）
@Test 
public void setAssigneeToGroupTask() { 
// 查询任务使用TaskService 
TaskService taskService = processEngine.getTaskService(); 
// 当前待办任务 
    String taskId = "6004";
    // 任务负责人 
    String userId = "zhangsan2"; 
    // 校验userId是否是taskId的负责人，如果是负责人才可以归还组任务 
    Task task = taskService.createTaskQuery()
        .taskId(taskId)
        .taskAssignee(userId)
        .singleResult(); 
    if (task != null) {
        // 如果设置为null，归还组任务,该 任务没有负责人
        taskService.setAssignee(taskId, null);
    } 
}

//任务交接,任务负责人将任务交给其它候选人办理该任务
@Test 
public void setAssigneeToCandidateUser() { 
	// 查询任务使用TaskService
    TaskService taskService = processEngine.getTaskService(); 
    // 当前待办任务 
    String taskId = "6004"; 
    // 任务负责人 
    String userId = "zhangsan2"; 
    // 校验userId是否是taskId的负责人，如果是负责人才可以归还组任务
    Task task = taskService.createTaskQuery().taskId(taskId) 
        .taskAssignee(userId).singleResult(); 
    if (task != null) {
        // 将此任务交给其它候选人办理该 任务 
        String candidateuser = "zhangsan";
        // 根据候选人和组任务id查询，如果有记录说明该 候选人有资格拾取该 任务 
        Task task2 = taskService.createTaskQuery()
            .taskId(taskId) 
            .taskCandidateUser(candidateuser)
            .singleResult();
        if (task2 != null) { 
            // 才可以交接 
            taskService.setAssignee(taskId, candidateuser); 
        } 
    } 
}

6.4 查询个人任务

java

//查询方式同个人任务查询
@Test 
public void findPersonalTaskList() {
    // 流程定义key 
    String processDefinitionKey = "holiday4";
    // 任务负责人 
    String assignee = "zhangsan";
    // 创建TaskService 
    TaskService taskService = processEngine.getTaskService(); 
    List<Task> list = taskService.createTaskQuery()// 
        .processDefinitionKey(processDefinitionKey)// 
        .taskAssignee(assignee).list();
    for (Task task : list) {
        System.out.println("----------------------------"); 
        System.out.println("流程实例id：" + task.getProcessInstanceId()); 
        System.out.println("任务id：" + task.getId()); 
        System.out.println("任务负责人：" + task.getAssignee()); 
        System.out.println("任务名称：" + task.getName()); 
    } 
}

6.5 办理个人任务

java

//同个人任务办理
/**完成任务*/
// 建议完成任务前校验该用户是否是该任务的负责人。
@Test 
public void completeTask(){ 
    //任务ID 
    String taskId = "12304"; 
    processEngine.getTaskService()//
        .complete(taskId);
    System.out.println("完成任务："+taskId); 
}

七、流程引擎配置类

流程引擎的配置类（ProcessEngineConfiguration），通过ProcessEngineConfiguration可以创建工作流引擎ProceccEngine，常用的两种方法如下：

7.1 StandaloneProcessEngineConfiguration

使用StandaloneProcessEngineConfigurationActiviti可以单独运行，来创建ProcessEngine，Activiti会自己处理事务。

配置文件方式：

通常在activiti.cfg.xml配置文件中定义一个id为 processEngineConfiguration 的bean.

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="123456"/>
    <!--actviti数据库表在生成时的策略  true - 如果数据库中已经存在相应的表，那么直接使用，如果不存在，那么会创建-->
    <property name="databaseSchemaUpdate" value="true"/>
</bean>

连接池方式

xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                    http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/contex
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql:///activiti"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
        <property name="maxActive" value="3"/>
        <property name="maxIdle" value="1"/>
    </bean>
    <!--在默认方式下 bean的id  固定为 processEngineConfiguration-->
    <bean id="processEngineConfiguration"
          class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
        <!--引入上面配置好的 链接池-->
        <property name="dataSource" ref="dataSource"/>
        <!--actviti数据库表在生成时的策略  true - 如果数据库中已经存在相应的表，那么直接使用，如果不存在，那么会创建-->
        <property name="databaseSchemaUpdate" value="true"/>
    </bean>
</beans>

7.2 SpringProcessEngineConfiguration

通过org.activiti.spring.SpringProcessEngineConfiguration 与Spring整合。

创建spring与activiti的整合配置文件：

activity-spring.cfg.xml（名称可修改）

xml

<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
   xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans 
      http://www.springframework.org/schema/beans/spring-beans-3.1.xsd 
      http://www.springframework.org/schema/mvc 
      http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd 
      http://www.springframework.org/schema/context 
       http://www.springframework.org/schema/context/spring-context-3.1.xsd 
      http://www.springframework.org/schema/aop 
      http://www.springframework.org/schema/aop/spring-aop-3.1.xsd 
      http://www.springframework.org/schema/tx 
      http://www.springframework.org/schema/tx/spring-tx-3.1.xsd ">
   <!-- 工作流引擎配置bean -->
   <bean id="processEngineConfiguration" class="org.activiti.spring.SpringProcessEngineConfiguration">
      <!-- 数据源 -->
      <property name="dataSource" ref="dataSource" />
      <!-- 使用spring事务管理器 -->
      <property name="transactionManager" ref="transactionManager" />
      <!-- 数据库策略 -->
      <property name="databaseSchemaUpdate" value="drop-create" />
      <!-- activiti的定时任务关闭 -->
     <property name="jobExecutorActivate" value="false" />
   </bean>
   <!-- 流程引擎 -->
   <bean id="processEngine" class="org.activiti.spring.ProcessEngineFactoryBean">
      <property name="processEngineConfiguration" ref="processEngineConfiguration" />
   </bean>
   <!-- 资源服务service -->
   <bean id="repositoryService" factory-bean="processEngine"
      factory-method="getRepositoryService" />
   <!-- 流程运行service -->
   <bean id="runtimeService" factory-bean="processEngine"
      factory-method="getRuntimeService" />
   <!-- 任务管理service -->
   <bean id="taskService" factory-bean="processEngine"
      factory-method="getTaskService" />
   <!-- 历史管理service -->
   <bean id="historyService" factory-bean="processEngine" factory-method="getHistoryService" />
   <!-- 用户管理service -->
   <bean id="identityService" factory-bean="processEngine" factory-method="getIdentityService" />
   <!-- 引擎管理service -->
   <bean id="managementService" factory-bean="processEngine" factory-method="getManagementService" />
   <!-- 数据源 -->
   <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
      <property name="driverClassName" value="com.mysql.jdbc.Driver" />
      <property name="url" value="jdbc:mysql://localhost:3306/activiti" />
      <property name="username" value="root" />
      <property name="password" value="mysql" />
      <property name="maxActive" value="3" />
      <property name="maxIdle" value="1" />
   </bean>
   <!-- 事务管理器 -->
   <bean id="transactionManager"
    class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
      <property name="dataSource" ref="dataSource" />
   </bean>
   <!-- 通知 -->
   <tx:advice id="txAdvice" transaction-manager="transactionManager">
      <tx:attributes></tx:attributes>
          <!-- 传播行为 -->
          <tx:method name="save*" propagation="REQUIRED" />
          <tx:method name="insert*" propagation="REQUIRED" />
          <tx:method name="delete*" propagation="REQUIRED" />
          <tx:method name="update*" propagation="REQUIRED" />
          <tx:method name="find*" propagation="SUPPORTS" read-only="true" />
          <tx:method name="get*" propagation="SUPPORTS" read-only="true" />
       </tx:attributes>
   </tx:advice>
   <!-- 切面，根据具体项目修改切点配置 -->
   <aop:config proxy-target-class="true">
      <aop:advisor advice-ref="txAdvice"  pointcut="execution(* com.itheima.ihrm.service.impl.*.(..))"* />
  </aop:config>
</beans>

7.3 创建processEngineConfiguration

java

ProcessEngineConfiguration configuration = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cfg.xml")

上边的代码要求activiti.cfg.xml中必须有一个processEngineConfiguration的bean

也可以使用下边的方法，更改bean 的名字：

java

ProcessEngineConfiguration.createProcessEngineConfigurationFromResource(String resource, String beanName);

八、工作流引擎创建

工作流引擎（ProcessEngine），相当于一个门面接口，通过ProcessEngineConfiguration创建processEngine，通过ProcessEngine创建各个service接口。

8.1 默认创建方式

将activiti.cfg.xml文件名及路径固定，且activiti.cfg.xml文件中有 processEngineConfiguration的配置，可以使用如下代码创建processEngine:

java

//直接使用工具类 ProcessEngines，使用classpath下的activiti.cfg.xml中的配置创建processEngine
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
System.out.println(processEngine);

8.2 一般创建方式

java

//先构建ProcessEngineConfiguration
ProcessEngineConfiguration configuration = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cfg.xml");
//通过ProcessEngineConfiguration创建ProcessEngine，此时会创建数据库
ProcessEngine processEngine = configuration.buildProcessEngine();

九、Servcie服务接口

Service是工作流引擎提供用于进行工作流部署、执行、管理的服务接口，我们使用这些接口可以就是操作服务对应的数据表

9.1 Service创建方式

通过ProcessEngine创建Service

java

RuntimeService runtimeService = processEngine.getRuntimeService();
RepositoryService repositoryService = processEngine.getRepositoryService();
TaskService taskService = processEngine.getTaskService();

9.2 Service总览

名称	作用
RepositoryService	activiti的资源管理类，提供了管理和控制流程发布包和流程定义的操作。使用工作流建模工具设计的业务流程图需要使用此service将流程定义文件的内容部署到计算机。除了部署流程定义以外还可以：查询引擎中的发布包和流程定义。暂停或激活发布包，对应全部和特定流程定义。暂停意味着它们不能再执行任何操作了，激活是对应的反向操作。获得多种资源，像是包含在发布包里的文件，或引擎自动生成的流程图。获得流程定义的pojo版本，可以用来通过java解析流程，而不必通过xml。
RuntimeService	Activiti的流程运行管理类。可以从这个服务类中获取很多关于流程执行相关的信息
TaskService	Activiti的任务管理类。可以从这个类中获取任务的信息。
HistoryService	Activiti的历史管理类，可以查询历史信息，执行流程时，引擎会保存很多数据（根据配置），比如流程实例启动时间，任务的参与者，完成任务的时间，每个流程实例的执行路径，等等。这个服务主要通过查询功能来获得这些数据。
ManagementService	Activiti的引擎管理类，提供了对 Activiti 流程引擎的管理和维护功能，这些功能不在工作流驱动的应用程序中使用，主要用于 Activiti 系统的日常维护。

一、概述 ​

1.1 核心类 ​

1.2 使用流程 ​

1.3 表结构 ​

具体表信息 ​

流程实例数据存储 ​

流程变量存储 ​

1.4 流程变量 ​

变量类型 ​

流程变量作用域 ​

1.5 组任务 ​

组任务办理流程 ​

组任务相关的数据库表 ​

1.6 网关 ​

排他网关 ​

并行网关 ​

包含网关 ​

事件网关EventGateway ​

1.7 数据库支持 ​

支持的数据库和版本 ​

创建mysql的表 ​

1.8 流程符号 ​

事件 Event ​

活动 Activity ​

网关 GateWay ​

流向 Flow ​

1.9 其他拓展 ​

idea插件 ​

二、整合开发 ​

2.1 与SpringBoot整合 ​

依赖 ​

配置 ​

启动类 ​

SpringSecurity安全框架整合 ​

创建Bpmn文件 ​

测试 ​

2.2 与Spring整合 ​

依赖 ​

配置 ​

测试 ​

三、流程操作 ​

3.1 流程部署 ​

单个文件部署 ​

压缩包部署 ​

操作的表 ​

3.2 流程定义 ​

3.3 查看流程定义 ​

3.4 流程删除 ​

3.5 流程资源下载 ​

3.6 流程历史信息查看 ​

3.7 启动流程实例 ​

3.8 查询流程实例 ​

3.9 查询并完成自己的任务 ​

3.10 挂起/激活流程 ​

3.11 挂起激活实例 ​

3.12 查询历史任务 ​

四、任务分配负责人 ​

4.1 固定分配 ​

4.2 表达式分配 ​

4.3 监听器方式 ​

五、设置流程变量 ​

5.1 globa变量 ​

5.2 local变量 ​

5.3 流程变量的使用方法 ​

六、操作组任务 ​

6.1 查询组任务 ​

6.2 拾取(claim)任务 ​

6.3 归还或任务交接 ​

6.4 查询个人任务 ​

6.5 办理个人任务 ​

七、流程引擎配置类 ​

7.1 StandaloneProcessEngineConfiguration ​

7.2 SpringProcessEngineConfiguration ​

7.3 创建processEngineConfiguration ​

八、工作流引擎创建 ​

8.1 默认创建方式 ​

8.2 一般创建方式 ​

九、Servcie服务接口 ​

9.1 Service创建方式 ​

9.2 Service总览 ​

一、概述

1.1 核心类

1.2 使用流程

1.3 表结构

具体表信息

流程实例数据存储

流程变量存储

1.4 流程变量

变量类型

流程变量作用域

1.5 组任务

组任务办理流程

组任务相关的数据库表

1.6 网关

排他网关

并行网关

包含网关

事件网关EventGateway

1.7 数据库支持

支持的数据库和版本

创建mysql的表

1.8 流程符号

事件 Event

活动 Activity

网关 GateWay

流向 Flow

1.9 其他拓展

idea插件

二、整合开发

2.1 与SpringBoot整合

依赖

配置

启动类

SpringSecurity安全框架整合

创建Bpmn文件

测试

2.2 与Spring整合

依赖

配置

测试

三、流程操作

3.1 流程部署

单个文件部署

压缩包部署

操作的表

3.2 流程定义

3.3 查看流程定义

3.4 流程删除

3.5 流程资源下载

3.6 流程历史信息查看

3.7 启动流程实例

3.8 查询流程实例

3.9 查询并完成自己的任务

3.10 挂起/激活流程

3.11 挂起激活实例

3.12 查询历史任务

四、任务分配负责人

4.1 固定分配

4.2 表达式分配

4.3 监听器方式

五、设置流程变量

5.1 globa变量

5.2 local变量

5.3 流程变量的使用方法

六、操作组任务

6.1 查询组任务

6.2 拾取(claim)任务

6.3 归还或任务交接

6.4 查询个人任务

6.5 办理个人任务

七、流程引擎配置类

7.1 StandaloneProcessEngineConfiguration

7.2 SpringProcessEngineConfiguration

7.3 创建processEngineConfiguration

八、工作流引擎创建

8.1 默认创建方式

8.2 一般创建方式

九、Servcie服务接口

9.1 Service创建方式

9.2 Service总览