关于java:史上最全-Activiti-学习教程一文搞定最强工作流引擎

64次阅读

共计 33817 个字符，预计需要花费 85 分钟才能阅读完成。

一、工作流介绍

1.1 概念

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

1.2 工作流零碎

一个软件系统中具备工作流的性能，咱们把它称为工作流零碎，一个零碎中工作流的性能是什么？就是对系统的业务流程进行自动化治理，所以工作流是建设在业务流程的根底上，所以一个软件的系统核心基本上还是零碎的业务流程，工作流只是帮助进行业务流程治理。即便没有工作流业务零碎也能够开发运行，只不过有了工作流能够更好的治理业务流程，进步零碎的可扩展性。

1.3 实用行业

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

1.4 具体利用

1、要害业务流程： 订单、报价解决、合同审核、客户电话解决、供应链治理等

2、行政治理类： 出差申请、加班申请、销假申请、用车申请、各种办公用品申请、购买申请、日报周报等但凡原来手工流转解决的行政表单。

3、人事管理类： 员工培训安顿、绩效考评、职位变动解决、员工档案信息管理等。

4、财务相干类： 付款申请、应收款解决、日常报销解决、出差报销、估算和打算申请等。

5、客户服务类： 客户信息管理、客户投诉、申请解决、售后服务治理等。

6、非凡服务类： ISO 系列对应流程、品质治理对应流程、产品数据信息管理、贸易公司报关解决、物流公司货物跟踪解决等各种通过表单逐渐手工流转实现的工作均可利用工作流软件主动标准地施行。

1.5 实现形式

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

针对有权限能够查看的记录，以后用户依据本人的角色来决定审批是否合格的操作。如果合格将状态字段设置一个值，来代表合格；当然如果不合格也须要设置一个值来代表不合格的状况。

这是一种最为原始的形式。通过状态字段尽管做到了流程管制，然而当咱们的流程产生变更的时候，这种形式所编写的代码也要进行调整。

那么有没有业余的形式来实现工作流的治理呢？并且能够做到业务流程变动之后，咱们的程序能够不必扭转，如果能够实现这样的成果，那么咱们的业务零碎的适应能力就失去了极大晋升。

举荐一个开源收费的 Spring Boot 最全教程：

https://github.com/javastacks/spring-boot-best-practice

二、Activiti7 概述

2.1 介绍

Alfresco 软件在 2010 年 5 月 17 日发表 Activiti 业务流程治理（BPM）开源我的项目的正式启动，其首席架构师由业务流程治理 BPM 的专家 Tom Baeyens 负责，Tom Baeyens 就是原来 jbpm 的架构师，而 jbpm 是一个十分有名的工作流引擎，当然 activiti 也是一个工作流引擎。

Activiti 是一个工作流引擎，activiti 能够将业务零碎中简单的业务流程抽取进去，应用专门的建模语言 BPMN2.0 进行定义，业务流程依照事后定义的流程进行执行，实现了零碎的流程由 activiti 进行治理，缩小业务零碎因为流程变更进行系统升级革新的工作量，从而进步零碎的健壮性，同时也缩小了零碎开发保护老本。

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

经验的版本:

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

2.1.1 BPM

BPM（Business Process Management），即业务流程治理，是一种规范化的结构端到端的业务流程，以继续的进步组织业务效率。常见商业治理教育如 EMBA、MBA 等均将 BPM 蕴含在内。

2.1.2 BPM 软件

BPM 软件就是依据企业中业务环境的变动，推动人与人之间、人与零碎之间以及零碎与零碎之间的整合及调整的经营办法与解决方案的 IT 工具。

通过 BPM 软件对企业外部及内部的业务流程的整个生命周期进行建模、自动化、治理监控和优化，使企业老本升高，利润得以大幅晋升。

BPM 软件在企业中应用领域宽泛，但凡有业务流程的中央都能够 BPM 软件进行治理，比方企业人事办公治理、洽购流程治理、公文审批流程治理、财务管理等。

2.1.3 BPMN

BPMN（Business Process Model AndNotation）- 业务流程模型和符号 是由 BPMI（BusinessProcess Management Initiative）开发的一套规范的业务流程建模符号，应用 BPMN 提供的符号能够创立业务流程。

2004 年 5 月公布了 BPMN1.0 标准.BPMI 于 2005 年 9 月并入 OMG（The Object Management Group 对象治理组织)组织。OMG 于 2011 年 1 月公布 BPMN2.0 的最终版本。

具体倒退历史如下:

BPMN 是目前被各 BPM 厂商宽泛承受的 BPM 规范。Activiti 就是应用 BPMN 2.0 进行流程建模、流程执行治理，它包含很多的建模符号，比方：Event

用一个圆圈示意，它是流程中运行过程中产生的事件。

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

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

<?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:activiti="http://activiti.org/bpmn" xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI" xmlns:omgdc="http://www.omg.org/spec/DD/20100524/DC" xmlns:omgdi="http://www.omg.org/spec/DD/20100524/DI" typeLanguage="http://www.w3.org/2001/XMLSchema" expressionLanguage="http://www.w3.org/1999/XPath" targetNamespace="http://www.activiti.org/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>

2.2 应用步骤

部署 activiti

Activiti 是一个工作流引擎（其实就是一堆 jar 包 API），业务零碎拜访(操作)activiti 的接口，就能够不便的操作流程相干数据，这样就能够把工作流环境与业务零碎的环境集成在一起。

流程定义

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

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

流程定义部署

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

应用 activiti 提供的 api 把流程定义内容存储起来，在 Activiti 执行过程中能够查问定义的内容

Activiti 执行把流程定义内容存储在数据库中

启动一个流程实例

流程实例也叫：ProcessInstance

启动一个流程实例示意开始一次业务流程的运行。

在员工销假流程定义部署实现后，如果张三要销假就能够启动一个流程实例，如果李四要销假也启动一个流程实例，两个流程的执行相互不影响。

用户查问待办工作(Task)

因为当初零碎的业务流程曾经交给 activiti 治理，通过 activiti 就能够查问以后流程执行到哪了，以后用户须要办理什么工作了，这些 activiti 帮咱们治理了，而不须要开发人员本人编写在 sql 语句查问。

用户办理工作

用户查问待办工作后，就能够办理某个工作，如果这个工作办理实现还须要其它用户办理，比方洽购单创立后由部门经理审核，这个过程也是由 activiti 帮咱们实现了。

流程完结

当工作办理实现没有下一个工作结点了，这个流程实例就实现了。

三、Activiti 环境

3.1 开发环境

  • Jdk1.8 或以上版本
  • Mysql 5 及以上的版本
  • Tomcat8.5
  • IDEA

留神：activiti 的流程定义工具插件能够装置在 IDEA 下，也能够装置在 Eclipse 工具下

3.2 Activiti 环境

咱们应用：Activiti7.0.0.Beta1 默认反对 spring5。

举荐一个开源收费的 Spring Boot 最全教程：

https://github.com/javastacks/spring-boot-best-practice

3.2.1 下载 activiti7

Activiti 下载地址：http://activiti.org/download.html，Maven 的依赖如下：

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

activiti 运行须要有数据库的反对，反对的数据库有：h2, mysql, oracle, postgres, mssql, db2。

3.2.2 流程设计器 IDEA 下装置

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

此时咱们就能够搜寻到 actiBPM 插件，它就是 Activiti Designer 的 IDEA 版本，咱们点击 Install 装置。

装置好后，页面如下：

提醒须要重启 idea，点击重启。

重启实现后，再次关上 Settings 下的 Plugins（插件列表），点击右侧的 Installed（已装置的插件），在列表中看到 actiBPM，就阐明曾经装置胜利了，如下图所示：

前面的课程里，咱们会应用这个流程设计器进行 Activiti 的流程设计。

3.3 Activiti 的数据库反对

Activiti 在运行时须要数据库的反对，应用 25 张表，把流程定义节点内容读取到数据库表中，以供后续应用。

3.3.1 Activiti 反对的数据库

activiti 反对的数据库和版本如下：

3.3.2 在 MySQL 生成表

3.3.2.1 创立数据库

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

CREATE DATABASE activiti DEFAULT CHARACTER SET utf8;

3.3.2.2 应用 java 代码生成表

  • 创立 java 工程

应用 idea 创立 java 的 maven 工程，取名：activiti01。

  • 退出 maven 依赖的坐标（jar 包）

首先须要在 java 工程中退出 ProcessEngine 所须要的 jar 包，包含：

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

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

残缺的依赖内容如下：

<properties>
    <slf4j.version>1.6.6</slf4j.version>
    <log4j.version>1.2.12</log4j.version>
    <activiti.version>7.0.0.Beta1</activiti.version>
</properties>
<dependencies>
    <dependency>
        <groupId>org.activiti</groupId>
        <artifactId>activiti-engine</artifactId>
        <version>${activiti.version}</version>
    </dependency>
    <dependency>
        <groupId>org.activiti</groupId>
        <artifactId>activiti-spring</artifactId>
        <version>${activiti.version}</version>
    </dependency>
    <!-- bpmn 模型解决 -->
    <dependency>
        <groupId>org.activiti</groupId>
        <artifactId>activiti-bpmn-model</artifactId>
        <version>${activiti.version}</version>
    </dependency>
    <!-- bpmn 转换 -->
    <dependency>
        <groupId>org.activiti</groupId>
        <artifactId>activiti-bpmn-converter</artifactId>
        <version>${activiti.version}</version>
    </dependency>
    <!-- bpmn json 数据转换 -->
    <dependency>
        <groupId>org.activiti</groupId>
        <artifactId>activiti-json-converter</artifactId>
        <version>${activiti.version}</version>
    </dependency>
    <!-- bpmn 布局 -->
    <dependency>
        <groupId>org.activiti</groupId>
        <artifactId>activiti-bpmn-layout</artifactId>
        <version>${activiti.version}</version>
    </dependency>
    <!-- activiti 云反对 -->
    <dependency>
        <groupId>org.activiti.cloud</groupId>
        <artifactId>activiti-cloud-services-api</artifactId>
        <version>${activiti.version}</version>
    </dependency>
    <!-- mysql 驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.40</version>
    </dependency>
    <!-- mybatis -->
    <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>
    <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>
</dependencies>
  • 增加 log4j 日志配置

咱们应用 log4j 日志包，能够对日志进行配置

在 resources 下创立 log4j.properties

# Set root category priority to INFO and its only appender to CONSOLE.
#log4j.rootCategory=INFO, CONSOLE debug info warn error fatal
log4j.rootCategory=debug, CONSOLE, LOGFILE
# Set the enterprise logger category to FATAL and its only appender to CONSOLE.
log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE
# CONSOLE is set to be a ConsoleAppender using a PatternLayout.
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{ISO8601} %-6r[%15.15t] %-5p %30.30c %x - %m\n
# LOGFILE is set to be a File appender using a PatternLayout.
log4j.appender.LOGFILE=org.apache.log4j.FileAppender
log4j.appender.LOGFILE.File=f:\act\activiti.log
log4j.appender.LOGFILE.Append=true
log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
log4j.appender.LOGFILE.layout.ConversionPattern=%d{ISO8601} %-6r[%15.15t] %-5p %30.30c %x - %m\n
  • 增加 activiti 配置文件

咱们应用 activiti 提供的默认形式来创立 mysql 的表。

默认形式的要求是在 resources 下创立 activiti.cfg.xml 文件，留神：默认形式目录和文件名不能批改，因为 activiti 的源码中曾经设置，到固定的目录读取固定文件名的文件。

<?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 中进行配置

默认形式要在在 activiti.cfg.xml 中 bean 的名字叫processEngineConfiguration，名字不可批改

在这里有 2 中配置形式：一种是独自配置数据源，一种是不独自配置数据源

1、间接配置processEngineConfiguration

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

<?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">
    <!-- 默认 id 对应的值 为 processEngineConfiguration -->
    <!-- processEngine Activiti 的流程引擎 -->
    <bean id="processEngineConfiguration"
          class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
        <property name="jdbcDriver" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql:///activiti"/>
        <property name="jdbcUsername" value="root"/>
        <property name="jdbcPassword" value="123456"/>
        <!-- activiti 数据库表处理策略 -->
        <property name="databaseSchemaUpdate" value="true"/>
    </bean>
</beans>

2、配置数据源后，在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:///activiti" />
        <property name="username" value="root" />
        <property name="password" value="123456" />
        <property name="maxActive" value="3" />
        <property name="maxIdle" value="1" />
    </bean>

    <bean id="processEngineConfiguration"
          class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
        <!-- 援用数据源 下面曾经设置好了 -->
        <property name="dataSource" ref="dataSource" />
        <!-- activiti 数据库表处理策略 -->
        <property name="databaseSchemaUpdate" value="true"/>
    </bean>
</beans>
  • java 类编写程序生成表

创立一个测试类，调用 activiti 的工具类，生成 acitivti 须要的数据库表。

间接应用 activiti 提供的工具类 ProcessEngines，会默认读取 classpath 下的activiti.cfg.xml 文件，读取其中的数据库配置，创立 ProcessEngine，在创立ProcessEngine 时会主动创立表。

代码如下：

package com.itheima.activiti01.test;

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngineConfiguration;
import org.junit.Test;

public class TestDemo {
    /**
     * 生成 activiti 的数据库表
     */
    @Test
    public void testCreateDbTable() {
        // 应用 classpath 下的 activiti.cfg.xml 中的配置创立 processEngine
  ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
  System.out.println(processEngine);
    }
}

阐明：

  • 运行以上程序段即可实现 activiti 表创立，通过扭转 activiti.cfg.xml 中databaseSchemaUpdate 参数的值执行不同的数据表解决策略。
  • 上 边 的 办法 getDefaultProcessEngine办法在执行时，从activiti.cfg.xml 中找固定的名称 processEngineConfiguration。

在测试程序执行过程中，idea 的控制台会输入日志，阐明程序正在创立数据表，相似如下，留神红线内容：

执行实现后咱们查看数据库，创立了 25 张表，后果如下：

到这，咱们就实现 activiti 运行须要的数据库和表的创立。

3.4 表构造介绍

3.4.1 表的命名规定和作用

看到方才创立的表，咱们发现 Activiti 的表都以 ACT_ 结尾。

第二局部是示意表的用处的两个字母标识。用处也和服务的 API 对应。

  • ACT_RE：’RE’示意 repository。这个前缀的表蕴含了流程定义和流程动态资源（图片，规定，等等）。
  • ACT_RU：’RU’示意 runtime。这些运行时的表，蕴含流程实例，工作，变量，异步工作，等运行中的数据。Activiti 只在流程实例执行过程中保留这些数据，在流程完结时就会删除这些记录。这样运行时表能够始终很小速度很快。
  • ACT_HI：’HI’示意 history。这些表蕴含历史数据，比方历史流程实例，变量，工作等等。
  • ACT_GE：GE 示意 general。通用数据，用于不同场景下
3.4.2 Activiti 数据表介绍

四、Activiti 类关系图

下面咱们实现了 Activiti 数据库表的生成，java 代码中咱们调用 Activiti 的工具类，上面来理解 Activiti 的类关系

4.1 类关系图

在新版本中，咱们通过试验能够发现 IdentityService，FormService 两个 Serivce 都曾经删除了。

所以前面咱们对于这两个 Service 也不解说了，但老版本中还是有这两个 Service，同学们须要理解一下

4.2 activiti.cfg.xml

activiti 的引擎配置文件，包含：ProcessEngineConfiguration的定义、数据源定义、事务管理器等，此文件其实就是一个 spring 配置文件。

4.3 流程引擎配置类

流程引擎的配置类（ProcessEngineConfiguration），通过 ProcessEngineConfiguration 能够创立工作流引擎ProceccEngine，罕用的两种办法如下：

4.3.1 StandaloneProcessEngineConfiguration

应用 StandaloneProcessEngineConfigurationActiviti 能够独自运行，来创立 ProcessEngine，Activiti 会本人处理事务。

配置文件形式：

通常在 activiti.cfg.xml 配置文件中定义一个 id 为 processEngineConfiguration 的 bean。

办法如下：

<bean id="processEngineConfiguration"
          class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
        <!-- 配置数据库相干的信息 -->
        <!-- 数据库驱动 -->
        <property name="jdbcDriver" value="com.mysql.jdbc.Driver"/>
        <!-- 数据库链接 -->
        <property name="jdbcUrl" value="jdbc:mysql:///activiti"/>
        <!-- 数据库用户名 -->
        <property name="jdbcUsername" value="root"/>
        <!-- 数据库明码 -->
        <property name="jdbcPassword" value="123456"/>
        <!--actviti 数据库表在生成时的策略  true - 如果数据库中曾经存在相应的表，那么间接应用，如果不存在，那么会创立 -->
        <property name="databaseSchemaUpdate" value="true"/>
    </bean>

还能够退出连接池:

<?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">
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql:///activiti"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
        <property name="maxActive" value="3"/>
        <property name="maxIdle" value="1"/>
    </bean>
    <!-- 在默认形式下 bean 的 id  固定为 processEngineConfiguration-->
    <bean id="processEngineConfiguration"
          class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
        <!-- 引入下面配置好的 链接池 -->
        <property name="dataSource" ref="dataSource"/>
        <!--actviti 数据库表在生成时的策略  true - 如果数据库中曾经存在相应的表，那么间接应用，如果不存在，那么会创立 -->
        <property name="databaseSchemaUpdate" value="true"/>
    </bean>
</beans>
4.3.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/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: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 configuration = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cfg.xml")

上边的代码要求 activiti.cfg.xml 中必须有一个 processEngineConfiguration 的 bean

也能够应用下边的办法，更改 bean 的名字：

ProcessEngineConfiguration.createProcessEngineConfigurationFromResource(String resource, String beanName);

4.4 工作流引擎创立

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

4.4.1 默认创立形式

将 activiti.cfg.xml 文件名及门路固定，且 activiti.cfg.xml 文件中有 processEngineConfiguration的配置，能够应用如下代码创立processEngine:

// 间接应用工具类 ProcessEngines，应用 classpath 下的 activiti.cfg.xml 中的配置创立 processEngine
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
System.out.println(processEngine);
4.4.2 个别创立形式
// 先构建 ProcessEngineConfiguration
ProcessEngineConfiguration configuration = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cfg.xml");
// 通过 ProcessEngineConfiguration 创立 ProcessEngine，此时会创立数据库
ProcessEngine processEngine = configuration.buildProcessEngine();
4.5 Servcie 服务接口

Service 是工作流引擎提供用于进行工作流部署、执行、治理的服务接口，咱们应用这些接口能够就是操作服务对应的数据表

4.5.1 Service 创立形式

通过 ProcessEngine 创立 Service

形式如下：

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

4.5.2 Service 总览

简略介绍：

  • RepositoryService

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

除了部署流程定义以外还能够：查问引擎中的公布包和流程定义。

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

取得流程定义的 pojo 版本，能够用来通过 java 解析流程，而不用通过 xml。

  • RuntimeService

Activiti 的流程运行治理类。能够从这个服务类中获取很多对于流程执行相干的信息

  • TaskService

Activiti 的工作治理类。能够从这个类中获取工作的信息。

  • HistoryService

Activiti 的历史治理类，能够查问历史信息，执行流程时，引擎会保留很多数据（依据配置），比方流程实例启动工夫，工作的参与者，实现工作的工夫，每个流程实例的执行门路，等等。这个服务次要通过查问性能来取得这些数据。

  • ManagementService

Activiti 的引擎治理类，提供了对 Activiti 流程引擎的治理和保护性能，这些性能不在工作流驱动的应用程序中应用，次要用于 Activiti 零碎的日常保护。

五、Activiti 入门

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

创立 Activiti 工作流次要蕴含以下几步：

  • 定义流程，依照 BPMN 的标准，应用流程定义工具，用流程符号把整个流程形容进去
  • 部署流程，把画好的流程定义文件，加载到数据库中，生成表的数据
  • 启动流程，应用 java 代码来操作数据库表中的内容

5.1 流程符号

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

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

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

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

BPMN2.0 的根本合乎次要蕴含：

事件 Event

流动 Activity

流动是工作或工作的一个通用术语。一个流动能够是一个工作，还能够是一个以后流程的子解决流程；其次，你还能够为流动指定不同的类型。常见流动如下：

网关 GateWay

网关用来解决决策，有几种罕用网关须要理解：

排他网关 (x)

——只有一条门路会被抉择。流程执行到该网关时，依照输入流的程序一一计算，当条件的计算结果为 true 时，继续执行以后网关的输入流；

  • 如果多条线路计算结果都是 true，则会执行第一个值为 true 的线路。如果所有网关计算结果没有 true，则引擎会抛出异样。
  • 排他网关须要和条件程序流联合应用，default 属性指定默认程序流，当所有的条件不满足时会执行默认程序流。

并行网关 (+)

——所有门路会被同时抉择

  • 拆分 —— 并行执行所有输入程序流，为每一条程序流创立一个并行执行线路。
  • 合并 —— 所有从并行网关拆分并执行实现的线路均在此等待，直到所有的线路都执行实现才持续向下执行。

容纳网关 (+)

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

  • 拆分 —— 计算每条线路上的表达式，当表达式计算结果为 true 时，创立一个并行线路并继续执行
  • 合并 —— 所有从并行网关拆分并执行实现的线路均在此等待，直到所有的线路都执行实现才持续向下执行。

事件网关 (+)

—— 专门为两头捕捉事件设置的，容许设置多个输入流指向多个不同的两头捕捉事件。当流程执行到事件网关后，流程处于期待状态，须要期待抛出事件能力将期待状态转换为活动状态。

流向 Flow

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

5.2 流程设计器应用

Activiti-Designer 应用
Palette（画板）

在 idea 中装置插件即可应用，画板中包含以下结点：

  • Connection—连贯
  • Event—事件
  • Task—工作
  • Gateway—网关
  • Container—容器
  • Boundary event—边界事件
  • Intermediate event- - 两头事件

流程图设计结束保留生成.bpmn 文件

新建流程(IDEA 工具)

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

弹出如下图所示框，输出 evection 示意 出差审批流程：

起完名字 evection 后（默认扩大名为 bpmn），就能够看到流程设计页面，如图所示：

左侧区域是绘图区，右侧区域是 palette 画板区域

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

绘制流程

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

指定流程定义 Key

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

指定工作负责人

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

  • 经理审批负责人为 jerry
  • 总经理审批负责人为 jack
  • 财务审批负责人为 rose

六、流程操作

6.1 流程定义

概述

流程定义是线下依照 bpmn2.0 规范去形容 业务流程，通常应用 idea 中的插件对业务流程进行建模。

应用 idea 下的 designer 设计器绘制流程，并会生成两个文件：.bpmn 和.png

.bpmn 文件

应用 activiti-desinger 设计业务流程，会生成.bpmn 文件，下面咱们曾经创立好了 bpmn 文件

BPMN 2.0 根节点是 definitions 节点。这个元素中，能够定义多个流程定义（不过咱们倡议每个文件只蕴含一个流程定义，能够简化开发过程中的保护难度）。

留神，definitions 元素 起码也要蕴含 xmlns 和 targetNamespace 的申明。targetNamespace 能够是任意值，它用来对流程实例进行分类。

  • 流程定义局部：定义了流程每个结点的形容及结点之间的流程流转。
  • 流程布局定义：定义流程每个结点在流程图上的地位坐标等信息。
生成.png 图片文件

IDEA 工具中的操作形式

1、批改文件后缀为 xml

首先将 evection.bpmn 文件改名为 evection.xml，如下图：

evection.xml 批改前的 bpmn 文件，成果如下：

2、应用 designer 设计器关上.xml 文件

在 evection.xml 文件下面，点右键并抉择 Diagrams 菜单，再抉择Show BPMN2.0 Designer…

3、查看关上的文件

关上后，却呈现乱码，如图：

4、解决中文乱码

1、关上 Settings，找到 File Encodings，把 encoding 的选项都抉择 UTF-8

2、关上 IDEA 装置门路，找到如下的装置目录

依据本人所装置的版本来决定，我应用的是 64 位的 idea，所以在 idea64.exe.vmoptions 文件的最初一行追加一条命令： -Dfile.encoding=UTF-8

如下所示：

肯定留神，不要有空格，否则重启 IDEA 时会打不开，而后 重启 IDEA。

如果以上办法曾经做完，还呈现乱码，就再批改一个文件，并在文件的开端增加：-Dfile.encoding=UTF-8，而后重启 idea，如图：

最初从新在 evection.xml 文件下面，点右键并抉择 Diagrams 菜单，再抉择Show BPMN2.0 Designer…，看到生成图片，如图：

到此，解决乱码问题

5、导出为图片文件

点击 Export To File 的小图标，关上如下窗口，留神填写文件名及扩展名，抉择好保留图片的地位：

而后，咱们把 png 文件拷贝到 resources 下的 bpmn 目录，并且把 evection.xml 改名为 evection.bpmn。

6.2 流程定义部署

概述

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

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

单个文件部署形式

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

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

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

压缩包部署形式

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

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

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

操作数据表

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

  • act_re_deployment 流程定义部署表，每部署一次减少一条记录
  • act_re_procdef 流程定义表，部署每个新的流程定义都会在这张表中减少一条记录
  • act_ge_bytearray 流程资源表

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

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

后果：

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

后果：

留神，KEY 这个字段是用来惟一辨认不同流程的关键字

SELECT * FROM act_ge_bytearray #资源表

后果：

留神：

act_re_deployment和 act_re_procdef 一对多关系，一次部署在流程部署表生成一条记录，但一次部署能够部署多个流程定义，每个流程定义在流程定义表生成一条记录。每一个流程定义在 act_ge_bytearray 会存在两个资源记录，bpmn 和 png。

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

6.3 启动流程实例

流程定义部署在 activiti 后就能够通过工作流治理业务流程了，也就是说上边部署的出差申请流程能够应用了。

针对该流程，启动一个流程示意发动一个新的出差申请单，这就相当于 java 类与 java 对象的关系，类定义好后须要 new 创立一个对象应用，当然能够 new 多个对象。对于请出差申请流程，张三发动一个出差申请单须要启动一个流程实例，出差申请单发动一个出差单也须要启动一个流程实例。

代码如下：

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

输入内容如下：

操作数据表

  • act_hi_actinst 流程实例执行历史
  • act_hi_identitylink 流程的参加用户历史信息
  • act_hi_procinst 流程实例历史信息
  • act_hi_taskinst 流程工作历史信息
  • act_ru_execution 流程执行信息
  • act_ru_identitylink 流程的参加用户信息
  • act_ru_task 工作信息

6.4 工作查问

流程启动后，工作的负责人就能够查问本人以后须要解决的工作，查问进去的工作都是该用户的待办工作。

/**
     * 查问以后集体待执行的工作
      */
    @Test
    public void testFindPersonalTaskList() {
//        工作负责人
        String assignee = "zhangsan";
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//        创立 TaskService
        TaskService taskService = processEngine.getTaskService();
//        依据流程 key 和 工作负责人 查问工作
        List<Task> list = taskService.createTaskQuery()
                .processDefinitionKey("myEvection") // 流程 Key
                .taskAssignee(assignee)// 只查问该工作负责人的工作
                .list();

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

        }
    }

输入后果如下：

流程实例 id：2501
工作 id：2505
工作负责人：zhangsan
工作名称：创立出差申请

6.5 流程工作解决

工作负责人查问待办工作，抉择工作进行解决，实现工作。

// 实现工作
    @Test
    public void completTask(){
//        获取引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//        获取 taskService
        TaskService taskService = processEngine.getTaskService();

//        依据流程 key 和 工作的负责人 查问工作
//        返回一个工作对象
        Task task = taskService.createTaskQuery()
                .processDefinitionKey("myEvection") // 流程 Key
                .taskAssignee("zhangsan")  // 要查问的负责人
                .singleResult();

//        实现工作, 参数：工作 id
        taskService.complete(task.getId());
    }

6.6 流程定义信息查问

查问流程相干信息，蕴含流程定义，流程部署，流程定义版本

    /**
     * 查问流程定义
     */
    @Test
    public void queryProcessDefinition(){
        //        获取引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//        repositoryService
        RepositoryService repositoryService = processEngine.getRepositoryService();
//        失去 ProcessDefinitionQuery 对象
        ProcessDefinitionQuery processDefinitionQuery = repositoryService.createProcessDefinitionQuery();
//          查问出以后所有的流程定义
//          条件：processDefinitionKey =evection
//          orderByProcessDefinitionVersion 依照版本排序
//        desc 顺叙
//        list 返回汇合
        List<ProcessDefinition> definitionList = processDefinitionQuery.processDefinitionKey("myEvection")
                .orderByProcessDefinitionVersion()
                .desc()
                .list();
//      输入流程定义信息
        for (ProcessDefinition processDefinition : definitionList) {System.out.println("流程定义 id="+processDefinition.getId());
            System.out.println("流程定义 name="+processDefinition.getName());
            System.out.println("流程定义 key="+processDefinition.getKey());
            System.out.println("流程定义 Version="+processDefinition.getVersion());
            System.out.println("流程部署 ID ="+processDefinition.getDeploymentId());
        }

    }

输入后果：

流程定义 id：myEvection:1:4
流程定义名称：出差申请单
流程定义 key：myEvection
流程定义版本：1

6.7 流程删除

public void deleteDeployment() {
  // 流程部署 id
  String deploymentId = "1";

    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    // 通过流程引擎获取 repositoryService
  RepositoryService repositoryService = processEngine
    .getRepositoryService();
  // 删除流程定义，如果该流程定义已有流程实例启动则删除时出错
  repositoryService.deleteDeployment(deploymentId);
  // 设置 true 级联删除流程定义，即便该流程有流程实例启动也能够删除，设置为 false 非级别删除形式，如果流程
  //repositoryService.deleteDeployment(deploymentId, true);
 }

阐明：

  • 应用 repositoryService 删除流程定义，历史表信息不会被删除
  • 如果该流程定义下没有正在运行的流程，则能够用一般删除。

如果该流程定义下存在曾经运行的流程，应用一般删除报错，可用级联删除办法将流程及相干记录全副删除。

先删除没有实现流程节点，最初就能够齐全删除流程定义信息

我的项目开发中级联删除操作个别只凋谢给超级管理员应用.

6.8 流程资源下载

当初咱们的流程资源文件曾经上传到数据库了，如果其余用户想要查看这些资源文件，能够从数据库中把资源文件下载到本地。

解决方案有：

  • jdbc 对 blob 类型，clob 类型数据读取进去，保留到文件目录
  • 应用 activiti 的 api 来实现

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

引入 commons-io 依赖包

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

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

import org.apache.commons.io.IOUtils;

@Test
    public void deleteDeployment(){
//        获取引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//        获取 repositoryService
        RepositoryService repositoryService = processEngine.getRepositoryService();
//        依据部署 id 删除部署信息, 如果想要级联删除，能够增加第二个参数，true
        repositoryService.deleteDeployment("1");
    }

    public void  queryBpmnFile() throws IOException {
//        1、失去引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//        2、获取 repositoryService
        RepositoryService repositoryService = processEngine.getRepositoryService();
//        3、失去查询器：ProcessDefinitionQuery，设置查问条件, 失去想要的流程定义
        ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()
                .processDefinitionKey("myEvection")
                .singleResult();
//        4、通过流程定义信息，失去部署 ID
        String deploymentId = processDefinition.getDeploymentId();
//        5、通过 repositoryService 的办法，实现读取图片信息和 bpmn 信息
//        png 图片的流
        InputStream pngInput = repositoryService.getResourceAsStream(deploymentId, processDefinition.getDiagramResourceName());
//        bpmn 文件的流
        InputStream bpmnInput = repositoryService.getResourceAsStream(deploymentId, processDefinition.getResourceName());
//        6、结构 OutputStream 流
        File file_png = new File("d:/evectionflow01.png");
        File file_bpmn = new File("d:/evectionflow01.bpmn");
        FileOutputStream bpmnOut = new FileOutputStream(file_bpmn);
        FileOutputStream pngOut = new FileOutputStream(file_png);
//        7、输出流，输入流的转换
        IOUtils.copy(pngInput,pngOut);
        IOUtils.copy(bpmnInput,bpmnOut);
//        8、敞开流
        pngOut.close();
        bpmnOut.close();
        pngInput.close();
        bpmnInput.close();}

阐明：

  • deploymentId为流程部署 ID
  • resource_name为 act_ge_bytearray 表中 NAME_列的值
  • 应用 repositoryService 的getDeploymentResourceNames办法能够获取指定部署下得所有文件的名称
  • 应用 repositoryService 的getResourceAsStream办法传入部署 ID 和资源图片名称能够获取部署下指定名称文件的输出流

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

6.9 流程历史信息的查看

即便流程定义曾经删除了，流程执行的历史信息通过后面的剖析，仍然保留在 activiti 的 act_hi_* 相干的表中。所以咱们还是能够查问流程执行的历史信息，能够通过 HistoryService 来查看相干的历史记录。

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

总结

基本功能介绍以及实现了，如果还须要更加高级的性能比方挂起、激活流程实例、流程变量等请参考

https://andyoung.blog.csdn.net/article/details/118345330

工作流引擎 Activiti 与 Spring boot 联合会是开发跟简略，不如来看下

https://andyoung.blog.csdn.net/article/details/118372175

起源：https://blog.csdn.net/agonie201218/article/details/118198535

近期热文举荐：

1.1,000+ 道 Java 面试题及答案整顿(2022 最新版)

2. 劲爆！Java 协程要来了。。。

3.Spring Boot 2.x 教程，太全了！

4. 别再写满屏的爆爆爆炸类了，试试装璜器模式，这才是优雅的形式！！

5.《Java 开发手册（嵩山版）》最新公布，速速下载！

感觉不错，别忘了顺手点赞 + 转发哦！

正文完
java
发表至： java
2023-05-16
 0
关于java:下单流程解耦新方案你知道Spring事件监听机制吗
关于java:高并发系统设计之限流
关于java:记一次lombok踩坑经历
MoreThanJavaDay-2变量数据类型和运算符