Activiti工作流、一

最新推荐文章于 2024-06-06 13:48:57 发布
最新推荐文章于 2024-06-06 13:48:57 发布
阅读量1.4k 收藏 6
点赞数 1
分类专栏： Java 文章标签： Acitivti工作流 工作流框架 Java工作流 Java Activiti工作流引擎

第1章 什么是工作流

1.1 工作流介绍

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

1.2 工作流系统

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

1.2.1 适用行业

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

1.2.2 具体应用

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

1.3 工作流实现方式

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

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

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

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

1.4 工作流实现原理分析

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

具体分析过程如下图所示：
在这里插入图片描述

第2章 什么是 Activiti7

2.1 Activiti 介绍

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

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

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

在这里插入图片描述

目前最新版本： activiti-7.1.0.M1d

2.1.1 BPM

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

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

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

流程一：

在这里插入图片描述

流程二：

在这里插入图片描述

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

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

流程一：

在这里插入图片描述

​ 流程二：

在这里插入图片描述

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

2.1.2 BPM 软件

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

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

2.1.3 BPMN

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

具体发展历史如下:
在这里插入图片描述

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

Event 用一个圆圈表示，它是流程中运行过程中发生的事情。
在这里插入图片描述

活动用圆角矩形表示，一个流程由一个活动或多个活动组成
在这里插入图片描述

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

在这里插入图片描述

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

2.2 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）流程结束

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

第3章 环境准备

3.1 三个环境

第一个环境：没有加入工作流 SaaS-IHRM 系统
作用：主要是为 activiti 工作流引擎的引入提供场景

第二个环境： activiti 测试环境
作用：用于测试 activiti 的 api，提供各种 service 接口。
需要创建一个数据库：
仅仅有 activiti 的数据表

第三个环境： activiti 应用环境，加入工作流的 SaaS-IHRM 系统
需要创建一个数据库：
包括 activiti 的数据表和业务表（SaaS-IHRM 系统的表）

3.2 开发环境

3.2.1 Java 环境

Jdk1.8 或以上版本。

3.2.2 数据库

Mysql 5 及以上的版本

3.2.3 Web 容器

Tomcat8.5 +

3.2.4 开发工具

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

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

3.3 Activiti 环境

Activiti7.0.0.Beta1
默认支持 spring5

3.3.1 下载 activiti7

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

<dependencyManagement>
		<dependencies>
<!-- https://mvnrepository.com/artifact/org.activiti.dependencies/activiti-dependencies -->
		<dependency>
    		<groupId>org.activiti.dependencies</groupId>
    		<artifactId>activiti-dependencies</artifactId>
    		<version>7.0.0.Beta1</version>
    		<type>pom</type>
		</dependency>
	</dependencies>
</dependencyManagement>

1）Database

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

2) Docs

Activiti 的帮助文档。

3) Wars

官方自带的示例工程。

3.3.2 Activiti Designer 流程设计器（IDEA）

在 IDEA 的 File 菜单中找到子菜单”Settings”,后面我们再选择左侧的“plugins”菜单，搜索到 actiBPM 插件，点击安装。 如下图所示：

在这里插入图片描述

安装完插件后记得重启生效。

3.3.3 Activiti 支持的数据库

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

Activiti数据库类型JDBC URL实例备注
h2jdbc:h2:tcp://localhost/activiti默认配置的数据库
mysqljdbc:mysql://localhost:3306/activiti?autoReconnect=true使用mysql-connector-java驱动测试
oraclejdbc:oracle:thin:@localhost:1521:xe
postgresjdbc:postgresql://localhost:5432/activiti
db2jdbc:db2://localhost:50000/activiti
mssqljdbc:sqlserver://localhost:1433/activiti

3.3.4 创建 mysql 数据库

使用图形化工具创建 mysql 数据库 activiti（名字可任意）

或者命令执行：

create database activiti character set utf8;  //创建activiti数据库
drop database activiti;  //删除activiti数据库

3.3.5 创建表方式

通过运行 java 程序创建表。

3.3.5.1 创建 java 工程

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

3.3.5.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 文件中：

<dependencies>
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-engine</artifactId>
            <version>7.0.0.Beta1</version>
        </dependency>

        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-spring</artifactId>
            <version>7.0.0.Beta1</version>
        </dependency>

        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-bpmn-model</artifactId>
            <version>7.0.0.Beta1</version>
        </dependency>

        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-bpmn-converter</artifactId>
            <version>7.0.0.Beta1</version>
        </dependency>

        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-json-converter</artifactId>
            <version>7.0.0.Beta1</version>
        </dependency>

        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-bpmn-layout</artifactId>
            <version>7.0.0.Beta1</version>
        </dependency>

        <dependency>
            <groupId>org.activiti.cloud</groupId>
            <artifactId>activiti-cloud-services-api</artifactId>
            <version>7.0.0.Beta1</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.40</version>
        </dependency>

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

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

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
        </dependency>

        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.4</version>
        </dependency>

    </dependencies>
    <repositories>
        <repository>
            <id>alfresco</id>
            <name>Activiti Releases</name>
            <url>https://artifacts.alfresco.com/nexus/content/repositories/activiti-releases/</url>
            <releases>
                <enabled>true</enabled>
            </releases>
        </repository>
    </repositories>
3.3.5.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

# 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=G:\logs\log.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
3.3.5.4 activiti.cfg.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--数据源配置dbcp-->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/activiti?useUnicode=true&amp;characterEncoding=utf-8"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>
    <!--activiti单独运行的ProcessEngine配置对象(processEngineConfiguration),使用单独启动方式
        默认情况下：bean的id=processEngineConfiguration
    -->

    <bean id="processEngineConfiguration" class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
        <!--代表数据源-->
        <property name="dataSource" ref="dataSource"></property>


        <!-- <property name="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>
</beans>

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

1）数据源 （上面代码已贴）

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

2）processEngineConfiguration

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

    <bean id="processEngineConfiguration" class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
        <!--代表数据源-->
        <property name="dataSource" ref="dataSource"></property>
        <!-- activiti数据库表处理策略 -->
        <property name="databaseSchemaUpdate" value="true"/>
    </bean>

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

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

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

    <bean id="processEngineConfiguration" class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
   <property name="jdbcDriver" value="com.mysql.jdbc.Driver" />
    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/activiti?useUnicode=true&amp;characterEncoding=utf-8" />
    <property name="jdbcUsername" value="root" />
    <property name="jdbcPassword" value="root" />
        
    <property name="databaseSchemaUpdate" value="true"/>
    </bean>
3.3.5.5 编写程序

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

在测试类下写一个ActivitiTest类生成表：

/**
 * 测试类
 *     作用：测试activiti所需要的25张表的生成
 */
public class ActivitiTest {
    
    @Test
    public void testGenTable(){
        //1.创建ProcessEngineConfiguration对象  第一个参数:配置文件名称  第二个参数是processEngineConfiguration的bean的id
        ProcessEngineConfiguration configuration = ProcessEngineConfiguration
                .createProcessEngineConfigurationFromResource("activiti.cfg.xml","processEngineConfiguration");
        //2.创建ProcesEngine对象
        ProcessEngine processEngine = configuration.buildProcessEngine();

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



    }
}

说明：

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

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

在这里插入图片描述
在这里插入图片描述
所以可以直接简化代码：

/**
 * 测试类
 *     作用：测试activiti所需要的25张表的生成
 */
public class ActivitiTest {

    @Test
    public void testGenTable(){
        //条件：1.activiti配置文件名称：activiti.cfg.xml   2.bean的id="processEngineConfiguration"
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        System.out.println(processEngine);

        // HistoryService historyService = processEngine.getHistoryService();

    }
}

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

在这里插入图片描述

3.3.6 数据库表的命名规则

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

ACT_RE_*: 'RE'表示 repository。 这个前缀的表包含了流程定义和流程静态资源 （图片，规则，等等）。

ACT_RU_*: 'RU'表示 runtime。 这些运行时的表，包含流程实例，任务，变量，异步任务，等运行中的数据。	Activiti 只在流程实例执行过程中保存这些数据， 在流程结束时就会删除这些记录。 这样运行时表可以一直很	小速度很快。

ACT_HI_*: 'HI'表示 history。 这些表包含历史数据，比如历史流程实例， 变量，任务等等。

ACT_GE_*: GE 表示 general。 通用数据，用于不同场景下。

第4章 Activiti 服务架构图

在这里插入图片描述

在新版本中，IdentityService， FormService 两个 Serivce 都已经删除了。所以后面我们对于这两个 Service 也不讲解了，但老版本中还是有这两个 Service，同学们需要自行了解一下。

4.1 activiti.cfg.xml

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

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

    <!--数据源配置dbcp-->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/activiti?useUnicode=true&amp;characterEncoding=utf-8"/>
        <property name="username" value="root"/>
        <property name="password" value="lcry"/>
    </bean>
    <!--activiti单独运行的ProcessEngine配置对象(processEngineConfiguration),使用单独启动方式
        默认情况下：bean的id=processEngineConfiguration
    -->

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

4.2 ProcessEngineConfiguration

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

4.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>
        <!--数据库策略-->
        <property name="databaseSchemaUpdate" value="true"/>
    </bean>

4.2.2 SpringProcessEngineConfiguration

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

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

<后面整合项目讲解>

4.2.3 创建 processEngineConfiguration

//1.创建ProcessEngineConfiguration对象  第一个参数:配置文件名称  第二个参数是processEngineConfiguration的bean的id
        ProcessEngineConfiguration configuration = ProcessEngineConfiguration
                .createProcessEngineConfigurationFromResource("activiti.cfg.xml","processEngineConfiguration");

4.3 ProcessEngine

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

4.3.1 一般创建方式

//2.创建ProcesEngine对象
        ProcessEngine processEngine = configuration.buildProcessEngine();

4.3.2 简单创建方式

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

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

4.4 Service

4.4.1 Service 创建方式

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

方式如下：

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

4.4.2 Service 总览

service说明
RepositoryServiceactiviti 的资源管理类
RuntimeServiceactiviti 的流程运行管理类
TaskServiceactiviti 的任务管理类
HistoryServiceactiviti 的历史管理类
ManagerServiceactiviti 的引擎管理类

注：加粗标注为常用 service。

4.4.3 RepositoryService

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

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

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

4.4.4 RuntimeService

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

4.4.5 TaskService

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

4.4.6 HistoryService

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

4.4.7 ManagementService

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

第5章 Activiti 入门体验

5.1 流程定义

5.1.1 Activiti-Designer 使用

5.1.1.1 Palette（画板）

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

Connection—连接
Event—事件
Task—任务
Gateway—网关
Container—容器
Boundary event—边界事件
Intermediate event- -中间事件
流程图设计完毕保存生成.bpmn 文件。

在这里插入图片描述

5.1.1.2 新建流程(IDEA 工具)

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

在这里插入图片描述

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

在这里插入图片描述

5.1.2 绘制流程

在这里插入图片描述

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

在这里插入图片描述

5.1.3 指定流程定义 key

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

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

在这里插入图片描述

5.1.4 指定任务负责人

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

在这里插入图片描述

5.2 部署流程定义

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

新建一个ActivitiDeployment类：

/**
 * ActivitiDeployment
 *
 * 流程定义部署
 */
public class ActivitiDeployment {
    public static void main(String[] args) {
        //1.创建processEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //2.得到repositoryService实例
        RepositoryService repositoryService = processEngine.getRepositoryService();
        //3.进行部署
        Deployment deployment = repositoryService.createDeployment()
                .addClasspathResource("diagram/holiday.bpmn")
                .addClasspathResource("diagram/holiday.png")
                .name("请假申请单流程")
                .deploy();
        //4.输入部署的一些信息
        System.out.println(deployment.getName());
        System.out.println(deployment.getId());
    }
}

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

会影响数据库下面几个表：

act_re_deployment 部署信息
act_re_procdef 流程定义的一些信息
act_ge_bytearray 流程定义的bpmn文件及png文件

5.3 启动一个流程实例

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

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

代码如下：

/**
 * ActivitiStartInstance
 * 启动流程实例
 */
public class ActivitiStartInstance {
    public static void main(String[] args) {
        //1.得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

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

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

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

会影响数据库下面几个表：

act_hi_actinst 已完成的活动信息
act_hi_identitylink 参与者信息
act_hi_procinst 流程实例
act_hi_taskinst 任务实例
act_ru_execution 执行表
act_ru_identitylink 参与者信息
act_ru_task 任务

5.4 任务查询

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

/**
 * ActivitiTaskQuery
 * 查询当前用户的任务列表
 */
public class ActivitiTaskQuery {
    //zhangsan任务列表的查询
    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());
        }
    }
}

5.5 任务处理

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

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（正常情况下应该直接查出任务ID2505）
        taskService.complete("2505");
    }*/

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

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

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

    }*/

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

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

        //3.查询当前用户的任务 singleResult方法获取唯一的一个任务。
        Task task = taskService.createTaskQuery()
                .processDefinitionKey("holiday")
                .taskAssignee("wangwu")
                .singleResult();

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

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

}

会影响数据库下面几个表：

act_hi_actinst
act_hi_identitylink
act_hi_taskinst
act_ru_identitylink
act_ru_task

第6章 流程定义

6.1 流程定义

6.1.1 什么是流程定义

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

6.1.2 .bpmn 文件

使用 activiti-desinger 设计业务流程，会生成.bpmn 文件，首先将 holiday.bpmn 文件改名为 holiday.xml，用记事本打开如下：

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:activiti="http://activiti.org/bpmn" xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI" xmlns:omgdc="http://www.omg.org/spec/DD/20100524/DC" xmlns:omgdi="http://www.omg.org/spec/DD/20100524/DI" xmlns:tns="http://www.activiti.org/test" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" expressionLanguage="http://www.w3.org/1999/XPath" id="m1560313818889" name="" targetNamespace="http://www.activiti.org/test" typeLanguage="http://www.w3.org/2001/XMLSchema">
  <process id="holiday" isClosed="false" isExecutable="true" processType="None">
    <startEvent id="_2" name="start"/>
    <userTask activiti:assignee="zhangsan" activiti:exclusive="true" id="_3" name="Submit a leave request"/>
    <sequenceFlow id="_4" sourceRef="_2" targetRef="_3"/>
    <userTask activiti:assignee="lisi" activiti:exclusive="true" id="_5" name="Department manager"/>
    <sequenceFlow id="_6" sourceRef="_3" targetRef="_5"/>
    <userTask activiti:assignee="wangwu" activiti:exclusive="true" id="_7" name="General manager"/>
    <sequenceFlow id="_8" sourceRef="_5" targetRef="_7"/>
    <endEvent id="_9" name="EndEvent"/>
    <sequenceFlow id="_10" sourceRef="_7" targetRef="_9"/>
  </process>
  <bpmndi:BPMNDiagram documentation="background=#3C3F41;count=1;horizontalcount=1;orientation=0;width=842.4;height=1195.2;imageableWidth=832.4;imageableHeight=1185.2;imageableX=5.0;imageableY=5.0" id="Diagram-_1" name="New Diagram">
    <bpmndi:BPMNPlane bpmnElement="holiday">
      <bpmndi:BPMNShape bpmnElement="_2" id="Shape-_2">
        <omgdc:Bounds height="32.0" width="32.0" x="385.0" y="210.0"/>
        <bpmndi:BPMNLabel>
          <omgdc:Bounds height="32.0" width="32.0" x="0.0" y="0.0"/>
        </bpmndi:BPMNLabel>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="_3" id="Shape-_3">
        <omgdc:Bounds height="95.0" width="145.0" x="325.0" y="290.0"/>
        <bpmndi:BPMNLabel>
          <omgdc:Bounds height="95.0" width="145.0" x="0.0" y="0.0"/>
        </bpmndi:BPMNLabel>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="_5" id="Shape-_5">
        <omgdc:Bounds height="85.0" width="145.0" x="330.0" y="465.0"/>
        <bpmndi:BPMNLabel>
          <omgdc:Bounds height="85.0" width="145.0" x="0.0" y="0.0"/>
        </bpmndi:BPMNLabel>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="_7" id="Shape-_7">
        <omgdc:Bounds height="80.0" width="140.0" x="330.0" y="640.0"/>
        <bpmndi:BPMNLabel>
          <omgdc:Bounds height="80.0" width="140.0" x="0.0" y="0.0"/>
        </bpmndi:BPMNLabel>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="_9" id="Shape-_9">
        <omgdc:Bounds height="32.0" width="32.0" x="375.0" y="795.0"/>
        <bpmndi:BPMNLabel>
          <omgdc:Bounds height="32.0" width="32.0" x="0.0" y="0.0"/>
        </bpmndi:BPMNLabel>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNEdge bpmnElement="_4" id="BPMNEdge__4" sourceElement="_2" targetElement="_3">
        <omgdi:waypoint x="401.0" y="242.0"/>
        <omgdi:waypoint x="401.0" y="290.0"/>
        <bpmndi:BPMNLabel>
          <omgdc:Bounds height="0.0" width="0.0" x="0.0" y="0.0"/>
        </bpmndi:BPMNLabel>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="_6" id="BPMNEdge__6" sourceElement="_3" targetElement="_5">
        <omgdi:waypoint x="400.0" y="385.0"/>
        <omgdi:waypoint x="400.0" y="465.0"/>
        <bpmndi:BPMNLabel>
          <omgdc:Bounds height="0.0" width="0.0" x="0.0" y="0.0"/>
        </bpmndi:BPMNLabel>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="_8" id="BPMNEdge__8" sourceElement="_5" targetElement="_7">
        <omgdi:waypoint x="400.0" y="550.0"/>
        <omgdi:waypoint x="400.0" y="640.0"/>
        <bpmndi:BPMNLabel>
          <omgdc:Bounds height="0.0" width="0.0" x="0.0" y="0.0"/>
        </bpmndi:BPMNLabel>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="_10" id="BPMNEdge__10" sourceElement="_7" targetElement="_9">
        <omgdi:waypoint x="391.0" y="720.0"/>
        <omgdi:waypoint x="391.0" y="795.0"/>
        <bpmndi:BPMNLabel>
          <omgdc:Bounds height="0.0" width="0.0" x="0.0" y="0.0"/>
        </bpmndi:BPMNLabel>
      </bpmndi:BPMNEdge>
    </bpmndi:BPMNPlane>
  </bpmndi:BPMNDiagram>
</definitions>

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

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

6.1.3 .png 图片文件

第一步：将 holiday.bpmn 文件改为扩展名 xml 的文件名称： holiday.xml

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

第三步： 打开后点击 Export To File 的小图标，导出到一个位置

第四步：中文乱码的解决

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

  2. 在idea.exe.vmoptions 和 idea64.exe.vmoptions 文件的最后一行追加一条命令： -Dfile.encoding=UTF-8

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

6.2 流程定义部署

6.2.1 什么是流程定义部署

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

6.2.2 单个文件部署方式

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

    public static void main(String[] args) {
        //1.创建processEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //2.得到repositoryService实例
        RepositoryService repositoryService = processEngine.getRepositoryService();
        //3.进行部署
        Deployment deployment = repositoryService.createDeployment()
                .addClasspathResource("diagram/holiday.bpmn")
                .addClasspathResource("diagram/holiday.png")
                .name("请假申请单流程")
                .deploy();
        //4.输入部署的一些信息
        System.out.println(deployment.getName());
        System.out.println(deployment.getId());
    }

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

6.2.3 压缩包部署方式

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

    //流程定义部署  流程制作出来后要上传到服务器 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);

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

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

6.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。

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

6.3 流程定义查询

查询部署的流程定义。

/**
 * QueryProcessDefinition
 * <p>
 * 查询流程定义信息
 */
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());
        }
    }
}

6.4 流程定义删除

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

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

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

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

会影响数据库下面几个表：

act_ge_bytearray
act_re_deployment
act_re_procdef

说明：

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

6.5 流程定义资源查询

pom文件引入commons-io-xx.jar，用于文件读写操作

        <!--文件读写操作-->
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.4</version>
        </dependency>

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

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

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

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

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

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

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

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

        //8.构建出OutputStream流
        OutputStream pngOs =
                new FileOutputStream("G:\\IdeaProjects\\activiti01\\src\\main\\resources\\outfile\\"+processDefinition.getDiagramResourceName());

        OutputStream bpmnOs =
                new FileOutputStream("G:\\IdeaProjects\\activiti01\\src\\main\\resources\\outfile\\"+processDefinition.getResourceName());

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

6.6 流程历史信息的查看

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

/**
 * HistoryQuery
 *
 * 历史流程数据的查看
 */
public class HistoryQuery {
    public static void main(String[] args) throws IOException {
        //1.得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

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

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

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

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

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

更多等待有空更新吧

Lcry
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Activiti7工作流+SpringBoot（上）
Firstlucky77的博客
06-08 1573
    Activiti是基于Apache许可的开源BPM平台，创始人Tom Baeyens原是JBPM架构师，可以理解为与JBPM出自同一祖师爷。它提供了Eclipse插件，开发可以通过插件直接绘制业务流程图。基于Spring，ibatis等框架，并在此之上构建了非常清晰的开发框架。是由Alfresco软件发布的业务流程管理（BPM）框架，它是覆盖了业务流程管理、工作流、服务协作等领域的一个开源的、灵活的、易扩展的可执行流程语言框架。 本文基于Activiti7的Activiti Core，基于Sprin
Activiti工作流
花开不败才是姿态
07-17 3239
 说明：本文章内容在我最大努力范围之内确保其正确性、实效性和可观性，但并不代表所有的观点都是正确的，而仅代表个人看法。如发现不当之处，请多指教，谢谢！   一、工作流 1.工作流 工作流（workflow），就是让计算机帮我们实行部分或全部的业务工作流程、逻辑的自动化执行管理，实现多个参与者按照预定的流程去自动执行业务流程。 主要解决的是：使在多个参与者之间按照某种预定义的规则传递文档、...
【青铜打铁篇】Activiti 工作流从入门到入土？
好好学java
05-26 925
点击上方“好好学java”，选择“置顶”公众号重磅资源、干货，第一时间送达重磅推荐① 纯福利 | 公众号资源大汇总，一年才一次！② 重磅！！2018年Java全套入门...
【工作流】 工作流相关概念及Activiti基本介绍
最新发布
低调做人，低调编码，神码都是浮云
06-06 1277
工作流相关概念，以及Activiti基本介绍
工作流引擎activiti的认识
weixin_46696282的博客
12-18 3007
摘要 Activiti是一个用Java编写的开源工作流引擎，可以执行BPMN 2.0中描述的业务流程。Activiti是Alfresco的Alfresco Process Services (APS)的基础，而Alfresco是Activiti项目的主要赞助商。 本文旨在帮助读者理解Activiti的工作机制，使其可以迅速上手该框架。本文将从这几个方面简单介绍了Activiti工作流引擎： 1、为什么要使用工作流引擎 2、BPMN2.0规范简介 3、开源BPMN项目对比 1. 为什么要使用工作流引擎 假定我
Alfresco发布Activiti项目——基于Apache 2许可的BPM引擎
cpongo5
05-25 1030
本周一，知名的企业内容管理（ECM）系统提供商Alfresco Software 发布了开源的业务流程管理（BPM）项目——Activiti，该项目由jBPM创建者，前JBoss jBPM领导与BPM权威Tom Baeyens主持大局。前jBPM团队成员Joram Barrez此前也加入了该项目，成为Activiti的核心开发人员。长久以来，Alfresco一直将jBPM嵌入到其产品当中，今后也将...
Alfresco 宣布开始Activiti业务流程管理BPM引擎开发项目
weixin_34326179的博客
06-07 573
为什么80%的码农都做不了架构师？>>> ...
Activiti工作流引擎入门
12-20
Activiti工作流引擎是Java平台上的一个开源工作流管理系统，专为简化业务流程自动化而设计。它使用BPMN（Business Process Model and Notation）2.0标准进行流程建模，使得非技术人员也能理解并创建复杂的业务流程。...
Activiti工作流面试相关知识
02-27
Activiti工作流引擎是一款开源的企业级业务流程管理（BPM）和工作流系统，它为组织提供了一种灵活、可扩展的方式来设计、执行和管理业务流程。在面试中，了解Activiti的核心服务对于理解其工作原理和实际应用至关...
activiti工作流（超详细）
04-07
activiti工作流文档，超详细，从0基础开始入门，包括数据库介绍、核心api等介绍，满足日常开发所需
Activiti工作流引擎实战入门
03-17
Activiti工作流引擎是一款强大的开源工作流管理系统，广泛应用于企业业务流程自动化。它基于Java，兼容BPMN 2.0标准，提供了丰富的API和图形化设计工具，使得流程定义和执行变得更加直观和灵活。 首先，让我们深入...
activiti工作流
06-15
Activiti项目是一项新的基于Apache许可的开源BPM平台，从基础开始构建，旨在提供支持新的BPMN 2.0标准，包括支持对象管理组（OMG），面对新技术的机遇，诸如互操作性和云架构，提供技术实现。
activity学习(一)
weixin_43075758的博客
04-29 1328
1，概述Activiti5是由Alfresco软件在2010年5月17日发布的业务流程管理（BPM）框架，它是覆盖了业务流程管理、工作流、服务协作等领域的一个开源的、灵活的、易扩展的可执行流程语言框架。Activiti基于Apache许可的开源BPM平台，创始人Tom Baeyens是JBoss jBPM的项目架构师，它特色是提供了eclipse插件，开发人员可以通过插件直接绘画出业务 2，工作流引擎 ProcessEngine对象，这是Activiti工作的核心。负责生成流程运行时的各种实例及数据、监
Activity工作流基本知识点
康宁的博客
05-06 804
Activiti5是由Alfresco软件在2010年5月17日发布的业务流程管理（BPM）框架，它是覆盖了业务流程管理、工作流、服务协作等领域的一个开源的、灵活的、易扩展的可执行流程语言框架。Activiti基于Apache许可的开源BPM平台，创始人Tom Baeyens是JBoss jBPM的项目架构师，它特色是提供了eclipse插件，开发人员可以通过插件直接绘画出业务流程图。
Activiti的基本配置
qianfeng_dashuju的博客
04-24 2058
工作流的定义Activiti的介绍Activiti的基本配置Activiti数据库表介绍什么是工作流（WorkFlow）工作流(Workflow)，就是通过计算机对业务流程自动化执行管理。它主要解决的是“使在多个参与者之间按照某种预定义的规则自动进行传递文档、信息或任务的过程，从而实现某个预期的业务目标，或者促使此目标的实现”。比如员工请假，就是由：员工申请、主管审批、人事确认等工作流程组成，在软...
JAVA实现一个工作流引擎
mxt51220的博客
06-18 6396
工作流是一种将一系列相关的任务和活动组织起来的技术，以便在企业或组织中自动化或半自动化地管理业务流程。工作流技术可以帮助企业或组织更好地管理和优化业务流程，提高生产效率和质量，降低成本和风险。JAVA作为一种面向对象编程语言，具有跨平台性、性能优异、可靠性高等优势，在实现工作流方面也有广泛的应用。JAVA实现工作流的优势在于，它可以基于开放的标准和框架，实现高效、灵活、可扩展的工作流应用，具有较好的可移植性和互操作性。同时，JAVA还提供了丰富的开发工具和集成环境，可以大大提高开发效率和质量。
极简 Java 工作流概念入门
mfmfmfo的博客
08-26 1578
这个流程比较简单，我们很容易想到解决方案，不用工作流也能解决，有一个专门的请假表，当 A 要请假的时候，就往请假表中添加一条记录，这条记录的内容包含了请假的天数、原因、请假的审批人 B 以及一个名为 status 的字段，这个 status 字段表示这个请假申请目前的状态（待审批、已批准还是已拒绝），然后 B 登录系统之后，在请假表中查询到了 A 的请假信息，然后选择批准，此时将 status 字段的值改一下就行了。举个中间定时事件的例子，比如用户下单之后，可以有一个中间定时事件，延迟 5 分钟发货。..
Java集成工作流经典案例（多个项目优化精华版）
weixin_41039677的博客
04-13 2291
本项目拥有用户管理，部门管理，代码生成，系统监管，报表，大屏展示，业务审批等功能。功能太强大，只能粗矿的介绍，所见即所得，体验一下吧。上面只是展示了平台的审批流功能，还有其他很多功能没展示出来，自己也写了一些非常好用的组件，做到系统敏捷快速开发，大大减少开发时间和成本，目前正在对接移动端审批。有需要源码的联系我。
Activiti工作流详解与实战
在本课程中，我们将深入探讨Activiti工作流，这是一种强大的业务流程管理框架，由Alfresco软件于2010年发布。Activiti不仅是一个开源的BPM平台，而且因其灵活性和可扩展性而在工作流、服务协作领域广泛应用。其创始...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值