神秘微笑

Activiti7 工作流引擎入门

做课目的

一、适用人群：普通人

不是每个人都能进入一线互联网大厂 BATJ

普通人，省城，软件公司，银行、政府做

二、适用项目：OA CRM ERP 系统

出差报销流程、请假流程

三、课程特点：说人话

快速上手工作流

（salvio修改）欢迎支持

第一章工作流相关术语

一、工作流介绍

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

企业OA：

请假----》内网系统----》小李填写请假单7天----》组长同意----》CTO同意------》人事部部长同意-----》结束

专门的公司做OA CRM ERP: 金蝶、用友

二、工作流系统

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

1、适用行业

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

2、具体应用

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

三、工作流实现方式

纸条：介绍信。档案管理部门，信息管理，上级学科：图情档

在没有专门的工作流引擎之前，我们之前为了实现流程控制，通常的做法就是采用状态字段的值来跟踪流程的变化情况。这样不用角色的用户，通过状态字段的取值来决定记录是否显示。

针对有权限可以查看的记录，当前用户根据自己的角色来决定审批是否合格的操作。如果合格将状态字段设置一个值，来代表合格；当然如果不合格也需要设置一个值来代表不合格的情况。

缺点：

这是一种最为原始的方式。通过状态字段虽然做到了流程控制，但是当我们的流程发生变更的时候，这种方式所编写的代码也要进行调整。

想看一条记录的历史发展，怎么办？

那么有没有专业的方式来实现工作流的管理呢？并且可以做到业务流程变化之后，我们的程序可以不用改变，如果可以实现这样的效果，那么我们的业务系统的适应能力就得到了极大提升。

四、工作流实现原理分析

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

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

文字版

第二章 Activiti7 概述

一、Activiti 介绍

Alfresco 软件在 2010 年 5 月 17 日宣布 Activiti 业务流程管理（BPM）开源项目的正式启动，其首席架构师由业务流程管理 BPM 的专家 Tom Baeyens 担任，Tom Baeyens 就是原来 jbpm 的架构师，而 jbpm 是一个非常有名的工作流引擎，当然 activiti 也是一个工作流引擎。

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

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

经历的版本 5.X 6.X 已经不维护

目前最新版本：Activiti7.3.0

多款工作流引擎的比较

1. Activiti

Alfresco软件开发，基于JBPM4，后并入OMG，目前最高版本activiti 7。Activiti5版本的时候，核心团队发生了比较大的变动（离职），activiti6的开发团队在新版本中去除了PVM，纳入了DMN，重构XML解析，BUG较多，目前主要团队致力于activiti7。 5&6已经官宣不维护。

2. Flowable

基于activiti6，最新的开源版本是flowable6，开发团队是从activiti中分裂出来的，修复了一众activiti6的bug，并在其基础上研发了DMN支持，BPEL支持等等。相对开源版，其商业版的功能会更强大。

3. Camunda

基于activiti5，所以其保留了PVM，最新版本Camunda7，开发团队也是从activiti中分裂出来的，发展轨迹与flowable相似，同时也提供了商业版。

4. JFlow

前身ccFlow，国产的工作流引擎，由济南驰骋公司开发维护，主打中国式的业务流程，由于是国产的软件，中文化程度比较深，业务开发也对用户比较友好。国产的开源工作流引擎还是挺多的，JFlow是其中功能比较完善的一个，同时对比activiti，流程上更加中国化，支持自定义流程跳转，加签等。其他国产工作流就不列举了。

1、BPM**

BPM（Business Process Management），即业务流程管理，是一种以规范化的构造端到端的卓越业务流程为中心，以持续的提高组织业务绩效为目的系统化方法，常见商业管理教育如 EMBA、MBA等均将 BPM 包含在内。

企业流程管理主要是对企业内部改革，改变企业职能管理机构重叠、中间层次多、流程不闭环等，做到机构不重叠、业务不重复，达到缩短流程周期、节约运作资本、提高企业效益的作用。

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

流程一：

流程二：

第二种情况效率更高：3天内请假，部门经理完全能处理了。不用打扰总经理。

2、 BPM 软件

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

BPM 软件在企业中应用领域广泛，凡是有业务流程的地方都可以 BPM 软件进行管理，比如企业人事办公管理、采购流程管理、公文审批流程管理、财务管理等。

3、 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 图形的例子：

填写请假单
部门经理审核
总经理审核

最后请假流程结束。


<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" 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" typeLanguage="http://www.w3.org/2001/XMLSchema" expressionLanguage="http://www.w3.org/1999/XPath" targetNamespace="http://www.activiti.org/processdef">
  <process id="Test1" name="Test1" isExecutable="true">
    <startEvent id="sid-9bb97b6a-8f2c-4e3e-bf95-ec61ae92e018" name="开始流程"/>
    <userTask id="sid-47945474-d1fe-41d7-b4ca-af9b7a997496" name="填写请假单"/>
    <userTask id="sid-4d508bbe-52a3-4818-a6b0-28a2cb93b1b0" name="部门经理审核"/>
    <sequenceFlow id="sid-5b4edab2-56a9-46c2-92f5-f271a7d3f69b" sourceRef="sid-47945474-d1fe-41d7-b4ca-af9b7a997496" targetRef="sid-4d508bbe-52a3-4818-a6b0-28a2cb93b1b0"/>
    <endEvent id="sid-a3b9010e-f840-4854-a0e8-923d3021a9c8"/>
    <sequenceFlow id="sid-2a784727-8ce3-4e6f-8926-268fa1ae2d35" sourceRef="sid-9bb97b6a-8f2c-4e3e-bf95-ec61ae92e018" targetRef="sid-47945474-d1fe-41d7-b4ca-af9b7a997496"/>
    <userTask id="sid-bf087e72-0224-4bbf-bc5c-c96bcd462788" name="总经理审核"/>
    <sequenceFlow id="sid-a52795e3-543e-4397-b35e-5251d2f23394" sourceRef="sid-4d508bbe-52a3-4818-a6b0-28a2cb93b1b0" targetRef="sid-bf087e72-0224-4bbf-bc5c-c96bcd462788"/>
    <sequenceFlow id="sid-bdae4683-75d1-4c3d-9a88-0929e70155d6" sourceRef="sid-bf087e72-0224-4bbf-bc5c-c96bcd462788" targetRef="sid-a3b9010e-f840-4854-a0e8-923d3021a9c8"/>
  process>
  <bpmndi:BPMNDiagram id="BPMNDiagram_Test1">
    <bpmndi:BPMNPlane bpmnElement="Test1" id="BPMNPlane_Test1">
      <bpmndi:BPMNShape id="shape-0d2bb75a-8781-4e85-ab05-3038b936eadb" bpmnElement="sid-9bb97b6a-8f2c-4e3e-bf95-ec61ae92e018">
        <omgdc:Bounds x="75.0" y="15.0" width="30.0" height="30.0"/>
      bpmndi:BPMNShape>
      <bpmndi:BPMNShape id="shape-15f1ad2b-eb83-4cb3-bc6b-4d298b039035" bpmnElement="sid-47945474-d1fe-41d7-b4ca-af9b7a997496">
        <omgdc:Bounds x="155.0" y="3.0" width="100.0" height="80.0"/>
      bpmndi:BPMNShape>
      <bpmndi:BPMNShape id="shape-978b3c5d-c77a-4da7-8fd5-1dbc914fea61" bpmnElement="sid-4d508bbe-52a3-4818-a6b0-28a2cb93b1b0">
        <omgdc:Bounds x="295.0" y="3.0" width="100.0" height="80.0"/>
      bpmndi:BPMNShape>
      <bpmndi:BPMNEdge id="edge-95b4c271-fa29-4ca8-8698-e7e50f10a686" bpmnElement="sid-5b4edab2-56a9-46c2-92f5-f271a7d3f69b">
        <omgdi:waypoint x="255.0" y="43.0"/>
        <omgdi:waypoint x="295.0" y="43.0"/>
      bpmndi:BPMNEdge>
      <bpmndi:BPMNShape id="shape-41da282d-8db5-4380-96ab-449d130aadcc" bpmnElement="sid-a3b9010e-f840-4854-a0e8-923d3021a9c8">
        <omgdc:Bounds x="600.0" y="28.0" width="30.0" height="30.0"/>
      bpmndi:BPMNShape>
      <bpmndi:BPMNEdge id="edge-638058be-afa1-4f0d-83ff-0bb5b985c4f1" bpmnElement="sid-2a784727-8ce3-4e6f-8926-268fa1ae2d35">
        <omgdi:waypoint x="105.0" y="22.5"/>
        <omgdi:waypoint x="155.0" y="23.0"/>
      bpmndi:BPMNEdge>
      <bpmndi:BPMNShape id="sid-6d43032f-c23d-4c9d-8982-35f85948682d" bpmnElement="sid-bf087e72-0224-4bbf-bc5c-c96bcd462788">
        <omgdc:Bounds x="447.47275" y="3.0" width="100.0" height="80.0"/>
      bpmndi:BPMNShape>
      <bpmndi:BPMNEdge id="edge-15d8075d-253b-4eb1-8f23-9040f879d4ec" bpmnElement="sid-a52795e3-543e-4397-b35e-5251d2f23394">
        <omgdi:waypoint x="395.0" y="43.0"/>
        <omgdi:waypoint x="447.47275" y="43.0"/>
      bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge id="edge-a9bb111b-d1bf-40a9-ad3d-0e9622157f6b" bpmnElement="sid-bdae4683-75d1-4c3d-9a88-0929e70155d6">
        <omgdi:waypoint x="547.4728" y="43.0"/>
        <omgdi:waypoint x="600.0" y="43.0"/>
      bpmndi:BPMNEdge>
    bpmndi:BPMNPlane>
  bpmndi:BPMNDiagram>
definitions>

二、Activit 如何使用

大的系统：电商、社交。父模块下，微服务小模块，其中有个activiti模块，专门管工作流。

1、部署 activiti

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

2、流程定义

使用 activiti 流程建模工具(activity-designer)定义业务流程(.bpmn 文件) 。

.bpmn 文件就是业务流程定义文件，通过 xml 定义业务流程。

如果使用其它公司开发的工作作引擎一般都提供了可视化的建模工具(Process Designer)用于生成流程定义文件，建模工具操作直观，一般都支持图形化拖拽方式、多窗口的用户界面、丰富的过程图形元素、过程元素拷贝、粘贴、删除等功能。传智播客——专注于 Java、.Net 和 Php、网页平面设计工程师的培训

3、流程定义部署

向 activiti 部署业务流程定义（.bpmn 文件）。

使用 activiti 提供的 api 向 activiti 中部署.bpmn 文件

4、启动一个流程实例（ProcessInstance）

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

5、用户查询待办任务(Task)

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

6、用户办理任务

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

7、流程结束

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

第三章搭建环境

一、项目环境

父工程 ydl-oa

子模块 ydl-common ydl-bussiness

子模块 activiti-demo

二、开发环境

1、 Java 环境

Jdk1.8 或以上版本

2、数据库

Mysql 5 及以上的版本

本教程采用 8 版本

3、 Web 容器

本项目采用的是 Tomcat8.5

4、开发工具

Mysql 客户端连接工具，navicat或其它

文本编辑器 EditPlus 或其它

Java 开发工具：IDEA

三、Activiti 环境

1、下载 activiti7

Activiti 下载地址：https://activiti.gitbook.io/activiti-7-developers-guide/releases/7.4.0

  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>org.activitigroupId>
        <artifactId>activiti-dependenciesartifactId>
        <version>7.4.0version>
        <scope>importscope>
        <type>pomtype>
      dependency>
    dependencies>
  dependencyManagement>

（1）Database：

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

（2） Docs

Activiti 的帮助文档。

（3） Wars

官方自带的示例工程

2、流程设计器插件安装

（1）简介

Activiti插件actiBPM在新版的idea 2020中已经不支持，这里找到一款替代的Activiti BPMN visualizer。

（2）安装（设置-插件-搜索 bpmn）

或者在idea插件官网：https://plugins.jetbrains.com/

3、 Activiti 支持的数据库

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

h2:1.3.168
mysql :5.1.21
oracle:11.2.0.1.0
postgres:8.1
db2:DB2 10.1 using db2jcc4
mssql:2008 using sqljdbc4

4、创建mysql数据库

本教程使用 mysql 数据库。

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

CREATE DATABASE activiti DEFAULT CHARACTER SET utf8;

5、创建表方式

通过运行 java 程序创建表。

（1）创建 java 工程

使用 idea 创建 maven 的 java 工程。

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

首先需要在 java 工程中加入 ProcessEngine 所需要的 jar 包，包括：传智播客——专注于 Java、.Net 和 Php、网页平面设计工程师的培训

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

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

<properties>
    <maven.compiler.source>8maven.compiler.source>
    <maven.compiler.target>8maven.compiler.target>
    <slf4j.version>1.6.6slf4j.version>
    <log4j.version>1.2.12log4j.version>
    <activiti.version>7.4.0activiti.version>
    <activiti.cloud.version>7.4.0activiti.cloud.version>
    <mysql.version>8.0.20mysql.version>
    <java.version>1.8java.version>
    <slf4j.version>1.6.6slf4j.version>
    <log4j.version>1.2.12log4j.version>
    <mybatis.version>3.4.5mybatis.version>
    <junit.version>4.12junit.version>
    <commonsio.version>2.6commonsio.version>
    <dbcp.version>1.4dbcp.version>
properties>

<dependencies>
    <dependency>
        <groupId>org.activitigroupId>
        <artifactId>activiti-engineartifactId>
        <version>${activiti.version}version>
    dependency>
    <dependency>
        <groupId>org.activitigroupId>
        <artifactId>activiti-springartifactId>
        <version>${activiti.version}version>
    dependency>
    
    <dependency>
        <groupId>org.activitigroupId>
        <artifactId>activiti-bpmn-modelartifactId>
        <version>${activiti.version}version>
    dependency>
    
    <dependency>
        <groupId>org.activitigroupId>
        <artifactId>activiti-bpmn-converterartifactId>
        <version>${activiti.version}version>
    dependency>
    
    <dependency>
        <groupId>org.activitigroupId>
        <artifactId>activiti-json-converterartifactId>
        <version>${activiti.version}version>
    dependency>
    
    <dependency>
        <groupId>org.activitigroupId>
        <artifactId>activiti-bpmn-layoutartifactId>
        <version>${activiti.version}version>
    dependency>
    
    <dependency>
        <groupId>mysqlgroupId>
        <artifactId>mysql-connector-javaartifactId>
        <version>${mysql.version}version>
    dependency>
    
    <dependency>
        <groupId>org.mybatisgroupId>
        <artifactId>mybatisartifactId>
        <version>${mybatis.version}version>
    dependency>
    
    <dependency>
        <groupId>commons-dbcpgroupId>
        <artifactId>commons-dbcpartifactId>
        <version>${dbcp.version}version>
    dependency>
    <dependency>
        <groupId>commons-iogroupId>
        <artifactId>commons-ioartifactId>
        <version>${commonsio.version}version>
    dependency>
    <dependency>
        <groupId>junitgroupId>
        <artifactId>junitartifactId>
        <version>${junit.version}version>
    dependency>
    
    <dependency>
        <groupId>log4jgroupId>
        <artifactId>log4jartifactId>
        <version>${log4j.version}version>
    dependency>
    <dependency>
        <groupId>org.slf4jgroupId>
        <artifactId>slf4j-apiartifactId>
        <version>${slf4j.version}version>
    dependency>
    <dependency>
        <groupId>org.slf4jgroupId>
        <artifactId>slf4j-log4j12artifactId>
        <version>${slf4j.version}version>
    dependency>
dependencies>

（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=f:\act\activiti.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

https://www.ydlclass.com/doc21xnv/other/activiti/#%E4%BA%8C%E3%80%81activit-%E5%A6%82%E4%BD%95%E4%BD%BF%E7%94%A8

（4）activiti.cfg.xml

在 classpath 下创建 activiti.cgf.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                    http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/contex
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">

    
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver" />
        <property name="url" value="jdbc:mysql://localhost:3306/activiti?nullCatalogMeansCurrent=true&serverTimezone=GMT%2B8" />
        <property name="username" value="root" />
        <property name="password" value="123456" />
        <property name="maxActive" value="3" />
        <property name="maxIdle" value="1" />
    bean>

    <bean id="processEngineConfiguration"
          class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
        
        <property name="dataSource" ref="dataSource" />
        
        <property name="databaseSchemaUpdate" value="true"/>
    bean>
beans>

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

false（默认）：检查数据库表的版本和依赖库的版本，如果版本不匹配就抛出异常。

true: 构建流程引擎时，执行检查，如果需要就执行更新。如果表不存在，就创建。

create-drop: 构建流程引擎时创建数据库表，关闭流程引擎时删除这些表。

drop-create：先删除表再创建表。

create: 构建流程引擎时创建数据库表，关闭流程引擎时不删除这些表。

（5）编写程序

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

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

说明：

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

2、上边的方法 createProcessEngineConfigurationFromResource 在执行时在activiti.cfg.xml 中找固定的名称 processEngineConfiguration也可以使用重载方法调用，这时可以不用限定 processEngineConfiguration 名称

注意问题：

1、 jdk版本号 55 52

方案：使用18jdk

2、

方案：nullCatalogMeansCurrent=true

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

（6）数据库表的命名规则

官网地址：https://www.activiti.org/userguide/#creatingDatabaseTable

a、表前缀说明

act_ge_ 通用数据表，ge是general的缩写
act_hi_ 历史数据表，hi是history的缩写，对应 HistoryService 接口
act_id_ 身份数据表，id是identity的缩写，对应 IdentityService 接口
act_re_ 流程存储表，re是repository的缩写，对应 RepositoryService 接口，存储流程部署和流程定义等静态数据
act_ru_ 运行时数据表，ru是runtime的缩写，对应 RuntimeService 接口和 TaskService 接口，存储流程实例和用户任务等动态数据

b、Activiti 数据表清单:

表分类	表名	备注说明
一般数据	ACT_GE_BYTEARRAY	流程定义的bpmn和png文件
	ACT_GE_PROPERTY	系统相关属性
流程历史记录	ACT_HI_ACTINST	历史的流程实例
	ACT_HI_ATTACHMENT	历史的流程附件
	ACT_HI_COMMENT	历史的说明性信息
	ACT_HI_DETAIL	历史的流程运行中的细节信息
	ACT_HI_IDENTITYLINK	历史的流程运行过程中用户关系
	ACT_HI_PROCINST	历史的流程实例
	ACT_HI_TASKINST	历史的任务实例
	ACT_HI_VARINST	历史的流程实例变量表
用户组表	ACT_ID_GROUP	身份信息-组信息
	ACT_ID_INFO	身份信息-信息
	ACT_ID_MEMBERSHIP	身份信息-用户和组关系的中间表
	ACT_ID_USER	身份信息-用户信息
流程定义表	ACT_RE_DEPLOYMENT	流程定义部署表
	ACT_RE_MODEL	模型信息
	ACT_RE_PROCDEF	流程定义信息
运行实例表	ACT_RU_EVENT_SUBSCR	运行时事件
	ACT_RU_EXECUTION	运行时流程执行实例
	ACT_RU_IDENTITYLINK	运行时参与者的用户信息
	ACT_RU_JOB	运行时作业
	ACT_RU_TASK	运行时任务
	ACT_RU_VARIABLE	流程运行时变量表，记录当前流程可使用的变量，包括 global 和 local

结合数据库看

第四章 Activiti架构

官网介绍：https://www.activiti.org/userguide/#chapterApi

引擎 API 是与 Activiti 交互的最常见方式。中心起点是ProcessEngine，可以按照配置部分open in new window中所述的多种方式创建。您可以从 ProcessEngine 获取包含工作流/BPM 方法的各种服务。ProcessEngine 和服务对象是线程安全的。因此，您可以为整个服务器保留对其中 1 个的引用。

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

RuntimeService runtimeService = processEngine.getRuntimeService();
RepositoryService repositoryService = processEngine.getRepositoryService();
TaskService taskService = processEngine.getTaskService();
ManagementService managementService = processEngine.getManagementService();
IdentityService identityService = processEngine.getIdentityService();
HistoryService historyService = processEngine.getHistoryService();
FormService formService = processEngine.getFormService();
DynamicBpmnService dynamicBpmnService = processEngine.getDynamicBpmnService();

ProcessEngines.getDefaultProcessEngine()将在第一次调用时初始化并构建流程引擎，然后总是返回相同的流程引擎。可以使用ProcessEngines.init() 和正确创建和关闭所有流程引擎ProcessEngines.destroy()。

activiti.cfg.xmlProcessEngines类将扫描所有activiti-context.xml文件。对于所有activiti.cfg.xml文件，流程引擎将以典型的 Activiti 方式构建：ProcessEngineConfiguration.createProcessEngineConfigurationFromInputStream(inputStream).buildProcessEngine(). 对于所有activiti-context.xml文件，流程引擎将以 Spring 方式构建：首先创建 Spring 应用程序上下文，然后从该应用程序上下文中获取流程引擎。

所有服务都是无状态的。这意味着您可以轻松地在集群中的多个节点上运行 Activiti，每个节点都访问同一个数据库，而不必担心哪台机器实际执行了先前的调用。无论在何处执行，对任何服务的任何调用都是幂等的。

获取各个表的相关操作，不用service-dao方式来获取。activiti的各种service已经帮我们写好了。

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

一、activiti.cfg.xml

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


<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                    http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/contex
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">

    
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver" />
        <property name="url" value="jdbc:mysql://localhost:3306/activiti?nullCatalogMeansCurrent=true&serverTimezone=GMT%2B8" />
        <property name="username" value="root" />
        <property name="password" value="ydlclass666" />
        <property name="maxActive" value="3" />
        <property name="maxIdle" value="1" />
    bean>

    <bean id="processEngineConfiguration"
          class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
        
        <property name="dataSource" ref="dataSource" />




        
        <property name="databaseSchemaUpdate" value="true"/>
    bean>
beans>

二、ProcessEngineConfiguration：

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

1、 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 name="databaseSchemaUpdate" value="true"/>
    bean>

2、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 id="processEngineConfiguration"
          class="org.activiti.spring.SpringProcessEngineConfiguration">
        
        <property name="dataSource" ref="dataSource"/>
        
        <property name="transactionManager" ref="transactionManager"/>
        
        <property name="databaseSchemaUpdate" value="drop-create"/>
        
        <property name="jobExecutorActivate" value="false"/>
    bean>
    
    <bean id="processEngine"
          class="org.activiti.spring.ProcessEngineFactoryBean">
        <property name="processEngineConfiguration"
                  ref="processEngineConfiguration"/>
    bean>
    
    <bean id="repositoryService" factory-bean="processEngine"
          factory-method="getRepositoryService"/>
    
    <bean id="runtimeService" factory-bean="processEngine"
          factory-method="getRuntimeService"/>
    
    <bean id="taskService" factory-bean="processEngine"
          factory-method="getTaskService"/>
    
    <bean id="historyService" factory-bean="processEngine"
          factory-method="getHistoryService"/>
    
    <bean id="identityService" factory-bean="processEngine"
          factory-method="getIdentityService"/>
    
    <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.ydlclass.ydloa.service.impl.*.*(..))"/>
    aop:config>
beans>

3、创建 processEngineConfiguration

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

1
2

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

ProcessEngineConfiguration.createProcessEngineConfigurationFromResource(String resource, String beanName);

三、ProcessEngine

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

1、一般创建方式

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

_2、简单创建方式

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

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

四、Servcie服务接口

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

1、 Service创建方式

通过ProcessEngine创建Service

方式如下：

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

2、 Service总览

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

简单介绍：

RepositoryService

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

除了部署流程定义以外还可以：查询引擎中的发布包和流程定义。

暂停或激活发布包，对应全部和特定流程定义。暂停意味着它们不能再执行任何操作了，激活是对应的反向操作。获得多种资源，像是包含在发布包里的文件，或引擎自动生成的流程图。

获得流程定义的pojo版本，可以用来通过java解析流程，而不必通过xml。

RuntimeService

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

TaskService

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

HistoryService

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

ManagementService

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

第五章 Activiti入门

在本章内容中，我们来创建一个Activiti工作流，并启动这个流程。

创建Activiti工作流主要包含以下几步：

1、定义流程，按照BPMN的规范，使用流程定义工具，用流程符号把整个流程描述出来

2、部署流程，把画好的流程定义文件，加载到数据库中，生成表的数据

3、启动流程，使用java代码来操作数据库表中的内容

一、流程符号

BPMN 2.0是业务流程建模符号2.0的缩写。

它由Business Process Management Initiative这个非营利协会创建并不断发展。作为一种标识，BPMN 2.0是使用一些符号来明确业务流程设计流程图的一整套符号规范，它能增进业务建模时的沟通效率。

目前BPMN2.0是最新的版本，它用于在BPM上下文中进行布局和可视化的沟通。

接下来我们先来了解在流程设计中常见的符号。

BPMN2.0的基本符合主要包含：

1、事件 Event

2、活动 Activity

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

3、网关 GateWay

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

（1）排他网关 (x)

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

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

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

（2）并行网关 (+)

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

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

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

（3）包容网关 (+)

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

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

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

#####（4）事件网关 (+)

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

4、流向 Flow

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

二、流程设计器使用

1、activiti BPMN visualizer 使用

Palette（画板）

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

Connection—连接

Event—事件

Task—任务

Gateway—网关

Container—容器

Boundary event—边界事件

Intermediate event- -中间事件

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

（1）新建流程(IDEA工具)

首先选中存放图形的目录(选择resources下的bpmn目录)，点击菜单：New -> bpmn file，如图：

弹出如下图所示框，输入holiday表示出差审批流程：

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

右键

鼠标先点击画板的元素即可在左侧绘图

#####（2）绘制流程

使用滑板来绘制流程，通过从右侧把图标拖拽到左侧的画板，最终效果如下：

（3）指定流程定义Key

流程定义key即流程定义的标识，通过properties视图查看流程的key

#####（4）指定任务负责人

在properties视图指定每个任务结点的负责人，如：填写出差申请的负责人为 itlils

经理审批负责人为 zhuzhu

总经理审批负责人为 itnanls

财务审批负责人为 weiwei

第六章流程操作

一、流程定义

1、概述

流程定义是线下按照bpmn2.0标准去描述业务流程，通常使用idea中的插件对业务流程进行建模。

2、.bpmn文件

使用activiti-desinger设计业务流程，会生成.bpmn文件，上面我们已经创建好了bpmn文件

BPMN 2.0根节点是definitions节点。这个元素中，可以定义多个流程定义（不过我们建议每个文件只包含一个流程定义，可以简化开发过程中的维护难度）。注意，definitions元素最少也要包含xmlns 和 targetNamespace的声明。 targetNamespace可以是任意值，它用来对流程实例进行分类。

流程定义部分：定义了流程每个结点的描述及结点之间的流程流转。

流程布局定义：定义流程每个结点在流程图上的位置坐标等信息。

3、生成.png图片文件

IDEA工具中的操作方式

二、流程定义部署

1、概述

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

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

2、单个文件部署方式

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

package com.ydlclass.test;

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.RepositoryService;
import org.activiti.engine.repository.Deployment;
import org.junit.Test;

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

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

3、压缩包部署方式

将holiday.bpmn20.xml和holiday.png压缩成zip包。

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

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

4、操作数据表

流程定义部署后操作activiti的3张表如下：

act_re_deployment 流程定义部署表，每部署一次增加一条记录

act_re_procdef 流程定义表，部署每个新的流程定义都会在这张表中增加一条记录

act_ge_bytearray 流程资源表

接下来我们来看看，写入了什么数据：

SELECT * FROM act_re_deployment #流程定义部署表，记录流程部署信息

结果：

SELECT * FROM act_re_procdef #流程定义表，记录流程定义信息

结果：

注意，KEY 这个字段是用来唯一识别不同流程的关键字

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uZemaDPu-1667528089250)(https://www.ydlclass.com/doc21xnv/assets/image-20220912164229052.011f3f42.png)]

SELECT * FROM act_ge_bytearray #资源表

结果：

流程总结：

插件画流程图

bpmn20.xml png

资源文件，记录整合流程整个节点、信息流转
部署

java代码

数据库涉及到3张表。deployment 部署记录 procdef记录部署的详细信息 bytearray xml\png资源都放到数据库
deployment 和 procdef是一对多的关系

itlils 出差流程

itnanls 出差流程

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

三、启动流程实例

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

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

代码如下：

    /**
     * 启动流程实例
     */
    @Test
    public void testStartProcess(){
//        1、创建ProcessEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//        2、获取RunTimeService
        RuntimeService runtimeService = processEngine.getRuntimeService();
//        3、根据流程定义Id启动流程
        ProcessInstance processInstance = runtimeService
                .startProcessInstanceByKey("holiday");
//        输出内容
        System.out.println("流程定义id：" + processInstance.getProcessDefinitionId());
        System.out.println("流程实例id：" + processInstance.getId());
        System.out.println("当前活动Id：" + processInstance.getActivityId());
    }

输出内容如下：

操作数据表

act_hi_actinst 流程实例执行历史

act_hi_identitylink 流程的参与用户历史信息

act_hi_procinst 流程实例历史信息

act_hi_taskinst 流程任务历史信息

act_ru_execution 流程执行信息

act_ru_identitylink 流程的参与用户信息

act_ru_task 任务信息

四、任务查询

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

/**
     * 查询当前个人待执行的任务
      */
    @Test
    public void testFindPersonalTaskList() {
//        任务负责人
        String assignee = "itlils";
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//        创建TaskService
        TaskService taskService = processEngine.getTaskService();
//        根据流程key 和 任务负责人 查询任务
        List<Task> list = taskService.createTaskQuery()
                .processDefinitionKey("holiday") //流程Key
                .taskAssignee(assignee)//只查询该任务负责人的任务
                .list();

        for (Task task : list) {
            System.out.println("流程实例id：" + task.getProcessInstanceId());
            System.out.println("任务id：" + task.getId());
            System.out.println("任务负责人：" + task.getAssignee());
            System.out.println("任务名称：" + task.getName());

        }
    }

五、流程任务处理

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

// 完成任务
    @Test
    public void completTask(){
//        获取引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//        获取taskService
        TaskService taskService = processEngine.getTaskService();

//        根据流程key 和 任务的负责人 查询任务
//        返回一个任务对象
        Task task = taskService.createTaskQuery()
                .processDefinitionKey("holiday") //流程Key
                .taskAssignee("itlils")  //要查询的负责人
                .singleResult();

//        完成任务,参数：任务id
        taskService.complete(task.getId());
    }

六、流程定义信息查询

查询流程相关信息，包含流程定义，流程部署，流程定义版本

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

    }

输出结果：

id=holiday:1:4
name=MyHoliday
key=holiday
Version=1
DeploymentId =1

七、流程删除

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

说明：

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

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

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

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

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

八、流程资源下载

现在我们的流程资源文件已经上传到数据库了，如果其他用户想要查看这些资源文件，可以从数据库中把资源文件下载到本地。

解决方案有：

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

2、使用activiti的api来实现

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

引入commons-io依赖包

<dependency>
    <groupId>commons-iogroupId>
    <artifactId>commons-ioartifactId>
    <version>2.6version>
dependency>

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

    @Test
    public void downloadFile() throws IOException {
        //创建流程引擎配置文件
        ProcessEngineConfiguration configuration
                = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cgf.xml","processEngineConfiguration");
        //通过配置文件，创建流程
        ProcessEngine processEngine = configuration.buildProcessEngine();

        RepositoryService repositoryService = processEngine.getRepositoryService();
        //1repositoryService 获取相应的数据
        ProcessDefinition definition = repositoryService.createProcessDefinitionQuery().processDefinitionKey("holiday").singleResult();
        String deploymentId = definition.getDeploymentId();

        InputStream xmlFileInputStream = repositoryService.getResourceAsStream(deploymentId,definition.getResourceName());
        InputStream pngInputStream = repositoryService.getResourceAsStream(deploymentId, definition.getDiagramResourceName());

        //2转成输出流，放到本地文件夹下
        FileOutputStream xmlFileOutputStream=new FileOutputStream(new File("e:/holiday.bpmn20.xml"));
        FileOutputStream pngFileOutputStream=new FileOutputStream(new File("e:/holiday.png"));

        //3工具类把输入流转成输出流
        IOUtils.copy(xmlFileInputStream,xmlFileOutputStream);
        IOUtils.copy(pngInputStream,pngFileOutputStream);

        //4关流
        pngFileOutputStream.close();
        xmlFileOutputStream.close();
        pngInputStream.close();
        xmlFileInputStream.close();
    }

说明：

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

  resource_name为act_ge_bytearray表中NAME_列的值

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

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

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

九、流程历史信息的查看

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

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

第七章流程实例

一、什么是流程实例

流程实例（ProcessInstance）代表流程定义的执行实例。

一个流程实例包括了所有的运行节点。我们可以利用这个对象来了解当前流程实例的进度等信息。

例如：用户或程序按照流程定义内容发起一个流程，这就是一个流程实例。

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

二、启动流程实例并添加Businesskey（业务标识）

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

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

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

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

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

    /**
     * 启动流程实例，添加businessKey
     */
    @Test
    public void addBusinessKey(){
//        1、得到ProcessEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//        2、得到RunTimeService
        RuntimeService runtimeService = processEngine.getRuntimeService();
//        3、启动流程实例，同时还要指定业务标识businessKey，也就是出差申请单id，这里是1001
        ProcessInstance processInstance = runtimeService.
                startProcessInstanceByKey("holiday","10001");
//        4、输出processInstance相关属性
        System.out.println("id=="+processInstance.getBusinessKey());

    }

Activiti的act_ru_execution中存储业务标识：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pJM0Kbv6-1667528089253)(data:image/png;base64,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)]

三、操作数据库表

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

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

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

四、挂起、激活流程实例

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

1、全部流程实例挂起

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

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

/**
     * 全部流程实例挂起与激活
     */
    @Test
    public void SuspendAllProcessInstance(){
//        获取processEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//        获取repositoryService
        RepositoryService repositoryService = processEngine.getRepositoryService();
//        查询流程定义的对象
        ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().
                processDefinitionKey("holiday").
                singleResult();
//        得到当前流程定义的实例是否都为暂停状态
        boolean suspended = processDefinition.isSuspended();
//        流程定义id
        String processDefinitionId = processDefinition.getId();
//        判断是否为暂停
        if(suspended){
//         如果是暂停，可以执行激活操作 ,参数1 ：流程定义id ，参数2：是否激活，参数3：激活时间
            repositoryService.activateProcessDefinitionById(processDefinitionId,
                    true,
                    null
            );
            System.out.println("processDefinitionId："+processDefinitionId+",activate");
        }else{
//          如果是激活状态，可以暂停，参数1 ：流程定义id ，参数2：是否暂停，参数3：暂停时间
            repositoryService.suspendProcessDefinitionById(processDefinitionId,
                    true,
                    null);
            System.out.println("processDefinitionId："+processDefinitionId+",suspend");
        }

    }

2、单个流程实例挂起

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

/**
     * 单个流程实例挂起与激活
     */
    @Test
    public void SuspendSingleProcessInstance(){
//        获取processEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//        RuntimeService
        RuntimeService runtimeService = processEngine.getRuntimeService();
//        查询流程定义的对象
        ProcessInstance processInstance = runtimeService.
                createProcessInstanceQuery().
                processInstanceId("15001").
                singleResult();
//        得到当前流程定义的实例是否都为暂停状态
        boolean suspended = processInstance.isSuspended();
//        流程定义id
        String processDefinitionId = processInstance.getId();
//        判断是否为暂停
        if(suspended){
//         如果是暂停，可以执行激活操作 ,参数：流程定义id
            runtimeService.activateProcessInstanceById(processDefinitionId);
            System.out.println("processDefinitionId："+processDefinitionId+",activate");
        }else{
//          如果是激活状态，可以暂停，参数：流程定义id
            runtimeService.suspendProcessInstanceById( processDefinitionId);
            System.out.println("processDefinitionId："+processDefinitionId+",suspend");
        }

    }

    /**
     * 测试完成个人任务
     */
    @Test
    public void completTask(){
//        获取引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//        获取操作任务的服务 TaskService
        TaskService taskService = processEngine.getTaskService();
//        完成任务,参数：流程实例id,完成zhangsan的任务
        Task task = taskService.createTaskQuery()
                .processInstanceId("15001")
                .taskAssignee("itlils")
                .singleResult();


        System.out.println("流程实例id="+task.getProcessInstanceId());
        System.out.println("任务Id="+task.getId());
        System.out.println("任务负责人="+task.getAssignee());
        System.out.println("任务名称="+task.getName());
        taskService.complete(task.getId());
    }

第八章个人任务

一、分配任务负责人

1、固定分配

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

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

2、表达式分配

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

（1）UEL 表达式

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

a、UEL-value 定义

如图： ${assignee0}

assignee 这个变量是 activiti 的一个流程变量，或者使用这种方式定义：

如图： ${user.assignee}

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

b、UEL-method 方式

如图： ${userBean.getUserId()

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

3、UEL-method 与 UEL-value 结合

再比如： ${ldapService.findManagerForEmployee(emp)} ldapService 是 spring 容器的一个 bean，findManagerForEmployee 是该 bean 的一个方法，emp 是 activiti 流程变量， emp 作为参数传到 ldapService.findManagerForEmployee 方法中。

d、其它)d、其它

表达式支持解析基础类型、 bean、 list、 array 和 map，也可作为条件判断。如下： ${order.price > 100 && order.price < 250}

（2）编写代码配置负责人

a、定义任务分配流程变量)a、定义任务分配流程变量

如图：

b、设置流程变量

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

    @Test
    public void testDeploy(){
        //创建流程引擎配置文件
        ProcessEngineConfiguration configuration
                = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cgf.xml","processEngineConfiguration");
        //通过配置文件，创建流程
        ProcessEngine processEngine = configuration.buildProcessEngine();

        RepositoryService repositoryService = processEngine.getRepositoryService();
        Deployment deployment = repositoryService.createDeployment()
                .addClasspathResource("bpmn/holiday-uel.bpmn20.xml")//增加bpmn.xml
                .name("出差流程-uel") //名字
                .deploy();

        System.out.println("id"+deployment.getId());
        System.out.println("Name"+deployment.getName());
    }


    @Test
    public void testStartProcess(){
        //创建流程引擎配置文件
        ProcessEngineConfiguration configuration
                = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cgf.xml","processEngineConfiguration");
        //通过配置文件，创建流程
        ProcessEngine processEngine = configuration.buildProcessEngine();

        RuntimeService runtimeService = processEngine.getRuntimeService();
        //启动实例
        Map<String,Object> map=new HashMap<>();
        map.put("assignee0","itlils");
        map.put("assignee1","zhuzhu");
        map.put("assignee2","itnanls");
        map.put("assignee3","weiwei");
        ProcessInstance instance = runtimeService.startProcessInstanceByKey("holiday1",map);

        System.out.println("ProcessDefinitionId"+instance.getProcessDefinitionId());
        System.out.println("Id"+instance.getId());
        System.out.println("ActivityId"+instance.getActivityId());
    }

执行成功后，可以在act_ru_variable表中看到刚才map中的数据

（3）注意事项

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

3、监听器

idea插件中没有，在Camunda modeler中可以查询

安装Camunda modeler

下载对应的软件,这里是在win10系统下,以camunda-modeler-3.0.0-win-x64.zip为例
将下载后的压缩包解压
在idea中File -> Settings -> Tools -> External Tools里添加外部工具

通过在项目中右键找到External Tools -> camunda-modeler开始流程设计

本质

    <userTask id="sid-a69711e6-f4ae-41cb-b17e-acf4fe0f6ab7" name="创建申请">
        <extensionElements>
            <activiti:taskListener class="com.ydlclass.delegrete.MyTaskListener" event="create" />
        extensionElements>
    userTask>

可以使用监听器来完成很多Activiti流程的业务。

在本章我们使用监听器的方式来指定负责人，那么在流程设计时就不需要指定assignee。

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

Event的选项包含：

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

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

public class MyTaskListener implements TaskListener {
    @Override
    public void notify(DelegateTask delegateTask) {
        if(delegateTask.getName().equals("创建出差申请")&&
                delegateTask.getEventName().equals("create")){
            //这里指定任务负责人
            delegateTask.setAssignee("itlils");
        }
    }
}

DelegateTask对象的内容如下：

1、注意事项

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

二、查询任务

1、查询任务负责人的待办任务

代码如下：

// 查询当前个人待执行的任务
@Test
public void findPersonalTaskList() {
    // 流程定义key
    String processDefinitionKey = "myEvection1";
    // 任务负责人
    String assignee = "itlils";
    // 获取TaskService
    TaskService taskService = processEngine.getTaskService();
    List<Task> taskList = taskService.createTaskQuery()
    	.processDefinitionKey(processDefinitionKey)
    	.includeProcessVariables()
        .taskAssignee(assignee)
        .list();
    for (Task task : taskList) {
        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());
    }
}

2、关联 businessKey

需求：在 activiti 实际应用时，查询待办任务可能要显示出业务系统的一些相关信息。

比如：查询待审批出差任务列表需要将出差单的日期、出差天数等信息显示出来。

出差天数等信息在业务系统中存在，而并没有在 activiti 数据库中存在，所以是无法通过 activiti 的 api 查询到出差天数等信息。实现：在查询待办任务时，通过 businessKey（业务标识）关联查询业务系统的出差单表，查询出出差天数等信息。

@Test
    public void findProcessInstance(){
//        获取processEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//        获取TaskService
        TaskService taskService = processEngine.getTaskService();
//        获取RuntimeService
        RuntimeService runtimeService = processEngine.getRuntimeService();
//        查询流程定义的对象
        Task task = taskService.createTaskQuery()
                .processDefinitionKey("holiday")
                .taskAssignee("itlils")
                .singleResult();
//        使用task对象获取实例id
        String processInstanceId = task.getProcessInstanceId();
//          使用实例id，获取流程实例对象
        ProcessInstance processInstance = runtimeService.createProcessInstanceQuery()
                .processInstanceId(processInstanceId)
                .singleResult();
//        使用processInstance，得到 businessKey
        String businessKey = processInstance.getBusinessKey();

        System.out.println("businessKey=="+businessKey);

    }

三、办理任务

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

/**
     * 完成任务，判断当前用户是否有权限
     */
    @Test
    public void completTask() {
        //任务id
        String taskId = "8888";
//        任务负责人
        String assingee = "itlils";
        //获取processEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        // 创建TaskService
        TaskService taskService = processEngine.getTaskService();
//        完成任务前，需要校验该负责人可以完成当前任务
//        校验方法：
//        根据任务id和任务负责人查询当前任务，如果查到该用户有权限，就完成
        Task task = taskService.createTaskQuery()
                .taskId(taskId)
                .taskAssignee(assingee)
                .singleResult();
        if(task != null){
            taskService.complete(taskId);
            System.out.println("完成任务");
        }
    }

第九章流程变量

一、什么是流程变量

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

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

二、流程变量类型

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

三、流程变量作用域

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

1、globa变量

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

注意：

如： Global变量：userId（变量名）、itlils（变量值）

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

2、local变量

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

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

四、流程变量的使用方法

1、在属性上使用UEL表达式

可以在 assignee 处设置 UEL 表达式，表达式的值为任务的负责人，比如： ${assignee}， assignee 就是一个流程变量名称。

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

2、在连线上使用UEL表达式

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

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

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

五、使用Global变量控制流程

1、需求

员工创建出差申请单，由部门经理审核，部门经理审核通过后出差3天及以下由人财务直接审批，3天以上先由总经理审核，总经理审核通过再由财务审批。

2、流程定义

a.出差天数大于等于3连线条件

也可以使用对象参数命名，如holidays.num：

b、出差天数小于3连线条件

也可以使用对象参数命名，如：

3、设置global流程变量

在部门经理审核前设置流程变量，变量值为出差单信息（包括出差天数），部门经理审核后可以根据流程变量的值决定流程走向。

在设置流程变量时，可以在启动流程时设置，也可以在任务办理时设置

a、创建POJO对象

创建出差申请pojo对象

public class Holidays implements Serializable {
    /**
     * 主键id
     */
    private Long id;
    /**
     * 出差申请单名称
     */
    private String holidaysName;
    /**
     * 出差天数
     */
    private Double num;
    /**
     * 预计开始时间
     */
    private Date beginDate;
    /**
     * 预计结束时间
     */
    private Date endDate;
    /**
     * 目的地
     */
    private String destination;
    /**
     * 出差事由
     */
    private String reson;

    @Override
    public String toString() {
        return "Holidays{" +
                "id=" + id +
                ", holidaysName='" + holidaysName + '\'' +
                ", num=" + num +
                ", beginDate=" + beginDate +
                ", endDate=" + endDate +
                ", destination='" + destination + '\'' +
                ", reson='" + reson + '\'' +
                '}';
    }

    public Long getId() {
        return id;
    }

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

    public String getHolidaysName() {
        return holidaysName;
    }

    public void setHolidaysName(String holidaysName) {
        this.holidaysName = holidaysName;
    }

    public Double getNum() {
        return num;
    }

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

    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 String getDestination() {
        return destination;
    }

    public void setDestination(String destination) {
        this.destination = destination;
    }

    public String getReson() {
        return reson;
    }

    public void setReson(String reson) {
        this.reson = reson;
    }
}

b、启动流程时设置变量

在启动流程时设置流程变量，变量的作用域是整个流程实例。

通过Map设置流程变量，map中可以设置多个变量，这个key就是流程变量的名字。

    /**
     * 启动流程实例,设置流程变量的值
     */
    @Test
    public void startProcess(){
        //创建流程引擎配置文件
        ProcessEngineConfiguration configuration
                = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cgf.xml","processEngineConfiguration");
        //通过配置文件，创建流程
        ProcessEngine processEngine = configuration.buildProcessEngine();

        RuntimeService runtimeService = processEngine.getRuntimeService();
        //启动实例
        Map<String,Object> map=new HashMap<>();
        Holidays holidays = new Holidays();
        holidays.setNum(2d);
        map.put("holidays",holidays);

        map.put("assignee0","itlils");
        map.put("assignee1","zhuzhu");
        map.put("assignee2","itnanls");
        map.put("assignee3","weiwei");
        ProcessInstance instance = runtimeService.startProcessInstanceByKey("holiday-global1",map);

        System.out.println("ProcessDefinitionId"+instance.getProcessDefinitionId());
        System.out.println("Id"+instance.getId());
        System.out.println("ActivityId"+instance.getActivityId());
    }

    @Test
    public void testCompletTask(){
        //创建流程引擎配置文件
        ProcessEngineConfiguration configuration
                = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cgf.xml","processEngineConfiguration");
        //通过配置文件，创建流程
        ProcessEngine processEngine = configuration.buildProcessEngine();
        TaskService taskService = processEngine.getTaskService();

        Task task1 = taskService.createTaskQuery()
                .processDefinitionKey("holiday-global1")
                .taskAssignee("weiwei1")
                .singleResult();

        if(task1!=null){
            taskService.complete(task1.getId());
        }

    }

说明：

startProcessInstanceByKey(processDefinitionKey, variables)

流程变量作用域是一个流程实例，流程变量使用Map存储，同一个流程实例设置变量map中key相同，后者覆盖前者。

c、任务办理时设置变量

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

这里需要在创建出差单任务完成时设置流程变量

    /**
     * 完成任务，判断当前用户是否有权限
     */
    @Test
    public void completTask() {
        //任务id
        String key = "holiday-global1";
//        任务负责人
        String assingee = "itlils";
//       获取processEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//       创建TaskService
        TaskService taskService = processEngine.getTaskService();
//       创建变量集合
        Map<String, Object> map = new HashMap<>();
//        创建出差pojo对象
        Holidays holidays = new Holidays();
        holidays.setNum(2d);
        map.put("holidays",holidays);
//        完成任务前，需要校验该负责人可以完成当前任务
//        校验方法：
//        根据任务id和任务负责人查询当前任务，如果查到该用户有权限，就完成
        Task task = taskService.createTaskQuery()
                .processDefinitionKey(key)
                .taskAssignee(assingee)
                .singleResult();
        if(task != null){
            //完成任务是，设置流程变量的值
            taskService.complete(task.getId(),map);
            System.out.println("任务执行完成");
        }
    }

说明：

通过当前任务设置流程变量，需要指定当前任务id，如果当前执行的任务id不存在则抛出异常。

任务办理时也是通过map设置流程变量，一次可以设置多个变量。

d、通过当前流程实例设置

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

    @Test
    public void setGlobalVariableByExecutionId(){
//    当前流程实例执行 id，通常设置为当前执行的流程实例
        String executionId="2601";
//     获取processEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//        获取RuntimeService
        RuntimeService runtimeService = processEngine.getRuntimeService();
//        创建出差pojo对象
        Holidays holidays = new Holidays();
        holidays.setNum(2d);
//      通过流程实例 id设置流程变量
        runtimeService.setVariable(executionId, "holidays", holidays);
//      一次设置多个值
//      runtimeService.setVariables(executionId, variables)
    }

注意：

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

e、通过当前任务设置

@Test
	public void setGlobalVariableByTaskId(){
		
		//当前待办任务id
		String taskId="1404";
//     获取processEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
		TaskService taskService = processEngine.getTaskService();
        Holidays holidays = new Holidays();
        holidays.setNum(2d);
		//通过任务设置流程变量
		taskService.setVariable(taskId, "holidays", holidays);
		//一次设置多个值 
		//taskService.setVariables(taskId, variables)
	}

注意：

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

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

4、测试

正常测试：

设置流程变量的值大于等于3天

设计流程变量的值小于3天

异常测试：

流程变量不存在

流程变量的值为空NULL，price属性为空

UEL表达式都不符合条件

不设置连线的条件

5、注意事项

1、如果UEL表达式中流程变量名不存在则报错。

2、如果UEL表达式中流程变量值为空NULL，流程不按UEL表达式去执行，而流程结束。

3、如果UEL表达式都不符合条件，流程结束

4、如果连线不设置条件，会走flow序号小的那条线

6、操作数据库表

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

//当前流程变量表
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 = "1404";
//  获取processEngine
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    TaskService taskService = processEngine.getTaskService();
//  定义流程变量
   Map<String, Object> variables = new HashMap<String, Object>();
   Holidays holidays = new Holidays();
   holidays.setNum(2d);
// 定义流程变量
   Map<String, Object> variables = new HashMap<String, Object>();
//  变量名是holiday，变量值是holiday对象
    variables.put("holidays", holidays);
//  设置local变量，作用域为该任务
    taskService.setVariablesLocal(taskId, variables);
//  完成任务
   taskService.complete(taskId);
}

说明：

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

2、通过当前任务设置

@Test
public void setLocalVariableByTaskId(){
//   当前待办任务id
    String taskId="1404";
//  获取processEngine
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    TaskService taskService = processEngine.getTaskService();
    Holidays holidays = new Holidays();
    holidays.setNum(2d);
//  通过任务设置流程变量
    taskService.setVariableLocal(taskId, "holidays", holidays);
//  一次设置多个值 
    //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变量需要经过反序列化，不推荐使用。

第十章组任务

一、需求

在流程定义中在任务结点的 assignee 固定设置任务负责人，在流程定义时将参与者固定设置在.bpmn 文件中，如果临时任务负责人变更则需要修改流程定义，系统可扩展性差。

针对这种情况可以给任务设置多个候选人，可以从候选人中选择参与者来完成任务。

二、设置任务候选人

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

查看bpmn文件

<userTask id="sid-d5f4b312-5249-4630-a903-4957eb84d0c4" name="部门经理审核" activiti:candidateUsers="itwangls,itsongls"/>

我们可以看到部门经理的审核人已经设置为 lisi,wangwu 这样的一组候选人，可以使用

activiti:candiateUsers=”用户 1,用户 2,用户 3”的这种方式来实现设置一组候选人

三、组任务

1、组任务办理流程

（1）查询组任务

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

候选人不能立即办理任务。

（2）拾取(claim)任务

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

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

如果拾取后不想办理该任务？

需要将已经拾取的个人任务归还到组里边，将个人任务变成了组任务。

（3）查询个人任务

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

（4）办理个人任务

2、查询组任务

根据候选人查询组任务

   @Test
   public void findGroupTaskList() {
      // 流程定义key
      String processDefinitionKey = "holiday-group1";
      // 任务候选人
      String candidateUser = "itwangls";
       //  获取processEngine
      ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
      // 创建TaskService
      TaskService taskService = processEngine.getTaskService();
      //查询组任务
      List<Task> list = taskService.createTaskQuery()
             .processDefinitionKey(processDefinitionKey)
             .taskCandidateUser(candidateUser)//根据候选人查询
             .list();
      for (Task task : list) {
          System.out.println("----------------------------");
          System.out.println("InstanceId：" + task.getProcessInstanceId());
          System.out.println("id：" + task.getId());
          System.out.println("Assignee：" + task.getAssignee());
          System.out.println("Name：" + task.getName());
      }
   }

3、拾取组任务

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

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

说明：即使该用户不是候选人也能拾取，建议拾取时校验是否有资格

组任务拾取后，该任务已有负责人，通过候选人将查询不到该任务

4、查询个人待办任务

查询方式同个人任务查询

@Test
public void findPersonalTaskList() {
   // 流程定义key
   String processDefinitionKey = "evection1";
   // 任务负责人
   String assignee = "itwangls";
    //  获取processEngine
      ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
   // 创建TaskService
   TaskService taskService = processEngine.getTaskService();
   List<Task> list = taskService.createTaskQuery()
       .processDefinitionKey(processDefinitionKey)
       .taskAssignee(assignee)
       .list();
   for (Task task : list) {
       System.out.println("----------------------------");
       System.out.println("流程实例id：" + task.getProcessInstanceId());
       System.out.println("任务id：" + task.getId());
       System.out.println("任务负责人：" + task.getAssignee());
       System.out.println("任务名称：" + task.getName());
   }
}

5、办理个人任务

同个人任务办理

 /*完成任务*/
   @Test
   public void completeTask(){
//     任务ID
      String taskId = "12304";
//     获取processEngine
      ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
      processEngine.getTaskService()
                   .complete(taskId);
      System.out.println("完成任务："+taskId);
   }

说明：建议完成任务前校验该用户是否是该任务的负责人。

6、归还组任务

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

/*
*归还组任务，由个人任务变为组任务，还可以进行任务交接
*/
@Test
public void setAssigneeToGroupTask() {
    //  获取processEngine
       ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
   // 查询任务使用TaskService
   TaskService taskService = processEngine.getTaskService();
   // 当前待办任务
   String taskId = "6004";
   // 任务负责人
   String userId = "zhangsan2";
    // 校验userId是否是taskId的负责人，如果是负责人才可以归还组任务
   Task task = taskService
       .createTaskQuery()
       .taskId(taskId)
       .taskAssignee(userId)
       .singleResult();
    if (task != null) {
       // 如果设置为null，归还组任务,该 任务没有负责人
       taskService.setAssignee(taskId, null);
    }
}

说明：建议归还任务前校验该用户是否是该任务的负责人

也可以通过setAssignee方法将任务委托给其它用户负责，注意被委托的用户可以不是候选人（建议不要这样使用）

7、任务交接

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

   @Test
   public void setAssigneeToCandidateUser() {
       //  获取processEngine
      ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
      // 查询任务使用TaskService
      TaskService taskService = processEngine.getTaskService();
      // 当前待办任务
      String taskId = "6004";
      // 任务负责人
      String userId = "itwangls";
      // 将此任务交给其它候选人办理该 任务
      String candidateuser = "itsongls";
      // 校验userId是否是taskId的负责人，如果是负责人才可以归还组任务
      Task task = taskService
          .createTaskQuery()
          .taskId(taskId)
          .taskAssignee(userId)
          .singleResult();
      if (task != null) {
          taskService.setAssignee(taskId, candidateuser);
      }
   }

8、数据库表操作

查询当前任务执行表

SELECT * FROM act_ru_task

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

查询任务参与者

SELECT * FROM act_ru_identitylink

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

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

第十一章网关

网关用来控制流程的流向

一、排他网关ExclusiveGateway

1、什么是排他网关：

排他网关，用来在流程中实现决策。当流程执行到这个网关，所有分支都会判断条件是否为true，如果为true则执行该分支，

注意：排他网关只会选择一个为true的分支执行。如果有两个分支条件都为true，排他网关会选择id值较小的一条分支去执行。

为什么要用排他网关？

不用排他网关也可以实现分支，如：在连线的condition条件上设置分支条件。

在连线设置condition条件的缺点：如果条件都不满足，流程就结束了(是异常结束)。

如果使用排他网关决定分支的走向，如下：

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

org.activiti.engine.ActivitiException: No outgoing sequence flow of the exclusive gateway 'exclusivegateway1' could be selected for continuing the process
   at org.activiti.engine.impl.bpmn.behavior.ExclusiveGatewayActivityBehavior.leave(ExclusiveGatewayActivityBehavior.java:85)

2、流程定义

排他网关图标，红框内：

3、测试

在部门经理审核后，走排他网关，从排他网关出来的分支有两条，一条是判断出差天数是否大于3天，另一条是判断出差天数是否小于等于3天。

设置分支条件时，如果所有分支条件都不是true，报错：

org.activiti.engine.ActivitiException: No outgoing sequence flow of the exclusive gateway 'exclusivegateway1' could be selected for continuing the process
       at org.activiti.engine.impl.bpmn.behavior.ExclusiveGatewayActivityBehavior.leave(ExclusiveGatewayActivityBehavior.java:85)

二、并行网关ParallelGateway

1、什么是并行网关

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

l fork分支：

并行后的所有外出顺序流，为每个顺序流都创建一个并发分支。

l join汇聚：

所有到达并行网关，在此等待的进入分支，直到所有进入顺序流的分支都到达以后，流程就会通过汇聚网关。

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

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

例子：

说明：

技术经理和项目经理是两个execution分支，在act_ru_execution表有两条记录分别是技术经理和项目经理，act_ru_execution还有一条记录表示该流程实例。

待技术经理和项目经理任务全部完成，在汇聚点汇聚，通过parallelGateway并行网关。

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

2、流程定义

并行网关图标，红框内：

3、测试

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

当前任务表：SELECT * FROM act_ru_task

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WIlOaSTI-1667528089274)(/Users/xiaoweiya/Desktop/笔记 2/img/image-20220914155246478.png)]

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

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

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

对并行任务的执行：

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

执行部门经理任务后，查询当前任务表 SELECT * FROM act_ru_task

已完成的技术经理任务在当前任务表act_ru_task_已被删除。

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

当所有分支任务都完成，都到达汇聚结点后：

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

三、包含网关InclusiveGateway

1、什么是包含网关

包含网关可以看做是排他网关和并行网关的结合体。

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

包含网关的功能是基于进入和外出顺序流的：

l 分支：

所有外出顺序流的条件都会被解析，结果为true的顺序流会以并行方式继续执行，会为每个顺序流创建一个分支。

l 汇聚：

所有并行分支到达包含网关，会进入等待状态，直到每个包含流程token的进入顺序流的分支都到达。这是与并行网关的最大不同。换句话说，包含网关只会等待被选中执行了的进入顺序流。在汇聚之后，流程会穿过包含网关继续执行。

2、流程定义：

出差申请大于等于3天需要由项目经理审批，小于3天由技术经理审批，出差申请必须经过人事经理审批。

包含网关图标，红框内：

定义流程：

注意：通过包含网关的每个分支的连线上设置condition条件。

3、测试

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

org.activiti.engine.ActivitiException: Unknown property used in expression: ${evection.num>=3}

需要在流程启动时设置流程变量holidays.num。

task表：

(1)启动

(2))itlils做完之后

(3))zhuzhu 和 itwangls 完成

(4)改cto审核

四、事件网关EventGateway

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

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

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

内部课程~~~~

第十二章 Activiti与Spring整合开发

一、 Activiti与Spring整合的配置

1、在pom.xml文件引入坐标

如下

<properties>
        <slf4j.version>1.6.6slf4j.version>
        <log4j.version>1.2.12log4j.version>
properties>
<dependencies>
    <dependency>
        <groupId>org.activitigroupId>
        <artifactId>activiti-engineartifactId>
        <version>7.0.0.Beta1version>
    dependency>
    <dependency>
        <groupId>org.activitigroupId>
        <artifactId>activiti-springartifactId>
        <version>7.0.0.Beta1version>
    dependency>
    <dependency>
        <groupId>org.activitigroupId>
        <artifactId>activiti-bpmn-modelartifactId>
        <version>7.0.0.Beta1version>
    dependency>
    <dependency>
        <groupId>org.activitigroupId>
        <artifactId>activiti-bpmn-converterartifactId>
        <version>7.0.0.Beta1version>
    dependency>
    <dependency>
        <groupId>org.activitigroupId>
        <artifactId>activiti-json-converterartifactId>
        <version>7.0.0.Beta1version>
    dependency>
    <dependency>
        <groupId>org.activitigroupId>
        <artifactId>activiti-bpmn-layoutartifactId>
        <version>7.0.0.Beta1version>
    dependency>
    <dependency>
        <groupId>org.activiti.cloudgroupId>
        <artifactId>activiti-cloud-services-apiartifactId>
        <version>7.0.0.Beta1version>
    dependency>
    <dependency>
        <groupId>aspectjgroupId>
        <artifactId>aspectjweaverartifactId>
        <version>1.5.4version>
    dependency>
    <dependency>
        <groupId>mysqlgroupId>
        <artifactId>mysql-connector-javaartifactId>
        <version>5.1.40version>
    dependency>
    <dependency>
        <groupId>junitgroupId>
        <artifactId>junitartifactId>
        <version>4.12version>
    dependency>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-testartifactId>
        <version>5.0.7.RELEASEversion>
    dependency>
    
    <dependency>
        <groupId>log4jgroupId>
        <artifactId>log4jartifactId>
        <version>${log4j.version}version>
    dependency>
    <dependency>
        <groupId>org.slf4jgroupId>
        <artifactId>slf4j-apiartifactId>
        <version>${slf4j.version}version>
    dependency>
    <dependency>
        <groupId>org.slf4jgroupId>
        <artifactId>slf4j-log4j12artifactId>
        <version>${slf4j.version}version>
    dependency>
    <dependency>
        <groupId>org.slf4jgroupId>
        <artifactId>slf4j-nopartifactId>
        <version>${slf4j.version}version>
    dependency>
    
    <dependency>
        <groupId>org.mybatisgroupId>
        <artifactId>mybatisartifactId>
        <version>3.4.5version>
    dependency>
    <dependency>
        <groupId>commons-dbcpgroupId>
        <artifactId>commons-dbcpartifactId>
        <version>1.4version>
    dependency>
dependencies>
<repositories>
    <repository>
        <id>alfrescoid>
        <name>Activiti Releasesname>
        <url>https://artifacts.alfresco.com/nexus/content/repositories/activiti-releases/url>
        <releases>
            <enabled>trueenabled>
        releases>
    repository>
repositories>

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

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

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

2、创建activiti-spring.xml

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/activiti"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
        <property name="maxActive" value="3"/>
        <property name="maxIdle" value="1"/>
    bean>
    
    <bean id="processEngineConfiguration" class="org.activiti.spring.SpringProcessEngineConfiguration">
        
        <property name="dataSource" ref="dataSource"/>
        
        <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>
    
    <bean id="repositoryService" factory-bean="processEngine" factory-method="getRepositoryService"/>
    
    <bean id="runtimeService" factory-bean="processEngine"  factory-method="getRuntimeService"/>
    
    <bean id="taskService" factory-bean="processEngine" factory-method="getTaskService"/>
    
    <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>
    
beans>

databaseSchemaUpdate的取值内容：

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

二、测试Activiti与Spring整合

1、测试代码

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

2、执行流程分析

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

1、加载activiti-spring.xml配置文件

2、加载SpringProcessEngineConfiguration对象，这个对象它需要依赖注入dataSource对象和transactionManager对象。

3、加载ProcessEngineFactoryBean工厂来创建ProcessEngine对象，而ProcessEngineFactoryBean工厂又需要依赖注入processEngineConfiguration对象。

4、processEngine对象来负责创建我们的Service对象，从而简化Activiti的开发过程。

第十三章 Activiti7与SpringBoot整合开发

Activiti7发布正式版之后，它与SpringBoot2.x已经完全支持整合开发。

一、SpringBoot整合Activiti7的配置

为了能够实现SpringBoot与Activiti7整合开发，首先我们要引入相关的依赖支持。

在工程的pom.xml文件中引入相关的依赖，其中activiti的依赖是：activiti-spring-boot-starter。

具体依赖如下所示：

<parent>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-parentartifactId>
    <version>2.1.0.RELEASEversion>
parent>
<properties>
    <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8project.reporting.outputEncoding>
    <java.version>1.8java.version>
properties>
<dependencies>
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-webartifactId>
    dependency>
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-jdbcartifactId>
    dependency>
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-testartifactId>
    dependency>
    <dependency>
        <groupId>org.activitigroupId>
        <artifactId>activiti-spring-boot-starterartifactId>
        <version>7.0.0.Beta2version>
    dependency>
    <dependency>
        <groupId>mysqlgroupId>
        <artifactId>mysql-connector-javaartifactId>
        <version>5.1.29version>
    dependency>
    <dependency>
        <groupId>org.projectlombokgroupId>
        <artifactId>lombokartifactId>
    dependency>
dependencies>
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-maven-pluginartifactId>
        plugin>
    plugins>
build>

通过该pom.xml文件所导入的坐标，我们就可以实现activiti7与Springboot整合。

二、 SpringBoot的application.yml文件配置

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

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

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

三、编写启动类

package com.ydlclass;

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

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

四、添加SpringSecurity安全框架整合配置

因为Activiti7与SpringBoot整合后，默认情况下，集成了SpringSecurity安全框架，这样我们就要去准备SpringSecurity整合进来的相关用户权限配置信息。

SpringBoot的依赖包已经将SpringSecurity的依赖包也添加进项目中。

1、添加SecurityUtil类

为了能够快速实现SpringSecurity安全框架的配置，所添加的一个组件。

package com.ydlclass.utils;

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

import java.util.Collection;


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

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

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

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

这个类可以从我们下载的Activiti7官方提供的Example中找到。

2、添加DemoApplicationConfig类

在Activiti7官方下载的Example中找到DemoApplicationConfig类，它的作用是为了实现SpringSecurity框架的用户权限的配置，这样我们就可以在系统中使用用户权限信息。

本次项目中基本是在文件中定义出来的用户信息，当然也可以是数据库中查询的用户权限信息。

后面处理流程时用到的任务负责人，需要添加在这里

package com.ydlclass.config;

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

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

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

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

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

五、创建Bpmn文件

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

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

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

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

六、使用Junit方式测试

package com.ydlclass;


import com.ydlclass.config.SecurityUtil;
import lombok.extern.slf4j.Slf4j;
import org.activiti.api.process.model.ProcessDefinition;
import org.activiti.api.process.model.ProcessInstance;
import org.activiti.api.process.model.builders.ProcessPayloadBuilder;
import org.activiti.api.process.runtime.ProcessRuntime;
import org.activiti.api.runtime.shared.query.Page;
import org.activiti.api.runtime.shared.query.Pageable;
import org.activiti.api.task.model.Task;
import org.activiti.api.task.model.builders.ClaimTaskPayloadBuilder;
import org.activiti.api.task.model.builders.TaskPayloadBuilder;
import org.activiti.api.task.runtime.TaskRuntime;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.List;

/**
 * @Created by IT李老师
 * 公主号 “元动力课堂”
 * 个人微 itlils
 */
@Slf4j
@RunWith(SpringRunner.class)
@SpringBootTest(classes = ActApplication.class)
public class TestAct {
    @Autowired
    ProcessRuntime processRuntime;

    @Autowired
    SecurityUtil securityUtil;

    //查看流程定义，体验自动部署：check-process-definitions: true
    @Test
    public void testProcessDef() {
        securityUtil.logInAs("admin");

        Page<ProcessDefinition> processDefinitionPage = processRuntime.processDefinitions(Pageable.of(0, 20));
        log.info("num:" + processDefinitionPage.getTotalItems());

        List<ProcessDefinition> content = processDefinitionPage.getContent();
        for (ProcessDefinition processDefinition : content) {
            log.info("================");
            log.info("DefinitionPag:" + processDefinition);
            log.info("================");
        }

    }


    //启动流程
    @Test
    public void testStartProcess() {
        securityUtil.logInAs("itlils");
        ProcessInstance holiday1 = processRuntime.start(
                ProcessPayloadBuilder
                        .start()
                        .withProcessDefinitionKey("holiday1")
                        .build());
        log.info(holiday1.getId());
        log.info(holiday1.toString());
    }

    @Autowired
    TaskRuntime taskRuntime;

    //拾取任务，完成任务
    @Test
    public void testClaimAndCompleteTask() {
        securityUtil.logInAs("itnanls");

        Page<Task> taskPage = taskRuntime.tasks(Pageable.of(0, 20));

        if (taskPage.getTotalItems() > 0) {
            for (Task task : taskPage.getContent()) {
                //拾取
                taskRuntime.claim(TaskPayloadBuilder.claim().withTaskId(task.getId()).build());
                log.info("itnanls claim task:"+task.getId());

                //完成
                taskRuntime.complete(TaskPayloadBuilder.complete().withTaskId(task.getId()).build());
            }
        }


    }
}

第十四章小demo

代码在资源下载区，只需导入4个sql即可。

项目结构

转载于https://www.ydlclass.com/doc21xnv/other/activiti/#%E4%BA%8C%E3%80%81activit-%E5%A6%82%E4%BD%95%E4%BD%BF%E7%94%A8
特别鸣谢元动力文档如有侵权联系删除

Activiti7 工作流引擎入门