Activiti7工作流引擎

一、什么是工作流

官网：

1.1、工作流介绍

• 工作流：工作的一个流程，事物发展的一个业务过程。
  • 流程：传统方式（请假条的传递来实现），现在（无纸化办公），在计算机的帮助下，能够实现流程的自动化控制，就称为工作流。
• 工作流引擎：为了实现自动化控制，Activiti引擎就产生了。
  • 作用：实现流程的自动化控制。
• 工作流系统：具有工作流的系统（如果一个系统具备流程的自动化管理功能，这个系统就可以称为工作流系统）。

工作流系统的实现手段（如何实现流程的自动化管理？）
流程自动化管理：程序员编码（通过状态字段）来实现—需求变更，需要改动源代码。
如何解决，以不变应万变？----Activiti就可以实现业务流程变化后，程序代码不需要改动。

1.2、工作流原理实现步骤

1. 先将流程图画好。（业务流程图规范化，要遵守一套标准【使用BPMN工具建模】）

2. 将流程图中每个结点的数据读取并放入表中。（流程图本质上是是一个xml文件）

3. 读取表中的第一条记录，处理并删除。（解析xml文件，将数据插入到mysql表中，形成一条记录）

4. 将所有的结点都读取并存入mysql表中

5. 后面只要读取mysql表中的记录就可以了，读一条记录就相当于读一个结点。

6. 业务流程的推进，后面就转化为读表中数据，并且处理数据，结束时这一行数据就可以删除了。

（实现的技术，xml + dom4j + mysql + jdbc）

1.3、SaaS-IHRM（人力资源管理项目）

1. 整合Activiti
2. 实现业务流程建模，使用BPMN实现业务流程图
3. 部署业务流程到Activiti
4. 启动流程实例
5. 查询待办任务
6. 处理待办任务
7. 结束流程

二、Activiti7和项目搭建

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

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

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

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

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

<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL"
             xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI"
             xmlns:omgdc="http://www.omg.org/spec/DD/20100524/DC"
             typeLanguage="http://www.w3.org/2001/XMLSchema"
             expressionLanguage="http://www.w3.org/1999/XPath"
             targetNamespace="http://www.activiti.org/test">
    <process id="myProcess" name="My process" isExecutable="true">
        <startEvent id="startevent1" name="Start">startEvent>
        <userTask id="usertask1" name="创建请假单">userTask>
        <sequenceFlow id="flow1" sourceRef="startevent1"
                      targetRef="usertask1">sequenceFlow>
        <userTask id="usertask2" name="部门经理审核">userTask>
        <sequenceFlow id="flow2" sourceRef="usertask1"
                      targetRef="usertask2">sequenceFlow>
        <userTask id="usertask3" name="人事复核">userTask>
        <sequenceFlow id="flow3" sourceRef="usertask2"
                      targetRef="usertask3">sequenceFlow>
        <endEvent id="endevent1" name="End">endEvent>
        <sequenceFlow id="flow4" sourceRef="usertask3"
                      targetRef="endevent1">sequenceFlow>
    process>
    <bpmndi:BPMNDiagram id="BPMNDiagram_myProcess">
        <bpmndi:BPMNPlane bpmnElement="myProcess" id="BPMNPlane_myProcess">
            <bpmndi:BPMNShape bpmnElement="startevent1" id="BPMNShape_startevent1">
                <omgdc:Bounds height="35.0" width="35.0" x="130.0"
                              y="160.0">omgdc:Bounds>
            bpmndi:BPMNShape>
            <bpmndi:BPMNShape bpmnElement="usertask1" id="BPMNShape_usertask1">
                <omgdc:Bounds height="55.0" width="105.0" x="210.0"
                              y="150.0">omgdc:Bounds>
            bpmndi:BPMNShape>
            <bpmndi:BPMNShape bpmnElement="usertask2" id="BPMNShape_usertask2">
                <omgdc:Bounds height="55.0" width="105.0" x="360.0"
                              y="150.0">omgdc:Bounds>
            bpmndi:BPMNShape>
            <bpmndi:BPMNShape bpmnElement="usertask3" id="BPMNShape_usertask3">
                <omgdc:Bounds height="55.0" width="105.0" x="510.0"y="150.0">omgdc:Bounds>
            bpmndi:BPMNShape>
            <bpmndi:BPMNShape bpmnElement="endevent1" id="BPMNShape_endevent1">
                <omgdc:Bounds height="35.0" width="35.0" x="660.0"
                              y="160.0">omgdc:Bounds>
            bpmndi:BPMNShape>
            <bpmndi:BPMNEdge bpmnElement="flow1" id="BPMNEdge_flow1">
                <omgdi:waypoint x="165.0" y="177.0">omgdi:waypoint>
                <omgdi:waypoint x="210.0" y="177.0">omgdi:waypoint>
            bpmndi:BPMNEdge>
            <bpmndi:BPMNEdge bpmnElement="flow2" id="BPMNEdge_flow2">
                <omgdi:waypoint x="315.0" y="177.0">omgdi:waypoint>
                <omgdi:waypoint x="360.0" y="177.0">omgdi:waypoint>
            bpmndi:BPMNEdge>
            <bpmndi:BPMNEdge bpmnElement="flow3" id="BPMNEdge_flow3">
                <omgdi:waypoint x="465.0" y="177.0">omgdi:waypoint>
                <omgdi:waypoint x="510.0" y="177.0">omgdi:waypoint>
            bpmndi:BPMNEdge>
            <bpmndi:BPMNEdge bpmnElement="flow4" id="BPMNEdge_flow4">
                <omgdi:waypoint x="615.0" y="177.0">omgdi:waypoint>
                <omgdi:waypoint x="660.0" y="177.0">omgdi:waypoint>
            bpmndi:BPMNEdge>
        bpmndi:BPMNPlane>
    bpmndi:BPMNDiagram>
definitions>

Activit 如何使用

1. 部署 activiti

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

2. 流程定义

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

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

3. 流程定义部署

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

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

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

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

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

6. 用户办理任务

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

7. 流程结束

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

2.1、搭建环境及步骤

2.1.1、开发环境

• Java 环境
  Jdk1.8 或以上版本。

• 数据库
  Mysql 5 及以上的版本
  本教程采用 5.5 版本

• Web 容器
  本项目采用的是 Tomcat8.5

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

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

2.1.2、Activiti 环境

• Activiti7.0.0.Beta1
  默认支持 spring5

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

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

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

2. Docs
   Activiti 的帮助文档。

3. Wars
   官方自带的示例工程。

2.1.3、步骤

1. 安装Activiti插件
2. 导入依赖jar包
3. properties日志文件添加
4. 配置activiti.cfg.xml（数据源配置dbcp、Activiti单独运行的ProcessEngine配置，使用单独启动的方式），默认情况下，bean的id=processEngineConfiguration。——（数据源可以直接配置在processEngineConfiguration中）
5. 测试类（在数据库生成25张表）
   • 创建ProcessEngineConfiguration对象（读取配置文件）
   • 创建ProcessEngine对象
   • 输出processEngine对象

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

Eclispe 工具下插件安装方式

本教程使用 Activiti –Designer-eclipse-plugin（activiti 流程设计器插件）完成流程的制作。
下面介绍了 activiti designer 设计器插件的安装方式，本教程使用的插件安装方式详细参考“activiti开发环境配置.docx”文档的“Eclipse 插件安装”章节。

网络在线安装：

1. 打开 Help -> Install New Software. 在如下面板中:
   
2. 在如下 Install 界面板中，点击 Add 按钮：
   
   配置新装插件的地址和名称
3. 然后填入下列字段

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

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

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

6. 安装完以后，点击新建工程 new->Other…打开面板，如果看到下图内容：
   
   说明安装成功了。

补充说明

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

虽然流程引擎在单独部署 bpmn 文件时会自动生成图片，但在实际开发过程中，自动生成的图片会导致和 BPMN 中的坐标有出入，在实际项目中展示流程当前位置图会有问题。

所在完成以上配置后，会由我们自己来管理流程图片。在发布流程时把流程规则文件和流程图片一起上传就行了。

2.1.5、Activiti Designer 流程设计器(IDEA 工具)

在 IDEA 的 File 菜单中找到子菜单”Settings”,后面我们再选择左侧的“plugins”菜单，如下图所示：

此时我们就可以搜索到 actiBPM 插件，它就是 Activiti Designer 的 IDEA 版本。

安装好后，页面如下：

2.2、创建mysql数据库

本教程使用 mysql 数据库。
创建 mysql 数据库 activiti（名字任意）：

CREATE DATABASE activiti DEFAULT CHARACTER SET utf8;

2.3、创建表方式

通过运行Java程序创建表。

2.3.1、创建 java 工程

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

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

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

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

我们使用 maven 来实现项目的构建，所以应当导入这些 jar 所对应的坐标到 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.activiti.cloudgroupId>
            <artifactId>activiti-cloud-services-apiartifactId>
            <version>7.0.0.Beta1version>
        dependency>
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
            <version>8.0.21version>
        dependency>
        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.12version>
        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.mybatisgroupId>
            <artifactId>mybatisartifactId>
            <version>3.4.5version>
        dependency>
        <dependency>
            <groupId>commons-dbcpgroupId>
            <artifactId>commons-dbcpartifactId>
            <version>1.4version>
        dependency>
    dependencies>

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

2.3.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">
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?useUnicode=true&characterEncoding=UTF-8&nullCatalogMeansCurrent=true"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    bean>

processEngineConfiguration

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

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

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

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

2.3.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 名称

2.5、数据表的命名规则

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，同学们需要了解一下。

3.1、activiti.cfg.xml

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

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-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/tx
 http://www.springframework.org/schema/tx/spring-tx-3.1.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="root" />

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

3.2、ProcessEngineConfiguration

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

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

3.2.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.itheima.ihrm.service.impl.*.*(..))" />
    aop:config>
beans>

3.2.3 创建 processEngineConfiguration

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

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

ProcessEngineConfiguration.createProcessEngineConfigurationFromResource(String resource, String beanName);

3.3、ProcessEngine

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

• 一般创建方式

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

• 简单创建方式

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

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

3.4、Service

3.4.1、Service 创建方式

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

方式如下：

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

3.4.2、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 入门体验

4.1、流程定义

4.1.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），就可以看到进入了流程设计页面

3. 新建流程(Eclipse 工具)

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

创建成功：

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

4.1.2、绘制流程

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

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

4.1.3、指定流程定义key

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

建议：相同的业务流程，流程定义的 key 名字定义一样，比如，如果需要创建新的业务流程，请假流程则使用新的 key。

4.1.4、指定任务负责人

在 properties 视图指定每个任务结点的负责人，比如下边是填写请假单的负责人为 zhangsan

4.2、部署流程定义

部署流程定义就是要将上边绘制的图形即流程定义（.bpmn）部署在工作流程引擎 activiti 中，方法如下：

创建一个activiti包，在创建一个ActivitiDeployment类：

package com.roc.activiti;

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

/**
 * @description: 流程定义的部署
 * @author:
 * @create: 2020-11-04 14:31
 * 影响的数据库表
 * 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")  //添加bpmn资源
                .addClasspathResource("diagram/holiday.png")
                .name("请假流程")
                .deploy();

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

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

4.3、启动一个流程实例

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

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

代码如下：

package com.roc.activiti;

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.runtime.ProcessInstance;

/**
 * @description: 启动流程实例：前提是先已经完成流程定义的部署工作
 * @author:
 * @create: 2020-11-04 15:04
 * 背后影响的数据库表：
 * 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需要知道
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("holiday");

        //4. 输出实例的相关信息
        System.out.println("流程部署ID" + processInstance.getDeploymentId());        //流程部署IDnull
        System.out.println("流程定义ID" + processInstance.getProcessDefinitionId()); //流程定义IDholiday:1:4
        System.out.println("流程实例ID" + processInstance.getId());                  //流程实例ID2501
        System.out.println("活动ID" + processInstance.getActivityId());              //活动IDnull
    }
}

4.4、任务查询

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

package com.roc.activiti;

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.TaskService;
import org.activiti.engine.task.Task;

import java.util.List;

/**
 * @description: 查询当前用户的任务列表
 * @author:
 * @create: 2020-11-04 15:32
 */
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());
        }
    }

}

4.5 任务处理

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

package com.roc.activiti;

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.TaskService;

/**
 * @description: 处理当前用户的任务
 * @author:
 * @create: 2020-11-04 15:53
 * 背后操作的表:
 * act_hi_actinst
 * act_hi_identitylink
 * act_hi_taskinst
 * act_ru_identitylink
 * act_ru_task
 */
public class ActivitiCompleteTask {

    //zhangsan完成自己的任务
    public static void main(String[] args) {
        //1. 得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

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

        //3. 处理任务，结合当前用户任务列表的查询操作的话，任务ID:2505
        taskService.complete("2505");

    }

 /*   //查询当前用户wangwu的任务并处理掉
    public static void main(String[] args) {
        //1. 得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

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

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

        //4. 处理任务，结合当前用户任务列表的查询操作的话，任务ID:task.getId()
        taskService.complete(task.getId());

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

    }*/
}

五、流程定义

5.1、流程定义

5.1.1、什么是流程定义

流程定义是线下按照 bpmn2.0 标准去描述 业务流程，通常使用 activiti-explorer（web 控制台）或activiti-eclipse-designer插件对业务流程进行建模，这两种方式都遵循 bpmn2.0 标准。本教程使用activiti-eclipse-designer 插件完成流程建模。使用 designer 设计器绘制流程，会生成两个文件：.bpmn和.png

5.1.2、.bpmn 文件改为.xml文件

使用 activiti-desinger 设计业务流程，会生成.bpmn 文件，
首先将holiday.bpmn 文件改名为 holiday.xml

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

流程定义部分： 定义了流程每个结点的描述及结点之间的流程流转。
流程布局定义： 定义流程每个结点在流程图上的位置坐标等信息。

5.1.3、.png 图片文件

Eclipse 工具中的操作

流程图片生成的两种方式：

使用 activiti-designer 设计流程图时自动生成
需在 eclipse 中进行配置：

使用 designer 设计流程图的同时自动生成与 bpmn 文件同名的图片文件(.png)

由 activiti 自动生成图形

流程图设计完毕向 activiti 中部署流程定义文件 bpmn，部署时由 activiti 自动生成流程图片。(流程部署在下面的章节讲解)

注意：此方法生成时如果图形中有中文生成的图片上显示乱码，且.bpmn 中的坐标和图片显示错位。

IDEA 工具中的操作方式

第一步：将 holiday.bpmn 文件改为扩展名 xml 的文件名称：holiday.xml修改前的 bpmn 文件，效果如下：

第二步：在 holiday.xml 文件上面，点右键并选择 Diagrams 菜单，再选择 Show BPMN2.0 Designer

第三步：打开后的效果图如下：

第四步：点击 Export To File 的小图标，如下：

打开窗口，注意填写文件名及扩展名，选择好保存图片的位置

第五步：中文乱码的解决

打开 IDEA 安装路径，找到如下的安装目录

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

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

5.2、流程定义部署

5.2.1、什么是流程定义部署

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

5.2.2、单个文件部署方式

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

    @Test
    public void deployProcess() {
        // 获取repositoryService
        RepositoryService repositoryService = processEngine.getRepositoryService();
        // bpmn输入流
        InputStream inputStream_bpmn = this
                .getClass()
                .getClassLoader()
                .getResourceAsStream(
                        "diagram/holiday.bpmn");
        // 图片输入流
        InputStream inputStream_png = this
                .getClass()
                .getClassLoader()
                .getResourceAsStream(
                        " diagram/holiday.png");
        // 流程部署对象
        Deployment deployment = repositoryService.createDeployment()
                .addInputStream("holiday.bpmn", inputStream_bpmn)
                .addInputStream("holiday.png", inputStream_png)
                .deploy();
        System.out.println("流程部署id：" + deployment.getId());
        System.out.println("流程部署名称：" + deployment.getName());
    }

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

5.2.3、压缩包部署方式

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

package com.roc.activiti;

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

import java.io.InputStream;
import java.util.zip.ZipInputStream;

/**
 * @description: 流程定义的部署
 * @author:
 * @create: 2020-11-04 14:31
 * 影响的数据库表
 * 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/holidayBPMN.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 数据库。

5.2.4、操作数据表

流程定义部署后操作 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。

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

5.3、流程定义查询

查询部署的流程定义。

package com.roc.activiti.process;

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.RepositoryService;
import org.activiti.engine.repository.ProcessDefinition;
import org.activiti.engine.repository.ProcessDefinitionQuery;

import java.util.List;

/**
 * @description: 查询流程定义信息
 * @author:
 * @create: 2020-11-04 17:18
 */
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());
        }

    }
}

5.4、流程定义删除

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

package com.roc.activiti.process;

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.RepositoryService;


/**
 * @description: 删除已经部署的流程定义信息
 * @author:
 * @create: 2020-11-04 17:18
 * 背后影响的表：
 * act_ge_bytearray
 * act_re_deployment
 * act_re_procdef
 */
public class DeleteProcessDefinition {

    /**
     * 注意事项：
     * 1.当我们正在执行的这一套流程没有完全审批结束的时候，此时如果要删除流程定义信息就会失败
     * 2.如果公司层面要强制删除，可以使用repositoryService.deleteDeployment("1",true);
     * 参数设置为true代表级联删除，此时就会先删除没有完成的流程结点，最后就可以删除流程定义信息  false的值代表不级联（默认就是false）
     *
     * @param args
     */
    public static void main(String[] args) {
        //1. 得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

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

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

        //repositoryService.deleteDeployment("1",true);
    }
}

说明：

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

5.5、流程定义资源查询

5.5.1、方式 1

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

先导包：

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

代码：

package com.roc.activiti.process;

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.RepositoryService;
import org.activiti.engine.repository.ProcessDefinition;
import org.activiti.engine.repository.ProcessDefinitionQuery;
import org.apache.commons.io.IOUtils;


import java.io.*;

/**
 * @description:
 * @author:
 * @create: 2020-11-04 18:17
 * 需求：
 * 1. 从Activiti的act_ge_bytearray表中读取两个资源文件
 * 2. 将两个资源文件保存到路径： D:\workspace\资料\文件
 * 

 * 技术方案:
 * 1.第一种方式使用activiti的api来实现
 * 2.第二种方式：其实就是原理层面，可以使用jdbc的对blob类型，clob类型数据的读取，并保存
 * 3.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.通过reositoryService的方法，实现读取图片信息及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("D:\\workspace\\资料\\文件\\" + processDefinition.getDiagramResourceName());

        OutputStream bpmnOs = new FileOutputStream("D:\\workspace\\资料\\文件\\" + processDefinition.getResourceName());

        //9.输入流，输出流的转换  commons-io-xx.jar中的方法
        IOUtils.copy(pngIs, pngOs);
        IOUtils.copy(bpmnIs, bpmnOs);

        //10.关闭流
        pngOs.close();
        bpmnOs.close();
        pngIs.close();
        bpmnIs.close();
    }
}

5.5.2、方式 2

通过查询流程部署信息获取流程定义资源。

        //方式二
        //1.得到ProcessEngine的对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //流程部署id
        String deploymentId = "12501";
        // 通过流程引擎获取repositoryService
        RepositoryService repositoryService = processEngine.getRepositoryService();
        //读取资源名称
        List<String> resources = repositoryService.getDeploymentResourceNames(deploymentId);
        String resource_image = null;
        //获取图片
        for (String resource_name : resources) {
            if (resource_name.indexOf(".png") >= 0) {
                resource_image = resource_name;
            }
        }//图片输入流
        InputStream inputStream = repositoryService.getResourceAsStream(deploymentId, resource_image);
        File exportFile = new File("D:/holiday.png");
        FileOutputStream fileOutputStream = new FileOutputStream(exportFile);
        byte[] buffer = new byte[1024];
        int len = -1;
        //输出图片
        while ((len = inputStream.read(buffer)) != -1) {
            fileOutputStream.write(buffer, 0, len);
        }
        inputStream.close();
        fileOutputStream.close();

说明：

1. deploymentId 为流程部署 ID
2. resource_name 为 act_ge_bytearray 表中 NAME_列的值
3. 使用 repositoryService 的 getDeploymentResourceNames方法可以获取指定部署下得所有文件的名
   称
4. 使用 repositoryService 的 getResourceAsStream 方法传入部署 ID和资源图片名称可以获取部署下指定名称文件的输入流
5. 最后的将输入流中的图片资源进行输出。

5.6、流程历史信息的查看

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

package com.roc.activiti.process;

import org.activiti.engine.HistoryService;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.history.HistoricActivityInstance;
import org.activiti.engine.history.HistoricActivityInstanceQuery;

import java.util.List;

/**
 * @description: 历史数据的查看
 * @author:
 * @create: 2020-11-06 16:30
 */
public class HistoryQuery {
    public static void main(String[] args) {
        //1. 得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

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

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

        historicActivityInstanceQuery.processInstanceId("2501"); //设置流程实例的ID
        //4.执行查询
        List<HistoricActivityInstance> list = historicActivityInstanceQuery
                .orderByHistoricActivityInstanceStartTime().asc().list();

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