SpringBoot集成Activiti7工作流引擎的示例代码

<?xml version="1.0" encoding="utf-8"?>
<project xmlns="http://maven.apache.org/pom/4.0.0" xmlns:xsi="http://www.w3.org/2001/xmlschema-instance"
         xsi:schemalocation="http://maven.apache.org/pom/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelversion>4.0.0</modelversion>
    <parent>
        <groupid>org.springframework.boot</groupid>
        <artifactid>spring-boot-starter-parent</artifactid>
        <version>3.3.4</version>
        <relativepath/> <!-- lookup parent from repository -->
    </parent>
    <groupid>com</groupid>
    <artifactid>activiti-demo</artifactid>
    <version>0.0.1-snapshot</version>
    <name>activiti-demo</name>
    <description>activiti-demo</description>
    <properties>
        <java.version>17</java.version>
    </properties>
    <dependencies>
        <!-- web依赖 -->
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-web</artifactid>
        </dependency>

        <!-- mysql依赖 -->
        <dependency>
            <groupid>com.mysql</groupid>
            <artifactid>mysql-connector-j</artifactid>
            <version>8.2.0</version>
        </dependency>

        <!-- lombok依赖 -->
        <dependency>
            <groupid>org.projectlombok</groupid>
            <artifactid>lombok</artifactid>
            <optional>true</optional>
        </dependency>

        <!-- mybatis数据访问层 -->
        <dependency>
            <groupid>com.baomidou</groupid>
            <artifactid>mybatis-plus-spring-boot3-starter</artifactid>
            <version>3.5.7</version>
        </dependency>

        <!-- activiti7 工作流引擎依赖  -->
        <dependency>
            <groupid>org.activiti</groupid>
            <artifactid>activiti-spring-boot-starter</artifactid>
            <version>7.1.0.m6</version>
        </dependency>

        <!-- 模块测试依赖 -->
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-test</artifactid>
            <scope>test</scope>
        </dependency>

    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupid>org.springframework.boot</groupid>
                <artifactid>spring-boot-maven-plugin</artifactid>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupid>org.projectlombok</groupid>
                            <artifactid>lombok</artifactid>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

create database `activiti` /*!40100 default character set utf8 */;

-- activiti.`user` definition

create table `user` (
  `id` bigint(20) not null auto_increment comment '主键',
  `name` varchar(100) default null comment '名称',
  `age` varchar(100) default null comment '年龄',
  `created_by` varchar(32) default null comment '创建人名称',
  `created_time` datetime default null comment '创建时间',
  `created_id` varchar(32) default null comment '创建人id',
  `updated_by` varchar(32) default null comment '更新人名称',
  `updated_time` datetime default null comment '更新时间',
  `updated_id` varchar(32) default null comment '更新人id',
  primary key (`id`)
) engine=innodb auto_increment=2 default charset=utf8mb4 comment='用户信息表';

insert into activiti.`user`
(id, name, age, created_by, created_time, created_id, updated_by, updated_time, updated_id)
values(1, '小王', '24', null, null, null, null, null, null);

spring:
  application:
    name: activiti-demo
  datasource:
    #url切换数据库之后如果对应数据库名称和路径有变动，需要修改url
    url: jdbc:mysql://localhost:3306/activiti?useunicode=true&characterencoding=utf-8&usessl=false
    username: root
    password: root
    driver-class-name: com.mysql.cj.jdbc.driver

<?xml version="1.0" encoding="utf-8"?>
<!doctype beans [
        <!element beans (bean)*>
        <!attlist beans
                xmlns cdata #required
                xmlns:xsi cdata #required
                xsi:schemalocation cdata #required>
        <!element bean (property)*>
        <!attlist bean
                id cdata #required
                class cdata #required>
        <!element property (#pcdata)>
        <!attlist property
                name cdata #required
                value cdata #required>
        ]>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/xmlschema-instance"
       xsi:schemalocation="http://www.springframework.org/schema/beans
                    http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- processenqine activiti 的流程引擎 -->
    <bean id="processengineconfiguration"
          class="org.activiti.engine.impl.cfg.standaloneprocessengineconfiguration">
        <property name="jdbcdriver" value="com.mysql.cj.jdbc.driver"/>
        <property name="jdbcurl"
                  value="jdbc:mysql://localhost:3306/activiti?useunicode=true&amp;characterencoding=utf-8&amp;servertimezone=asia/shanghai&amp;usessl=false&amp;nullcatalogmeanscurrent=true"/>
        <property name="jdbcusername" value="root"/>
        <property name="jdbcpassword" value="root"/>

        <!-- activiti 数据库表处理策略 -->
        <!-- databaseschemaupdate 属性的值可以设置为以下几种 -->
        <!-- none：这是默认值，表示不对数据库模式做任何变更，应用程序启动时不会检查数据库表结构是否与实体类匹配-->
        <!-- true：设置为 true 时，spring会在应用程序启动时检查数据库表结构，并在发现不匹配时自动创建或修改表结构以匹配实体类定义。这相当于执行了数据库迁移-->
        <!-- create：与 true 类似，但 create 会在每次启动时删除并重新创建表，这可能会导致数据丢失，因此使用时需要谨慎-->
        <!-- create-drop：在每次启动应用程序时创建表，在关闭应用程序时删除表。这通常用于测试环境-->
        <!-- validate：在启动时验证数据库表结构是否与实体类定义匹配，如果不匹配则抛出异常，但不会自动进行任何更改-->
        <property name="databaseschemaupdate" value="true"/>

    </bean>
</beans>

package com.activitidemo.act.controller;


import com.activitidemo.act.entity.userentity;
import com.activitidemo.act.service.impl.userserviceimp;
import com.baomidou.mybatisplus.core.conditions.query.querywrapper;
import jakarta.annotation.resource;
import org.springframework.web.bind.annotation.postmapping;
import org.springframework.web.bind.annotation.requestbody;
import org.springframework.web.bind.annotation.requestmapping;
import org.springframework.web.bind.annotation.restcontroller;

/**
 * <p>
 *  前端控制器
 * </p>
 *
 * @author ningbeibei
 * @since 2024-09-26
 */
@restcontroller
@requestmapping("/user-entity")
public class usercontroller {

    @resource
    private userserviceimp userservice;

    @postmapping("/user")
    public object getuser(@requestbody userentity user){
        querywrapper<userentity> querywrapper = new querywrapper<>();
        querywrapper.eq("id",user.getid());
        return userservice.getbasemapper().selectlist(querywrapper);
    }

}

package com.activitidemo.act.service;

import com.activitidemo.act.entity.userentity;
import com.baomidou.mybatisplus.extension.service.iservice;

/**
 * @author ningbeibei
 * @since 2024-09-26
 */
public interface userservice extends iservice<userentity> {

}

package com.activitidemo.act.service.impl;

import com.activitidemo.act.mapper.usermapper;
import com.activitidemo.act.service.userservice;
import com.baomidou.mybatisplus.extension.service.impl.serviceimpl;
import org.springframework.stereotype.service;
import com.activitidemo.act.entity.userentity;

/**
 * <p>
 * 服务实现类
 * </p>
 *
 * @author ningbeibei
 * @since 2024-09-26
 */
@service
public class userserviceimp extends serviceimpl<usermapper, userentity> implements userservice {
}

package com.activitidemo.act.mapper;

import com.activitidemo.act.entity.userentity;
import com.baomidou.mybatisplus.core.mapper.basemapper;
import org.apache.ibatis.annotations.mapper;

/**
 * <p>
 *  mapper 接口
 * </p>
 *
 * @author ningbeibei
 * @since 2024-09-26
 */
@mapper
public interface usermapper extends basemapper<userentity> {

}

<?xml version="1.0" encoding="utf-8"?>
<!doctype mapper public "-//mybatis.org//dtd mapper 3.0//en" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.activitidemo.act.entity.userentity">

</mapper>

package com.activitidemo.act.entity;

import com.baomidou.mybatisplus.annotation.tablefield;
import com.baomidou.mybatisplus.annotation.tablename;
import lombok.getter;
import lombok.setter;

import java.io.serializable;
import java.time.localdatetime;

/**
 * @author ningbeibei
 * @since 2024-09-26
 */
@getter
@setter
@tablename("user")
public class userentity implements serializable {

    private static final long serialversionuid = 1l;

    @tablefield("id")
    private integer id;

    @tablefield("name")
    private string name;

    @tablefield("age")
    private int age;

    @tablefield("created_by")
    private string createdby;

    @tablefield("created_time")
    private localdatetime createdtime;

    @tablefield("created_id")
    private string createdid;

    @tablefield("updated_by")
    private string updatedby;

    @tablefield("updated_time")
    private localdatetime updatedtime;

    @tablefield("updated_id")
    private string updatedid;


}

package com.activitidemo;

import org.activiti.engine.historyservice;
import org.activiti.engine.processengine;
import org.activiti.engine.processengineconfiguration;
import org.activiti.engine.processengines;
import org.activiti.engine.repositoryservice;
import org.activiti.engine.runtimeservice;
import org.activiti.engine.taskservice;
import org.activiti.engine.history.historicactivityinstance;
import org.activiti.engine.repository.deployment;
import org.activiti.engine.repository.processdefinition;
import org.activiti.engine.runtime.processinstance;
import org.activiti.engine.task.comment;
import org.activiti.engine.task.task;
import org.junit.jupiter.api.test;
import org.springframework.boot.test.context.springboottest;
import org.springframework.util.filecopyutils;

import java.io.file;
import java.io.ioexception;
import java.io.inputstream;
import java.nio.file.files;
import java.nio.file.paths;
import java.util.list;

@springboottest
class activitidemoapplicationtests {


    // 创建 processengine 对象
//    private processengine processengine = processengines.getdefaultprocessengine();




//    /**
//     * 初始化数据库表：第一种方式
//     */
//    @test
//    public void testinitone() {
//        processengine processengine = processengines.getdefaultprocessengine();
//        system.err.println("processengine = " + processengine);
//    }


    /**
     * 初始化数据库表
     * 通过读取 activiti.cfg.xml 配置文件
     */
    @test
    public void testinittwo() {
        processengineconfiguration configuration = processengineconfiguration.createprocessengineconfigurationfromresource("activiti.cfg.xml");
        processengine processengine = configuration.buildprocessengine();
        system.err.println("processengine = " + processengine);
    }

    /**
     * 流程部署
     */
    @test
    public void testdeploy() {
        // 创建 processengine 对象
        processengine processengine = processengines.getdefaultprocessengine();
        // 获取 repositoryservice 对象
        repositoryservice repositoryservice = processengine.getrepositoryservice();
        // 进行部署
        deployment deployment = repositoryservice.createdeployment()
                .addclasspathresource("process/leave.bpmn20.xml")
                .addclasspathresource("process/leave.bpmn20.png")
                .name("请假流程")
                .deploy();
        // 输出部署的一些信息
        system.out.println("流程部署id：" + deployment.getid());
        system.out.println("流程部署名称：" + deployment.getname());
        system.out.println("流程部署成功");
    }

        /**
     * 启动流程实例
     */
    @test
    public void teststartprocess() {
        // 创建 processengine 对象
        processengine processengine = processengines.getdefaultprocessengine();
        // 获取 runtimeservice 对象
        runtimeservice runtimeservice = processengine.getruntimeservice();
        // 1.根据流程定义的key启动流程实例，这个key是在定义bpmn的时候设置的
        processinstance instance = runtimeservice.startprocessinstancebykey("leave");
        // 2.根据流程定义id启动流程实例
//        processinstance instance = runtimeservice.startprocessinstancebyid("leave:1:4");

        // 获取流程实例的相关信息
        system.out.println("流程定义的id = " + instance.getprocessdefinitionid());
        system.out.println("流程实例的id = " + instance.getid());
        system.out.println("启动流程成功 ");
    }



    /**
     * 查询待办任务
     */
    @test
    public void testselecttodotasklist() {
        string assignee = "李四";
        // 创建 processengine 对象
        processengine processengine = processengines.getdefaultprocessengine();
        // 获取指定用户审核任务
        taskservice taskservice = processengine.gettaskservice();
        // 使用面对对象方式查询数据库
        list<task> tasks = taskservice.createtaskquery()
                .processdefinitionkey("leave")
                .taskassignee(assignee)
                // 返回多个结果
                .list();
        // 只返回一个结果
        // .singleresult();

        // 自定义 sql 查询
        // taskservice.createnativetaskquery();

        // 获取流程实例的相关信息
        for (task task : tasks) {
            system.out.println("流程定义的id = " + task.getprocessdefinitionid());
            system.out.println("流程实例的id = " + task.getprocessinstanceid());
            system.out.println("任务id = " + task.getid());
            system.out.println("任务名称 = " + task.getname());
        }
    }


    /**
     * 指定用户去完成任务待办：多人审批在这操作，改变审核人名称就行了
     */
    @test
    public void testcompletetask() {
        string assignee = "李四";
        // 创建 processengine 对象
        processengine processengine = processengines.getdefaultprocessengine();
        // 获取指定用户审核任务
        taskservice taskservice = processengine.gettaskservice();
        list<task> tasks = taskservice.createtaskquery()
                .processdefinitionkey("leave")
                .taskassignee(assignee)
                .list();
        if (tasks != null && !tasks.isempty()){
            // 当前流程图所限制，只能做审核同意的动作
            for (task task : tasks) {
                taskservice.complete(task.getid());
            }
        }
    }


    /**
     * 审批添加备注
     */
    @test
    public void testaddcomment() {
        string assignee = "张三";
        // 创建 processengine 对象
        processengine processengine = processengines.getdefaultprocessengine();
        // 获取指定用户审核任务
        taskservice taskservice = processengine.gettaskservice();
        list<task> tasks = taskservice.createtaskquery()
                .processdefinitionkey("leave")
                .taskassignee(assignee)
                .list();
        if (tasks != null && !tasks.isempty()) {
            // 当前流程图所限制，只能做审核同意的动作
            for (task task : tasks) {
                // 添加备注
                taskservice.addcomment(task.getid(), task.getprocessinstanceid(), assignee + "表示同意");
                taskservice.complete(task.getid());
            }
        }
    }


    /**
     * 查询审批历史
     */
    @test
    public void testselecthistorytask() {
        string processinstanceid = "2501";
        string assignee = "张三";
        // 创建 processengine 对象
        processengine processengine = processengines.getdefaultprocessengine();
        // 查看历史信息
        historyservice historyservice = processengine.gethistoryservice();
        // 获取指定用户审核任务
        taskservice taskservice = processengine.gettaskservice();
        // 获取历史审核信息
        list<historicactivityinstance> usertask = historyservice.createhistoricactivityinstancequery()
                .activitytype("usertask")
                // 指定实例的id
                .processinstanceid(processinstanceid)
                .taskassignee(assignee)
                .finished()
                .list();

        for (historicactivityinstance instance : usertask) {
            system.out.println("任务名称 = " + instance.getactivityname());
            system.out.println("任务开始时间 = " + instance.getstarttime());
            system.out.println("任务结束时间 = " + instance.getendtime());
            system.out.println("任务耗时 = " + instance.getdurationinmillis());
            // 获取审批批注信息
            list<comment> taskcomments = taskservice.gettaskcomments(instance.gettaskid());
            if (!taskcomments.isempty()){
                system.out.println("审批批注 = " + taskcomments.get(0).getfullmessage());
            }
        }
    }


    /**
     * 查询流程相关信息
     */
    @test
    public void testdefinitionquery() {
        // 创建 processengine 对象
        processengine processengine = processengines.getdefaultprocessengine();
        // 获取仓库服务
        repositoryservice repositoryservice = processengine.getrepositoryservice();
        // 获取流程定义集合
        list<processdefinition> processdefinitionlist = repositoryservice.createprocessdefinitionquery()
                .processdefinitionkey("leave")
                // 最新的一个版本
                .latestversion()
                .list();
        // 遍历集合
        for (processdefinition definition : processdefinitionlist) {
            system.out.println("流程定义id = " + definition.getid());
            system.out.println("流程定义名称 = " + definition.getname());
            system.out.println("流程定义key = " + definition.getkey());
            system.out.println("流程定义版本 = " + definition.getversion());
            system.out.println("流程部署id = " + definition.getdeploymentid());
            system.out.println("===============");
        }
    }


    /**
     * 资源文件下载
     */
    @test
    public void testdownloadresource() throws ioexception {
        // 创建 processengine 对象
        processengine processengine = processengines.getdefaultprocessengine();
        // 获取仓库服务
        repositoryservice repositoryservice = processengine.getrepositoryservice();
        // 获取流程定义集合
        list<processdefinition> list = repositoryservice.createprocessdefinitionquery()
                .processdefinitionkey("leave")
                // 按照版本降序
                .orderbyprocessdefinitionversion()
                // 降序
                .desc()
                .list();

        // 获取最新那个
        processdefinition definition = list.get(0);
        // 获取部署id
        string deploymentid = definition.getdeploymentid();

        // 获取bpmn的输入流
        inputstream bpmninputstream = repositoryservice.getresourceasstream(deploymentid, definition.getresourcename());
        // 获取png的输入流
//        inputstream pnginputstream = repositoryservice.getresourceasstream(deploymentid, definition.getdiagramresourcename());

        string resourcepath = "c:/users/asus/desktop/" + file.separator + definition.getresourcename();
        file file = new file(resourcepath);
        if (!file.exists()) {
            file.getparentfile().mkdirs();
        }

        string diagramresourcepath = "c:/users/asus/desktop/" + file.separator + definition.getdiagramresourcename();
        file = new file(diagramresourcepath);
        if (!file.exists()) {
            file.getparentfile().mkdirs();
        }

        //复制文件
        filecopyutils.copy(bpmninputstream, files.newoutputstream(paths.get(resourcepath)));
//        filecopyutils.copy(pnginputstream, files.newoutputstream(paths.get(diagramresourcepath)));
    }


    /**
     * 删除已经部署的流程定义
     */
    @test
    public void testdeletedeploy() {
        // 删除已经部署的流程定义
        string deploymentid = "45001";
        // 创建 processengine 对象
        processengine processengine = processengines.getdefaultprocessengine();
        // 获取仓库服务
        repositoryservice repositoryservice = processengine.getrepositoryservice();
        // 删除流程定义，如果改流程定义已有流程实例启动，则会报错
//        repositoryservice.deletedeployment(deploymentid);
        // 设置 true，级联删除流程定义，即使有启动的实例也可以删除
        repositoryservice.deletedeployment(deploymentid, true);
    }


    /**
     * 启动流程，需要进行 businesskey 绑定流程实例
     */
    @test
    public void teststartbindbusinesskey() {
        string businesskey = "1";
        // 创建 processengine 对象
        processengine processengine = processengines.getdefaultprocessengine();
        runtimeservice runtimeservice = processengine.getruntimeservice();
        // 根据流程定义的key启动流程实例，这个key是在定义bpmn的时候设置的
        // 在启动流程的时候将业务key加进去
        processinstance instance = runtimeservice.startprocessinstancebykey("leave", businesskey);
        // 获取流程实例的相关信息
        system.out.println("流程定义id = " + instance.getprocessdefinitionid());
        system.out.println("流程实例id = " + instance.getid());
        system.out.println("业务标识 = " + instance.getbusinesskey());
    }


    /**
     * 跑到下一个节点，需要进行审批了，此时需要获取 businesskey 进而获取请假单信息
     */
    @test
    public void testgetbusinesskey() {
        // 1、获取李四的待办信息
        processengine processengine = processengines.getdefaultprocessengine();
        taskservice taskservice = processengine.gettaskservice();
        list<task> task = taskservice.createtaskquery()
                .taskassignee("李四")
                .processdefinitionkey("leave")
                .list();

        // 2、获取 businesskey
        // 获取流程实例id
        string processinstanceid = task.get(1).getprocessinstanceid();
        runtimeservice runtimeservice = processengine.getruntimeservice();
        processinstance processinstance = runtimeservice.createprocessinstancequery()
                .processinstanceid(processinstanceid)
                .singleresult();
        string businesskey = processinstance.getbusinesskey();

        system.out.println("业务标识 = " + businesskey);
    }


    /**
     * 流程定义挂起与激活
     */
    @test
    public void testsuspendallprocessinstance() {
        // 创建 processengine 对象
        processengine processengine = processengines.getdefaultprocessengine();
        // 获取仓库服务
        repositoryservice repositoryservice = processengine.getrepositoryservice();
        // 获取流程定义对象
        processdefinition processdefinition = repositoryservice.createprocessdefinitionquery()
                .processdefinitionkey("leave")
                .singleresult();
        boolean suspended = processdefinition.issuspended();
        // 输出流程定义状态
        system.out.println("流程定义状态：" + (suspended ? "已挂起" : "已激活"));
        string processdefinitionid = processdefinition.getid();

        if (suspended) {
            repositoryservice.activateprocessdefinitionbyid(processdefinitionid, true, null);
            system.out.println("流程id：" + processdefinitionid + "已激活");
        } else {
            repositoryservice.suspendprocessdefinitionbyid(processdefinitionid, true, null);
            system.out.println("流程id：" + processdefinitionid + "已挂起");
        }
    }


    /**
     * 流程实例挂起与激活
     */
    @test
    public void testprocessinstance() {
        // 创建 processengine 对象
        processengine processengine = processengines.getdefaultprocessengine();
        runtimeservice runtimeservice = processengine.getruntimeservice();
        // 获取流程定义对象
        list<processinstance> processinstancelist = runtimeservice.createprocessinstancequery()
                .processdefinitionkey("leave")
                .list();

        // 遍历集合
        for (processinstance processinstance  : processinstancelist) {
            boolean suspended = processinstance.issuspended();
            // 输出流程定义状态
            system.out.println("流程实例状态：" + processinstance + "," + (suspended ? "已挂起" : "已激活"));
            string processdefinitionid = processinstance.getid();

            if (suspended) {
                runtimeservice.activateprocessinstancebyid(processdefinitionid);
                system.out.println("流程实例id：" + processdefinitionid + "已激活");
            } else {
                runtimeservice.suspendprocessinstancebyid(processdefinitionid);
                system.out.println("流程实例id：" + processdefinitionid + "已挂起");
            }
        }
    }
}