kejizhentan

十四、工作流引擎——Activiti7

一、什么是工作流

1. 工作流介绍

工作流(Workflow)，就是通过计算机对业务流程自动化执行管理。它主要解决的是“使在多个参与者之间按照某种预定义的规则自动进行传递文档、信息或任务的过程，从而实现某个预期的业务目标，或者促使此目标的实现”。

2. 工作流系统

一个软件系统中具有工作流的功能，我们把它称为工作流系统，一个系统中工作流的功能是什么？就是对系统的业务流程进行自动化管理，所以工作流是建立在业务流程的基础上，所以一个软件的系统核心根本上还是系统的业务流程，工作流只是协助进行业务流程管理。即使没有工作流业务系统也可以开发运行，只不过有了工作流可以更好的管理业务流程，提高系统的可扩展性。

⑴ 适用行业

消费品行业，制造业，电信服务业，银证险等金融服务业，物流服务业，物业服务业，物业管理，大中型进出口贸易公司，政府事业机构，研究院所及教育服务业等，特别是大的跨国企业和集团公司。

⑵ 具体应用

关键业务流程：订单、报价处理、合同审核、客户电话处理、供应链管理等
行政管理类:出差申请、加班申请、请假申请、用车申请、各种办公用品申请、购买申请、日报周报等凡是原来手工流转处理的行政表单。
人事管理类：员工培训安排、绩效考评、职位变动处理、员工档案信息管理等。
财务相关类：付款请求、应收款处理、日常报销处理、出差报销、预算和计划申请等。
客户服务类：客户信息管理、客户投诉、请求处理、售后服务管理等。
特殊服务类：ISO 系列对应流程、质量管理对应流程、产品数据信息管理、贸易公司报关处理、
物流公司货物跟踪处理等各种通过表单逐步手工流转完成的任务均可应用工作流软件自动规范
地实施。

3. 工作流实现方式

在没有专门的工作流引擎之前，我们之前为了实现流程控制，通常的做法就是采用状态字段的值来跟踪流程的变化情况。这样不用角色的用户，通过状态字段的取值来决定记录是否显示。
针对有权限可以查看的记录，当前用户根据自己的角色来决定审批是否合格的操作。如果合格将状态字段设置一个值，来代表合格；当然如果不合格也需要设置一个值来代表不合格的情况。
这是一种最为原始的方式。通过状态字段虽然做到了流程控制，但是当我们的流程发生变更的时候，这种方式所编写的代码也要进行调整。
那么有没有专业的方式来实现工作流的管理呢？并且可以做到业务流程变化之后，我们的程序可以不用改变，如果可以实现这样的效果，那么我们的业务系统的适应能力就得到了极大提升。

4. 工作流实现原理分析

如何可以做到我们在业务流程发生变更后，我们的业务系统代码可以不发生改变？此时我们就来分析一下原理。

具体分析过程如下图所示：

二、什么是Activiti7

1. Activiti 介绍

Alfresco 软件在 2010 年 5 月 17 日宣布 Activiti 业务流程管理（BPM）开源项目的正式启动，其首席架构师由业务流程管理 BPM 的专家 Tom Baeyens 担任，Tom Baeyens 就是原来 jbpm 的架构师，而jbpm 是一个非常有名的工作流引擎，当然 activiti 也是一个工作流引擎。
Activiti 是一个工作流引擎， activiti 可以将业务系统中复杂的业务流程抽取出来，使用专门的建模语言（BPMN2.0）进行定义，业务系统按照预先定义的流程进行执行，实现了业务系统的业务流程由 activiti 进行管理，减少业务系统由于流程变更进行系统升级改造的工作量，从而提高系统的健壮性，同时也减少了系统开发维护成本。

官方网站：https://www.activiti.org/

经历的版本:

目前最新版本：Activiti7.0.0.Beta

⑴ BPM

BPM（Business Process Management），即业务流程管理，是一种以规范化的构造端到端的卓越业务流程为中心，以持续的提高组织业务绩效为目的系统化方法，常见商业管理教育如 EMBA、MBA等均将 BPM 包含在内。
企业流程管理主要是对企业内部改革，改变企业职能管理机构重叠、中间层次多、流程不闭环等，做到机构不重叠、业务不重复，达到缩短流程周期、节约运作资本、提高企业效益的作用。

比较下边的两个人事加薪流程哪个效率更高？

流程一：

流程二：

上边两个流程的区别在于第二个流程在执行时，如果本次加薪金额在一万元以内不再由总经理审批将比第一个流程缩短流程周期，从而提交效率。

再比较下边的例子，哪个效率更高？

流程一：

流程二：

上边两个流程的区别在于第二个流程将交费和取药放在一起进行，这样导致的结果是此窗口的工作人员必须具备财务、药学专业知识，岗位强度加大，人员培训难度加大从而导致人员不易扩展，工作效率低下。

⑵ BPM 软件

BPM 软件就是根据企业中业务环境的变化，推进人与人之间、人与系统之间以及系统与系统之间的整合及调整的经营方法与解决方案的 IT 工具。通常以 Internet 方式实现信息传递、数据同步、业务监控和企业业务流程的持续升级优化，从而实现跨应用、跨部门、跨合作伙伴与客户的企业运作。通过 BPM 软件对企业内部及外部的业务流程的整个生命周期进行建模、自动化、管理监控和优化，使企业成本降低，利润得以大幅提升。
BPM 软件在企业中应用领域广泛，凡是有业务流程的地方都可以 BPM 软件进行管理，比如企业人事办公管理、采购流程管理、公文审批流程管理、财务管理等。

⑶ BPMN

BPMN（Business Process Model And Notation）- 业务流程模型和符号是由 BPMI（Business Process Management Initiative）开发的一套标准的业务流程建模符号，使用 BPMN 提供的符号可以创建业务流程。 2004 年 5 月发布了 BPMN1.0 规范.BPMI 于 2005 年 9 月并入 OMG（The Object Management Group 对象管理组织)组织。OMG 于 2011 年 1 月发布 BPMN2.0 的最终版本。

具体发展历史如下:

BPMN 是目前被各 BPM 厂商广泛接受的 BPM 标准。Activiti 就是使用 BPMN 2.0 进行流程建模、流程执行管理，它包括很多的建模符号，比如：

Event 用一个圆圈表示，它是流程中运行过程中发生的事情。

活动用圆角矩形表示，一个流程由一个活动或多个活动组成

一个 bpmn 图形的例子：
首先当事人发起一个请假单；
其次他所在部门的经理对请假单进行审核；
然后人事经理进行复核并进行备案；
最后请假流程结束。

Bpmn 图形其实是通过 xml 表示业务流程，上边的.bpmn 文件使用文本编辑器打开：

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:activiti="http://activiti.org/bpmn" xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI" xmlns:omgdc="http://www.omg.org/spec/DD/20100524/DC" xmlns:omgdi="http://www.omg.org/spec/DD/20100524/DI" xmlns:tns="http://www.activiti.org/test" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" expressionLanguage="http://www.w3.org/1999/XPath" id="m1653752833115" name="" targetNamespace="http://www.activiti.org/test" typeLanguage="http://www.w3.org/2001/XMLSchema">
  <process id="myProcess_1" isClosed="false" isExecutable="true" processType="None">
    <startEvent id="_2" name="StartEvent"/>
    <userTask activiti:exclusive="true" id="_3" name="创建请假单"/>
    <sequenceFlow id="_5" sourceRef="_2" targetRef="_3"/>
    <userTask activiti:exclusive="true" id="_6" name="部门经理审核"/>
    <sequenceFlow id="_7" sourceRef="_3" targetRef="_6"/>
    <userTask activiti:exclusive="true" id="_8" name="人事复核"/>
    <sequenceFlow id="_9" sourceRef="_6" targetRef="_8"/>
    <endEvent id="_10" name="EndEvent"/>
    <sequenceFlow id="_11" sourceRef="_8" targetRef="_10"/>
  </process>
  <bpmndi:BPMNDiagram documentation="background=#3C3F41;count=1;horizontalcount=1;orientation=0;width=842.4;height=1195.2;imageableWidth=832.4;imageableHeight=1185.2;imageableX=5.0;imageableY=5.0" id="Diagram-_1" name="New Diagram">
    <bpmndi:BPMNPlane bpmnElement="myProcess_1">
      <bpmndi:BPMNShape bpmnElement="_2" id="Shape-_2">
        <omgdc:Bounds height="32.0" width="32.0" x="10.0" y="265.0"/>
        <bpmndi:BPMNLabel>
          <omgdc:Bounds height="32.0" width="32.0" x="0.0" y="0.0"/>
        </bpmndi:BPMNLabel>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="_3" id="Shape-_3">
        <omgdc:Bounds height="55.0" width="85.0" x="100.0" y="255.0"/>
        <bpmndi:BPMNLabel>
          <omgdc:Bounds height="55.0" width="85.0" x="0.0" y="0.0"/>
        </bpmndi:BPMNLabel>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="_6" id="Shape-_6">
        <omgdc:Bounds height="55.0" width="85.0" x="275.0" y="255.0"/>
        <bpmndi:BPMNLabel>
          <omgdc:Bounds height="55.0" width="85.0" x="0.0" y="0.0"/>
        </bpmndi:BPMNLabel>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="_8" id="Shape-_8">
        <omgdc:Bounds height="55.0" width="85.0" x="415.0" y="255.0"/>
        <bpmndi:BPMNLabel>
          <omgdc:Bounds height="55.0" width="85.0" x="0.0" y="0.0"/>
        </bpmndi:BPMNLabel>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="_10" id="Shape-_10">
        <omgdc:Bounds height="32.0" width="32.0" x="545.0" y="265.0"/>
        <bpmndi:BPMNLabel>
          <omgdc:Bounds height="32.0" width="32.0" x="0.0" y="0.0"/>
        </bpmndi:BPMNLabel>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNEdge bpmnElement="_5" id="BPMNEdge__5" sourceElement="_2" targetElement="_3">
        <omgdi:waypoint x="42.0" y="281.0"/>
        <omgdi:waypoint x="100.0" y="282.5"/>
        <bpmndi:BPMNLabel>
          <omgdc:Bounds height="0.0" width="0.0" x="0.0" y="0.0"/>
        </bpmndi:BPMNLabel>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="_7" id="BPMNEdge__7" sourceElement="_3" targetElement="_6">
        <omgdi:waypoint x="185.0" y="282.5"/>
        <omgdi:waypoint x="275.0" y="282.5"/>
        <bpmndi:BPMNLabel>
          <omgdc:Bounds height="0.0" width="0.0" x="0.0" y="0.0"/>
        </bpmndi:BPMNLabel>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="_9" id="BPMNEdge__9" sourceElement="_6" targetElement="_8">
        <omgdi:waypoint x="360.0" y="282.5"/>
        <omgdi:waypoint x="415.0" y="282.5"/>
        <bpmndi:BPMNLabel>
          <omgdc:Bounds height="0.0" width="0.0" x="0.0" y="0.0"/>
        </bpmndi:BPMNLabel>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="_11" id="BPMNEdge__11" sourceElement="_8" targetElement="_10">
        <omgdi:waypoint x="500.0" y="282.5"/>
        <omgdi:waypoint x="545.0" y="281.0"/>
        <bpmndi:BPMNLabel>
          <omgdc:Bounds height="0.0" width="0.0" x="0.0" y="0.0"/>
        </bpmndi:BPMNLabel>
      </bpmndi:BPMNEdge>
    </bpmndi:BPMNPlane>
  </bpmndi:BPMNDiagram>
</definitions>

2. Activit 如何使用

⑴ 部署 activiti

Activiti 是一个工作流引擎（其实就是一堆 jar 包 API），业务系统使用 activiti 来对系统的业务流程进行自动化管理，为了方便业务系统访问(操作)activiti 的接口或功能，通常将 activiti 环境与业务系统的环境集成在一起。

⑵ 流程定义

使用 activiti 流程建模工具(activity-designer)定义业务流程(.bpmn 文件) 。
.bpmn 文件就是业务流程定义文件，通过 xml 定义业务流程。

如果使用其它公司开发的工作作引擎一般都提供了可视化的建模工具(Process Designer)用于生成流程定义文件，建模工具操作直观，一般都支持图形化拖拽方式、多窗口的用户界面、丰富的过程图形元素、过程元素拷贝、粘贴、删除等功能。

⑶ 流程定义部署

向 activiti 部署业务流程定义（.bpmn 文件）。使用 activiti 提供的 api 向 activiti 中部署.bpmn 文件（一般情况还需要一块儿部署业务流程的图片.png）

⑷ 启动一个流程实例（ProcessInstance）

启动一个流程实例表示开始一次业务流程的运行，比如员工请假流程部署完成，如果张三要请假就可以启动一个流程实例，如果李四要请假也启动一个流程实例，两个流程的执行互相不影响，就好比定义一个 java 类，实例化两个对象一样，部署的流程就好比 java 类，启动一个流程实例就好比 new 一个 java 对象。

⑸ 用户查询待办任务(Task)

因为现在系统的业务流程已经交给 activiti 管理，通过 activiti 就可以查询当前流程执行到哪了，当前用户需要办理什么任务了，这些 activiti帮我们管理了，而不像上边需要我们在 sql语句中的where条件中指定当前查询的状态值是多少。

⑹ 用户办理任务

用户查询待办任务后，就可以办理某个任务，如果这个任务办理完成还需要其它用户办理，比如采购单创建后由部门经理审核，这个过程也是由 activiti 帮我们完成了，不需要我们在代码中硬编码指定下一个任务办理人了。

⑺ 流程结束

当任务办理完成没有下一个任务/结点了，这个流程实例就完成了。

3. 开发环境

⑴ Java 环境

Jdk1.8 或以上版本。

⑵ 数据库

Mysql 5 及以上的版本

⑶ Web 容器

Tomcat8.5

⑷ 开发工具

Mysql 客户端连接工具，Sqlyog 或其它
文本编辑器 EditPlus 或其它
Java 开发工具：IDEA 或 Eclipse 工具

注意：activiti 的流程定义工具插件可以安装在 IDEA 下，也可以安装在 Eclipse 工具下。

4. Activiti 环境

Activiti7.0.0.Beta1
默认支持 spring5

⑴ 下载 activiti7

Activiti 下载地址：http://activiti.org/download.html

<dependencyManagement>
	 <dependencies>
		 <dependency>
			 <groupId>org.activiti</groupId>
			 <artifactId>activiti-dependencies</artifactId>
			 <version>7.0.0.Beta1</version>
			 <scope>import</scope>
			 <type>pom</type>
		 </dependency>
	 </dependencies>
</dependencyManagement>

1） Database：

activiti 运行需要有数据库的支持，支持的数据库有：h2, mysql, oracle, postgres, mssql, db2等，该目录存放 activiti 的建表脚本。

2）Docs

Activiti 的帮助文档。

3）Wars

官方自带的示例工程。

⑵ Activiti Designer 流程设计器(Eclipse 工具)

1） Eclispe 工具下插件安装方式：网络在线安装

① 打开 Help -> Install New Software. 在如下面板中:

② 在如下 Install 界面板中，点击 Add 按钮：

配置新装插件的地址和名称

③ 然后填入下列字段

Name: Activiti BPMN 2.0 designer
Location: http://activiti.org/designer/update/

④ 回到 Install 界面，在面板正中列表中把所有展示出来的项目都勾上：

⑤ 点击复选框

在 Detail 部分记得选中"Contact all updates sites..", 因为它会检查所有当前安装所需要的插件并可以被 Eclipse 下载.

⑥ 安装完以后，点击新建工程 new->Other…打开面板，如果看到下图内容：

说明安装成功了。

2）补充说明

打开菜单 Windows->Preferences->Activiti->Save 下流程图片的生成方式:

虽然流程引擎在单独部署 bpmn 文件时会自动生成图片，但在实际开发过程中，自动生成的图片会导致和 BPMN 中的坐标有出入，在实际项目中展示流程当前位置图会有问题。所在完成以上配置后，会由我们自己来管理流程图片。在发布流程时把流程规则文件和流程图片一起上传就行了。

3）Activiti Designer 流程设计器(IDEA 工具)

① 下载插件

下载地址：https://plugins.jetbrains.com/plugin/7429-actibpm/versions

② 安装插件

安装后重启IDEA

建议直接安装Activiti BPMN visualizer

⑶ Activiti 支持的数据库

Activiti 的运行需要数据库支撑，需要安装 activiti 数据库，支持如下版本：

创建 mysql 数据库：
创建 mysql 数据库 activiti（名字任意)

CREATE DATABASE activiti DEFAULT CHARACTER SET utf8;

⑷ 创建表方式: 通过运行 java 程序创建表

1) 创建 java 工程

使用 eclipse 或 idea 创建 maven 的 java 工程。

2) 加入 maven 依赖的坐标（jar 包）

首先需要在 java 工程中加入 ProcessEngine 所需要的 jar 包，包括：

activiti-engine-7.0.0.beta1.jar
activiti 依赖的 jar 包：mybatis、alf4j、log4j 等
activiti 依赖的 spring 包
数据库驱动
第三方数据连接池 dbcp
单元测试 Junit-4.12.jar

我们使用 maven 来实现项目的构建，所以应当导入这些 jar 所对应的坐标到 pom.xml 文件中。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.kejizhentan</groupId>
    <artifactId>activiti-project</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <slf4j.version>1.6.6</slf4j.version>
        <log4j.version>1.2.12</log4j.version>
    </properties>

    <dependencies>

        <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>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.40</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

        <!-- log start -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <!-- log end -->

        <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>

    </dependencies>
</project>

3) 放入log4j.properties文件

# Set root category priority to INFO and its only appender to CONSOLE.
#log4j.rootCategory=INFO, CONSOLE            debug   info   warn error fatal
log4j.rootCategory=debug, CONSOLE, LOGFILE

# Set the enterprise logger category to FATAL and its only appender to CONSOLE.
log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE

# CONSOLE is set to be a ConsoleAppender using a PatternLayout.
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

# LOGFILE is set to be a File appender using a PatternLayout.
log4j.appender.LOGFILE=org.apache.log4j.FileAppender
log4j.appender.LOGFILE.File=d:\axis.log
log4j.appender.LOGFILE.Append=true
log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
log4j.appender.LOGFILE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

4) activiti.cfg.xml

在 classpath 下创建 activiti.cgf.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://localhost:3306/activiti" />
        <property name="username" value="root" />
        <property name="password" value="123456" />
    </bean>
    <!--activiti单独运行的ProcessEngine配置对象(processEngineConfiguration),使用单独启动方式
        默认情况下：bean的id=processEngineConfiguration
    -->

    <bean id="processEngineConfiguration" class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
    <!--代表数据源-->
    <property name="dataSource" ref="dataSource"></property>
    <!--代表是否生成表结构-->
    <property name="databaseSchemaUpdate" value="true"/>
    </bean>
</beans>

在 activiti.cfg.xml 中配置数据源和 processEngineConfiguration

① 数据源

<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" />
</bean>

② processEngineConfiguration

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

<bean id="processEngineConfiguration" class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
	<!--代表数据源-->
	<property name="dataSource" ref="dataSource"></property>
	<!--代表是否生成表结构-->
	<property name="databaseSchemaUpdate" value="true"/>
</bean>

关于 processEngineConfiguration 中的 databaseSchemaUpdate 参数，通过此参数设计 activiti
数据表的处理策略，参数如下：

false（默认）：检查数据库表的版本和依赖库的版本，如果版本不匹配就抛出异常。
true: 构建流程引擎时，执行检查，如果需要就执行更新。如果表不存在，就创建。
create-drop: 构建流程引擎时创建数据库表，关闭流程引擎时删除这些表。
drop-create：先删除表再创建表。
create: 构建流程引擎时创建数据库表，关闭流程引擎时不删除这些表。

注意：在 activiti.cfg.xml 配置文件中的 dataSource 和 processEngineConfiguration 也可以使用一次性配置出来。

<bean id="processEngineConfiguration" class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
   <!--代表数据源-->
    <property name="jdbcDriver" value="com.mysql.jdbc.Driver" />
    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/activiti" />
    <property name="jdbcUsername" value="root" />
    <property name="jdbcPassword" value="root" />
    <!--代表是否生成表结构-->
    <property name="databaseSchemaUpdate" value="true"/>
</bean>

5) 编写程序:ActivitiTest.java

创建 ProcessEngineConfiguration，通过 ProcessEngineConfiguration 创建 ProcessEngine，在创建
ProcessEngine 时会自动创建数据库。

public class ActivitiTest {
    @Test
    public void testGenTable(){
        //1.创建ProcessEngineConfiguration对象  第一个参数:配置文件名称  第二个参数是processEngineConfiguration的bean的id
        ProcessEngineConfiguration configuration = ProcessEngineConfiguration
                .createProcessEngineConfigurationFromResource("activiti.cfg.xml");
        //2.创建ProcesEngine对象
        ProcessEngine processEngine = configuration.buildProcessEngine();

        //3.输出processEngine对象
        System.out.println(processEngine);
    }
}

说明：

1、运行以上程序段即可完成 activiti 数据库创建，通过改变 activiti.cfg.xml 中 databaseSchemaUpdate 参数的值执行不同的数据表处理策略。

2、上边的方法 createProcessEngineConfigurationFromResource 在执行时在
activiti.cfg.xml 中找固定的名称 processEngineConfiguration

也可以使用重载方法调用，这时可以不用限定 processEngineConfiguration 名称

此时我们查看数据库，创建了 25 张表，结果如下：

数据库表的命名规则

Activiti 的表都以 ACT_开头。第二部分是表示表的用途的两个字母标识。用途也和服务的 API 对
应。

ACT_RE_*: 'RE’表示 repository。这个前缀的表包含了流程定义和流程静态资源（图片，规则，等等）。
ACT_RU_*: 'RU’表示 runtime。这些运行时的表，包含流程实例，任务，变量，异步任务，等运行中的数据。 Activiti 只在流程实例执行过程中保存这些数据，在流程结束时就会删除这些记录。这样运行时表可以一直很小速度很快。
ACT_HI_*: 'HI’表示 history。这些表包含历史数据，比如历史流程实例，变量，任务等等。
ACT_GE_*: GE 表示 general。通用数据，用于不同场景下。

三、 Activiti 服务架构图

在新版本中，我们通过实验可以发现 IdentityService，FormService 两个 Serivce 都已经删除了。
所以后面我们对于这两个 Service 也不讲解了，但老版本中还是有这两个 Service，需要了解
一下。

1. activiti.cfg.xml

activiti 的引擎配置文件，包括：ProcessEngineConfiguration 的定义、数据源定义、事务管理器等，此文件其实就是一个 spring 配置文件，下面是一个基本的配置只配置了 ProcessEngineConfiguration和数据源：

<?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://localhost:3306/activiti" />
        <property name="username" value="root" />
        <property name="password" value="123456" />
    </bean>
    <!--activiti单独运行的ProcessEngine配置对象(processEngineConfiguration),使用单独启动方式
        默认情况下：bean的id=processEngineConfiguration
    -->

    <bean id="processEngineConfiguration" class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
        <!--代表数据源-->
        <property name="dataSource" ref="dataSource"></property>
        <!--代表是否生成表结构-->
        <property name="databaseSchemaUpdate" value="true"/>
    </bean>
</beans>

2. ProcessEngineConfiguration：

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

⑴ StandaloneProcessEngineConfiguration

通过 org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration

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

配置文件方式：

通常在activiti.cfg.xml配置文件中定义一个 id 为 processEngineConfiguration 的 bean，这里会使用 spring 的依赖注入来构建引擎。

方法如下：

<bean id="processEngineConfiguration" class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
    <!--代表数据源-->
    <property name="dataSource" ref="dataSource"></property>
    <!--代表是否生成表结构-->
    <property name="databaseSchemaUpdate" value="true"/>
</bean>

⑵ SpringProcessEngineConfiguration

通过 org.activiti.spring.SpringProcessEngineConfiguration 与 Spring 整合。
创建 spring 与 activiti 的整合配置文件
activity-spring.cfg.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: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.kejizhentan.ihrm.service.impl.*.*(..))"/>
    </aop:config>
</beans>

⑶ 创建 processEngineConfiguration

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

上边的代码要求 activiti.cfg.xml 中必须有一个 processEngineConfiguration 的 bean也可以使用下边的方法，更改 bean 的名字：

ProcessEngineConfiguration.
			createProcessEngineConfigurationFromResource(String resource, String beanName);

3. ProcessEngine

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

⑴ 一般创建方式

//通过ProcessEngineConfiguration创建ProcessEngine
ProcessEngine processEngine = processEngineConfiguration.buildProcessEngine();

例如：

public class ActivitiTest {
    @Test
    public void testGenTable(){
        //1.创建ProcessEngineConfiguration对象  第一个参数:配置文件名称  第二个参数是processEngineConfiguration的bean的id
        ProcessEngineConfiguration configuration = ProcessEngineConfiguration
                .createProcessEngineConfigurationFromResource("activiti.cfg.xml");
        //2.创建ProcesEngine对象
        ProcessEngine processEngine = configuration.buildProcessEngine();

        //3.输出processEngine对象
        System.out.println(processEngine);
    }
}

⑵ 简单创建方式

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

//条件：1.activiti配置文件名为：activiti.cfg.xml     
//2. bean的id="processEngineConfiguration"
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

例如：

/**
 * @Auther: kejizhentan
 * @Date 2022/5/29 16:41
 * @Description: 测试activiti所需的25张表的生成
 */
public class ActivitiTest {
    @Test
    public void testGenTable(){
        //条件：1.activiti配置文件名为：activiti.cfg.xml     2. bean的id="processEngineConfiguration"
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        System.out.println(processEngine);
    }
}

4. Service

⑴ Service 创建方式

通过 ProcessEngine 创建 Service，Service 是工作流引擎提供用于进行工作流部署、执行、管理的服务接口。

方式如下：
RuntimeService runtimeService = processEngine.getRuntimeService();
RepositoryService repositoryService = processEngine.getRepositoryService();
TaskService taskService = processEngine.getTaskService();
……

⑵ Service 总览

名称	作用
RepositoryService	activiti 的资源管理类
RuntimeService	activiti 的流程运行管理类
TaskService	activiti 的任务管理类
HistoryService	activiti 的历史管理类
ManagerService	activiti 的引擎管理类

注：前四个是常用 service。

1) RepositoryService

是 activiti 的资源管理类，提供了管理和控制流程发布包和流程定义的操作。使用工作流建模工具设计的业务流程图需要使用此 service 将流程定义文件的内容部署到计算机。

除了部署流程定义以外还可以：

查询引擎中的发布包和流程定义。
暂停或激活发布包，对应全部和特定流程定义。暂停意味着它们不能再执行任何操作了，激活是对应的反向操作。
获得多种资源，像是包含在发布包里的文件，或引擎自动生成的流程图。
获得流程定义的 pojo 版本，可以用来通过 java 解析流程，而不必通过 xml。

2) RuntimeService

它是 activiti 的流程运行管理类。可以从这个服务类中获取很多关于流程执行相关的信息

3) TaskService

是 activiti 的任务管理类。可以从这个类中获取任务的信息。

4) HistoryService

是 activiti 的历史管理类，可以查询历史信息，执行流程时，引擎会保存很多数据（根据配置），比如流程实例启动时间，任务的参与者，完成任务的时间，每个流程实例的执行路径，等等。这个服务主要通过查询功能来获得这些数据。

5) ManagementService

是 activiti 的引擎管理类，提供了对 Activiti 流程引擎的管理和维护功能，这些功能不在工作流驱动的应用程序中使用，主要用于 Activiti 系统的日常维护。

四、 Activiti 入门体验

1、流程定义

⑴ Activiti-Designer 使用

1) Palette（画板）

在 eclipse 或 idea 中安装 activiti-designer 插件即可使用，画板中包括以下结点：

Connection—连接
Event—事件
Task—任务
Gateway—网关
Container—容器
Boundary event—边界事件
Intermediate event- -中间事件

流程图设计完毕保存生成.bpmn 文件。

2) 新建流程(IDEA 工具)

首先选中存放图形的目录(本次我们选择 resources 下的 bpmn 目录)，点击菜单：New-BpmnFile，如下图所示：

弹出如下图所示框：

起完名字 holiday 后（默认扩展名为 bpmn），就可以看到进入了流程设计页面，如图所示：

① idea绘制流程

resources文件夹下新建diagram文件夹，用于存放bpmnfile文件
新建holiday.bpmn文件
绘制流程
绘制流程图给流程图设置id和name

设置每个任务节点的分配者

② IDEA 工具中怎么将.bpmn文件转换成png图片

第一步：将 holiday.bpmn 文件改为扩展名 xml 的文件名称：holiday.xml
修改前的 bpmn 文件，效果如下：
第二步：在 holiday.xml 文件上面，点右键并选择 Diagrams 菜单，再选择 Show BPMN2.0 Designer…
第三步：打开后的效果图如下：
第四步：点击 Export To File 的小图标，如下：

打开如下窗口，注意填写文件名及扩展名，选择好保存图片的位置：
将生成的png图片放到diagram文件夹下，并将holiday.xml改回holiday.bpmn

如果出现中文乱码需要进行如下操作：

打开 IDEA 安装路径，找到如下的安装目录
根据自己所安装的版本来决定，我使用的是 64 位的 idea，所以在 idea64.exe.vmoptions 文件的最后一行追加一条命令： -Dfile.encoding=UTF-8
如下所示：

一定注意，不要有空格，否则重启 IDEA 时会打不开，然后重启 IDEA，把原来的 png 图片删掉，再重新生成，即可解决乱码问题

3) 新建流程(Eclipse 工具)

首先选中存放图形的目录(本次我们选择 resources 下的 bpmn 目录)， File-New-Other 菜单，打开如下窗口。

创建成功：

左侧区域是绘图区，右侧区域是 palette 画板区域
鼠标先点击画板的元素即可在左侧绘图。

① eclipse绘制流程

图形绘制好后会生成两个文件：

自动生成图形，需要设置 eclipse:

⑵ 部署流程定义

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

1) 单个文件部署方式

分别将 bpmn 文件和 png图片文件部署。

使用 ProcessEngine 创建 RepositoryService，代码如下：

/**
 * @Auther: kejizhentan
 * @Date 2022/5/29 18:51
 * @Description:
 * 流程定义部署
 *   activiti表有哪些？
 *     act_re_deployment  部署信息
 *     act_re_procdef     流程定义的一些信息
 *     act_ge_bytearray   流程定义的bpmn文件及png文件
 */
public class ActivitiDeployment {
    //流程定义部署
    public static void main(String[] args) {
        //1.创建ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //2.得到RepositoryService实例
        RepositoryService repositoryService = processEngine.getRepositoryService();
        //3.进行部署
        Deployment deployment = repositoryService.createDeployment()
                .addClasspathResource("diagram/holiday.bpmn")
                .addClasspathResource("diagram/holiday.png")
                .name("请假申请流程")
                .deploy();
        //4.输出部署的一些信息
        System.out.println(deployment.getName());
        System.out.println(deployment.getId());
    }
}

执行此操作后 activiti 会将上边代码中指定的 bpm 文件和图片文件保存在 activiti 数据库。

2) 压缩包部署方式

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

使用 ProcessEngine 创建 RepositoryService，代码如下：

/**
 * @Auther: kejizhentan
 * @Date 2022/5/29 18:51
 * @Description:
 * 流程定义部署
 *   activiti表有哪些？
 *     act_re_deployment  部署信息
 *     act_re_procdef     流程定义的一些信息
 *     act_ge_bytearray   流程定义的bpmn文件及png文件
 */
public class ActivitiDeployment {
    //流程定义部署  流程制作出来后要上传到服务器 zip文件更便于上传
    public static void main(String[] args) {
        //1.创建ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

        //2.得到RepositoryService实例
        RepositoryService repositoryService = processEngine.getRepositoryService();

        //3.转化出ZipInputStream流对象
        InputStream is = ActivitiDeployment.class.getClassLoader().getResourceAsStream("diagram/holiday.zip");

        //将 inputstream流转化为ZipInputStream流
        ZipInputStream zipInputStream = new ZipInputStream(is);

        //3.进行部署
        Deployment deployment = repositoryService.createDeployment()
                .addZipInputStream(zipInputStream)
                .name("请假申请单流程")
                .deploy();

        //4.输出部署的一些信息
        System.out.println(deployment.getName());
        System.out.println(deployment.getId());
    }
}

执行此操作后 activiti 会将上边代码中指定的压缩包中的bpm 文件和图片文件解压后保存在 activiti 数据库。

3）操作数据表

流程定义部署后操作 activiti 数据表如下：

SELECT * FROM act_re_deployment --流程定义部署表，记录流程部署信息
SELECT * FROM act_re_procdef --流程定义表，记录流程定义信息
SELECT * FROM act_ge_bytearray --资源表

说明：
act_re_deployment 和 act_re_procdef 一对多关系，一次部署在流程部署表生成一条记录，但一次部署可以部署多个流程定义，每个流程定义在流程定义表生成一条记录。每一个流程定义在act_ge_bytearray 会存在两个资源记录，bpmn 和 png。
建议：一次部署一个流程，这样部署表和流程定义表是一对一有关系，方便读取流程部署及流程定义信息。

⑶ 启动一个流程实例

流程定义部署在 activiti 后就可以通过工作流管理业务流程了，也就是说上边部署的请假申请流程可以使用了。

针对该流程，启动一个流程表示发起一个新的请假申请单，这就相当于 java 类与 java 对象的关系，类定义好后需要 new 创建一个对象使用，当然可以 new 多个对象。对于请假申请流程，张三发起一个请假申请单需要启动一个流程实例，请假申请单发起一个请假单也需要启动一个流程实例。

代码如下：

/**
 * @Auther: kejizhentan
 * @Date 2022/5/29 19:29
 * @Description:
 *      启动流程实例:
 *        前提是先已经完成流程定义的部署工作
 *      背后影响的表：
 *          act_hi_actinst     已完成的活动信息
 *          act_hi_identitylink   参与者信息
 *          act_hi_procinst   流程实例
 *          act_hi_taskinst   任务实例
 *          act_ru_execution   执行表
 *          act_ru_identitylink   参与者信息
 *          act_ru_task  任务
 */
public class ActivitiStartInstance {
    public static void main(String[] args) {
        //1.得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //2.得到RunService对象
        RuntimeService runtimeService = processEngine.getRuntimeService();
        //3.创建流程实例  流程定义的key需要知道 holiday
        ProcessInstance processInstance  = runtimeService.startProcessInstanceByKey("holiday");
        //4.输出实例的相关信息
        System.out.println("流程部署ID"+processInstance.getDeploymentId());//null
        System.out.println("流程定义ID"+processInstance.getProcessDefinitionId());//holiday:1:4
        System.out.println("流程实例ID"+processInstance.getId());//2501
        System.out.println("活动ID"+processInstance.getActivityId());//null
    }
}

⑷ 任务查询

流程启动后，各各任务的负责人就可以查询自己当前需要处理的任务，查询出来的任务都是该用户的待办任务。

/**
 * 查询当前用户的任务列表
 */
public class ActivitiTaskQuery {
    public static void main(String[] args) {
        //1.得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //2.得到TaskService对象
        TaskService taskService = processEngine.getTaskService();
        //3.根据流程定义的key，负责人assignee来实现当前用户的任务列表查询
        List<Task> taskList = taskService.createTaskQuery()
                .processDefinitionKey("holiday")
                .taskAssignee("zhangsan")
                .list();
        //4.任务列表的展示
        for (Task task : taskList) {
            System.out.println("流程实例ID："+task.getProcessInstanceId());
            System.out.println("任务ID:"+task.getId());
            System.out.println("任务负责人:"+task.getAssignee());
            System.out.println("任务名称:"+task.getName());
        }
    }
}

⑸ 任务处理

任务负责人查询待办任务，选择任务进行处理，完成任务。

/**
 * @Auther: kejizhentan
 * @Date 2022/5/29 21:27
 * @Description:
 *  处理当前用户的任务
 *    背后操作的表：
 *      act_hi_actinst
 *      act_hi_identitylink
 *      act_hi_taskinst
 *      act_ru_identitylink
 *      act_ru_task
 */
public class ActivitiCompleteTask {
    public static void main(String[] args) {
        //1. 得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //2. 得到TaskService对象
        TaskService taskService = processEngine.getTaskService();
        //3. 处理任务,结合当前用户任务列表的查询操作得到任务ID: 2505
        taskService.complete("2505");
        System.out.println("完成任务id=2505");
    }
}

⑹ 流程定义查询

查询部署的流程定义。

/**
 * 查询流程定义信息
 */
public class QueryProcessDefinition {
    public static void main(String[] args) {
        //1.得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //2.创建RepositoryService对象
        RepositoryService repositoryService = processEngine.getRepositoryService();
        //3.得到ProcessDefinitionQuery对象,可以认为它就是一个查询器
        ProcessDefinitionQuery processDefinitionQuery = repositoryService.createProcessDefinitionQuery();
        //4.设置条件，并查询出当前的所有流程定义   查询条件：流程定义的key=holiday
        //orderByProcessDefinitionVersion() 设置排序方式,根据流程定义的版本号进行排序
        List<ProcessDefinition> list = processDefinitionQuery.processDefinitionKey("holiday")
                .orderByProcessDefinitionVersion()
                .desc().list();
        //5.输出流程定义信息
        for (ProcessDefinition processDefinition : list) {
            System.out.println("流程定义ID："+processDefinition.getId());
            System.out.println("流程定义名称："+processDefinition.getName());
            System.out.println("流程定义的Key："+processDefinition.getKey());
            System.out.println("流程定义的版本号："+processDefinition.getVersion());
            System.out.println("流程部署的ID:"+processDefinition.getDeploymentId());
        }
    }
}

⑺ 流程定义删除

删除已经部署成功的流程定义

/**
 * 删除已经部署的流程定义
 *
 * 背后影响的表:
 * act_ge_bytearray
 * act_re_deployment
 * act_re_procdef
 */
public class DeleteProcessDefinition {
    /**
     * @descrition：
     *      注意事项：
     *         1.当我们正在执行的这一套流程没有完全审批结束的时候，此时如果要删除流程定义信息就会失败
     *         2.如果公司层面要强制删除,可以使用repositoryService.deleteDeployment("1",true);
     *          //参数true代表级联删除，此时就会先删除没有完成的流程结点，最后就可以删除流程定义信息  false的值代表不级联
     * @auther: kejizhentan
     * @date: 2022/5/29 23:17
     */
    public static void main(String[] args) {
        //1.得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

        //2.创建RepositoryService对象
        RepositoryService repositoryService = processEngine.getRepositoryService();

        //3.执行删除流程定义  参数代表流程部署的id
        repositoryService.deleteDeployment("1");
    }
}

说明：

使用 repositoryService 删除流程定义

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

如果该流程定义下存在已经运行的流程，使用普通删除报错，可用级联删除方法将流程及相关记录全部删除。项目开发中使用级联删除的情况比较多，删除操作一般只开放给超级管理员使用。

⑻ 流程定义资源查询

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

/**
 * 需求：
 * 1.从Activiti的act_ge_bytearray表中读取两个资源文件
 * 2.将两个资源文件保存到路径：   E:\activiti_resources
 *
 * 技术方案：
 *     1.第一种方式使用actviti的api来实现
 *     2.第二种方式：其实就是原理层面，可以使用jdbc的对blob类型，clob类型数据的读取，并保存
 *        IO流转换，最好commons-io.jar包可以轻松解决IO操作
 *
 * 真实应用场景：用户想查看这个请假流程具体有哪些步骤要走？
 *
 *
 */
public class QueryBpmnFile {
    public static void main(String[] args) throws IOException {
        //1.得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

        //2.得到RepositoryService对象
        RepositoryService repositoryService = processEngine.getRepositoryService();

        //3.得到查询器:ProcessDefinitionQuery对象
        ProcessDefinitionQuery processDefinitionQuery = repositoryService.createProcessDefinitionQuery();

        //4.设置查询条件
        processDefinitionQuery.processDefinitionKey("holiday");//参数是流程定义的key

        //5.执行查询操作,查询出想要的流程定义
        ProcessDefinition processDefinition = processDefinitionQuery.singleResult();

        //6.通过流程定义信息，得到部署ID
        String deploymentId = processDefinition.getDeploymentId();

        /*7.通过repositoryService的方法,实现读取图片信息及bpmn文件信息(输入流)
            getResourceAsStream()方法的参数说明：第一个参数部署id,第二个参数代表资源名称
                processDefinition.getDiagramResourceName() 代表获取png图片资源的名称
                processDefinition.getResourceName()代表获取bpmn文件的名称
        */
        InputStream pngIs = repositoryService
                .getResourceAsStream(deploymentId,processDefinition.getDiagramResourceName());
        InputStream bpmnIs = repositoryService
                .getResourceAsStream(deploymentId,processDefinition.getResourceName());

        //8.构建出OutputStream流
        OutputStream pngOs = new FileOutputStream("E:\\activiti_resources\\"+processDefinition.getDiagramResourceName());
        OutputStream bpmnOs = new FileOutputStream("E:\\activiti_resources\\"+processDefinition.getResourceName());
        //9.输入流，输出流的转换  commons-io-xx.jar中的方法
        IOUtils.copy(pngIs,pngOs);
        IOUtils.copy(bpmnIs,bpmnOs);
        //10.关闭流
        pngOs.close();
        bpmnOs.close();
        pngIs.close();
        bpmnIs.close();

    }
}

效果如下：

说明：

deploymentId 为流程部署 ID

resource_name 为 act_ge_bytearray 表中 NAME_列的值

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

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

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

⑼ 流程历史信息的查看

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

/**
 * @Auther: kejizhentan
 * @Date 2022/5/30 23:02
 * @Description: 历史数据的查看
 */
public class HistoryQuery {
    public static void main(String[] args) {
        //1.得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

        //2.得到HistoryService
        HistoryService historyService = processEngine.getHistoryService();

        //3.得到HistoricActivitiInstanceQuery对象
        HistoricActivityInstanceQuery historicActivityInstanceQuery = historyService.createHistoricActivityInstanceQuery();

        historicActivityInstanceQuery.processInstanceId("5001");//设置流程实例的id

        //4.执行查询
        List<HistoricActivityInstance> list = historicActivityInstanceQuery
                .orderByHistoricActivityInstanceStartTime().asc().list();//排序StartTime

        //5.遍历查询结果
        for (HistoricActivityInstance instance :list){
            System.out.println(instance.getActivityId());
            System.out.println(instance.getActivityName());
            System.out.println(instance.getProcessDefinitionId());
            System.out.println(instance.getProcessInstanceId());
            System.out.println("=============================");
        }
    }
}

五、流程实例

1. 什么是流程实例

参与者（可以是用户也可以是程序）按照流程定义内容发起一个流程，这就是一个流程实例。是动态的

流程定义和流程实例的图解：

2. 启动流程实例

流程定义部署在 activiti 后，就可以在系统中通过 activiti 去管理该流程的执行，执行流程表示流程的一次执行。比如部署系统请假流程后，如果某用户要申请请假这时就需要执行这个流程，如果另外一个用户也要申请请假则也需要执行该流程，每个执行互不影响，每个执行是单独的流程实例。

原来执行流程首先需要启动流程实例的方式。

/**
 * @Auther: kejizhentan
 * @Date 2022/5/29 19:29
 * @Description:
 *      启动流程实例:
 *        前提是先已经完成流程定义的部署工作
 *      背后影响的表：
 *          act_hi_actinst     已完成的活动信息
 *          act_hi_identitylink   参与者信息
 *          act_hi_procinst   流程实例
 *          act_hi_taskinst   任务实例
 *          act_ru_execution   执行表
 *          act_ru_identitylink   参与者信息
 *          act_ru_task  任务
 */
public class ActivitiStartInstance {
    public static void main(String[] args) {
        //1.得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //2.得到RunService对象
        RuntimeService runtimeService = processEngine.getRuntimeService();
        //3.创建流程实例  流程定义的key需要知道 holiday
        ProcessInstance processInstance  = runtimeService.startProcessInstanceByKey("holiday");
        //4.输出实例的相关信息
        System.out.println("流程部署ID"+processInstance.getDeploymentId());//null
        System.out.println("流程定义ID"+processInstance.getProcessDefinitionId());//holiday:1:4
        System.out.println("流程实例ID"+processInstance.getId());//2501
        System.out.println("活动ID"+processInstance.getActivityId());//null
    }
}

3. Businesskey(业务标识)

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

Businesskey：业务标识，通常为业务表的主键，业务标识和流程实例一一对应。业务标识来源于业务系统。存储业务标识就是根据业务标识来关联查询业务系统的数据。
比如：
请假流程启动一个流程实例，就可以将请假单的 id 作为业务标识存储到 activiti 中，将来查询activiti 的流程实例信息就可以获取请假单的 id 从而关联查询业务系统数据库得到请假单信息。

核心代码：

// 根据流程定义的key启动一个流程实例
ProcessInstance processInstance = runtimeService
	.startProcessInstanceByKey(processDefinitionKey, businessKey);

Activiti 中存储业务标识：

4. 操作数据库表

启动流程实例，操作如下数据库表：

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 活动历史表，记录所有活动

活动包括任务，所以此表中不仅记录了任务，还记录了流程执行过程的其它活动，比如开始事件、结束事件。

5. 查询流程实例

流程在运行过程中可以查询流程实例的状态，当前运行结点等信息。

public class queryProcessInstance {
    public static void main(String[] args) {
        //1.得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        // 获取RunTimeService
        RuntimeService runtimeService = processEngine.getRuntimeService();
        List<ProcessInstance> list = runtimeService
                .createProcessInstanceQuery()
                .processDefinitionKey("holiday")//
                .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());
        }
    }
}

⑴ 关联 businessKey

需求：

在 activiti 实际应用时，查询流程实例列表时可能要显示出业务系统的一些相关信息，比如：查询当前运行的请假流程列表需要将请假单名称、请假天数等信息显示出来，请假天数等信息在业务系统中存在，而并没有在 activiti 数据库中存在，所以是无法通过 activiti 的 api 查询到请假天数等信息。

实现：
在查询流程实例时，通过 businessKey（业务标识 ）关联查询业务系统的请假单表，查询出请假天数等信息。
通过下面的代码就可以获取 activiti 中所对应实例保存的业务 Key。而这个业务 Key 一般都会保存相关联的业务操作表的主键，再通过主键 ID 去查询业务信息，比如通过请假单的 ID，去查询更多的请假信息（请假人，请假时间，请假天数，请假事由等）
String businessKey = processInstance.getBusinessKey();

在 activiti 的 act_ru_execution 表，字段 BUSINESS_KEY 就是存放业务 KEY 的。

关联 businessKey添加和查询代码如下：

/**
 *  启动流程实例，添加进businessKey
 *
 *  本质：act_ru_execution表中的businessKey的字段要存入业务标识
 */
public class BusinessKeyAdd {
    public static void main(String[] args) {
        //1.得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //2.得到RuntimeService对象
        RuntimeService runtimeService = processEngine.getRuntimeService();
        /*3.启动流程实例,同时还要指定业务标识businessKey  它本身就是请假单的id
                第一个参数：是指流程定义key
                第二个参数：业务标识businessKey
         */
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("holiday", "1001");
        //4.输出processInstance相关的属性,取出businessKey使用:processInstance.getBusinessKey()
        System.out.println(processInstance.getBusinessKey());
    }
}

6. 挂起、激活流程实例

某些情况可能由于流程变更需要将当前运行的流程暂停而不是直接删除，流程暂停后将不会继续执行。

⑴ 全部流程实例挂起

操作流程定义为挂起状态，该流程定义下边所有的流程实例全部暂停：

流程定义为挂起状态该流程定义将不允许启动新的流程实例，同时该流程定义下所有的流程实例将全部挂起暂停执行。

/**
 * @Auther: kejizhentan
 * @Date 2022/6/1 15:56
 * @Description: 全部流程实例挂起与激活
 */
public class SuspendProcessInstance {
    public static void main(String[] args) {
        //1.得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //2.得到RepositoryService
        RepositoryService repositoryService = processEngine.getRepositoryService();
        //3.查询流程定义的对象
        ProcessDefinition processDefinition  = repositoryService.createProcessDefinitionQuery().processDefinitionKey("holiday").singleResult();
        //4.得到当前流程定义的实例是否都为暂停状态
        boolean suspended = processDefinition.isSuspended();
        //5. 获取流程实例id
        String  processDefinitionId = processDefinition.getId();
        //5.判断
        if(suspended){
            //说明是暂停，就可以激活操作
            repositoryService.activateProcessDefinitionById(processDefinitionId,true,null);
            System.out.println("流程定义："+processDefinitionId+"激活");
        }else{
            repositoryService.suspendProcessDefinitionById(processDefinitionId,true,null);
            System.out.println("流程定义："+processDefinitionId+"挂起");
        }
    }
}

⑵ 单个流程实例挂起

操作流程实例对象，针对单个流程执行挂起操作，某个流程实例挂起则此流程不再继续执行，完成该流程实例的当前任务将报异常。

/**
 * @Auther: kejizhentan
 * @Date 2022/6/1 16:32
 * @Description: 单个流程实例挂起与激活
 */
public class SuspendProcessInstance2 {
    public static void main(String[] args) {
        //1.得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //2.得到RuntimeService
        RuntimeService runtimeService = processEngine.getRuntimeService();
        //3.查询流程实例对象
        ProcessInstance processInstance = runtimeService.createProcessInstanceQuery()
                .processInstanceId("12501").singleResult();
        //4.得到当前流程定义的实例是否都为暂停状态
        boolean suspended = processInstance.isSuspended();
        //5. 获取实例id
        String processId = processInstance.getId();
        //6. 判断
        if(suspended){
            //说明是暂停，就可以激活操作
            runtimeService.activateProcessInstanceById(processId);
            System.out.println("流程："+processId+"激活");
        }else{
            runtimeService.suspendProcessInstanceById(processId);
            System.out.println("流程定义："+processId+"挂起");
        }
    }
}

六、个人任务

1. 分配任务负责人

⑴ 固定分配

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

在 properties 视图中，填写 Assignee 项为任务负责人。

注意事项:

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

⑵ 表达式分配

1) UEL 表达式

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

① `UEL-value` 定义如下：

assignee 这个变量是 activiti 的一个流程变量。
或

user 也是 activiti 的一个流程变量，user.assignee 表示通过调用 user 的 getter 方法获取值。
UEL-method 方式如下：

userBean 是 spring 容器中的一个 bean，表示调用该 bean 的 getUserId()方法。

③ `UEL-method` 与`UEL-value`结合

再比如：

${ldapService.findManagerForEmployee(emp)}

ldapService 是 spring 容器的一个 bean，findManagerForEmployee 是该 bean 的一个方法，emp 是 activiti流程变量，emp 作为参数传到 ldapService.findManagerForEmployee 方法中。

④ 其它

表达式支持解析基础类型、bean、list、array 和 map，也可作为条件判断。

如下：

${order.price > 100 && order.price < 250}

2) 使用流程变量分配任务

① 定义任务分配流程变量

② 设置流程变量

设置流程变量的前期准备：

绘制bpmn图，设置可变参数
将绘制的bpmn文件和png文件部署到数据库中

在启动流程实例时设置流程变量，如下：

//启动流程实例时设计流程变量
//定义流程变量
Map<String, Object> variables = new HashMap<String, Object>();
//设置流程变量assignee
variables.put("assignee", "张三");
ProcessInstance processInstance = runtimeService
	.startProcessInstanceByKey(processDefinitionKey, variables);

详细代码如下：

/**
 * @Auther: kejizhentan
 * @Date 2022/6/1 23:26
 * @Description: 启动流程实例动态设值
 */
public class AssigneeUEL {
    public static void main(String[] args) {
        //1.得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //2.得到RuntimeService对象
        RuntimeService runtimeService = processEngine.getRuntimeService();
        //3.设置assignee的取值   用户可以在界面上设置流程的执行人
        Map<String,Object> map = new HashMap<>();
        map.put("assignee0","zhangsan");
        map.put("assignee1","lisi");
        map.put("assignee2","wangwu");
        //4.启动流程实例，同时还要设置流程定义的assignee的值
        runtimeService.startProcessInstanceByKey("holiday2",map);
        //5.输出
        System.out.println(processEngine.getName());
    }
}

3)监听器分配

任务监听器是发生对应的任务相关事件时执行自定义 java 逻辑或表达式

任务相当事件包括：

Create：任务创建后触发
Assignment：任务分配后触发
Delete：任务完成后触发
All：所有事件发生都触发

java 逻辑或表达式：

表达式参考上边的介绍的 UEL 表达式，这里主要介绍监听类使用。

定义任务监听类，且类必须实现 org.activiti.engine.delegate.TaskListener 接口

public class MyTaskListener implements TaskListener {
	@Override
	public void notify(DelegateTask delegateTask) {
		//这里指定任务负责人
		delegateTask.setAssignee("张三");
	} 
}

注意事项:
使用监听器分配方式，按照监听事件去执行监听类的 notify 方法，方法如果不能正常执行也会影响任务的执行。

2. 查询任务

查询任务负责人的待办任务：

// 查询当前个人待执行的任务
@Test
public void findPersonalTaskList() {
	// 流程定义key
	String processDefinitionKey = "holiday";
	// 任务负责人
	String assignee = "张三丰";
	// 创建TaskService
	TaskService taskService = processEngine.getTaskService();
	List<Task> list = taskService.createTaskQuery()//
		.processDefinitionKey(processDefinitionKey)//
		.includeProcessVariables().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());
	} 
}

⑴ 关联 businessKey

需求：

在 activiti 实际应用时，查询待办任务可能要显示出业务系统的一些相关信息，比如：查询待审批请假单任务列表需要将请假单的日期、请假天数等信息显示出来，请假天数等信息在业务系统中存在，而并没有在 activiti 数据库中存在，所以是无法通过 activiti 的 api 查询到请假天数等信息。

实现：
在查询待办任务时，通过 businessKey（业务标识）关联查询业务系统的请假单表，查询出请假天数等信息。

⑵ 办理任务

指定任务 id，调用 TaskService 完成任务：

// 完成任务
@Test
public void completTask() {
	//任务id
	String taskId = "10305";
	// 创建TaskService
	TaskService taskService = processEngine.getTaskService();
	taskService.complete(taskId);
	System.out.println("完成任务");
}

注意：在实际应用中，完成任务前需要校验任务的负责人是否具有务的办理权限。

七、流程变量

1. 什么是流程变量

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

注意：

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

2. 流程变量类型

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

3. 流程变量作用域

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

如下图：

global 变量中变量名不允许重复，设置相同名称的变量，后设置的值会覆盖前设置的变量值。Local 变量由于在不同的任务或不同的执行实例中，作用域互不影响，变量名可以相同没有影响。Local 变量名也可以和 global 变量名相同，没有影响。

4. 流程变量的使用方法

⑴ 第一步：设置流程变量

⑵ 第二步：通过 UEL 表达式使用流程变量

1> 可以在 assignee 处设置 UEL 表达式，表达式的值为任务的负责人

比如：${assignee}，assignee 就是一个流程变量名称

Activiti 获取 UEL 表达式的值，即流程变量 assignee 的值，将 assignee 的值作为任务的负责人
进行任务分配

2> 可以在连线上设置 UEL 表达式，决定流程走向

比如：${price>=10000}和${price<10000}: price 就是一个流程变量名称，uel 表达式结果类型为
布尔类型

如果 UEL 表达式是 true，要决定流程执行走向。

⑶ 使用 Global 变量控制流程

1) 需求：

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

2) 启动流程时设置 global 流程变量的完整步骤

在启动流程时设置流程变量，变量的作用域是整个流程实例。
通过 map设置流程变量，map 中可以设置多个变量，这个 key 就是流程变量的名字。

① BPMN定义

② 创建pojo对象holiday

/**
 * 请假实体类:
 *    注意POJO类型，一定要实现Serializable接口，否则在存储这个pojo时就会报异常
 */
public class Holiday implements Serializable {
    private Integer id;
    private String holidayName;//申请人的名字
    private Date beginDate;//开始时间
    private Date endDate;//结束日期
    private Float num;//请假天数
    private String reason;//事由
    private String type;//请假类型

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getHolidayName() {
        return holidayName;
    }

    public void setHolidayName(String holidayName) {
        this.holidayName = holidayName;
    }

    public Date getBeginDate() {
        return beginDate;
    }

    public void setBeginDate(Date beginDate) {
        this.beginDate = beginDate;
    }

    public Date getEndDate() {
        return endDate;
    }

    public void setEndDate(Date endDate) {
        this.endDate = endDate;
    }

    public Float getNum() {
        return num;
    }

    public void setNum(Float num) {
        this.num = num;
    }

    public String getReason() {
        return reason;
    }

    public void setReason(String reason) {
        this.reason = reason;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }
}

③ 新的请假流程定义的部署

/**
 * @Auther: kejizhentan
 * @Date 2022/6/2 15:01
 * @Description:  新的请假流程定义的部署
 */
public class VariableDeployment {
    public static void main(String[] args) {
        //1.得到ProcessEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

        //2.得到RepositoryService对象
        RepositoryService repositoryService = processEngine.getRepositoryService();

        //3.部署
        Deployment deploy = repositoryService.createDeployment()
                .addClasspathResource("diagram/holiday3.bpmn")
                .addClasspathResource("diagram/holiday3.png")
                .name("请假流程-流程变量")
                .deploy();

        System.out.println(deploy.getId());
        System.out.println(deploy.getName());
    }
}

④ 启动流程实例，同时还要设置流程变量的值

/**
 * @Auther: kejizhentan
 * @Date 2022/6/2 15:07
 * @Description: 启动流程实例，同时还要设置流程变量的值 影响的表有 act_ge_bytearray 、act_ru_variable
 */
public class VariableStartInstance {
    public static void main(String[] args) {
        //1.得到ProcessEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

        //2.得到RuntimeService
        RuntimeService runtimeService =  processEngine.getRuntimeService();

        //3.流程定义的key问题   myProcess_1
        String key = "holiday3";
        Map<String ,Object> map = new HashMap<>();

        Holiday holiday = new Holiday();
        holiday.setNum(1F);
        map.put("holiday",holiday);

        //4.启动流程实例，并且设置流程变量的值
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(key, map);

        //5.输出实例信息
        System.out.println(processInstance.getName());
        System.out.println(processInstance.getProcessDefinitionId());

    }
}

说明：
startProcessInstanceByKey(processDefinitionKey,variables)流程变量作用域是一个流程实例，流程变量使用 Map 存储，同一个流程实例设置变量 map 中 key 相同，后者覆盖前者。

⑤ 完成任务

/**
 * @Auther: kejizhentan
 * @Date 2022/6/2 15:38
 * @Description: 完成任务  zhangsan  -----lishi----判断流程变量的请假天数,1天----分支：人事经理存档(zhaoliu)
 */
public class VariableCompleteTask {
    public static void main(String[] args) {
        //1.得到ProcessEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

        //2.得到TaskService
        TaskService taskService = processEngine.getTaskService();

        //3.查询当前用户是否有任务
        String key = "holiday3";
        Task task = taskService.createTaskQuery().processDefinitionKey(key)
                .taskAssignee("zhangsan").singleResult();

        //4.判断task!=null,说明当前用户有任务
        if (task != null) {
            taskService.complete(task.getId());
            System.out.println("任务执行完毕");
        }

    }
}

这个流程审批结果如下：

3) 任务办理时设置 global 流程变量的完整步骤

在完成任务时设置流程变量，该流程变量只有在该任务完成后其它结点才可使用该变量，它的作用域是整个流程实例，如果设置的流程变量的 key 在流程实例中已存在相同的名字则后设置的变量替换前边设置的变量。

① BPMN定义

② 创建pojo对象holiday

/**
 * 请假实体类:
 *    注意POJO类型，一定要实现Serializable接口，否则在存储这个pojo时就会报异常
 */
public class Holiday implements Serializable {
    private Integer id;
    private String holidayName;//申请人的名字
    private Date beginDate;//开始时间
    private Date endDate;//结束日期
    private Float num;//请假天数
    private String reason;//事由
    private String type;//请假类型

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getHolidayName() {
        return holidayName;
    }

    public void setHolidayName(String holidayName) {
        this.holidayName = holidayName;
    }

    public Date getBeginDate() {
        return beginDate;
    }

    public void setBeginDate(Date beginDate) {
        this.beginDate = beginDate;
    }

    public Date getEndDate() {
        return endDate;
    }

    public void setEndDate(Date endDate) {
        this.endDate = endDate;
    }

    public Float getNum() {
        return num;
    }

    public void setNum(Float num) {
        this.num = num;
    }

    public String getReason() {
        return reason;
    }

    public void setReason(String reason) {
        this.reason = reason;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }
}

③ 新的请假流程定义的部署

/**
 * @Auther: kejizhentan
 * @Date 2022/6/2 15:01
 * @Description:  新的请假流程定义的部署
 */
public class VariableDeployment {
    public static void main(String[] args) {
        //1.得到ProcessEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

        //2.得到RepositoryService对象
        RepositoryService repositoryService = processEngine.getRepositoryService();

        //3.部署
        Deployment deploy = repositoryService.createDeployment()
                .addClasspathResource("diagram/holiday3.bpmn")
                .addClasspathResource("diagram/holiday3.png")
                .name("请假流程-流程变量")
                .deploy();

        System.out.println(deploy.getId());
        System.out.println(deploy.getName());
    }
}

④ 启动流程实例

/**
 * @Auther: kejizhentan
 * @Date 2022/6/2 15:07
 * @Description: 启动流程实例
 */
public class VariableStartInstance {
    public static void main(String[] args) {
        //1.得到ProcessEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

        //2.得到RuntimeService
        RuntimeService runtimeService =  processEngine.getRuntimeService();

        //3.流程定义的key问题   holiday3
        String key = "holiday3";
        //4.启动流程实例，并且设置流程变量的值
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(key);

        //5.输出实例信息
        System.out.println(processInstance.getName());
        System.out.println(processInstance.getProcessDefinitionId());

    }
}

⑤ 完成任务时，设置流程变量的值

/**
 * @Auther: kejizhentan
 * @Date 2022/6/2 15:38
 * @Description: 完成任务时，设置流程变量的值  zhangsan  -----lisi----判断流程变量的请假天数,1天----分支：人事经理存档(zhaoliu)
 */
public class VariableCompleteTask {
    //完成任务  zhangsan  -----lisi----判断流程变量的请假天数,1天----分支：人事经理存档(zhaoliu)
    public static void main(String[] args) {
        //1.得到ProcessEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

        //2.得到TaskService
        TaskService taskService = processEngine.getTaskService();

        //3.查询当前用户是否有任务
        String key = "holiday3";
        Task task = taskService.createTaskQuery().processDefinitionKey(key)
                .taskAssignee("zhangsan").singleResult();

        //初始化一些参数
        Map<String, Object> map = new HashMap<>();

        Holiday holiday = new Holiday();
        holiday.setNum(1F);
        map.put("holiday", holiday);

        //4.判断task!=null,说明当前用户有任务
        if (task != null) {
            taskService.complete(task.getId(), map);//完成任务时，设置流程变量的值
            System.out.println("任务执行完毕");
        }
    }
}

说明：
通过当前任务设置流程变量，需要指定当前任务 id，如果当前执行的任务 id 不存在则抛出异常。任务办理时也是通过 map设置流程变量，一次可以设置多个变量。

4) 通过当前流程实例设置global 流程变量的完整步骤

通过流程实例 id 设置全局变量，该流程实例必须未执行完成。

① BPMN定义

② 创建pojo对象holiday

/**
 * 请假实体类:
 *    注意POJO类型，一定要实现Serializable接口，否则在存储这个pojo时就会报异常
 */
public class Holiday implements Serializable {
    private Integer id;
    private String holidayName;//申请人的名字
    private Date beginDate;//开始时间
    private Date endDate;//结束日期
    private Float num;//请假天数
    private String reason;//事由
    private String type;//请假类型

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getHolidayName() {
        return holidayName;
    }

    public void setHolidayName(String holidayName) {
        this.holidayName = holidayName;
    }

    public Date getBeginDate() {
        return beginDate;
    }

    public void setBeginDate(Date beginDate) {
        this.beginDate = beginDate;
    }

    public Date getEndDate() {
        return endDate;
    }

    public void setEndDate(Date endDate) {
        this.endDate = endDate;
    }

    public Float getNum() {
        return num;
    }

    public void setNum(Float num) {
        this.num = num;
    }

    public String getReason() {
        return reason;
    }

    public void setReason(String reason) {
        this.reason = reason;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }
}

③ 新的请假流程定义的部署

/**
 * @Auther: kejizhentan
 * @Date 2022/6/2 15:01
 * @Description:  新的请假流程定义的部署
 */
public class VariableDeployment {
    public static void main(String[] args) {
        //1.得到ProcessEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

        //2.得到RepositoryService对象
        RepositoryService repositoryService = processEngine.getRepositoryService();

        //3.部署
        Deployment deploy = repositoryService.createDeployment()
                .addClasspathResource("diagram/holiday3.bpmn")
                .addClasspathResource("diagram/holiday3.png")
                .name("请假流程-流程变量")
                .deploy();

        System.out.println(deploy.getId());
        System.out.println(deploy.getName());
    }
}

④ 启动流程实例

/**
 * @Auther: kejizhentan
 * @Date 2022/6/2 15:07
 * @Description: 启动流程实例
 */
public class VariableStartInstance {
    public static void main(String[] args) {
        //1.得到ProcessEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

        //2.得到RuntimeService
        RuntimeService runtimeService =  processEngine.getRuntimeService();

        //3.流程定义的key问题   holiday3
        String key = "holiday3";
        //4.启动流程实例，并且设置流程变量的值
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(key);

        //5.输出实例信息
        System.out.println(processInstance.getName());
        System.out.println(processInstance.getProcessDefinitionId());
        System.out.println(processInstance.getId());

    }
}

⑤ 通过流程实例id，来测试流程变量

/**
 * @Auther: kejizhentan
 * @Date 2022/6/2 17:29
 * @Description: 新加入的：通过流程实例id，来测试流程变量
 */
public class VariableCreateById {
    public static void main(String[] args) {
        //1.得到ProcessEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

        //2.得到RuntimeService
        RuntimeService runtimeService =  processEngine.getRuntimeService();

        //3.流程定义的key问题   myProcess_1

        Holiday holiday = new Holiday();
        holiday.setNum(1F);

        //4.通过实例id,来设置流程变量
        //第一个参数：流程实例的id
        //第二个参数：流程变量名
        //第三个变量：流程变量名，所对应的值
        runtimeService.setVariable("2501","holiday",holiday);
        //一次设置多个值
		//runtimeService.setVariables(executionId, variables)
    }
}

注意：
executionId 必须当前未结束流程实例的执行 id，通常此 id 设置流程实例的 id。也可以通过runtimeService.getVariable()获取流程变量

⑥ 完成任务

/**
 * @Auther: kejizhentan
 * @Date 2022/6/2 15:38
 * @Description: 完成任务  zhangsan  -----lisi----判断流程变量的请假天数,1天----分支：人事经理存档(zhaoliu)
 */
public class VariableCompleteTask {
    public static void main(String[] args) {
        //1.得到ProcessEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

        //2.得到TaskService
        TaskService taskService = processEngine.getTaskService();

        //3.查询当前用户是否有任务
        String key = "holiday3";
        Task task = taskService.createTaskQuery().processDefinitionKey(key)
                .taskAssignee("lisi").singleResult();

        //4.判断task!=null,说明当前用户有任务
        if (task != null) {
            taskService.complete(task.getId());
            System.out.println("任务执行完毕");
        }

    }
}

5) 通过当前任务设置global 流程变量的完整步骤

@Test
public void setGlobalVariableByTaskId(){
	//当前待办任务id
	String taskId="1404";
	TaskService taskService = processEngine.getTaskService();
	Holiday holiday = new Holiday();
	holiday.setNum(3);
	//通过任务设置流程变量
	taskService.setVariable(taskId, "holiday", holiday);
	//一次设置多个值
	//taskService.setVariables(taskId, variables)
}

注意：

任务id必须是当前待办任务id，act_ru_task中存在。如果该任务已结束，报错：

也可以通过 taskService.getVariable()获取流程变量。

6) 注意事项

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

7) 操作数据库表

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

SELECT * FROM act_ru_variable 当前流程变量表
记录当前运行流程实例可使用的流程变量，包括 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 类型变量值

SELECT * FROM act_hi_varinst 历史流程变量表
记录所有已创建的流程变量，包括 global 和 local 变量
字段意义参考当前流程变量表。

⑷ 设置 local 流程变量

1) 任务办理时设置

任务办理时设置 local 流程变量，当前运行的流程实例只能在该任务结束前使用，任务结束该变量无法在当前流程实例使用，可以通过查询历史任务查询。

// 办理任务时设置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);
}

说明：
设置作用域为任务的 local 变量，每个任务可以设置同名的变量，互不影响。

2) 通过当前任务设置

@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)
}

注意：
任务 id 必须是当前待办任务 id，act_ru_task 中存在。

3) Local 变量测试 1

如果上边例子中设置 global 变量改为设置 local变量是否可行？为什么？
Local 变量在任务结束后无法在当前流程实例执行中使用，如果后续的流程执行需要用到此变量则会报错。

4) Local 变量测试 2

在部门经理审核、总经理审核、人事经理审核时设置 local 变量，可通过 historyService 查询每个历史任务时将流程变量的值也查询出来。

代码如下：

// 创建历史任务查询对象
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());
}

注意：
查询历史流程变量，特别是查询 pojo 变量需要经过反序列化，不推荐使用。

八、组任务

1. Candidate-users 候选人

⑴ 需求

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

1) 设置任务候选人

在流程图中任务节点的配置中设置 candidate-users(候选人)，多个候选人之间用逗号分开。

查看 bpmn 文件：

我们可以看到部门经理的审核人已经设置为 zhangsan,lishi 这样的一组候选人，可以使用activiti:candiateUsers=”用户 1,用户 2,用户 3”的这种方式来实现设置一组候选人。

2) 办理组任务

① 组任务办理流程

第一步：查询组任务

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

第二步：拾取(claim)任务

该组任务的所有候选人都能拾取。
将候选人的组任务，变成个人任务。原来候选人就变成了该任务的负责人。

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

第三步：查询个人任务

查询方式同个人任务部分，根据 assignee 查询用户负责的个人任务。

第四步：办理个人任务

3) 组任务完整实现过程

① 创建pbmn文件，设置任务候选人

② 新的请假流程定义的部署

/**
 * @Auther: kejizhentan
 * @Date 2022/6/2 23:04
 * @Description:  新的请假流程定义的部署
 */
public class GroupDeployment {
    public static void main(String[] args) {
        //1.得到ProcessEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

        //2.得到RepositoryService对象
        RepositoryService repositoryService = processEngine.getRepositoryService();

        //3.部署
        Deployment deploy = repositoryService.createDeployment()
                .addClasspathResource("diagram/holiday4.bpmn")
                .addClasspathResource("diagram/holiday4.png")
                .name("请假流程-组任务")
                .deploy();

        System.out.println(deploy.getId());
        System.out.println(deploy.getName());
    }
}

③ 启动流程实例

/**
 * @Auther: kejizhentan
 * @Date 2022/6/2 23:37
 * @Description: 启动流程实例
 */
public class GroupStartInstance {
    public static void main(String[] args) {
        //1.得到ProcessEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

        //2.得到RuntimeService
        RuntimeService runtimeService =  processEngine.getRuntimeService();

        //3.流程定义的key问题   holiday4
        String key = "holiday4";
        //4.启动流程实例，并且设置流程变量的值
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(key);

        //5.输出实例信息
        System.out.println(processInstance.getName());
        System.out.println(processInstance.getProcessDefinitionId());
        System.out.println(processInstance.getId());

    }
}

④ 完成任务

/**
 * @Auther: kejizhentan
 * @Date 2022/6/2 23:47
 * @Description: 完成任务  
 */
public class GroupCompleteTask {
    public static void main(String[] args) {
        //1.得到ProcessEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

        //2.得到TaskService
        TaskService taskService = processEngine.getTaskService();

        //3.查询当前用户是否有任务
        String key = "holiday4";
        Task task = taskService.createTaskQuery().processDefinitionKey(key)
                .taskAssignee("xiaozhang").singleResult();

        //4.判断task!=null,说明当前用户有任务
        if (task != null) {
            taskService.complete(task.getId());
            System.out.println("任务执行完毕");
        }
    }
}

执行完填写请假单任务之后：

⑤ 查询候选用户的组任务

/**
 * @Auther: kejizhentan
 * @Date 2022/6/3 0:03
 * @Description: 查询候选用户的组任务
 */
public class GropTaskQuery {
    public static void main(String[] args) {
        //1.得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

        //2.得到TaskService对象
        TaskService taskService = processEngine.getTaskService();

        //3.设置一些参数，流程定义的key,候选用户
        String key = "holiday4";
        String candidate_users="zhangsan";

        //4.执行查询
        List<Task> list = taskService.createTaskQuery()
                .processDefinitionKey(key)
                .taskCandidateUser(candidate_users)//设置候选用户
                .list();
        //5.输出
        for(Task task :list){
            System.out.println(task.getProcessInstanceId());
            System.out.println(task.getId());
            System.out.println(task.getName());
            System.out.println(task.getAssignee());//为null，说明当前的zhangsan只是一个候选人，并不是任务的执行人
        }
    }
}

⑥ 拾取组任务

候选人员拾取组任务后该任务变为自己的个人任务

/**
 * @Auther: kejizhentan
 * @Date 2022/6/3 17:20
 * @Description: 测试zhangsan用户，来拾取组任务（抽取任务的过程就是将候选用户转化为真正任务的负责人（让任务的assignee有值））
 */
public class GroupCliam {
    public static void main(String[] args) {
        //1.得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //2.得到TaskService对象
        TaskService taskService = processEngine.getTaskService();
        //3.设置一些参数，流程定义的key,候选用户
        String key = "holiday4";
        String candidate_users="zhangsan";
        //4.执行查询
        Task task = taskService.createTaskQuery()
                .processDefinitionKey(key)
                .taskCandidateUser(candidate_users)//设置候选用户
                .singleResult();
        if(task != null){
            taskService.claim(task.getId(),candidate_users);//第一个参数任务ID,第二个参数为具体的候选用户名
            System.out.println("任务拾取完成");
        }
    }
}

说明：
即使该用户不是候选人也能拾取，建议拾取时校验是否有资格
组任务拾取后，该任务已有负责人，通过候选人将查询不到该任务

⑦ 用户查询个人待办任务

查询方式同个人任务查询

/**
 * @Auther: kejizhentan
 * @Date 2022/6/3 17:53
 * @Description:当前的用户查询自己的任务
 */
public class GroupAssigneeTaskQuery {
    public static void main(String[] args) {
        //1.得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

        //2.得到TaskService对象
        TaskService taskService = processEngine.getTaskService();

        //3.设置一些参数，流程定义的key,用户
        String key = "holiday4";
        String assignee="zhangsan";

        //4.执行查询
        List<Task> list = taskService.createTaskQuery()
                .processDefinitionKey(key)
                .taskAssignee(assignee)  //设置任务的负责人
                .list();
        //5.输出
        for(Task task :list){
            System.out.println(task.getProcessInstanceId());
            System.out.println(task.getId());
            System.out.println(task.getName());
            System.out.println(task.getAssignee());//任务的执行人
        }
    }
}

⑧ 用户完成个人任务

/**
 * @Auther: kejizhentan
 * @Date 2022/6/2 23:47
 * @Description: 当前用户完成自己的任务
 */
public class GroupCompleteTask {
    public static void main(String[] args) {
        //1.得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

        //2.得到TaskService对象
        TaskService taskService = processEngine.getTaskService();

        //3.设置一些参数，流程定义的key,用户
        String key = "holiday4";
        String assignee="zhangsan";

        //4.执行查询
        Task task = taskService.createTaskQuery()
                .processDefinitionKey(key)
                .taskAssignee(assignee)  //设置任务的负责人
                .singleResult();
        //5.执行当前的任务
        if(task!=null){
            taskService.complete(task.getId());
            System.out.println("任务执行完毕!");
        }
    }
}

⑨ 归还组任务

如果个人不想办理该组任务，可以归还组任务，归还后该用户不再是该任务的负责人

/**
 * @Auther: kejizhentan
 * @Date 2022/6/3 18:12
 * @Description: 归还组任务
 */
public class GroupTaskReturn {
    public static void main(String[] args) {
        //1.得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //2.得到TaskService对象
        TaskService taskService = processEngine.getTaskService();
        //3.设置一些参数，流程定义的key,任务负责人
        String key = "holiday4";
        String userId="zhangsan";
        //4.校验userId是否是taskId的负责人，如果是负责人才可以归还组任务
        Task task = taskService.createTaskQuery()
                .processDefinitionKey(key)
                .taskAssignee(userId)//设置候选用户
                .singleResult();
        if(task != null){
            taskService.claim(task.getId(),null);// 如果设置为null，归还组任务,该 任务没有负责人
            System.out.println("归还组任务成功");
        }
    }
}

说明：
建议归还任务前校验该用户是否是该任务的负责人
也可以通过 setAssignee 方法将任务委托给其它用户负责，注意被委托的用户可以不是候选人（建议不要这样使用）

⑩ 任务交接

任务交接,任务负责人将任务交给其它候选人办理该任务

/**
 * @Auther: kejizhentan
 * @Date 2022/6/3 19:01
 * @Description: 任务交接，前提要保证当前用户是这个任务的负责人，这时候他才可以有权限去将任务交接给其他候选人
 */
public class GroupTaskHandover {
    public static void main(String[] args) {
        //1.得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

        //2.得到TaskService对象
        TaskService taskService = processEngine.getTaskService();

        //3.设置一些参数，流程定义的key,用户
        String key = "holiday4";
        String assignee = "lisi";

        //4.执行查询
        Task task = taskService.createTaskQuery()
                .processDefinitionKey(key)
                .taskAssignee(assignee)  //设置任务的负责人
                .singleResult();
        //5.判断是否有这个任务
        if (task != null) {
            taskService.setAssignee(task.getId(), "zhangsan");//交接任务为zhangsan  ,交接任务就是一个候选人拾取用户的过程
            System.out.println("交接任务完成~!");
        }
    }
}

4) 数据库表操作

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

SELECT * FROM act_ru_identitylink 任务参与者，记录当前参考任务用户或组，当前任务如果设置了候选人，会向该表插入候选人记录，有几个候选就插入几个

于 act_ru_identitylink 对应的还有一张历史表 act_hi_identitylink，向 act_ru_identitylink 插入记录的同时也会向历史表插入记录。任务完成

九、网关

1. 排他网关

⑴ 什么是排他网关

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

为什么要用排他网关：
不用排他网关也可以实现分支，如下图：

上图中，在连线的 condition 条件上设置分支条件，正常情况下没啥问题。

非正常情况下：

上图中，在连线的 condition 条件上设置分支条件，如果请假天数是5，两个分支都满足就会出现流程混乱的情况。

⑵ 排他网关演示的完整过程

1) 流程定义bpmb图绘制

2) 完整代码演示

① 排他网关部署流程定义

/**
 * @Auther: kejizhentan
 * @Date 2022/6/4 0:00
 * @Description: 排他网关部署流程定义
 */
public class ExclusiveGateWayDeployment {
    public static void main(String[] args) {
        //1.创建ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

        //2.得到RepositoryService实例
        RepositoryService repositoryService = processEngine.getRepositoryService();

        //3.进行部署
        Deployment deployment = repositoryService.createDeployment()
                .addClasspathResource("diagram/holiday5.bpmn")  //添加bpmn资源
                .addClasspathResource("diagram/holiday5.png")
                .name("请假申请单流程")
                .deploy();

        //4.输出部署的一些信息
        System.out.println(deployment.getName());
        System.out.println(deployment.getId());
    }
}

② 创建pojo对象holiday

/**
 * 请假实体类:
 *    注意POJO类型，一定要实现Serializable接口，否则在存储这个pojo时就会报异常
 */
public class Holiday implements Serializable {
    private Integer id;
    private String holidayName;//申请人的名字
    private Date beginDate;//开始时间
    private Date endDate;//结束日期
    private Float num;//请假天数
    private String reason;//事由
    private String type;//请假类型

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getHolidayName() {
        return holidayName;
    }

    public void setHolidayName(String holidayName) {
        this.holidayName = holidayName;
    }

    public Date getBeginDate() {
        return beginDate;
    }

    public void setBeginDate(Date beginDate) {
        this.beginDate = beginDate;
    }

    public Date getEndDate() {
        return endDate;
    }

    public void setEndDate(Date endDate) {
        this.endDate = endDate;
    }

    public Float getNum() {
        return num;
    }

    public void setNum(Float num) {
        this.num = num;
    }

    public String getReason() {
        return reason;
    }

    public void setReason(String reason) {
        this.reason = reason;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }
}

③ 启动流程实例

启动流程实例的时候设置请假日期为5，使两个分支条件同时满足

/**
 * @Auther: kejizhentan
 * @Date 2022/6/4 0:08
 * @Description:启动流程实例 设置请假日期为5，使两个分支条件同时满足
 */
public class ExclusiveGateWayStartInstance {
    public static void main(String[] args) {
        //1.得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

        //2.得到RunService对象
        RuntimeService runtimeService = processEngine.getRuntimeService();

        Holiday holiday = new Holiday();
        holiday.setNum(5F);
        Map<String,Object> map = new HashMap<>();
        map.put("holiday",holiday);//流程变量赋值

        //3.创建流程实例  流程定义的key需要知道 holiday
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("holidayExclusive1",map);


        //4.输出实例的相关信息
        System.out.println("流程定义ID"+processInstance.getProcessDefinitionId());//holiday:1:4
        System.out.println("流程实例ID"+processInstance.getId());//2501
    }
}

④ 依次完成请假流程任务

/**
 * @Auther: kejizhentan
 * @Date 2022/6/4 0:15
 * @Description: 依次完成请假流程任务
 */
public class ExclusiveGateWayCompleteTask {
    public static void main(String[] args) {
        //1.得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

        //2.得到TaskService对象
        TaskService taskService = processEngine.getTaskService();

        //3.查询当前用户的任务
        Task task = taskService.createTaskQuery()
                .processDefinitionKey("holidayExclusive1")
                .taskAssignee("lisi")
                .singleResult();

        //4.处理任务,结合当前用户任务列表的查询操作的话,任务ID:task.getId()
        if(task!=null){
            taskService.complete(task.getId());
            System.out.println("用户任务执行完毕...");
        }
        //5.输出任务的id
        System.out.println(task.getId());
    }
}

当lisi执行完之后我们发现流程直接来到了总经理wangwu这里，人事经理zhaoliu这个分支并没有走。这样就实现了排他网关的功能（排他网关只会选择一个为 true 的分支执行）

注意：

当好几个分总都满足条件的时候，排他网关默认会走id小的分支

因为总经理分支的id小，所有只走总经理的分支

如果从网关出去的线所有条件都不满足则系统抛出异常

说明：经过排他网关必须要有一条且只有一条分支走

2. 并行网关

⑴ 什么是并行网关

并行网关允许将流程分成多条分支，也可以把多条分支汇聚到一起，并行网关的功能是基于进入和外出顺序流的：
● fork 分支：
并行后的所有外出顺序流，为每个顺序流都创建一个并发分支。
● join 汇聚：
所有到达并行网关，在此等待的进入分支，直到所有进入顺序流的分支都到达以后，流程就会通过汇聚网关。

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

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

例子：

说明：
财务会计和行政考勤是两个 execution 分支，在 act_ru_execution 表有两条记录分别是财务会计和行政考勤,act_ru_execution 还有一条记录表示该流程实例。
财务会计和行政考勤全部完成，在汇聚点汇聚，通过 parallelGateway 并行网关。
并行网关在业务应用中常用于会签任务，会签任务即多个参与者共同办理的任务。

⑵ 并行网关演示的完整过程

1) 流程定义bpmb图绘制

2) 完整代码演示

① 并行网关部署流程定义

/**
 * @Auther: kejizhentan
 * @Date 2022/6/4 11:35
 * @Description: 部署流程定义  带排他网关，同时还带并行网关
 */
public class ParallelGateWayDeployment {
    public static void main(String[] args) {
        //1.创建ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

        //2.得到RepositoryService实例
        RepositoryService repositoryService = processEngine.getRepositoryService();

        //3.进行部署
        Deployment deployment = repositoryService.createDeployment()
                .addClasspathResource("diagram/holiday6.bpmn")  //添加bpmn资源
                .addClasspathResource("diagram/holiday6.png")
                .name("请假申请单流程")
                .deploy();

        //4.输出部署的一些信息
        System.out.println(deployment.getName());
        System.out.println(deployment.getId());
    }
}

② 创建pojo对象holiday

/**
 * 请假实体类:
 *    注意POJO类型，一定要实现Serializable接口，否则在存储这个pojo时就会报异常
 */
public class Holiday implements Serializable {
    private Integer id;
    private String holidayName;//申请人的名字
    private Date beginDate;//开始时间
    private Date endDate;//结束日期
    private Float num;//请假天数
    private String reason;//事由
    private String type;//请假类型

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getHolidayName() {
        return holidayName;
    }

    public void setHolidayName(String holidayName) {
        this.holidayName = holidayName;
    }

    public Date getBeginDate() {
        return beginDate;
    }

    public void setBeginDate(Date beginDate) {
        this.beginDate = beginDate;
    }

    public Date getEndDate() {
        return endDate;
    }

    public void setEndDate(Date endDate) {
        this.endDate = endDate;
    }

    public Float getNum() {
        return num;
    }

    public void setNum(Float num) {
        this.num = num;
    }

    public String getReason() {
        return reason;
    }

    public void setReason(String reason) {
        this.reason = reason;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }
}

③ 启动流程实例

/**
 * @Auther: kejizhentan
 * @Date 2022/6/4 11:44
 * @Description:启动流程实例
 */
public class ParallelGateWayStartInstance {
    public static void main(String[] args) {
        //1.得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

        //2.得到RunService对象
        RuntimeService runtimeService = processEngine.getRuntimeService();

        Holiday holiday = new Holiday();
        holiday.setNum(5F);
        Map<String,Object> map = new HashMap<>();
        map.put("holiday",holiday);//流程变量赋值

        //3.创建流程实例  流程定义的key需要知道 holiday
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("holidayParallel",map);


        //4.输出实例的相关信息
        System.out.println("流程定义ID"+processInstance.getProcessDefinitionId());//holiday:1:4
        System.out.println("流程实例ID"+processInstance.getId());//2501
    }
}

④ 依次完成请假流程任务

/**
 * @Auther: kejizhentan
 * @Date 2022/6/4 11:56
 * @Description: 依次完成并行网关中的任务
 */
public class ParallelGateWayCompleteTask {
    public static void main(String[] args) {
        //1.得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

        //2.得到TaskService对象
        TaskService taskService = processEngine.getTaskService();

        //3.查询当前用户的任务
        Task task = taskService.createTaskQuery()
                .processDefinitionKey("holidayParallel")
                .taskAssignee("zhaoliu")
                .singleResult();

        //4.处理任务,结合当前用户任务列表的查询操作的话,任务ID:task.getId()
        if(task!=null){
            taskService.complete(task.getId());
            System.out.println("用户任务执行完毕...");
        }
    }
}

整个流程过程如下：

3) 当执行到并行网关数据库跟踪如下

当前任务表：SELECT * FROM act_ru_task 当前任务表

上图中：有两个(多个)任务当前执行。

通过流程实例执行表：SELECT * FROM act_ru_execution 流程实例的执行表

上图中，说明当前流程实例有多个分支(两个)在运行。

对并行任务的执行：
并行任务执行不分前后，由任务的负责人去执行即可。

当完成并任务中一个任务后：
已完成的任务在当前任务表 act_ru_task_已被删除。
在流程实例执行表：SELECT * FROM act_ru_execution 有中多个分支存在且有并行网关的汇聚结点。

有并行网关的汇聚结点：说明有一个分支已经到汇聚，等待其它的分支到达。

当所有分支任务都完成，都到达汇聚结点后：
流程实例执行表：SELECT * FROM act_ru_execution，执行流程实例不存在，说明流程执行结束。

总结：所有分支到达汇聚结点，并行网关执行完成。

3. 包含网关

⑴ 什么是包含网关

包含网关可以看做是排他网关和并行网关的结合体。和排他网关一样，你可以在外出顺序流上定义条件，包含网关会解析它们。但是主要的区别是包含网关可以选择多于一条顺序流，这和并行网关一样。
包含网关的功能是基于进入和外出顺序流的：
● 分支：
所有外出顺序流的条件都会被解析，结果为 true 的顺序流会以并行方式继续执行，会为每个顺序流创建一个分支。
●汇聚：
所有并行分支到达包含网关，会进入等待状态，直到每个包含流程 token 的进入顺序流的分支都到达。这是与并行网关的最大不同。换句话说，包含网关只会等待被选中执行了的进入顺序流。在汇聚之后，流程会穿过包含网关继续执行。

⑵ 包含网关演示的完整过程

1) 流程定义bpmb图绘制

2) 完整代码演示

① 包含网关部署流程定义

/**
 * @Auther: kejizhentan
 * @Date 2022/6/4 16:46
 * @Description:部署包含网关流程定义(带排他网关，同时还带并行网关)
 */
public class InclusiveGateWayDeployment {
    public static void main(String[] args) {
        //1.创建ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

        //2.得到RepositoryService实例
        RepositoryService repositoryService = processEngine.getRepositoryService();

        //3.进行部署
        Deployment deployment = repositoryService.createDeployment()
                .addClasspathResource("diagram/examine.bpmn")  //添加bpmn资源
                .addClasspathResource("diagram/examine.png")
                .name("体检流程")
                .deploy();

        //4.输出部署的一些信息
        System.out.println(deployment.getName());
        System.out.println(deployment.getId());
    }
}

② 创建pojo对象holiday

/**
 * 请假实体类:
 *    注意POJO类型，一定要实现Serializable接口，否则在存储这个pojo时就会报异常
 */
public class Holiday implements Serializable {
    private Integer id;
    private String holidayName;//申请人的名字
    private Date beginDate;//开始时间
    private Date endDate;//结束日期
    private Float num;//请假天数
    private String reason;//事由
    private String type;//请假类型

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getHolidayName() {
        return holidayName;
    }

    public void setHolidayName(String holidayName) {
        this.holidayName = holidayName;
    }

    public Date getBeginDate() {
        return beginDate;
    }

    public void setBeginDate(Date beginDate) {
        this.beginDate = beginDate;
    }

    public Date getEndDate() {
        return endDate;
    }

    public void setEndDate(Date endDate) {
        this.endDate = endDate;
    }

    public Float getNum() {
        return num;
    }

    public void setNum(Float num) {
        this.num = num;
    }

    public String getReason() {
        return reason;
    }

    public void setReason(String reason) {
        this.reason = reason;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }
}

③ 启动流程实例

/**
 * @Auther: kejizhentan
 * @Date 2022/6/4 16:50
 * @Description:启动流程实例
 */
public class InclusiveGateWayStartInstance {
    public static void main(String[] args) {
        //1.得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

        //2.得到RunService对象
        RuntimeService runtimeService = processEngine.getRuntimeService();

        Integer userType = 2;//代表管理者
        Map<String,Object> map = new HashMap<>();
        map.put("userType",userType);//流程变量赋值

        //3.创建流程实例  流程定义的key需要知道 holiday
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("examine",map);


        //4.输出实例的相关信息
        System.out.println("流程定义ID"+processInstance.getProcessDefinitionId());//holiday:1:4
        System.out.println("流程实例ID"+processInstance.getId());//2501
    }
}

④ 依次完成体检单审批流程任务

/**
 * @Auther: kejizhentan
 * @Date 2022/6/4 17:04
 * @Description: 任务执行完成
 */
public class InclusiveGateWayCompleteTask {
    public static void main(String[] args) {
        //1.得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

        //2.得到TaskService对象
        TaskService taskService = processEngine.getTaskService();

        //3.查询当前用户的任务
        Task task = taskService.createTaskQuery()
                .processDefinitionKey("examine")
                .taskAssignee("zhangsan")
                .singleResult();

        //4.处理任务,结合当前用户任务列表的查询操作的话,任务ID:task.getId()
        if(task!=null){
            taskService.complete(task.getId());
            System.out.println("用户任务执行完毕...");
        }


        //5.输出任务的id
        System.out.println(task.getId());
    }
}

整个流程过程如下：

注意：

如果userType==1,那只有申请体检单、常规体检项目、抽血化验、早餐四个流程节点

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

3) 当执行到包含网关数据库跟踪如下

流程实例执行表：SELECT * FROM act_ru_execution

第一条记录：包含网关分支。
后两条记录：两个分支：常规项体检，抽血化验

当前任务表：ACT_RU_TASK_

上图中，常规项体检，抽血化验都是当前的任务，在并行执行。

如果有一个分支执行到汇聚：

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

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

完整演示代码如下：https://kejizhentan.lanzouj.com/izlY305x0xtg

十、课程总结

什么是工作流？
就是通过计算机对业务流程进行自动化管理，实现多个参与者按照预定义的流程去自动执行业务流程。

什么 activiti？
Activiti 是一个工作流的引擎，开源的架构，基本 bpmn2.0 标准进行流程定义，它的是前身是 jbpm。Activiti 通过是要嵌入到业务系统开发使用。

如何使用 activiti 开发？
 第一步：部署 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 方法拾取任务，拾取任务之后组任务就变成了个人任务（该任务就有负责人）。

网关：
排他网关：任务执行之后的分支，经过排他网关分支只有一条有效。
并行网关：任务执行后，可以多条分支，多条分支总会汇聚，汇聚完成，并行网关结束。
包含网关：是排他网关和并行网关结合体。

十一、 Activiti 与 Spring 整合开发

1. Activiti 与 Spring 整合的配置

⑴ 项目结构如下

⑵ 引入 pom.xml 坐标，如下

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.kejizhentan</groupId>
    <artifactId>spring-activiti-project</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <slf4j.version>1.6.6</slf4j.version>
        <log4j.version>1.2.12</log4j.version>
    </properties>
    <dependencies>
    <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>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.0.7.RELEASE</version>
    </dependency>
    <!-- log start -->
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>${log4j.version}</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>${slf4j.version}</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>${slf4j.version}</version>
    </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-nop</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <!-- log end -->
        <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>
    </dependencies>
    <repositories>
        <repository>
            <id>alfresco</id>
            <name>Activiti Releases</name>

            <url>https://artifacts.alfresco.com/nexus/content/repositories/activiti-releases/</url>
            <releases>
                <enabled>true</enabled>
            </releases>
        </repository>
    </repositories>
</project>

我们除了使用 StandaloneProcessEngineConfiguration 来创建 ProcessEngine 流程引擎对象。还可以通过 org.activiti.spring.SpringProcessEngineConfiguration 与 Spring 整合方式来创建ProcessEngine 对象。

⑶ 创建 spring 与 activiti 的整合配置文件：`activiti-spring.xml`（名称不固定）

<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"
       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/context
 http://www.springframework.org/schema/context/spring-context.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.kejizhentan.service.impl.*.*(..))"/>
    </aop:config>
</beans>

⑷ 测试 Activiti 与 Spring 整合

/**
 *测试 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);
    }
}

效果如下：

同时创建了25张表

2. Activiti 与 Spring 整合执行流程分析

下面我们一起来分析 Activiti 与 Spring 整合加载的过程。如下图所示：

从图中我们可以看出，首先我们加载 activiti-spring.xml 配置文件，而该配置文件中又会加载SpringProcessEngineConfiguration 对象，这个对象它需要依赖注入 dataSource 对象和transactionManager 对象。其次会加载 ProcessEngineFactoryBean 工厂来创建 ProcessEngine 对象而ProcessEngineFactoryBean 工厂又需要依赖注入 processEngineConfiguration 对象。最后由processEngine 对象来负责创建我们的 Service 对象，从而简化 Activiti 的开发过程。在程序代码中我们可以根据实际需求来决定使用的 Service 对象。

十二、 Activiti7 现状分析

1. Activiti7 基本介绍

Alfresco 软件在 2010 年 5 月 17 日宣布 Activiti 业务流程管理（BPM）开源项目的正式启动，其首席架构师由业务流程管理 BPM 的专家 Tom Baeyens 担任，Tom Baeyens 就是原来 jbpm 的架构师，而 jbpm 是一个非常有名的工作流引擎，当然 activiti 也是一个工作流引擎。
Activiti 是一个工作流引擎， activiti 可以将业务系统中复杂的业务流程抽取出来，使用专门的建模语言（BPMN2.0）进行定义，业务系统按照预先定义的流程进行执行，实现了业务系统的业务流程由 activiti 进行管理，减少业务系统由于流程变更进行系统升级改造的工作量，从而提高系统的健壮性，同时也减少了系统开发维护成本。
官方网站：https://www.activiti.org/

经历的版本:

目前最新版本：Release 7.2.0

2. 下载官网资源

⑴ 进入 Activiti-Core 学习向导页面

https://github.com/Activiti/activiti-7-developers-guide/blob/51a1681c0e4bb5e2f96a6dea73516c9fd53
d8521/getting-started/getting-started-activiti-core.md

⑵ 下载 Activiti-Core 的 Example 示例

https://github.com/Activiti/activiti-examples

我们可以通过官方文档和官方示例来学习 Activiti7，目前国内的关于 Activiti7 的参考资料还很少，我们本次将结合这些资料来学习 Activiti7 课程。

⑶ Activiti 新的 API 介绍

Activiti7 为了简化对工作流的操作，特别在原有 API 的基础上再次进行封闭，这样我们原来所学习的 Activiti 基本 API 就被封闭起来了。具体要学习的包括：
ProcessRuntime 接口
TaskRuntime 接口

1) ProcessRuntime 接口

通过上面的分析，我们发现使用 Activiti7 开发时，只要注入 ProcessRuntime 的实现对象，就可以实现流程定义信息的操作。当然这个过程中因为 Activiti7 与 SpringSecurity 的强耦合，引导我们也必须将 SpringSecurity 加入进来。

2) TaskRuntime 接口

上面部分给我们介绍了如何引入 Activiti Core 所需的坐标，同时介绍了如何添加 TaskRuntime 实现对象，源码介绍等。我们会发现 TaskRuntime 本身就是对于 TaskService 的一个封装。

十三、 Activiti7 与 SpringBoot 整合开发

Activiti7 发布正式版之后，它与 SpringBoot2.x 已经完全支持整合开发。我们可以将 Activiti7 与SpringBoot 整合开发的坐标引入到工程中，从而达到 SpringBoot 支持 Activti7 整合。

1. SpringBoot 整合 Activti7 的具体步骤如下：

⑴ 项目结构如下

⑵ 添加 SpringBoot 整合 Activti7 的坐标

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.kejizhentan</groupId>
    <artifactId>springboot-activiti</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!--activiti7与SpringBoot整合的相关依赖-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.0.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.activiti/activiti-spring-boot-starter -->
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-spring-boot-starter</artifactId>
            <version>7.0.0.Beta2</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.27</version>
        </dependency>


    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

⑶ 添加 SpringSecurity 安全框架的整合配置信息

application.yml文件配置

# 数据库相关配置
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/activiti?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT
    username : root
    password : 123456
    driver-class-name: com.mysql.jdbc.Driver

# activiti相关配置
  activiti:
    db-history-used: true
    history-level: full

SecurityUtil.java工具类

@Component
public class SecurityUtil {

    @Autowired
    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");
        }

        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);
    }
}

DemoApplicationConfiguration.java配置类

@Configuration
@EnableWebSecurity
public class DemoApplicationConfiguration extends WebSecurityConfigurerAdapter {

    private Logger logger = LoggerFactory.getLogger(DemoApplicationConfiguration.class);

    @Override
    @Autowired
    public void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(myUserDetailsService());
    }

    @Bean
    public UserDetailsService myUserDetailsService() {

        InMemoryUserDetailsManager inMemoryUserDetailsManager = new InMemoryUserDetailsManager();

        String[][] usersGroupsAndRoles = {
                {"salaboy", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"},
                {"ryandawsonuk", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"},
                {"erdemedeiros", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"},
                {"other", "password", "ROLE_ACTIVITI_USER", "GROUP_otherTeam"},
                {"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;
    }


    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                .csrf().disable()
                .authorizeRequests()
                .anyRequest()
                .authenticated()
                .and()
                .httpBasic();


    }

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

⑷ 创建一个`/src/main/resource/processes/`目录，专门用于放置bpmn文件

/src/main/resource/processes/目录下的bpmn文件会自动的部署到数据库中

设置组信息：
1. activiti组都是以GROUP_开头
2. bpmn组信息的设置一定要跟配置文件中的信息对应上

⑸ 查看流程定义测试

@RunWith(SpringRunner.class)
@SpringBootTest
public class QueryTask {
    @Autowired
    private ProcessRuntime processRuntime;
    @Autowired
    private TaskRuntime taskRuntime;
    @Autowired
    private SecurityUtil securityUtil;
    /**
     * 查看流程定义
     */
    @Test
    public void queryTask(){
        securityUtil.logInAs("salaboy");//模拟身份认证
        Page<ProcessDefinition> processDefinitionPage = processRuntime.processDefinitions(Pageable.of(0, 10));
        System.out.println("可用的流程定义数量：" + processDefinitionPage.getTotalItems());
        for (ProcessDefinition pd : processDefinitionPage.getContent()) {
            System.out.println("流程定义：" + pd);
        }
    }
}

执行结果：

数据库默认创建了25张表

kjztteam.bpmn自动部署到了数据库中

通过 ProcessRuntime 的方法，我们可以查看已经部署的流程定义信息。通过加入 Pageable.of()方法可以实现分页查询效果。

⑹ 启动流程实例测试

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

    /**
     * 启动流程实例
     */
    @Test
    public void testStartProcess() {
        securityUtil.logInAs("salaboy");//模拟身份认证
        ProcessInstance pi = processRuntime.start(ProcessPayloadBuilder.start().withProcessDefinitionKey("kjztteam")
                .build());
        System.out.println("流程实例ID：" + pi.getId());
    }
}

效果如下：

现在要启动流程实例，我们可以使用 ProcessRuntime 的 start()方法就可以实现流程实例的启动

⑺ 查询并完成任务测试

@RunWith(SpringRunner.class)
@SpringBootTest
public class QueryAndCompleteTask {
    @Autowired
    private ProcessRuntime processRuntime;
    @Autowired
    private TaskRuntime taskRuntime;
    @Autowired
    private SecurityUtil securityUtil;
    /**
     * @descrition：查询任务，并完成自己的任务
     * @auther: kejizhentan
     * @date: 2022/6/5 15:45
     */
    @Test
    public void queryAndCompleteTask(){
        securityUtil.logInAs("ryandawsonuk");//模拟身份认证
        Page<Task> taskPage=taskRuntime.tasks(Pageable.of(0,10)); //分页查询任务列表
        if(taskPage.getTotalItems() > 0){
            //说明有任务
            for (Task task : taskPage.getContent()) {
                //遍历任务列表
                System.out.println("任务1："+task);
                //拾取任务    condidateGroups="activitiTeam"
                taskRuntime.claim(TaskPayloadBuilder.claim().withTaskId(task.getId()).build());
                //执行任务
                taskRuntime.complete(TaskPayloadBuilder.complete().withTaskId(task.getId()).build());
            }
        }
        //再次查询新任务
        taskPage=taskRuntime.tasks(Pageable.of(0,10)); //分页查询任务列表
        if(taskPage.getTotalItems() > 0){
            //说明有任务
            for (Task task : taskPage.getContent()) {
                //遍历任务列表
                System.out.println("任务2："+task);
            }
        }
    }
}

使用 TaskRuntime 接口的 tasks()方法实现任务的查询。
使用 TaskRuntime 接口的 claim()方法实现任务拾取。
使用 TaskRuntime 接口的 complete()方法实现任务的完成

十四、 Activiti7+ SpringBoot+SpringMVC 开发

⑴ 项目结构如下

⑵ 添加 SpringBoot 整合 Activti7 的坐标

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.kejizhentan</groupId>
    <artifactId>springboot-activiti</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!--activiti7与SpringBoot整合的相关依赖-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.0.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.activiti/activiti-spring-boot-starter -->
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-spring-boot-starter</artifactId>
            <version>7.0.0.Beta2</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.27</version>
        </dependency>


    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

⑶ 添加 SpringSecurity 安全框架的整合配置信息

application.yml文件配置

# 数据库相关配置
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/activiti?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT
    username : root
    password : 123456
    driver-class-name: com.mysql.jdbc.Driver

# activiti相关配置
  activiti:
    db-history-used: true
    history-level: full

SecurityUtil.java工具类

@Component
public class SecurityUtil {

    @Autowired
    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");
        }

        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);
    }
}

DemoApplicationConfiguration.java配置类

@Configuration
@EnableWebSecurity
public class DemoApplicationConfiguration extends WebSecurityConfigurerAdapter {

    private Logger logger = LoggerFactory.getLogger(DemoApplicationConfiguration.class);

    @Override
    @Autowired
    public void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(myUserDetailsService());
    }

    @Bean
    public UserDetailsService myUserDetailsService() {

        InMemoryUserDetailsManager inMemoryUserDetailsManager = new InMemoryUserDetailsManager();

        String[][] usersGroupsAndRoles = {
                {"salaboy", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"},
                {"ryandawsonuk", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"},
                {"erdemedeiros", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"},
                {"other", "password", "ROLE_ACTIVITI_USER", "GROUP_otherTeam"},
                {"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;
    }


    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                .csrf().disable()
                .authorizeRequests()
                .anyRequest()
                .authenticated()
                .and()
                .httpBasic();


    }

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

⑷ 创建一个`/src/main/resource/processes/`目录，专门用于放置bpmn文件

/src/main/resource/processes/目录下的bpmn文件会自动的部署到数据库中

设置组信息：
1. activiti组都是以GROUP_开头
2. bpmn组信息的设置一定要跟配置文件中的信息对应上

⑸ 创建ActivitiController.java控制器

/**
 * @Auther: kejizhentan
 * @Date 2022/6/5 16:34
 * @Description: 控制器：activiti任务的执行
 */
@RestController
public class ActivitiController {
    @Autowired
    private ProcessRuntime processRuntime;
    @Autowired
    private TaskRuntime taskRuntime;
    @Autowired
    private SecurityUtil securityUtil;
    /**
     * @descrition：查询并执行任务
     * @auther: kejizhentan
     * @date: 2022/6/5 16:46
     */
    @RequestMapping("/test")
    public String testActiviti(){
       // securityUtil.logInAs("ryandawsonuk");//模拟身份认证
        Page<Task> taskPage=taskRuntime.tasks(Pageable.of(0,10)); //分页查询任务列表
        if(taskPage.getTotalItems() > 0){
            //说明有任务
            for (Task task : taskPage.getContent()) {
                //遍历任务列表
                System.out.println("任务1："+task);
                //拾取任务    condidateGroups="activitiTeam"
                taskRuntime.claim(TaskPayloadBuilder.claim().withTaskId(task.getId()).build());
                //执行任务
                taskRuntime.complete(TaskPayloadBuilder.complete().withTaskId(task.getId()).build());
            }
        }
        //再次查询新任务
        taskPage=taskRuntime.tasks(Pageable.of(0,10)); //分页查询任务列表
        if(taskPage.getTotalItems() > 0){
            //说明有任务
            for (Task task : taskPage.getContent()) {
                //遍历任务列表
                System.out.println("任务2："+task);
            }
        }
        return "工作流执行成功";
    }
}

⑹ 启动流程实例testStartProcess

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

    /**
     * 启动流程实例
     */
    @Test
    public void testStartProcess() {
        securityUtil.logInAs("salaboy");//模拟身份认证
        ProcessInstance pi = processRuntime.start(ProcessPayloadBuilder.start().withProcessDefinitionKey("kjztteam")
                .build());
        System.out.println("流程实例ID：" + pi.getId());
    }
}

⑺ 编写 SpringBoot 启动类

@SpringBootApplication(exclude = SecurityAutoConfiguration.class)
public class ActivitiApplication {
    private Logger logger = LoggerFactory.getLogger(ActivitiApplication.class);

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

    @Bean
    public Connector testConnector() {
        return integrationContext -> {
            logger.info("以前叫代理，现在叫连接器被调用啦~~");
            return integrationContext;
        };
    }
}

⑻ 测试

先通过testStartProcess启动流程实例
通过ActivitiApplication启动项目
访问：http://localhost:8080/test
注意账号密码如下：

十五、activiti7案例项目

完整项目如下：https://gitee.com/wangren2020/actSpringBoot.git

执行流程：

项目演示：

启动boot项目，访问：http://localhost:8080/

输入账号：jack 密码：123456

部署任务

部署任务前端有个bug总是提示部署失败，其实是部署成功的，看控制台就行，这个bug可以忽略

创建申请


查看SELECT * FROM act_ru_task 可知下个任务执行人id是2

执行SELECT * FROM tb_user WHERE id = 2可知下个任务执行人是rose

切换rose账号，登录密码同样是123456

然后重复以上操作，切换用户执行任务

执行过程

十四、工作流引擎——Activiti7

一、什么是工作流

1. 工作流介绍

2. 工作流系统

⑴ 适用行业

⑵ 具体应用

3. 工作流实现方式

4. 工作流实现原理分析

二、 什么是Activiti7

1. Activiti 介绍

⑴ BPM

⑵ BPM 软件

⑶ BPMN

2. Activit 如何使用

⑴ 部署 activiti

⑵ 流程定义

⑶ 流程定义部署

⑷ 启动一个流程实例（ProcessInstance）

⑸ 用户查询待办任务(Task)

⑹ 用户办理任务

⑺ 流程结束

3. 开发环境

⑴ Java 环境

⑵ 数据库

⑶ Web 容器

⑷ 开发工具

4. Activiti 环境

⑴ 下载 activiti7

1） Database：

2）Docs

3）Wars

⑵ Activiti Designer 流程设计器(Eclipse 工具)

1） Eclispe 工具下插件安装方式 ：网络在线安装

① 打开 Help -> Install New Software. 在如下面板中:

② 在如下 Install 界面板中，点击 Add 按钮：

③ 然后填入下列字段

④ 回到 Install 界面，在面板正中列表中把所有展示出来的项目都勾上：

⑤ 点击复选框

⑥ 安装完以后，点击新建工程 new->Other…打开面板，如果看到下图内容：

2） 补充说明

3）Activiti Designer 流程设计器(IDEA 工具)

① 下载插件

② 安装插件

⑶ Activiti 支持的数据库

⑷ 创建表方式: 通过运行 java 程序创建表

1) 创建 java 工程

2) 加入 maven 依赖的坐标（jar 包）

3) 放入log4j.properties文件

4) activiti.cfg.xml

① 数据源

② processEngineConfiguration

5) 编写程序:ActivitiTest.java

三、 Activiti 服务架构图

1. activiti.cfg.xml

2. ProcessEngineConfiguration：

⑴ StandaloneProcessEngineConfiguration

⑵ SpringProcessEngineConfiguration

⑶ 创建 processEngineConfiguration

3. ProcessEngine

⑴ 一般创建方式

⑵ 简单创建方式

4. Service

⑴ Service 创建方式

⑵ Service 总览

1) RepositoryService

2) RuntimeService

3) TaskService

4) HistoryService

5) ManagementService

四、 Activiti 入门体验

1、流程定义

⑴ Activiti-Designer 使用

1) Palette（画板）

2) 新建流程(IDEA 工具)

① idea绘制流程

② IDEA 工具中怎么将.bpmn文件转换成png图片

3) 新建流程(Eclipse 工具)

① eclipse绘制流程

⑵ 部署流程定义

1) 单个文件部署方式

二、什么是Activiti7

1） Eclispe 工具下插件安装方式：网络在线安装

2）补充说明

3）操作数据表

五、流程实例

① `UEL-value` 定义如下：

③ `UEL-method` 与`UEL-value`结合