Spring Boot + Activiti 完美结合，快速实现工作流

最新推荐文章于 2024-03-05 10:37:54 发布
最新推荐文章于 2024-03-05 10:37:54 发布
阅读量2.4k 收藏 2
点赞数
文章标签： spring boot spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/doxopcsdn/article/details/131138889
版权

1、概念

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

2、Activiti7

介绍

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

在使用activiti之前，首先需要编写activiti.cfg.xml配置文件。

activiti.cfg.xml

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

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

    <!--dbcp连接池-->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/activiti"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
        <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"/>
        <!--
            activiti数据库表处理策略
                false(默认值)：检查数据库的版本和依赖库的版本，如果不匹配就抛出异常
                true：构建流程引擎时，执行检查，如果需要就执行更新。如果表不存在，就创建。
                create-drop：构建流程引擎时创建数据库报表，关闭流程引擎时就删除这些表。
                drop-create：先删除表再创建表。
                create：构建流程引擎时创建数据库表，关闭流程引擎时不删除这些表
        -->
        <property name="databaseSchemaUpdate" value="true"/>
        <property name="asyncExecutorActivate" value="false"/>
        <property name="mailServerHost" value="mail.my-corp.com"/>
        <property name="mailServerPort" value="5025"/>
    </bean>

</beans>

Activiti流程框架，在前期主要需要了解的就是数据库表的创建、流程的部署、流程的启动和各个阶段任务的完成。

3、流程引擎配置类

流程引擎配置类（ProcessEngineConfiguration），通过 ProcessEngineConfiguration 可以创建工作流引擎 ProceccEngine。

4、工作流引擎的创建

工作流引擎的创建主要有两种方式：默认创建方式和一般创建方式

默认创建方式

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
System.out.println(processEngine);

一般创建方式

//使用自定义方式创建
ProcessEngineConfiguration processEngineConfiguration = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cfg.xml");
//获取流程引擎对象:通过 ProcessEngineConfiguration 创建 ProcessEngine,此时会创建数据库
ProcessEngine processEngine = processEngineConfiguration.buildProcessEngine();

当创建好工作流引擎后，对应的数据库中会自动生成25张数据库表。

ACT_GE_PROPERTY中会先展示下一次流程的ID（next.dbid），并且在下一次流程部署的时候，对下一次流程的ID进行赋值。

5、Activiti表说明

这里以表名的前缀进行说明：

6、Service服务接口

Activiti中还有许多的Service服务接口。

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

Service创建方式

通过ProcessEngine创建Service方式：

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

Service总览

  • RepositoryService

Activiti 的资源管理类，提供了管理和控制流程发布包和流程定义的操作。使用工作流建模工具设计的业务流程图需要使用此service将流程定义文件的内容部署到计算机。除了部署流程定义以外，还可以查询引擎中的发布包和流程定义。

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

  • Runtimeservice

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

  • Taskservice

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

  • Historyservice

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

  • ManagementService

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

7、流程图符号说明

BPMN插件

使用IDEA进行开发，建议下载一个插件。actiBPM插件，直接搜索下载。

流程符号、画流程图

流程符号：事件Event，活动Activity，网关Gateway，流向

使用流程设计器画出流程图

  • 创建bpmn文件，在流程设计器使用流程符号来表达流程，指定流程的key，指定任务负责人

  • 生成png文件

  • 创建的bpmn文件要放在resourse下的bpmn文件夹下。

注意：当前任务流程的ID不能是数字开头。

8、流程的操作

部署流程

使用 Activiti 提供的 API 把流程图的内容写入到数据库中

属于资源操作类，使用 RepositoryService

  • 单文件部署：把bpmn文件和png文件逐个处理

  • 压缩包部署：把bpmn文件和png文件打成压缩包来处理

  • 部署操作表：act_re_deployment、act_re_procdef、act_ge_bytearray

/
 * 流程部署
 */
public void deployment() {
    // 创建 ProcessEngine
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    // 获取 RepositoryService
    RepositoryService repositoryService = processEngine.getRepositoryService();
    // 使用 service 进行流程的部署,定义一个流程的名字,把bpmn和png部署到数据中
    Deployment deployment = repositoryService.createDeployment()
            .name("出差申请流程") //流程图标的名字
            .addClasspathResource("bpmn/evection.bpmn") //bpmn文件
            .addClasspathResource("bpmn/evection.png") //bpmn文件生成的
            .deploy();
    // 输出部署信息
    System.out.println("流程部署ID:" + deployment.getId());
    System.out.println("流程部署名字:" + deployment.getName());
}

有时候我们会有多个流程，需要创建多个bpmn流程文件，这个时候想要同时部署，我们可以对bpmn文件进行打包压缩，使用Zip包进行批量的部署

/
 * 使用Zip包进行批量的部署
 */
@Test
public void deployProcessByZip() {
    // 获取流程引擎
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    // 获取 RepositoryService
    RepositoryService repositoryService = processEngine.getRepositoryService();
    // 流程部署
    // 读取资源包文件，构造成 InputStream
    InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream("bpmn/evection.zip");
    // 使用 InputStream 构造 ZipInputStream
    ZipInputStream zipInputStream = new ZipInputStream(inputStream);
    // 使用压缩包的流，进行流程的部署
    Deployment deploy = repositoryService.createDeployment()
            .addZipInputStream(zipInputStream)
            .deploy();
    // 输出
    System.out.println("流程部署的ID：" + deploy.getId());
    System.out.println("流程部署的名称：" + deploy.getName());
}

操作的数据库表：

  • act_ge_bytearray

  • act_ge_property

  • act_re_deployment

  • act_re_procdef

启动流程实例

流程部署完成以后，需要启动流程实例。使用 RuntimeService 根据流程定义的 key进行启动。

核心代码：

/
 * 启动流程
 */
public void starProcess() {
    // 创建 ProcessEngine
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    // 获取 RunTimeService
    RuntimeService runtimeService = processEngine.getRuntimeService();
    // 根据流程定义的ID启动流程
    ProcessInstance instance = runtimeService.startProcessInstanceByKey("myEvection");
    // 输出内容
    System.out.println("流程定义ID:" + instance.getProcessDefinitionId());
    System.out.println("流程实例的ID:" + instance.getId());
    System.out.println("当前活动的ID:" + instance.getActivityId());
}

任务查询

使用 TaskService ，根据流程定义的 key ，任务负责人来进行查询

核心代码：

/
 * 查询个人待执行的任务
 */
@Test
public void findPersonalTaskList() {
    // 获取流程引擎
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    // 获取TaskService
    TaskService taskService = processEngine.getTaskService();
    // 根据流程的key和任务的负责人去查询任务
    List<Task> taskList = taskService.createTaskQuery()
            .processDefinitionKey("myEvection") // 流程的key
            .includeProcessVariables()
            .taskAssignee("zhangsan") // 要查询的负责人
            .list();
    // 输出
    for (Task task : taskList) {
        System.out.println("流程实例的ID：" + task.getProcessInstanceId());
        System.out.println("任务的ID：" + task.getId());
        System.out.println("任务的负责人：" + task.getAssignee());
        System.out.println("任务的名称：" + task.getName());
    }
}

任务完成

使用 TaskService ，用任务 ID 直接完成任务。

核心代码：

/
 * 完成个人任务
 */
@Test
public void completTask() {
    String key = "testCandidiate";
    String assignee = "张三1"; //任务的负责人
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    TaskService taskService = processEngine.getTaskService();
    Task task = taskService.createTaskQuery()
            .processDefinitionKey(key)
            .taskAssignee(assignee)
            .singleResult();
    if (task != null) {
        taskService.complete(task.getId());
    }
}

关于流程实例的挂起和激活

全部流程实例的挂起和激活

/
 * 全部流程实例的挂起和激活
 */
@Test
public void suspendAllProcessInstance() {
    // 1.获取流程引擎
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    // 2.获取 RepositoryService
    RepositoryService repositoryService = processEngine.getRepositoryService();
    // 3.查询流程定义
    ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()
            .processDefinitionKey("myEvection")
            .singleResult();
    // 4.获取当前流程定义的实例是否都是挂起状态
    boolean flag = processDefinition.isSuspended();
    // 5.获取流程定义的ID
    String id = processDefinition.getId();
    // 6.判断是否挂起状态。是:改为激活;否:改为挂起
    if (flag) {
        // 改为激活. 参数1:流程定义的ID,参数2:是否激活,参数3:激活时间
        repositoryService.activateProcessDefinitionById(id, true, null);
        System.out.println("流程定义ID：" + id + "已激活");
    } else {
        // 改为挂起. 参数1:流程定义的ID;参数2:是否挂起;参数3:挂起时间
        repositoryService.suspendProcessDefinitionById(id, true, null);
        System.out.println("流程定义ID：" + id + "已挂起");
    }
}

单个流程实例的挂起和激活

/
 * 单个流程实例的挂起和激活
 */
@Test
public void suspendSingleProcessInstance() {
    // 1.获取流程引擎
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    // 2.获取 RuntimeService
    RuntimeService runtimeService = processEngine.getRuntimeService();
    // 3.通过 RuntimeService 获取流程实例对象
    ProcessInstance instance = runtimeService.createProcessInstanceQuery()
            .processInstanceId("17501")
            .singleResult();
    // 4.得到当前流程实例的暂停状态
    boolean flag = instance.isSuspended();
    // 5.获取流程实例的ID
    String instanceId = instance.getId();
    // 6.判断是否暂停。是:改为激活;否:改为暂停
    if (flag) {
        runtimeService.activateProcessInstanceById(instanceId);
        System.out.println("流程实例ID：" + instanceId + "已激活");
    } else {
        runtimeService.suspendProcessInstanceById(instanceId);
        System.out.println("流程实例ID：" + instanceId + "已暂停");
    }
}

注意：流程实例在挂起的状态下是无法进行下一步操作的。

9、流程变量

我们在使用流程变量的时候。如果我们将一个对象存储到一个流程变量中，那么这个对象需要实现Serializable接口。

/
 * 出差申请中的流程变量对象
 */
@NoArgsConstructor
@AllArgsConstructor
@Data
public class Evection implements Serializable {

    private Long id; //主键ID
    private Integer days; //出差天数
    private String evectionName; //出差单名字
    private Date startTime; //出差开始时间
    private Date endTime; //出差结束时间
    private String address; //目的地
    private String reason; //出差原因

}

流程变量的作用域

  • 整个流程实例、任务、执行实例。

  • 默认：整个流程实例。

使用方法

在属性上使用UEL表达式 ${assignee}，assignee就是一个流程变量的名称。

在连线上使用UEL表达式 ${days<=3}，days就是一个流程变量名称，返回结果为true或者false。

Activiti有很多种方式设置流程变量，这里简单介绍两种：

启动流程时设置流程变量

/
 * 启动流程
 */
@Test
public void startProcess() {
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    RuntimeService runtimeService = processEngine.getRuntimeService();
    // 流程变量map
    Map<String, Object> map = new HashMap<>();
    // 设置流程变量
    Evection evection = new Evection();
    evection.setDays(2);
    // 把流程变量的pojo放入map
    map.put("evection", evection);
    map.put("assignee0", "张三");
    map.put("assignee1", "李经理");
    map.put("assignee2", "王财务");
    map.put("assignee3", "赵总经理");
    runtimeService.startProcessInstanceByKey("myProcess_1", map);
}

任务办理时设置

/
 * 完成任务
 */
@Test
public void completTask() {
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    TaskService taskService = processEngine.getTaskService();
    Evection evection = new Evection();
    evection.setDays(2);
    Map<String, Object> map = new HashMap<>();
    map.put("evection", evection);
    Task task = taskService.createTaskQuery()
            .processDefinitionKey("myProcess_2")
            .taskAssignee("王财务0")
            .singleResult();
    if (task != null) {
        String taskId = task.getId();
        // 完成任务
        taskService.complete(taskId, map);
    }
}

10、网关

用来控制流程的走向

排他网关——ExclusiveGateway

用来在流程中实现决策，当流程执行到这个网关，所有的分支都会判断条件是否为true，如果为true，则执行该分支。

注意：排他网关只会选择一个作为true的分支执行，如果有两个分支都为true，排他网关会选择ID值比较小的一条分支去执行。

如果从排他网关出去的流程所有的条件都不满足，则会抛出异常。

并行网关——ParallelGateway

并行网关，允许流程分成多条分支，也可以把多分支汇聚到一起，并行网关的功能是基于进入和外出顺序流的：

  • fork分支：并行后的所有外出顺序流，为每个顺序流都创建一个并发分支

  • join汇聚：所有到达并行网关，在此等待的分支，直到所有进入顺序流的分支都到达以后，流程就会通过汇聚网关。

注意：如果同一个并行网关有多个进入和多个外出顺序流，它就同时具有分支和汇聚功能，这时，网关会先汇聚所有进入的顺序流，然后再切分成多个并行分支。

与其他网关的主要区别是：并行网关不会解析条件，即使顺序流中定义了条件，也会被忽略。

并行网关需要所有分支的全部运行完了，才会汇聚，继续向下执行。

包含网关——InclusiveGateway

包含网关可以看成是排他网关和并行网关的结合体，和排他网关一样，可以在外出顺序流上定义条件，包含网关会解析它们，但是主要的区别是：包含网关可以选择多于一条顺序流，这和并行网关一样。

包含网关的功能是基于进入和外出顺序流的。

  • 分支：所有外出顺序流的条件都会被解析，结果为true的顺序流会以并行方式继续执行，会为每一个顺序流创建一个分支。

  • 汇聚：所有并行分支到达包含网关，会进入等待状态，直到每个包含流程token的进入顺序流的分支都到达。这是和并行网关最大的不同。

事件网关——EventGateway

Activiti和Spring的整合开发

配置文件：

<?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:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
         http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!--工作流引擎配置对象-->
    <bean id="processEngineConfiguration" class="org.activiti.spring.SpringProcessEngineConfiguration">
        <!--数据源-->
        <property name="dataSource" ref="dataSource"/>
        <!--使用Spring的事务管理器-->
        <property name="transactionManager" ref="transactionManager"/>
        <!--
        数据库策略:
            false:默认值。activiti在启动时，会对比数据库表中保存的版本。如果没有表或者版本不匹配，将抛出 异常。
            true:activiti会对数据库中所有表进行更新操作，如果表不存在，则会自动创建。
            create_drop:在activiti启动时创建表，在关闭时删除表（必须手动关闭引擎，才能删除表）。
            drop-create:在activiti启动时删除原来的旧表，然后再创建新表（不需要手动关闭引擎）。
        -->
        <property name="databaseSchemaUpdate" value="true"/>
    </bean>

    <!--配置数据源-->
    <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/actspring"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
        <property name="maxActive" value="3"/>
        <property name="maxIdle" value="1"/>
    </bean>

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

    <!--资源服务-->
    <bean id="repositoryService" factory-bean="processEngine" factory-method="getRepositoryService"/>
    <!--流程管理-->
    <bean id="runtimeService" factory-bean="processEngine" factory-method="getRuntimeService"/>
    <!--任务管理-->
    <bean id="taskService" factory-bean="processEngine" factory-method="getTaskService"/>
    <!--历史管理-->
    <bean id="historyService" factory-bean="processEngine" factory-method="getHistoryService"/>

    <!--事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--通知-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <!--传播行为-->
            <tx:method name="save*" propagation="REQUIRED"/>
            <tx:method name="insert*" propagation="REQUIRED"/>
            <tx:method name="delete*" propagation="REQUIRED"/>
            <tx:method name="update*" propagation="REQUIRED"/>
            <tx:method name="find*" propagation="SUPPORTS" read-only="true"/>
            <tx:method name="get*" propagation="SUPPORTS" read-only="true"/>
        </tx:attributes>
    </tx:advice>
</beans>

Activiti和SpringBoot的整合开发

配置文件：

spring:
  application:
    name: actspringboot
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/actspring?useUnicode=true&characterEncoding=utf-8&useSSL=false&autoReconnect=true&serverTimezone=UTC
    username: root
    password: root
  activiti:
    # false:默认值。activiti在启动时，会对比数据库表中保存的版本。如果没有表或者版本不匹配，将抛出异常
    # true:activiti会对数据库中所有表进行更新操作，如果表不存在，则会自动创建
    # create_drop:在activiti启动时创建表，在关闭时删除表（必须手动关闭引擎，才能删除表）
    # drop-create:在activiti启动时删除原来的旧表，然后再创建新表（不需要手动关闭引擎）
    # 线上一般使用false,开发中使用true
    database-schema-update: true
    # 自动部署验证设置:true-开启（默认）、false-关闭
    check-process-definitions: false
    # 开启历史表
    db-history-used: true
    # 历史记录存储等级
    history-level: full
server:
  port: 8082

PS：防止找不到本篇文章，可以收藏点赞，方便翻阅查找哦。

莉子小姐拜托辣
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring boot整合activiti工作流引擎
06-21
1、使用若依框架作为权限管理系统，集成activiti框架完成工作流引擎开发，打造集流程设计、流程部署、流程执行、任务办理、流程监控于一体的强大工作流平台。 11、对于表单的处理，一律使用外置表单，将业务表单数据保存在业务表中，不保存在activiti流程的变量表中。 111、前端页面与用户任务通过formkey进行关联，办理任务时，通过获取formkey值展示对应的前端页面。 1111、整合流程图在线设计器，设计后需要发布，完成流程的部署。 11111、如需添加新的流程，设计好后还需编写前后端代码完成业务逻辑的开发。 111111、增删改查、权限管理、代码生成、页面交互的基础设施由若依平台提供。 11111111、流程实例管理用于管理正在运行的流程实例列表，你可以挂起或唤醒一个流程实例。 111111111、流程运行历史用于查看流程的历史记录（包含运行中和已结束），还可以查看所有流程的变量。 1111111111、支持动态流程，可对流程实例进行撤销、驳回、跳转等操作。 11111111111、打开http://localhost 访问登录页面,账号admin密码是admin123。
SpringBoot + Activiti 完美结合，快速实现工作流（最详细版）
好好学java
12-16 8255
​本篇介绍如何在SpringBoot项目中使用Activiti7。其他框架实现工作流，可以移步：SpringBoot+flowable快速实现工作流，超级方便（附源码）一、依赖<!--添加activiti和SpringBoot整合的依赖 MyBatis版本会有冲突，所以需要排除,所需数据库的依赖根据需求添加--> <dependency> &...
SpringBoot集成Flowable工作流
packge的博客
02-04 1318
Flowable下载Flowable源码GitHub下载Flowable用户使用手册Flowable是一个使用Java编写的轻量级业务流程引擎。Flowable流程引擎可用于部署BPMN 2.0流程定义（用于定义流程的行业XML标准）， 创建这些流程定义的流程实例，进行查询，访问运行中或历史的流程实例与相关数据，等等。具体介绍请看Flowable介绍Flowable在项目启动的时候会自动创建表，以下是主要几张表介绍每次启动的流程都会再这张表中,表示代办项, 流程结束会删除该流程数据。
SpringBoot + Activiti 工作流搭建与实现（完整源码和配套文档）
2301_81867536的博客
03-05 747
activiti工作流引擎项目，企业erp、oa、hr、crm等企事业办公系统轻松落地，一套完整并且实际运用在多套项目中的案例，满足日常业务流程审批需求。
Springboot整合Activiti/Flowable（最详细版）
热门推荐
m0_49605579的博客
06-21 2万+
springboot整合activiti（最详细版，包含flowable）
SpringBoot集成Activiti
CodeMan丶
12-07 5533
SpringBoot集成Activiti 首先创建springboot项目，可以直接在IDEA上File -> New -> Project -> Spring Initializr -> Next 即可创建简单的springboot项目。 项目前提： Jdk1.8 Mysql5.7+ Maven3.6+ 项目需引入的依赖 <dependency> <groupId>org.activiti</groupId>
SpringBoot集成Activiti完整工作流管理系统源码及SQL
01-11
SpringBoot集成Activiti完整工作流管理系统源码及SQL 包含如下主要内容： 1、工作流完整案例（请假流程、请假会签流程Demo） 2、系统用户权限、工作流用户和用户组管理 3、支持在线流程模型定义、部署、导出。也可用.bpmn文件直接导入系统
SpringBoot整合Activiti工作流（附源码）
知识分享
12-16 3932
依赖： 新建springBoot项目时勾选activiti，或者在已建立的springBoot项目添加以下依赖： <dependency> <groupId>org.activiti</groupId> <artifactId>activiti-spring-boot-starter-basic</artifactId&g...
spring boot整合activiti
11-14
spring boot整合activiti，包含最全的实例、并且有详细步骤，不能运行你找我。
Spring Boot + Activiti 完美结合，快速实现工作流~
m0_71777195的博客
11-25 7361
Activiti是一个工作流引擎，Activiti可以将业务系统中复杂的业务流程抽取出来，使用专门的建模语言BPMN2.0进行定义，业务流程按照预先定义的流程进行执行，实现了系统的流程由Activiti进行管理，减少业务系统由于流程变更进行系统升级改造的工作量，从而提高系统的健壮性，同时也减少了系统开发维护成本。在使用activiti之前，首先需要编写配置文件。并且引入相关依赖。
Activiti实战——Springboot整合Activiti
weixin_49561506的博客
05-21 8427
使用springboot整合Activiti，以及一个完整流程的各个步骤的实战，包括部署流程定义、启动流程、完成任务、查询历史信息等
jeecgboot +activiti5.22集成
07-15
jeecgboot++activiti5.22集成
基于 Spring Boot + MyBatis Plus + Vue实现的后台管理系统.zip
01-22
RuoYi-Vue-Plus-Activiti，基于 Spring Boot + MyBatis Plus + Vue & Element 实现的后台管理系统 集成的工作流，支持 RBAC 动态权限、数据权限、工作流 ，可自由驳回，委托，提交，会签，认领，并行网关，分支网关… 各领域数据集，工具源码，适合毕业设计、课程设计作业，所有源码均经过严格测试，可以直接运行，可以放心下载使用。有任何使用问题欢迎随时与博主沟通，第一时间进行解答！ 软件开发设计：PHP、QT、应用软件开发、系统软件开发、移动应用开发、网站开发C++、Java、python、web、C#等语言的项目开发与学习资料 硬件与设备：单片机、EDA、proteus、RTOS、包括计算机硬件、服务器、网络设备、存储设备、移动设备等 操作系统：LInux、IOS、树莓派、安卓开发、微机操作系统、网络操作系统、分布式操作系统等。此外，还有嵌入式操作系统、智能操作系统等。 云计算与大数据：数据集、包括云计算平台、大数据分析、人工智能、机器学习等，云计算是一种基于互联网的计算方式，通过这种方式，共享的软硬件资源和信息可以按需提供给计算机和其他设备。
spring boot activiti工作流的搭建与简单使用
08-27
主要给大家介绍了关于spring boot activiti工作流的搭建与简单使用的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
spring boot activiti
04-10
采用spring boot +mybatis+shiro+swagger+ehcache+quartz+freemarker+layui技术开发；实现功能有系统模块：菜单管理、用户管理、角色管理，系统监控：系统日志、接口api、sql监控。本项目会一直维护并集成新的技术，给您的开发节约时间成本
activiti Spring boot 整合
11-09
Springboot 2.0.3.RELEASE版本 + activiti 5.22.0版本 + mysql 代码整合真实案例。
act-boot.zip springboot整合activiti工作流Workflow
09-09
springboot整合activiti工作流Workflow 安装本机java环境 用idea打开本项目文件 启动项目 即可生成activiti工作流的相应配置，基本环境 act_evt_log.sql里是新建activiti工作流所需要的表列表
springboot 整合Activiti工作流 集成 Diagram Viewer跟踪流程
10-09
springboot 整合Activiti工作流 集成 Diagram Viewer跟踪流程
springboot+activiti+angular 这是spring boot框架集成activiti工作流实现.zip
最新发布
04-24
2,使编码变得简单，SpringBoot采用 JavaConfig的方式对Spring进行配置，并且提供了大量的注解，极大的提高了工作效率，比如@Configuration和@bean注解结合，基于@Configuration完成类扫描，基于@bean注解把返回值...
spring boot引入activiti7
09-20
### 回答1： 要在 Spring Boot 应用中引入 Activiti 7，需要按照以下步骤操作： 1. 在项目的 pom.xml 文件中添加 Activiti 7 的依赖，例如： ``` <dependency> <groupId>org.activiti</groupId> <artifactId>activiti-spring-boot-starter-basic</artifactId> <version>7.1.0</version> </dependency> ``` 2. 创建一个名为 `application.properties` 的配置文件，并在其中指定 Activiti 所使用的数据库连接信息，例如： ``` spring.datasource.url=jdbc:h2:mem:activiti;DB_CLOSE_DELAY=-1 spring.datasource.username=sa spring.datasource.password= spring.datasource.driver-class-name=org.h2.Driver ``` 3. 在应用的启动类中添加 `@EnableProcessEngine` 注解，例如： ``` @SpringBootApplication @EnableProcessEngine public class MyApplication { public static void main(String[] args) { SpringApplication.run(MyApplication.class, args); } } ``` 4. 在应用中使用 Activiti 相关的 API 进行开发即可。 希望这些信息能够帮到你！ ### 回答2： Spring Boot是一个用于快速构建Spring应用程序的框架，而Activiti是一个开源的工作流引擎。将Activiti7引入Spring Boot可以让开发人员更方便地在Spring应用程序中集成工作流系统。 引入Activiti7到Spring Boot的步骤如下： 1. 在Spring Boot项目的依赖管理文件（pom.xml）中添加Activiti7的依赖。可以通过在Maven或Gradle中加入相应的依赖引入Activiti7。 2. 配置Activiti7的相关属性。在Spring Boot的配置文件（application.properties或application.yml）中设置Activiti7的配置参数，例如数据库连接、用户名密码等。 3. 创建工作流模型。使用Activiti7提供的图形化工作流设计器，或者直接编写BPMN 2.0规范的XML文件来定义工作流程。 4. 基于工作流模型创建流程实例。使用Activiti7的API来加载并部署工作流模型，然后可以根据需要创建流程实例。 5. 处理工作流任务。根据工作流的定义和流程实例的状态，使用Activiti7的API来处理工作流任务，例如启动工作流实例、完成任务等。 6. 监控和管理工作流。利用Activiti7提供的监控和管理功能，可以查看工作流的执行情况、统计数据等。 通过将Activiti7引入到Spring Boot中，可以大大简化工作流系统的开发过程，提高开发效率。同时，由于Spring Boot的自动配置特性，可以将工作流引擎与其他Spring相关组件无缝集成，提供更强大的功能。 ### 回答3： Spring Boot是一个用于开发微服务的框架，而Activiti 是一个用于构建和管理业务流程的开源工作流引擎。将Spring Boot与Activiti 7整合，可以使开发者更加方便地使用工作流引擎来管理和控制业务流程。 首先，使用Spring Boot引入Activiti 7，需要在项目的pom.xml文件中添加Activiti的依赖。在依赖中指定Activiti的版本号，然后使用Maven或Gradle进行依赖的下载和安装。 接下来，在Spring Boot的配置文件中配置Activiti的相关属性，如数据库连接信息、流程定义文件的存放路径等。可以使用YAML 或 properties 格式的配置文件进行配置。 然后，创建流程定义文件（BPMN文件），定义业务流程的各个环节和流程节点。在每个节点中，可以配置相应的操作、表单和响应等信息。可以使用Activiti Designer等工具来创建和编辑BPMN文件。 在Spring Boot的代码中，通过Activiti的API，可以使用Activiti的各种功能和组件。例如，可以使用Activiti 的流程引擎来启动、挂起、审核、撤回或终止流程实例。还可以使用任务服务来查询、领取、完成或委托任务等。 此外，也可以使用Activiti的表单服务来创建、编辑和提交表单。还可以使用历史服务来跟踪和查询流程实例的历史记录，如流程的启动时间、结束时间、当前状态等。 最后，在Spring Boot的应用中，可以根据需要监听和处理Activiti的事件。例如，可以监听流程实例的启动、挂起、完成等事件，并在事件发生时触发相应的业务逻辑。 综上所述，通过在Spring Boot中引入Activiti 7，可以方便地使用工作流引擎来构建和管理业务流程。这样，开发者可以更加高效地实现复杂的业务逻辑，并有效地提高工作效率。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值