添加链接
link管理
链接快照平台
  • 输入网页链接,自动生成快照
  • 标签化管理网页链接

一、介绍

1、工作流介绍

(1)概念

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

(2)工作流系统

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

(3)具体应用

1、关键业务流程:订单、报价处理、合同审核、客户电话处理、供应链管理等

2、行政管理类:出差申请、加班申请、请假申请、用车申请、各种办公用品申请、购买申请、日报周报等凡是原来手工流转处理的行政表单。

3、人事管理类:员工培训安排、绩效考评、职位变动处理、员工档案信息管理等。

4、财务相关类:付款请求、应收款处理、日常报销处理、出差报销、预算和计划申请等。

5、客户服务类:客户信息管理、客户投诉、请求处理、售后服务管理等。

6、特殊服务类:ISO系列对应流程、质量管理对应流程、产品数据信息管理、贸易公司报关处理、物流公司货物跟踪处理等各种通过表单逐步手工流转完成的任务均可应用工作流软件自动规范地实施。

(4)实现方式

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

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

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

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

2、Activity介绍

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

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

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

(1)BPM

BPM(Business Process Management),即业务流程管理,是一种规范化的构造端到端的业务流程,以持续的提高组织业务效率。常见商业管理教育如EMBA、MBA等均将BPM包含在内。

(2)BPM软件

BPM软件就是根据企业中业务环境的变化,推进人与人之间、人与系统之间以及系统与系统之间的整合及调整的经营方法与解决方案的IT工具。

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

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

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

二、使用步骤

1、部署activiti

Activiti是一个工作流引擎(其实就是一堆jar包API),业务系统访问(操作)activiti的接口,就可以方便的操作流程相关数据,这样就可以把工作流环境与业务系统的环境集成在一起。

2、流程定义

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

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

3、流程定义部署

activiti部署业务流程定义(.bpmn文件)。

使用activiti提供的api把流程定义内容存储起来,在Activiti执行过程中可以查询定义的内容

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

4、启动一个流程实例

流程实例也叫:ProcessInstance

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

在员工请假流程定义部署完成后,如果张三要请假就可以启动一个流程实例,如果李四要请假也启动一个流程实例,两个流程的执行互相不影响。

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

因为现在系统的业务流程已经交给activiti管理,通过activiti就可以查询当前流程执行到哪了,当前用户需要办理什么任务了,这些activiti帮我们管理了,而不需要开发人员自己编写在sql语句查询。

6、用户办理任务

用户查询待办任务后,就可以办理某个任务,如果这个任务办理完成还需要其它用户办理,比如采购单创建后由部门经理审核,这个过程也是由activiti帮我们完成了。

7、流程结束

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

三、数据库支持

activiti运行需要有数据库的支持,支持的数据库有:h2, mysql, oracle, postgres, mssql, db2。

activiti 支持的数据库和版本如下:

数据库类型 JDBC连接示例 1.3.168 jdbc:h2:tcp://localhost/activiti 默认配置的数据库 mysql 5.1.21 jdbc:mysql://localhost:3306/activiti?autoReconnect=true 使用 mysql-connector-java 驱动测试 oracle 11.2.0.1.0 jdbc:oracle:thin:@localhost:1521:xe postgres jdbc:postgresql://localhost:5432/activiti DB2 10.1 using db2jcc4 jdbc:db2://localhost:50000/activiti mssql 2008 using sqljdbc4 jdbc:sqlserver://localhost:1433/activiti
  • act_hi_* :history,此前缀的表包含 历史数据 ,如历史(结束)流程实例,变量,任务等等。
  • act_ge_* :general,此前缀的表为 通用数据 ,用于不同场景中。
  • act_evt_* :event,此前缀的表为 事件日志
  • act_procdef_* :processdefine,此前缀的表为记录 流程定义变更 信息。
  • act_re_* :repository,此前缀的表包含了 流程定义和流程静态资源 (图片,规则等等)。
  • act_ru_* :runtime,此前缀的表是 记录运行时的数据 ,包含流程实例,任务,变量,异步任务等运行中的数据。Activiti只在流程实例执行过程中保存这些数据,在流程结束时就会删除这些
  • 1、历史数据表-8张

    2、通用数据表-2张

    act_hi_actinst 历史节点表 act_hi_attachment 历史附件表 act_hi_comment 历史意见表 act_hi_detail 历史详情表,提供历史变量的查询 act_hi_identitylink 历史流程用户信息表 act_hi_procinst 历史流程实例表 act_hi_taskinst 历史任务实例表 act_hi_varinst 历史变量表

    3、事件日志表-1张

    act_ge_bytearray 二进制数据表,存储通用的流程定义和流程资源。 act_ge_property 系统相关属性,属性数据表存储整个流程引擎级别的数据,初始化表结构时,会默认插入三条记录。

    4、流程定义变更表-1张

    act_evt_log 流程引擎的通用事件日志记录表

    5、流程定义表-3张

    act_procdef_info 流程定义的动态变更信息

    6、运行时数据表-10张

    act_re_deployment 部署信息表 act_re_model 流程设计模型部署表 act_re_procdef 流程定义数据表

    四、项目引入

    1、依赖

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

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

            <dependency>
                <groupId>org.activiti</groupId>
                <artifactId>activiti-spring-boot-starter</artifactId>
                <version>7.0.0.Beta2</version>
                <exclusions>
                    <!-- 排除activiti的mybatis,避免和外面的mybatis-plus冲突 -->
                    <exclusion>
                        <artifactId>mybatis</artifactId>
                        <groupId>org.mybatis</groupId>
                    </exclusion>
                </exclusions>
            </dependency>

    2、配置文件

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

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

    3、SpringSecurity配置

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

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

    默认情况下,springsecurity会自动配置,从而,在访问项目接口的时候,需要输入用户名和密码。

    (1)添加SecurityUtil类

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

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

    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.security.core.Authentication;
    import org.springframework.security.core.GrantedAuthority;
    import org.springframework.security.core.context.SecurityContextHolder;
    import org.springframework.security.core.context.SecurityContextImpl;
    import org.springframework.security.core.userdetails.UserDetails;
    import org.springframework.security.core.userdetails.UserDetailsService;
    import org.springframework.stereotype.Component;
    import java.util.Collection;
    @Component
    public class SecurityUtil {
        private Logger logger = LoggerFactory.getLogger(SecurityUtil.class);
        @Autowired
        @Qualifier("myUserDetailsService")
        private UserDetailsService userDetailsService;
        public void logInAs(String username) {
            UserDetails user = userDetailsService.loadUserByUsername(username);
            if (user == null) {
                throw new IllegalStateException("User " + username + " doesn't exist, please provide a valid user");
            logger.info("> Logged in as: " + username);
            SecurityContextHolder.setContext(
                new SecurityContextImpl(
                    new Authentication() {
                        @Override
                        public Collection<? extends GrantedAuthority> getAuthorities() {
                            return user.getAuthorities();
                        @Override
                        public Object getCredentials() {
                            return user.getPassword();
                        @Override
                        public Object getDetails() {
                            return user;
                        @Override
                        public Object getPrincipal() {
                            return user;
                        @Override
                        public boolean isAuthenticated() {
                            return true;
                        @Override
                        public void setAuthenticated(boolean isAuthenticated) throws IllegalArgumentException { }
                        @Override
                        public String getName() {
                            return user.getUsername();
                    }));
            org.activiti.engine.impl.identity.Authentication.setAuthenticatedUserId(username);
    

    (2)用户权限配置类

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

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

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

    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.security.core.authority.SimpleGrantedAuthority;
    import org.springframework.security.core.userdetails.User;
    import org.springframework.security.core.userdetails.UserDetailsService;
    import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
    import org.springframework.security.crypto.password.PasswordEncoder;
    import org.springframework.security.provisioning.InMemoryUserDetailsManager;
    import java.util.Arrays;
    import java.util.List;
    import java.util.stream.Collectors;
    @Configuration
    public class DemoApplicationConfiguration {
        private Logger logger = LoggerFactory.getLogger(DemoApplicationConfiguration.class);
         @Bean
         public UserDetailsService myUserDetailsService() {
             InMemoryUserDetailsManager inMemoryUserDetailsManager = new InMemoryUserDetailsManager();
             //这里添加用户,后面处理流程时用到的任务负责人,需要添加在这里
             String[][] usersGroupsAndRoles = {
                     {"jack", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"},
                     {"rose", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"},
                     {"tom", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"},
                     {"other", "password", "ROLE_ACTIVITI_USER", "GROUP_otherTeam"},
                     {"system", "password", "ROLE_ACTIVITI_USER"},
                     {"admin", "password", "ROLE_ACTIVITI_ADMIN"},
             for (String[] user : usersGroupsAndRoles) {
                 List<String> authoritiesStrings = Arrays.asList(Arrays.copyOfRange(user, 2, user.length));
                 logger.info("> Registering new user: " + user[0] + " with the following Authorities[" + authoritiesStrings + "]");
                 inMemoryUserDetailsManager.createUser(new User(user[0], passwordEncoder().encode(user[1]),
                         authoritiesStrings.stream().map(s -> new SimpleGrantedAuthority(s)).collect(Collectors.toList())));
             return inMemoryUserDetailsManager;
         @Bean
         public PasswordEncoder passwordEncoder() {
             return new BCryptPasswordEncoder();
    

    (3)自定义配置

    (4)不使用SpringSecurity

    如果项目中不使用 SpringSecurity ,则可以通过以下方法去除

    @SpringBootApplication(
        exclude = {               org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration.class,                 org.springframework.boot.actuate.autoconfigure.security.servlet.ManagementWebSecurityAutoConfiguration.class
    public class Application {
        public static void main(String[] args) {
            SpringApplication.run(Application.class, args);
     * 该配置类仅仅为了跳过spring-security的验证
    @Configuration
    public class SpringSecurityConfig extends WebSecurityConfigurerAdapter {
    

    这样,访问接口的时候,就不要求用户认证了。即springSecurity的认证就不起作用了。

    4、创建Bpmn文件

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

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

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

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

    5、测试

    @RunWith(SpringRunner.class)
    @SpringBootTest
     public class Actviti7DemoApplicationTests {
         @Autowired
         private ProcessRuntime processRuntime;
         @Autowired
         private TaskRuntime taskRuntime;
         @Autowired
         private SecurityUtil securityUtil;
        @Test
        public void testActBoot(){
            System.out.println(taskRuntime);
         * 查看流程定义
        @Test
        public void contextLoads() {
            securityUtil.logInAs("system");
            Page<org.activiti.api.process.model.ProcessDefinition> processDefinitionPage =
                    processRuntime.processDefinitions(Pageable.of(0, 10));
            System.out.println("可用的流程定义数量:" + processDefinitionPage.getTotalItems());
            for (org.activiti.api.process.model.ProcessDefinition pd : processDefinitionPage.getContent()) {
                System.out.println("流程定义:" + pd);
         * 启动流程实例
        @Test
        public void testStartProcess() {
            securityUtil.logInAs("system");
            ProcessInstance pi = processRuntime.start(ProcessPayloadBuilder.
                    start().
                    withProcessDefinitionKey("myProcess").
                    build());
            System.out.println("流程实例ID:" + pi.getId());
         **查询任务,并完成自己的任务
        @Test
        public void testTask() {
            securityUtil.logInAs("jack");
            Page<Task> taskPage=taskRuntime.tasks(Pageable.of(0,10));
            if (taskPage.getTotalItems()>0){
                for (Task task:taskPage.getContent()){
                    taskRuntime.claim(TaskPayloadBuilder.
                            claim().
                            withTaskId(task.getId()).build());
                    System.out.println("任务:"+task);
                    taskRuntime.complete(TaskPayloadBuilder.
                            complete().
                            withTaskId(task.getId()).build());
            Page<Task> taskPage2=taskRuntime.tasks(Pageable.of*(0,10));
            if (taskPage2.getTotalItems()>0){
                System.out.println("任务:"+taskPage2.getContent());
    

    五、API

    1、Activiti 的架构

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

    Activiti的工作流程是通过读取一个配置文件,然后得到一个工作流引擎实例,通过这个引擎可以获取多个不同模块的Service,然后就可以使用这些Service去完成相应的接口,比如部署会使用到RepositoryService,实例会用到RuntimeService等。(注意:FormServiceIdentityService已经在新版本中删除了)

    2、流程引擎配置类

    流程引擎的配置类(ProcessEngineConfiguration 抽象类),通过ProcessEngineConfiguration可以创建工作流引擎ProceccEngine,常用的两种方法如下:

  • StandaloneProcessEngineConfiguration :未集成 Spring 使用的配置类
  • SpringProcessEngineConfiguration:集成 Spring 的配置类
  • 集成 Spring-Boot

    可通过注入的方式直接获取

    @Autowired
    private SpringProcessEngineConfiguration springProcessEngineConfiguration;
    public void test13(){
        ProcessEngine processEngine = springProcessEngineConfiguration.buildProcessEngine();
    

    因为在 starter 中已经自动注入了

    @Configuration
    @AutoConfigureAfter(DataSourceAutoConfiguration.class)
    @EnableConfigurationProperties(ActivitiProperties.class)
    public class ProcessEngineAutoConfiguration extends AbstractProcessEngineAutoConfiguration {
        @Bean
        @ConditionalOnMissingBean
        public SpringProcessEngineConfiguration springProcessEngineConfiguration(){
            ...
    

    3、工作流引擎的创建

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

    (1)默认创建方式-Spring下

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

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

    (2)一般创建方式-Spring下

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

    (3)SpringBoot创建

    @Autowired
    private ProcessEngine processEngine;

    在 starter 下,是通过 FactoryBean 注入的

    public abstract class AbstractProcessEngineAutoConfiguration
            extends AbstractProcessEngineConfiguration {
        @Bean
        public ProcessEngineFactoryBean processEngine(SpringProcessEngineConfiguration configuration) {
            return super.springProcessEngineBean(configuration);
    

    4、Servcie服务接口

    (1)总览

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

    简单介绍:

    RepositoryService

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

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

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

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

    RuntimeService

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

    TaskService

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

    HistoryService

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

    ManagementService

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

    (2)创建方式

    原生

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

    SpringBoot

    @Autowired
    private RuntimeService runtimeService;

    自动注入源码如下

    public abstract class AbstractProcessEngineAutoConfiguration
        extends AbstractProcessEngineConfiguration {
        @Bean
        @ConditionalOnMissingBean
        @Override
        public RuntimeService runtimeServiceBean(ProcessEngine processEngine) {
            return super.runtimeServiceBean(processEngine);
        @Bean
        @ConditionalOnMissingBean
        @Override
        public RepositoryService repositoryServiceBean(ProcessEngine processEngine) {
            return super.repositoryServiceBean(processEngine);
        @Bean
        @ConditionalOnMissingBean
        @Override
        public TaskService taskServiceBean(ProcessEngine processEngine) {
            return super.taskServiceBean(processEngine);
        @Bean
        @ConditionalOnMissingBean
        @Override
        public HistoryService historyServiceBean(ProcessEngine processEngine) {
            return super.historyServiceBean(processEngine);
        @Bean
        @ConditionalOnMissingBean
        @Override
        public ManagementService managementServiceBeanBean(ProcessEngine processEngine) {
            return super.managementServiceBeanBean(processEngine);
    

    六、流程图创建

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

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

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

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

    1、流程符号

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

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

    (1)事件 Event

    image-20230305200958694

    (2)活动 Activity

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

    (3)网关 GateWay

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

  • 排他网关 (x)
  • 只有一条路径会被选择。流程执行到该网关时,按照输出流的顺序逐个计算,当条件的计算结果为true时,继续执行当前网关的输出流;

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

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

  • 并行网关 (+)
  • 所有路径会被同时选择

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

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

  • 包容网关 (+)
  • 可以同时执行多条线路,也可以在网关上设置条件

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

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

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

    (4)流向 Flow

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

    2、创建流程图

    因高版本的 IDEA 不支持 actiBPM 插件,故采用 Camunda Modeler 软件来绘制流程图

    官网下载:https://camunda.com/download/modeler/

    百度云:https://pan.baidu.com/s/1KdQrCBo4k5j6UNF4m1Ki4g
    提取码:8i44

    双击 Camunda Modeler.exe 打开

    1、点击右上角 file - new file - 创建BPMN文件

    在properties视图指定每个任务结点的负责人,如:

    填写出差申请的负责人为 zhangsan

    经理审批负责人为 jerry

    总经理审批负责人为 jack

    财务审批负责人为 rose

    3、导出 BPMN 文件和 PNG 文件

    3、注意

    如果使用 Camunda Modeler 软件进行绘图,生成的 xml 文件,如果有手动指定任务处理人,需要将其中的 camunda:assignee 替换为 activiti:assignee

    <bpmn:userTask id="Task_17tkcmk" name="创建出差申请单" camunda:assignee="zhangsan">
    <bpmn:userTask id="Task_17tkcmk" name="创建出差申请单" activiti:assignee="zhangsan">

    七、流程定义

    1、流程定义部署

    将上面在设计器中定义的流程(.bpmn和png文件)部署到activiti数据库中,就是流程定义部署。

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

    先将两个文件放置到 /resources/bpmn/ 目录下

    (1)单文件部署

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

    @Autowired
    private RepositoryService repositoryService;
    @Test
    public void test14(){
        // 使用RepositoryService进行部署
        Deployment deployment = repositoryService.createDeployment()
            .addClasspathResource("bpmn/evection.bpmn") // 添加bpmn资源
            .addClasspathResource("bpmn/evection.png")  // 添加png资源
            .name("出差申请流程")
            .key("myEvection")    // 指定流程定义的 KEY,流程唯一键,后续启动流程需要这个
            .deploy();
        // 输出部署信息
        System.out.println("流程部署id:" + deployment.getId());
        System.out.println("流程部署名称:" + deployment.getName());
    

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

    如果报错文件 NOT FOUND 重新编译下项目就可以了

    (2)压缩包部署

    @Autowired
    private RepositoryService repositoryService;
    @Test
    public void test14(){
        // 定义zip输入流
        InputStream inputStream = this
            .getClass()
            .getClassLoader()
            .getResourceAsStream(
            "bpmn/evection.zip");
        ZipInputStream zipInputStream = new ZipInputStream(inputStream);
        // 流程部署
        Deployment deployment = repositoryService.createDeployment()
            .addZipInputStream(zipInputStream)
            .deploy();
        System.out.println("流程部署id:" + deployment.getId());
        System.out.println("流程部署名称:" + deployment.getName());
    

    (3)相关数据表

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

  • act_re_procdef 的 KEY 这个字段是用来唯一识别不同流程的关键字

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

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

    2、启动流程实例

    (1)代码

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

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

    // 根据流程定义Id启动流程
    ProcessInstance processInstance = runtimeService
        .startProcessInstanceByKey("myEvection");
    System.out.println("流程定义id:" + processInstance.getProcessDefinitionId());
    System.out.println("流程实例id:" + processInstance.getId());
    System.out.println("当前活动Id:" + processInstance.getActivityId());

    (2)相关数据表

  • act_ru_deadletter_job 作业死亡信息表,作业失败超过重试次数 act_ru_event_subscr 运行时事件表 act_ru_execution 运行时流程执行实例表 act_ru_identitylink 运行时用户信息表 act_ru_integration 运行时积分表 act_ru_job 运行时作业信息表 act_ru_suspended_job 运行时作业暂停表 act_ru_task 运行时任务信息表 act_ru_timer_job 运行时定时器作业表 act_ru_variable 运行时变量信息表 service名称 service作用 RepositoryService activiti的资源管理类 RuntimeService activiti的流程运行管理类 TaskService activiti的任务管理类 HistoryService activiti的历史管理类 ManagerService activiti的引擎管理类 act_re_deployment 流程定义部署表,每部署一次增加一条记录 act_re_procdef 流程定义表,部署每个新的流程定义都会在这张表中增加一条记录 act_ge_bytearray 流程资源表

    3、待办任务查询

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

    // 任务负责人
    String assignee = "zhangsan";
    // 根据流程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());
    

    4、流程任务处理

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

    //  根据流程key 和 任务的负责人 查询任务
    //  返回一个任务对象
    Task task = taskService.createTaskQuery()
        .processDefinitionKey("myEvection") //流程Key
        .taskAssignee("zhangsan")  //要查询的负责人
        .singleResult();
    // 完成任务,参数:任务id
    taskService.complete(task.getId());

    5、流程定义信息查询

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

    // 得到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());
    

    6、流程删除

    // 流程部署id
    String deploymentId = "1";
    //删除流程定义,如果该流程定义已有流程实例启动则删除时出错
    repositoryService.deleteDeployment(deploymentId);
    //设置true 级联删除流程定义,即使该流程有流程实例启动也可以删除,设置为false非级别删除方式,如果流程
    //repositoryService.deleteDeployment(deploymentId, true);
  • 使用repositoryService删除流程定义,历史表信息不会被删除

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

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

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

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

    7、流程资源下载

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

    解决方案有:

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

    2、使用activiti的api来实现

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

    引入commons-io依赖包

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

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

    // 得到查询器:ProcessDefinitionQuery,设置查询条件,得到想要的流程定义
    ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()
        .processDefinitionKey("myEvection")
        .singleResult();
    // 通过流程定义信息,得到部署ID
    String deploymentId = processDefinition.getDeploymentId();
    //  通过repositoryService的方法,实现读取图片信息和bpmn信息
    //  png图片的流
    InputStream pngInput = repositoryService.getResourceAsStream(deploymentId, processDefinition.getDiagramResourceName());
    //  bpmn文件的流
    InputStream bpmnInput = repositoryService.getResourceAsStream(deploymentId, processDefinition.getResourceName());
    // 构造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);
    // 输入流,输出流的转换
    IOUtils.copy(pngInput,pngOut);
    IOUtils.copy(bpmnInput,bpmnOut);
    // 关闭流
    pngOut.close();
    bpmnOut.close();
    pngInput.close();
    bpmnInput.close();
  • deploymentId为流程部署ID

  • resource_name为act_ge_bytearray表中NAME_列的值

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

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

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

    8、流程历史信息的查看

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

    // 获取 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());
    

    八、流程实例

    1、什么是流程实例

    流程实例(ProcessInstance)代表流程定义的执行实例。

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

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

    其实就可以类比为 类和对象 的关系,流程定义就是类,用户发起流程就是创建对象,发起的流程就是流程实例。

    2、启动流程实例

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

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

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

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

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

    // 启动流程实例,同时还要指定业务标识businessKey,也就是出差申请单id,这里是1001
    ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("myEvection","1001");
    // 输出processInstance相关属性
    System.out.println("业务id=="+processInstance.getBusinessKey());

    3、相关数据表

    act_ru_execution:程实例执行表,记录当前流程实例的执行情况

    流程实例执行,如果当前只有一个分支时,一个流程实例只有一条记录且执行表的主键id和流程实例id相同,如果当前有多个分支正在运行则该执行表中有多条记录,存在执行表的主键和流程实例id不相同的记录。不论当前有几个分支总会有一条记录的执行表的主键和流程实例id相同

    一个流程实例运行完成,此表中与流程实例相关的记录删除。

    act_ru_task:任务执行表,记录当前执行的任务

    启动流程实例,流程当前执行到第一个任务结点,此表会插入一条记录表示当前任务的执行情况,如果任务完成则记录删除。

    act_ru_identitylink:任务参与者,记录当前参与任务的用户或组

    act_hi_procinst:流程实例历史表

    流程实例启动,会在此表插入一条记录,流程实例运行完成记录也不会删除。

    act_hi_taskinst:任务历史表,记录所有任务

    开始一个任务,不仅在act_ru_task表插入记录,也会在历史任务表插入一条记录,任务历史表的主键就是任务id,任务完成此表记录不删除。

    act_hi_actinst:活动历史表,记录所有活动

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

    4、查询流程实例

    流程在运行过程中可以查询流程实例的状态,当前运行结点等信息。

    // 流程定义key
    String processDefinitionKey = "evection";
    // 查询流程实例
    List<ProcessInstance> list = runtimeService
        .createProcessInstanceQuery()
        .processDefinitionKey(processDefinitionKey)//
        .list();
    for (ProcessInstance processInstance : list) {
        System.out.println("----------------------------");
        System.out.println("流程实例id:"
                           + processInstance.getProcessInstanceId());
        System.out.println("所属流程定义id:"
                           + processInstance.getProcessDefinitionId());
        System.out.println("是否执行完成:" + processInstance.isEnded());
        System.out.println("是否暂停:" + processInstance.isSuspended());
        System.out.println("当前活动标识:" + processInstance.getActivityId());
    

    5、关联业务数据

    需求:

    在activiti实际应用时,查询流程实例列表时可能要显示出业务系统的一些相关信息,比如:查询当前运行的出差流程列表需要将出差单名称、出差天数等信息显示出来,出差天数等信息在业务系统中存在,而并没有在activiti数据库中存在,所以是无法通过activiti的api查询到出差天数等信息。

    在查询流程实例时,通过businessKey(业务标识 )关联查询业务系统的出差单表,查询出出差天数等信息。

    通过下面的代码就可以获取activiti中所对应实例保存的业务Key。而这个业务Key一般都会保存相关联的业务操作表的主键,再通过主键ID去查询业务信息,比如通过出差单的ID,去查询更多的请假信息(出差人,出差时间,出差天数,出差目的地等)

    6、挂起/激活流程实例

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

    (1)操作流程定义-全部

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

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

    // 查询流程定义的对象
    ProcessDefinition processDefinition = repositoryService
        .createProcessDefinitionQuery().
        processDefinitionKey("myEvection").
        singleResult();
    // 得到当前流程定义的实例是否为暂停状态
    boolean suspended = processDefinition.isSuspended();
    // 流程定义id
    String processDefinitionId = processDefinition.getId();
    // 判断是否为暂停
    if(suspended){
        // 如果是暂停,可以执行激活操作 ,参数1 :流程定义id ,参数2:是否激活,参数3:激活时间
        repositoryService.activateProcessDefinitionById(processDefinitionId,true,null);
        System.out.println("流程定义:"+processDefinitionId+",已激活");
    }else{
        // 如果是激活状态,可以暂停,参数1 :流程定义id ,参数2:是否暂停,参数3:暂停时间
        repositoryService.suspendProcessDefinitionById(processDefinitionId,true,null);
        System.out.println("流程定义:"+processDefinitionId+",已挂起");
    

    (2)操作流程实例-单条

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

    // 查询流程定义的对象
    ProcessInstance processInstance = runtimeService.
        createProcessInstanceQuery().
        processInstanceId("15001").
        singleResult();
    // 得到当前流程定义的实例是否都为暂停状态
    boolean suspended = processInstance.isSuspended();
    // 流程定义id
    String processDefinitionId = processInstance.getId();
    // 判断是否为暂停
    if(suspended){
        // 如果是暂停,可以执行激活操作 ,参数:流程定义id
        runtimeService.activateProcessInstanceById(processDefinitionId);
        System.out.println("流程定义:"+processDefinitionId+",已激活");
    }else{
        // 如果是激活状态,可以暂停,参数:流程定义id
        runtimeService.suspendProcessInstanceById( processDefinitionId);
        System.out.println("流程定义:"+processDefinitionId+",已挂起");
    

    九、个人任务

    1、分配任务责任人-固定

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

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

    2、分配任务责任人-表达式

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

    (1)UEL 表达式

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

    UEL-value 定义

    可在绘制的流程图中的用户任务中的 Assignee 的值设置为${assignee},从而可以进行动态配置,即启动流程实例时通过代码进行赋值

    ${user.assignee} 表示通过调用 user 的 getter 方法获取值。

    UEL-method 方式

    ${UserBean.getUserId()}:userBean 是 spring 容器中的一个 bean,表示调用该 bean 的 getUserId()方法。

    UEL-method 与 UEL-value 结合

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

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

  • 支持的运算符

    (2)代码设置变量

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

    // 设置assignee的取值,用户可以在界面上设置流程的执行
    Map<String,Object> assigneeMap = new HashMap<>();
    assigneeMap.put("assignee0","张三");
    assigneeMap.put("assignee1","李经理");
    assigneeMap.put("assignee2","王总经理");
    assigneeMap.put("assignee3","赵财务");
    // 启动流程实例,同时还要设置流程定义的assignee的值
    runtimeService.startProcessInstanceByKey("myEvection1",assigneeMap);
    // 输出
    System.out.println(processEngine.getName());

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

    3、分配任务责任人-监听器

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

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

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

    Task Linsteners 事件包括:

  • take:执行监听,只能加在序列流上面
  • create:任务创建后触发
  • assigment:任务分配后触发
  • complete:任务完成后触发
  • delete:任务完成后自动删除时触发
  • Execution Listeners 事件包括

  • start:流程实例/任务启动监听,不能加在序列流(流程图上的箭头)上面
  • end:流程实例/任务结束监听,不能加在序列流上面
  • (1)监听器

    /**
     * Activity 监听器
    public class MyStartListener implements TaskListener,ExecutionListener {
        * Execution Listeners 相关事件监听
        @Override
        public void notify(DelegateExecution delegateExecution) {
            System.out.println("ExecutionListener...");
            System.out.println(delegateExecution);
            System.out.println(delegateExecution.getEventName());
        * Task Linsteners 相关事件监听
        @Override
        public void notify(DelegateTask delegateTask) {
            System.out.println("TaskListener...");
            System.out.println(delegateTask);
            System.out.println(delegateTask.getEventName());
            if(delegateTask.getName().equals("创建出差申请单") &&
                    delegateTask.getEventName().equals("create")){
                System.out.println("创建出差申请单");
                //这里指定任务负责人
                delegateTask.setAssignee("zhangsan");
            System.out.println(delegateTask.getAssignee());
    

    (2)流程代码

    @Test
    public void test14(){
        // 流程定义 KEY
        String processDefinitionKey = "myEvection";
        repositoryService.deleteDeployment("ec1bb8ec-bcb7-11ed-87b9-744ca153de09", true);
        // 使用RepositoryService进行部署
        Deployment deployment = repositoryService.createDeployment()
            .addClasspathResource("bpmn/evection.bpmn") // 添加bpmn资源
            .addClasspathResource("bpmn/evection.png")  // 添加png资源
            .name("出差申请流程")
            .key(processDefinitionKey)
            .deploy();
        // 输出部署信息
        System.out.println("流程部署id:" + deployment.getId());
        System.out.println("流程部署名称:" + deployment.getName());
        // 启动流程实例,同时还要指定业务标识businessKey,也就是出差申请单id,这里是1001
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(processDefinitionKey,deployment.getId());
        System.out.println("流程启动:" + processInstance);
        finishTask(processDefinitionKey, "zhangsan");
        finishTask(processDefinitionKey, "jerry");
        finishTask(processDefinitionKey, "jack");
        finishTask(processDefinitionKey, "rose");
        // 查询流程实例
        List<ProcessInstance> list = runtimeService
            .createProcessInstanceQuery()
            .processDefinitionKey(processDefinitionKey)
            .list();
        for (ProcessInstance instance : list) {
            System.out.println("流程实例:" + instance.getName());
            System.out.println("是否执行完成:" + instance.isEnded());
    public void finishTask(String processDefinitionKey, String assignee){
        List<Task> taskList = taskService.createTaskQuery()
            .processDefinitionKey(processDefinitionKey)
            .includeProcessVariables()
            .taskAssignee(assignee)
            .list();
        System.out.println(assignee + "流程实例查询:" + taskList);
        for (Task task : taskList) {
            System.out.println("----------------------------");
            System.out.println("任务负责人: " + task.getAssignee());
            System.out.println("任务名称: " + task.getName());
            taskService.complete(task.getId());
            System.out.println("----------------------------");
    

    (3)输出

    流程部署id:6644fd6b-c3ce-11ed-b225-744ca153de09
    流程部署名称:出差申请流程
    ExecutionListener...
    Execution[ id '66d90010-c3ce-11ed-b225-744ca153de09' ] - activity 'Task_17tkcmk - parent '66d8b1ef-c3ce-11ed-b225-744ca153de09'
    start
    TaskListener...
    Task[id=66dca993-c3ce-11ed-b225-744ca153de09, name=创建出差申请单]
    assignment
    zhangsan
    TaskListener...
    Task[id=66dca993-c3ce-11ed-b225-744ca153de09, name=创建出差申请单]
    create
    创建出差申请单
    zhangsan
    流程启动:ProcessInstance[66d8b1ef-c3ce-11ed-b225-744ca153de09]
    zhangsan流程实例查询:[Task[id=66dca993-c3ce-11ed-b225-744ca153de09, name=创建出差申请单]]
    ----------------------------
    任务负责人: zhangsan
    任务名称: 创建出差申请单
    TaskListener...
    Task[id=66dca993-c3ce-11ed-b225-744ca153de09, name=创建出差申请单]
    complete
    zhangsan
    TaskListener...
    Task[id=66dca993-c3ce-11ed-b225-744ca153de09, name=创建出差申请单]
    delete
    zhangsan
    ExecutionListener...
    Execution[ id '66d90010-c3ce-11ed-b225-744ca153de09' ] - activity 'Task_17tkcmk - parent '66d8b1ef-c3ce-11ed-b225-744ca153de09'
    ----------------------------
    jerry流程实例查询:[Task[id=67f67e06-c3ce-11ed-b225-744ca153de09, name=部门经理审批]]
    ----------------------------
    任务负责人: jerry
    任务名称: 部门经理审批
    ----------------------------
    jack流程实例查询:[Task[id=6900c219-c3ce-11ed-b225-744ca153de09, name=总经理审批]]
    ----------------------------
    任务负责人: jack
    任务名称: 总经理审批
    ----------------------------
    rose流程实例查询:[Task[id=6a5814bc-c3ce-11ed-b225-744ca153de09, name=财务审批]]
    ----------------------------
    任务负责人: rose
    任务名称: 财务审批
    ----------------------------

    4、查询个人任务

    // 流程定义key
    String processDefinitionKey = "myEvection1";
    // 任务负责人
    String assignee = "张三";
    List<Task> taskList = taskService.createTaskQuery()
        .processDefinitionKey(processDefinitionKey)
        .includeProcessVariables()
        .taskAssignee(assignee)
        .list();
    for (Task task : taskList) {
        System.out.println("----------------------------");
        System.out.println("流程实例id: " + task.getProcessInstanceId());
        System.out.println("任务id: " + task.getId());
        System.out.println("任务负责人: " + task.getAssignee());
        System.out.println("任务名称: " + task.getName());
    

    5、获取业务单号

    // 查询流程定义的对象
    Task task = taskService.createTaskQuery()
        .processDefinitionKey("myEvection1")
        .taskAssignee("张三")
        .singleResult();
    // 使用task对象获取实例id
    String processInstanceId = task.getProcessInstanceId();
    // 使用实例id,获取流程实例对象
    ProcessInstance processInstance = runtimeService.createProcessInstanceQuery()
        .processInstanceId(processInstanceId)
        .singleResult();
    // 使用processInstance,得到 businessKey
    String businessKey = processInstance.getBusinessKey();

    6、办理任务

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

    //        完成任务前,需要校验该负责人可以完成当前任务
    //        校验方法:
    //        根据任务id和任务负责人查询当前任务,如果查到该用户有权限,就完成
    Task task = taskService.createTaskQuery()
        .taskId(taskId)
        .taskAssignee(assingee)
        .singleResult();
    if(task != null){
        taskService.complete(taskId);
        System.out.println("完成任务");
    

    十、流程变量

    1、介绍

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

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

    2、变量类型

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

    3、作用域

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

    (1)globa变量

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

    如: Global变量:userId(变量名)、zhangsan(变量值)

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

    (2)local变量

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

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

    4、流程变量使用方法

    (1)在属性上使用UEL表达式

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

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

    (2)在连线上使用UEL表达式

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

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

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

    5、Global变量控制流程案例

    (1)需求

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

    (3)设置global变量

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

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

    (4)创建POJO类

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

    (5)启动流程时设置变量

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

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

    * 启动流程实例,设置流程变量的值 @Test public void startProcess(){ // 流程定义key String key = "myEvection2"; // 创建变量集合 Map<String, Object> map = new HashMap<>(); // 创建出差pojo对象 Evection evection = new Evection(); // 设置出差天数 evection.setNum(2d); // 定义流程变量,把出差pojo对象放入map map.put("evection",evection); // 设置assignee的取值,用户可以在界面上设置流程的执行 map.put("assignee0","张三"); map.put("assignee1","李经理"); map.put("assignee2","王总经理"); map.put("assignee3","赵财务"); // 启动流程实例,并设置流程变量的值(把map传入) ProcessInstance processInstance = runtimeService .startProcessInstanceByKey(key, map); // 输出 System.out.println("流程实例名称="+processInstance.getName()); System.out.println("流程定义id=="+processInstance.getProcessDefinitionId());

    startProcessInstanceByKey(processDefinitionKey, variables)

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

    (6)任务办理时设置变量

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

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

    * 完成任务,判断当前用户是否有权限 @Test public void completTask() { //任务id String key = "myEvection2"; // 任务负责人 String assingee = "张三"; // 创建变量集合 Map<String, Object> map = new HashMap<>(); // 创建出差pojo对象 Evection evection = new Evection(); // 设置出差天数 evection.setNum(2d); // 定义流程变量 map.put("evection",evection); // 完成任务前,需要校验该负责人可以完成当前任务 // 校验方法: // 根据任务id和任务负责人查询当前任务,如果查到该用户有权限,就完成 Task task = taskService.createTaskQuery() .processDefinitionKey(key) .taskAssignee(assingee) .singleResult(); if(task != null){ //完成任务是,设置流程变量的值 taskService.complete(task.getId(), map); System.out.println("任务执行完成");

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

    任务办理时也是通过 map<key,value> 设置流程变量,一次可以设置多个变量。

    (7)通过当前流程实例设置

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

    @Test
    public void setGlobalVariableByExecutionId(){
        // 当前流程实例执行 id,通常设置为当前执行的流程实例
        String executionId="2601";
        // 创建出差pojo对象
        Evection evection = new Evection();
        // 设置天数
        evection.setNum(3d);
        // 通过流程实例 id设置流程变量
        runtimeService.setVariable(executionId, "evection", evection);
        // 一次设置多个值
        // runtimeService.setVariables(executionId, variables)
    

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

    (8)通过当前任务设置

    @Test
    public void setGlobalVariableByTaskId(){
        //当前待办任务id
        String taskId="1404";
        Evection evection = new Evection();
        evection.setNum(3);
        //通过任务设置流程变量
        taskService.setVariable(taskId, "evection", evection);
        //一次设置多个值 
        //taskService.setVariables(taskId, variables)
    

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

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

    (9)注意事项

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

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

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

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

    (10)操作数据库表

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

    #当前流程变量表
    SELECT * FROM act_ru_variable 

    记录当前运行流程实例可使用的流程变量,包括 global和local变量

    Id_:主键

    Type_:变量类型

    Name_:变量名称

    Execution_id_:所属流程实例执行id,global和local变量都存储

    Proc_inst_id_:所属流程实例id,global和local变量都存储

    Task_id_:所属任务id,local变量存储

    Bytearray_:serializable类型变量存储对应act_ge_bytearray表的id

    Double_:double类型变量值

    Long_:long类型变量值

    Text_:text类型变量值

     #历史流程变量表
    SELECT * FROM act_hi_varinst 

    记录所有已创建的流程变量,包括 global和local变量

    字段意义参考当前流程变量表。

    6、设置local流程变量案例

    (1)任务办理时设置

    任务办理时设置local流程变量,当前运行的流程实例只能在该任务结束前使用,任务结束该变量无法在当前流程实例使用,可以通过查询历史任务查询。

    *处理任务时设置local流程变量 @Test public void completTask() { //任务id String taskId = "1404"; // 定义流程变量 Map<String, Object> variables = new HashMap<String, Object>(); Evection evection = new Evection (); evection.setNum(3d); // 定义流程变量 Map<String, Object> variables = new HashMap<String, Object>(); // 变量名是holiday,变量值是holiday对象 variables.put("evection", evection); // 设置local变量,作用域为该任务 taskService.setVariablesLocal(taskId, variables); // 完成任务 taskService.complete(taskId);

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

    (2)通过当前任务设置

    @Test
    public void setLocalVariableByTaskId(){
        //   当前待办任务id
        String taskId="1404";
        Evection evection = new Evection ();
        evection.setNum(3d);
        //  通过任务设置流程变量
        taskService.setVariableLocal(taskId, "evection", evection);
        //  一次设置多个值 
        //taskService.setVariablesLocal(taskId, variables)
    

    注意:任务id必须是当前待办任务id,act_ru_task 中存在。

    (3)查询变量

    // 创建历史任务查询对象
    HistoricTaskInstanceQuery historicTaskInstanceQuery = historyService.createHistoricTaskInstanceQuery();
    // 查询结果包括 local变量
    historicTaskInstanceQuery.includeTaskLocalVariables();
    for (HistoricTaskInstance historicTaskInstance : list) {
        System.out.println("==============================");
        System.out.println("任务id:" + historicTaskInstance.getId());
        System.out.println("任务名称:" + historicTaskInstance.getName());
        System.out.println("任务负责人:" + historicTaskInstance.getAssignee());
        System.out.println("任务local变量:"+ historicTaskInstance.getTaskLocalVariables());
    

    注意:查询历史流程变量,特别是查询pojo变量需要经过反序列化,不推荐使用。

    十一、组任务

    act_hi_actinst 流程实例执行历史 act_hi_identitylink 流程的参与用户历史信息 act_hi_procinst 流程实例历史信息 act_hi_taskinst 流程任务历史信息 act_ru_execution 流程执行信息 act_ru_identitylink 流程的参与用户信息 act_ru_task ${var} 获取 var 的值 ${var.name} 获取 var 的 name 属性的值 ${serviceBean.confirm()} 执行变量名为 serviceBean 的 confirm 方法 ${serviceBean.confirm(‘str1’)} 执行变量名为 serviceBean 的 confirm 方法,参数为 str1 。参数也可以为变量。 ${serviceBean.confirm(‘str1’,execution)} 执行变量名为 serviceBean 的 confirm 方法,参数为变量 name。第二个变量是引擎内置变量。 ${order.price > 100 && order.price < 250} ${name=="zhangsan"} ${name=="zhangsan" and pwd=="123"} ${name=="zhangsan" or name=="lisi"} ${1+1} ${1-1} ${1*1} /或div ${1/1} ${1 div 1} %或mod ${1+1} ${1 mod 1}