一、概念

工作流是通过计算机对业务流程自动化管理。解决多个参与者按照某种预定义的规则自动进行传递文档、信息或者任务的过程，从而实现某个预期的业务目标。
工作流系统是具有工作流的功能的系统，对系统业务流程进行自动化管理
工作流引擎：为了实现自动化控制，Activiti引擎就产生了。
具体应用
订单审核、合同审核、加班申请、职位变动、付款申请、出差报销

二、Activiti概述

Activiti是一个工作流引擎
BPMN是由业务流程和符号组成的，使用BPMN提供的符号创建业务流程。BPMN图形是通过xml表示业务流程，用文本编辑器打开就是一个xml文件。

三、Activiti环境准备

进入https://plugins.jetbrains.com/plugin/7429-actibpm/versions下载actiBPM插件
导入插件
使用插件

在这里插入图片描述

四、Activiti生成表

mysql要5.1.2版本以上

创建数据库
CREATE DATABASE activiti7 default CHARACTER set utf8;
使用 idea 创建 maven 的 java 工程
加入 maven 依赖的坐标（jar 包）
activiti-engine-7.0.0.beta1.jar
activiti 依赖的 jar 包：mybatis、alf4j、log4j 等
activiti 依赖的 spring 包
数据库驱动
第三方数据连接池 dbcp
单元测试 Junit-4.12.jar

 <properties>
        <java.version>1.8</java.version>
        <slf4j.version>1.6.6</slf4j.version>
        <log4j.version>1.2.12</log4j.version>
    </properties>
 <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-engine</artifactId>
            <version>7.0.0.Beta1</version>
        </dependency>
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-spring</artifactId>
            <version>7.0.0.Beta1</version>
        </dependency>
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-bpmn-model</artifactId>
            <version>7.0.0.Beta1</version>
        </dependency>
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-bpmn-converter</artifactId>
            <version>7.0.0.Beta1</version>
        </dependency>
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-json-converter</artifactId>
            <version>7.0.0.Beta1</version>
        </dependency>
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-bpmn-layout</artifactId>
            <version>7.0.0.Beta1</version>
        </dependency>
        <dependency>
            <groupId>org.activiti.cloud</groupId>
            <artifactId>activiti-cloud-services-api</artifactId>
            <version>7.0.0.Beta1</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.21</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <!-- log start -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <!-- log end -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
        </dependency>
        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.4</version>
        </dependency>

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:/activity/activity.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

activiti.cfg.xml
在 resources 下创建 activiti.cgf.xml 文件：

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

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

    <!--数据源配置dbcp-->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/activiti7?useUnicode=true&amp;characterEncoding=UTF-8&amp;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" />
        <!-- activiti数据库表处理策略 true数据库中如果存在相对应的表直接使用，不存在就会创建-->
        <property name="databaseSchemaUpdate" value="true"/>
    </bean>

编写程序，运行生成25张表
使用activiti提供的默认方法创建mysql表

 //默认创建 配置文件名固定activiti.cfg.xml，bean的id固定processEngineConfiguration
  ProcessEngine ProcessEngine = ProcessEngines.getDefaultProcessEngine();
  System.out.println(ProcessEngine);

或者生成置顶mysql表

        ProcessEngineConfiguration configuration = ProcessEngineConfiguration
       .createProcessEngineConfigurationFromResource("activiti.cfg.xml");
        ProcessEngine processEngine = configuration.buildProcessEngine();
        System.out.println(processEngine);

运行程序段就可以完成 activiti 数据库创建，通过改变 activiti.cfg.xml中 databaseSchemaUpdate参数的值执行不同的数据表处理策略。
上边的方法 createProcessEngineConfigurationFromResource 在执行时在activiti.cfg.xml中找固定的名称processEngineConfiguration也可以使用重载方法调用，这时可以不用限定 processEngineConfiguration 名称。

五、Activiti表的命名规则

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

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

六、Activiti服务架构图

6.1、类关系图

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

6.2、activiti.cfg.xml（流程引擎配置类）

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

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

    <!--数据源配置dbcp-->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/activit7?useUnicode=true&amp;characterEncoding=UTF-8&amp;nullCatalogMeansCurrent=true"/>
        <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" />
        <!-- activiti数据库表处理策略 true数据库中如果存在相对应的表直接使用，不存在就会创建-->
        <property name="databaseSchemaUpdate" value="true"/>
    </bean>
</beans>

6.2.1、ProcessEngineConfiguration

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

6.2.1.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" />
        <!-- activiti数据库表处理策略 true数据库中如果存在相对应的表直接使用，不存在就会创建-->
        <property name="databaseSchemaUpdate" value="true"/>
    </bean>

6.2.1.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 -->
    <bean id="processEngineConfiguration" class="org.activiti.spring.SpringProcessEngineConfiguration">
        <!-- 数据源 -->
        <property name="dataSource" ref="dataSource" />
        <!-- 使用spring事务管理器 -->
        <property name="transactionManager" ref="transactionManager" />
        <!-- 数据库策略 -->
        <property name="databaseSchemaUpdate" value="drop-create" />
        <!-- activiti的定时任务关闭 -->
        <property name="jobExecutorActivate" value="false" />
    </bean>

    <!-- 流程引擎 -->
    <bean id="processEngine" class="org.activiti.spring.ProcessEngineFactoryBean">
        <property name="processEngineConfiguration" ref="processEngineConfiguration" />
    </bean>

    <!-- 资源服务service -->
    <bean id="repositoryService" factory-bean="processEngine" factory-method="getRepositoryService" />

    <!-- 流程运行service -->
    <bean id="runtimeService" factory-bean="processEngine" factory-method="getRuntimeService" />

    <!-- 任务管理service -->
    <bean id="taskService" factory-bean="processEngine" factory-method="getTaskService" />

    <!-- 历史管理service -->
    <bean id="historyService" factory-bean="processEngine" factory-method="getHistoryService" />

    <!-- 用户管理service -->
    <bean id="identityService" factory-bean="processEngine" factory-method="getIdentityService" />

    <!-- 引擎管理service -->
    <bean id="managementService" factory-bean="processEngine" factory-method="getManagementService" />

    <!-- 数据源 -->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <property name="url" value="jdbc:mysql://localhost:3306/activiti7" />
        <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>

创建 processEngineConfiguration

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

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

ProcessEngineConfiguration.createProcessEngineConfigurationFromResource(String resource, String beanName);

6.3、ProcessEngine（流程引擎）

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

简单方式

     //默认创建 配置文件名固定activiti.cfg.xml，bean的id固定processEngineConfiguration
      ProcessEngine ProcessEngine = ProcessEngines.getDefaultProcessEngine();
      System.out.println(ProcessEngine);

一般方式

//自定义创建流程引擎对象，配置文件名可以自定义，bean名字可以自定义
        //创建ProcessEngineConfiguration流程引擎配置类
        ProcessEngineConfiguration configuration = ProcessEngineConfiguration
                .createProcessEngineConfigurationFromResource("activiti.cfg.xml","processEngineConfiguration");
        //通过ProcessEngineConfiguration创建ProcessEngine流程引擎对象，此时会创建数据库
        ProcessEngine processEngine =
                configuration.buildProcessEngine();
        System.out.println(processEngine);

6.4、Service服务接口

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

6.4.1、创建方式

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

6.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 入门体验

创建Activiti流程

流程定义：按照BPMN规范，使用流程定义工具，用流程符号把流程描述出来
流程部署：把画好的文件，加载到数据库中，生成表数据
流程启动：用java代码操作数据库

7.1、流程定义

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

Palette（画板）
在 eclipse 或 idea 中安装 activiti-designer 插件即可使用，画板中包括以下结点：
Connection—连接
Event—事件
Task—任务
Gateway—网关
Container—容器
Boundary event—边界事件
Intermediate event- -中间事件
流程图设计完毕保存生成.bpmn 文件。
新建流程
首先选中存放图形的目录(本次我们选择 resources 下的 bpmn 目录)，点击bpmn–>New–>BpmnFile，如下图所示：
绘制流程

图形绘制好后会生成两个文件：.bpmn和.png
指定流程定义key
流程定义 key 即流程定义的标识
指定任务负责人

在这里插入图片描述

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

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

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

.png 图片生成
在 holiday.xml 文件上面，点右键并选择 Diagrams 菜单，再选择 Show BPMN2.0 Designer
效果图
点击 Export To File 的小图标，如下：
把 evection.xml 文件改名为 evection.bpmn
evection.png放入到项目中

在这里插入图片描述

解决乱码
https://blog.csdn.net/sunpanlong123/article/details/123577797

7.1、流程部署

7.7.1、什么是流程定义部署

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

 @Test
    public void processDeployment(){
        //1. 创建ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //2. 得到RepositoryService实例
        RepositoryService repositoryService = processEngine.getRepositoryService();
        //3. 进行部署
        Deployment deployment = repositoryService.createDeployment()
                .addClasspathResource("bpmn/evection.bpmn")  //添加bpmn资源
                .addClasspathResource("bpmn/evection.png")
                .name("出差申请流程")
                .deploy();
        //4. 输出部署的一些信息
        System.out.println("出差申请流程部署名字："+deployment.getName());
        System.out.println("出差申请流程部署ID："+deployment.getId());
    }

7.7.2、部署后数据表中分析

ACT_RE_PROCDEF 定义表
ACT_RE_DEPLOYMENT 部署表，每部署一次增加一条记录
ACT_GE_BYTEARRAY 流程资源表
ACT_GE_PROPERTY update
会改变这四个表的数据，ACT_RE_DEPLOYMENT和ACT_RE_PROCDEF是一对多关系，也就是说每次一个申请在ACT_RE_PROCDEF中都会生成一条记录

7.2、流程启动

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

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

 //启动流程实例
    @Test
    public void startProcessDeployment(){
        //1. 得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //2. 得到RunService对象
        RuntimeService runtimeService = processEngine.getRuntimeService();
        //3. 创建流程实例  流程定义的key需要知道
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("myEvection");
        //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

    }

7.3、任务查询

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

 //查询当前用户的任务列表
    @Test
    public void findProcessDeploymentTaskList(){
        //1. 得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //2. 得到TaskService对象
        TaskService taskService = processEngine.getTaskService();
        //3. 根据流程定义的key，负责人assignee来实现当前用户的任务列表查询
        List<Task> taskList = taskService.createTaskQuery()
                .processDefinitionKey("myEvection")
                .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());
        }
    }

7.4、任务处理

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

    //完成自己的任务
    @Test
    public void completProcessDeploymentTaskList(){
        //1. 得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //2. 得到TaskService对象
        TaskService taskService = processEngine.getTaskService();
        //3. 处理任务，结合当前用户任务列表的查询操作的话，任务ID:2505
        taskService.complete("2505");
    }

7.5、单个文件部署

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

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

7.6、压缩包部署方式

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

//部署流程为zip
    @Test
    public void processDeploymentByZip(){

        //1. 创建ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //2. 得到RepositoryService实例
        RepositoryService repositoryService = processEngine.getRepositoryService();
        //3. 进行部署
        //转化出ZipInputStream流对象
        InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream("bpmn/evection.zip");
        //将inputstream流转化为ZipInputStream流
        ZipInputStream zipInputStream = new ZipInputStream(inputStream);
        Deployment deployment = repositoryService.createDeployment()
                .addZipInputStream(zipInputStream)
                .deploy();
        //4. 输出部署的一些信息
        System.out.println("流程部署名字："+deployment.getName());
        System.out.println("流程部署ID："+deployment.getId());
    }

7.7、操作数据表

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

7.8、流程定义查询

查询部署的流程定义。

//查询流程定义
    @Test
    public void queryProcessDefinition () {
        //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("myEvection")
                .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());
        }

    }

7.9、流程定义查询

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

//流程定义删除
    /**
     *  act_ge_bytearray
     *  act_re_deployment
     *  act_re_procdef
     *  1.当我们正在执行的这一套流程没有完全审批结束的时候，此时如果要删除流程定义信息就会失败
     *  2.如果公司层面要强制删除，可以使用repositoryService.deleteDeployment("1",true);
     *   参数设置为true代表级联删除，此时就会先删除没有完成的流程结点，最后就可以删除流程定义信息  false的值代表不级联（默认就是false）
     */
    @Test
    public void deleteProcessDefinition () {
        //1. 得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //2. 创建RepositoryService对象
        RepositoryService repositoryService = processEngine.getRepositoryService();
        //3. 执行删除流程定义  参数代表流程部署的ID
        String deploymentId = "2501";
        repositoryService.deleteDeployment(deploymentId);
//        repositoryService.deleteDeployment(deploymentId,true);
    }

注意：

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

八、流程定义的资源

8.1、流程定义的资源下载

先导包：

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

代码演示：

//资源下载
    /**
     * * 需求：
     *  1. 从Activiti的act_ge_bytearray表中读取两个资源文件
     *  2. 将两个资源文件保存到路径： D:\workspace\资料\文件
     *  技术方案:
     *  1.第一种方式使用activiti的api来实现
     *  2.第二种方式：其实就是原理层面，可以使用jdbc的对blob类型，clob类型数据的读取，并保存
     *  3.IO流转换：最好commons-io.jar包可以轻松解决IO操作
     */
    @Test
    public void getDeployment() throws IOException {
        //1.得到ProcessEngine的对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //2.得到RepositoryService对象
        RepositoryService repositoryService = processEngine.getRepositoryService();
        //3.得到查询器：ProcessDefinitionQuery对象
        ProcessDefinitionQuery processDefinitionQuery = repositoryService.createProcessDefinitionQuery();
        //4.设置查询条件
        processDefinitionQuery.processDefinitionKey("myEvection");//参数是流程定义的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流
        File pngFile = new File("d:/evectionflow01.png");
        File bpmnFile = new File("d:/evectionflow01.bpmn");
        OutputStream pngOs = new FileOutputStream(pngFile);
        OutputStream bpmnOs = new FileOutputStream(bpmnFile);

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

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

8.2、流程历史信息的查看

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

 //查看历史信息
    @Test
    public void getHistoryInfo(){
        //1. 得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //2. 得到HistoryService
        HistoryService historyService = processEngine.getHistoryService();
        //3. 得到HistoricActivityInstanceQuery对象
        HistoricActivityInstanceQuery historicActivityInstanceQuery = historyService.createHistoricActivityInstanceQuery();
        historicActivityInstanceQuery.processInstanceId("10001"); //设置流程实例的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("***************************");
        }
    }