1. Toy模板网首页
  2. > Toy博客

工作流引擎Flowable

10月前 作者：sp_wxf 分类：Toy博客 阅读(55) 违法举报

这篇具有很好参考价值的文章主要介绍了工作流引擎Flowable。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

1.Flowable基础

官方手册

1.1 入门学习

一、依赖

<dependencies>
    <dependency>
        <groupId>org.flowable</groupId>
        <artifactId>flowable-engine</artifactId>
        <version>6.3.0</version>
    </dependency>

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

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.2</version>
    </dependency>
    
	<dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.21</version>
    </dependency>

    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>1.7.21</version>
    </dependency>

</dependencies>

二、demo

@Test
public void testProcessEngine() {
    // 获取config对象
    ProcessEngineConfiguration config = new StandaloneProcessEngineConfiguration();
    // 设置数据库连接
    config.setJdbcDriver("com.mysql.cj.jdbc.Driver");
    config.setJdbcUsername("root");
    config.setJdbcPassword("root");
    // 注意:要添加nullCatalogMeansCurrent=true属性, 不然会执行报错
    config.setJdbcUrl("jdbc:mysql://localhost:3306/flowable?serverTimezone=UTC&nullCatalogMeansCurrent=true");
    // 如果数据库中的表结构不存在, 就新建
    config.setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);
    // 构建我们需要的对象
    ProcessEngine processEngine = config.buildProcessEngine();
}

三、日志文件
在resources中添加日志文件log4j.properties

log4j.rootLogger=DEBUG, CA

log4j.appender.CA=org.apache.log4j.ConsoleAppender
log4j.appender.CA.layout=org.apache.log4j.PatternLayout
log4j.appender.CA.layout.ConversionPattern= %d{hh:mm:ss,SSS} [%t] %-5p %c %x - %m%n

2.流程图设计器

Flowable流程图

  • Eclipse Designer, 一款Eclipse插件, 用于图形化建模, 测试与部署BPMN2.0流程
  • FlowableUI
  • Flowable BPMN visualizer, 一款idea插件

2.1 FlowableUI

从官网下载flowable-6.7.2.zip解压后, 可以看到如下两个文件
工作流引擎Flowable
将这两个文件, 扔到tomcat中, 并启动tomcat
工作流引擎Flowable
之后我们就可以在网页中访问FlowableUI
访问地址
账户密码:admin/test
工作流引擎Flowable

2.2 绘制流程图

一、创建流程
创建一个简单的请假流程
开始 > 提交审核流程(user1) > 总经理审批流程(user2) > 结束
工作流引擎Flowable
二、部署
绘制好的流程图, 我们只需要一键导出即可(BPMN文件)
工作流引擎Flowable
下载后, 将文件复制到idea中
工作流引擎Flowable

private ProcessEngineConfiguration config;

    @Before
    public void before() {
        // 获取config对象
        config = new StandaloneProcessEngineConfiguration();
        // 设置数据库连接
        config.setJdbcDriver("com.mysql.cj.jdbc.Driver");
        config.setJdbcUsername("root");
        config.setJdbcPassword("root");
        // 注意:要添加nullCatalogMeansCurrent=true属性, 不然会执行报错
        config.setJdbcUrl("jdbc:mysql://localhost:3306/flowable?serverTimezone=UTC&nullCatalogMeansCurrent=true");
        // 如果数据库中的表结构不存在, 就新建
        config.setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);
    }

    /**
     * 部署流程
     */
    @Test
    public void testDeploy() {
        // 1.获取ProcessEngine对象
        ProcessEngine processEngine = config.buildProcessEngine();
        // 2.获取repositoryService
        RepositoryService repositoryService = processEngine.getRepositoryService();
        // 3.完成流程的部署操作
        repositoryService.createDeployment()
                .addClasspathResource("MyHolidayUI.bpmn20.xml")
                .name("请求流程")
                .deploy();
    }
}

执行部署后, 我们回头看看表中的数据
act_re_procdef
act_re_deployment

三、执行流程

@Test
public void testRun() {
    // 1.获取ProcessEngine对象
    ProcessEngine processEngine = config.buildProcessEngine();
    // 2.获取runtimeService
    RuntimeService runtimeService = processEngine.getRuntimeService();
    // 3.启动流程实例
    ProcessInstance processInstance = runtimeService.startProcessInstanceById("MyHolidayUI:1:4");
    System.out.println("processDefinitionId = " + processInstance.getProcessDefinitionId());
    System.out.println("activityId = " + processInstance.getActivityId());
    System.out.println("id = " + processInstance.getId());
}

工作流引擎Flowable
可以通过act_ru_task查看任务流程
工作流引擎Flowable
工作流引擎Flowable

四、用户处理
user1对任务进行处理

@Test
public void testCompleteTask() {
    // 1.获取ProcessEngine对象
    ProcessEngine processEngine = config.buildProcessEngine();
    // 2.获取TaskService
    TaskService taskService = processEngine.getTaskService();
    // 3.获取任务
    Task task = taskService.createTaskQuery()
            .processDefinitionKey("MyHolidayUI")
            .taskAssignee("user1")
            .singleResult();
    // 4.创建流程变量
    HashMap<String, Object> map = new HashMap<>();
    map.put("approved", false);
    // 5.完成任务
    taskService.complete(task.getId(), map);
}

处理完成后, 任务就流转到user2了
工作流引擎Flowable
user2对任务进行处理

@Test
public void testCompleteTask() {
    // 1.获取ProcessEngine对象
    ProcessEngine processEngine = config.buildProcessEngine();
    // 2.获取TaskService
    TaskService taskService = processEngine.getTaskService();
    // 3.获取任务
    Task task = taskService.createTaskQuery()
            .processDefinitionKey("MyHolidayUI")
            .taskAssignee("user2")
            .singleResult();
    // 4.创建流程变量
    HashMap<String, Object> map = new HashMap<>();
    map.put("approved", false);
    // 5.完成任务
    taskService.complete(task.getId(), map);
}

user2处理完成后, 任务就结束了, 在task表中就删除了这条记录
工作流引擎Flowable
五、查看历史信息

@Test
public void testHistory() {
    // 1.获取ProcessEngine对象
    ProcessEngine processEngine = config.buildProcessEngine();
    // 2.获取historyService
    HistoryService historyService = processEngine.getHistoryService();
    // 3.获取任务
    List<HistoricActivityInstance> list = historyService.createHistoricActivityInstanceQuery()
            .processDefinitionId("MyHolidayUI:1:4")
            .finished() // 查询已完成的历史记录
            .orderByHistoricActivityInstanceEndTime().asc() // 指定排序的字段
            .list();

    for (HistoricActivityInstance history : list) {
        System.out.println(history.getActivityName() + ":" + history.getAssignee() + "--"
                + history.getActivityId() + ":" + history.getDurationInMillis() + "毫秒");
    }
}

3.Flowable高级

3.2 启动流程

/**
 * 部署流程
*/
@Test
public void testRunInstance() {
   // 1.获取ProcessEngine对象
   ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
   // 2.获取runtimeService, 通过runtimeService来启动流程实例
   RuntimeService runtimeService = engine.getRuntimeService();
   // 3.启动流程实例
   Map<String, Object> variables = new HashMap<>();
   variables.put("name", "张三"); // 谁申请请假
   variables.put("days", 3); // 请几天
   variables.put("reason", "世界这么大, 我想出去转转");   // 请假理由

   ProcessInstance processInstance = runtimeService.startProcessInstanceById("MyHolidayUI:1:4", "order10001", variables);
   System.out.println("processDefinitionId = " + processInstance.getProcessDefinitionId());
   System.out.println("activityId = " + processInstance.getActivityId());
   System.out.println("id = " + processInstance.getId());
}
  • ACT_RU_EXECUTION 运行时流程执行实例
  • ACT_RU_IDENTITYLINK 运行时用户关系信息
  • ACT_RU_TASK 运行时任务表
  • ACT_RU_VARIABLE 运行时变量表

一、ACT_RU_EXECUTION
(1) 启动伊始, 会初始化两条记录, 其中第一条记录的PARENT_ID_为空, 这意味着这条记录是流程实例的第一个节点, ROOT_PROC_INST_ID_会记录这个节点的ID_, BUSINESS_KEY_是运行时添加的参数工作流引擎Flowable
二、ACT_RU_IDENTITYLINK
(1) USER_ID_ 代表当前节点用户
(2) TYPE_ 为participant代表用户为参与者

  • assignee 指派人
  • candidate 候选人
  • owner 拥有者
  • starter 启动者
  • participant 参与者
    工作流引擎Flowable
    三、ACT_RU_VARIABLE
    流程变量信息
    工作流引擎Flowable

3.3 处理流程

@Test
public void testCompleteTask() {
    // 1.获取ProcessEngine对象
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    // 2.获取TaskService
    TaskService taskService = processEngine.getTaskService();
    // 3.获取任务
    Task task = taskService.createTaskQuery()
            .processInstanceId("20001")
            .taskAssignee("user1")
            .singleResult();

    // 获取当前流程实例绑定的流程变量
    Map<String, Object> processVariables = task.getProcessVariables();
    for (String key : processVariables.keySet()) {
        System.out.println(key + ":" + processVariables.get(key));
    }

    // 4.创建流程变量
    processVariables.put("approved", true);
    // 覆盖之前的流程变量
    processVariables.put("days", 10);

    // 5.完成任务
    taskService.complete(task.getId(), processVariables);
}

因为我们一个流程定义启动了两个流程实例, 所以我们如果通过流程定义的key(MyHolidayUI)来处理的话, 就会处理所有流程定义下的进程

正确的方式: 我们找到想要处理的流程实例, 获取到流程实例的唯一编号(ROOT_PROC_INST_ID_), 然后指定相应用户处理流程
工作流引擎Flowable
工作流引擎Flowable

3.4 流程结束

@Test
public void testCompleteTask() {
    // 1.获取ProcessEngine对象
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    // 2.获取TaskService
    TaskService taskService = processEngine.getTaskService();
    // 3.获取任务
    Task task = taskService.createTaskQuery()
            .processInstanceId("20001")
            .taskAssignee("user2")
            .singleResult();
            
    // 4.结束任务
    taskService.complete(task.getId(), processVariables);
}

结束任务之后, 在_RU表中, 所有跟此流程实例的相关的数据都会删除

  • ACT_RU_EXECUTION 运行时流程执行实例
  • ACT_RU_IDENTITYLINK 运行时用户关系信息
  • ACT_RU_TASK 运行时任务表
  • ACT_RU_VARIABLE 运行时变量表

那么如果我们想要查看历史记录, 怎么办

  • act_hi_taskinst
  • act_hi_varinst
  • act_hi_identitylink
  • act_hi_procinst
  • act_hi_actinst

3.5 任务分配

之前我们任务分配, 是在流程定义时, 就将用户写死了, 例如user1、user2, 在实际开发过程中, 我们并不会使用这个方式

3.5.1 表达式分配

Flowable使用UEL进行表达式解析, Flowable支持两种表达式:

  • UEL-value (值表达式)
  • UEL-method (方法表达式)

工作流引擎Flowable
在启动流程实例时, 添加参数

@Test
public void testDeploy() {
    // 1.获取processEngine对象
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    // 2.获取repositoryService
    RepositoryService repositoryService = processEngine.getRepositoryService();
    // 3.完成流程的部署操作
    Deployment deploy = repositoryService.createDeployment()
            .addClasspathResource("HolidayNew.bpmn20.xml")
            .name("请求流程")
            .deploy();
    System.out.println("deploy.getId() = " + deploy.getId());
    System.out.println("deploy.getName() = " + deploy.getName());
}

@Test
public void testRun() {
    // 1.获取ProcessEngine对象
    ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
    // 2.获取runtimeService, 通过runtimeService来启动流程实例
    RuntimeService runtimeService = engine.getRuntimeService();

    Map<String, Object> variables = new HashMap<>();
    variables.put("assignee0", "张三");
    variables.put("assignee1", "李四");
	
	// 开启流程实例时, 设置参数
    ProcessInstance processInstance = runtimeService.startProcessInstanceById("holiday-new:1:27504", variables);
    System.out.println("processDefinitionId = " + processInstance.getProcessDefinitionId());
    System.out.println("activityId = " + processInstance.getActivityId());
    System.out.println("id = " + processInstance.getId());
}

工作流引擎Flowable

3.5.2 监听器分配

工作流引擎Flowable
配置监听器
工作流引擎Flowable

3.6 流程变量

支持的流程变量有两类

  • 全局变量: 主要跟流程实例相关
  • 局部变量: 主要跟task相关

3.6.1 实例关系

  • 一个流程定义可以创建多个流程实例
    工作流引擎Flowable

3.6.2 出差流程图

一、全局变量
全部变量, 设置相同名称的变量后, 后设置的会覆盖前面设置的变量值

二、局部变量
local变量由于在不同的任务或者不同的执行实例中, 作用域互不影响, 变量名可以相同没有影响, local变量名也可以和全局变量名相同

3.6.3 案例

  • 如果${num>=3}则需要总经理审批
  • 如果${num<3}则不需要总经理审批

工作流引擎Flowable
一、流程定义

@Test
public void testDeploy() {
    // 1.获取processEngine对象
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    // 2.获取repositoryService
    RepositoryService repositoryService = processEngine.getRepositoryService();
    // 3.完成流程的部署操作
    Deployment deploy = repositoryService.createDeployment()
            .addClasspathResource("出差申请单.bpmn20.xml")
            .name("出差申请单")
            .deploy();
    System.out.println("deploy.getId() = " + deploy.getId());
    System.out.println("deploy.getName() = " + deploy.getName());
}

流程定义表: act_re_procdef
工作流引擎Flowable

二、创建流程实例

@Test
public void testRun() {
    // 1.获取ProcessEngine对象
    ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
    // 2.获取runtimeService, 通过runtimeService来启动流程实例
    RuntimeService runtimeService = engine.getRuntimeService();

    Map<String, Object> variables = new HashMap<>();
    variables.put("assignee0", "张三");
    variables.put("assignee1", "李四");
    variables.put("assignee2", "王五");
    variables.put("assignee3", "赵六");

    ProcessInstance processInstance = runtimeService.startProcessInstanceById("evection:1:32504", variables);
    System.out.println("processDefinitionId = " + processInstance.getProcessDefinitionId());
    System.out.println("activityId = " + processInstance.getActivityId());
    System.out.println("id = " + processInstance.getId());
}

查看当前节点走到哪儿
工作流引擎Flowable

3.7 候选人

3.7.1 流程定义和部署

工作流引擎Flowable
工作流引擎Flowable

@Test
public void testRun() {
    // 1.获取ProcessEngine对象
    ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
    // 2.获取runtimeService, 通过runtimeService来启动流程实例
    RuntimeService runtimeService = engine.getRuntimeService();

    Map<String, Object> variables = new HashMap<>();
    variables.put("candidate1", "张三");
    variables.put("candidate2", "李四");
    variables.put("candidate3", "王五");

    ProcessInstance processInstance = runtimeService.startProcessInstanceById("holiday-candidate:1:40004", variables);
    System.out.println("processDefinitionId = " + processInstance.getProcessDefinitionId());
    System.out.println("activityId = " + processInstance.getActivityId());
    System.out.println("id = " + processInstance.getId());
}

启动项目后, 发现在task表中并没有assignee, 这是因为候选人并非处理人(指派人)
工作流引擎Flowable

工作流引擎Flowable
虽然我们并没有指派处理人, 但我们知道有三个候选者, 在ru_variable表中也能看到
工作流引擎Flowable

3.7.2 候选任务查询

根据当前登录的用户查询对应的, 可以拾取的任务

 @Test
public void queryTaskCandidate() {
    // 1.获取ProcessEngine对象
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    // 2.获取TaskService
    TaskService taskService = processEngine.getTaskService();
    // 3.获取任务
    List<Task> list = taskService.createTaskQuery()
            .processInstanceId("42501")
            // 候选人
            .taskCandidateUser("张三")
            .list();

    for (Task task : list) {
        System.out.println("task.getId() = " + task.getId());
        System.out.println("task.getName() = " + task.getName());
    }
}

工作流引擎Flowable

3.7.3 拾取、归还、交接等操作

使用张三拾取任务

@Test
public void claimTask() {
    // 1.获取ProcessEngine对象
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    // 2.获取TaskService
    TaskService taskService = processEngine.getTaskService();
    // 3.获取任务
    Task task = taskService.createTaskQuery()
            .processInstanceId("42501")
            .taskAssignee("张三")
            .singleResult();

    if (task != null) {
        taskService.claim(task.getId(), "张三");
        System.out.println("任务拾取成功");
    }
}

工作流引擎Flowable

  • 一个候选人拾取了这个任务之后, 其他用户就没有办法拾取这个任务了
  • 所以如果一个用户拾取了任务之后不想处理了, 那么可以退还
@Test
public void unclaimTask() {
    // 1.获取ProcessEngine对象
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    // 2.获取TaskService
    TaskService taskService = processEngine.getTaskService();
    // 3.获取任务
    Task task = taskService.createTaskQuery()
            .processInstanceId("42501")
            .taskAssignee("张三")
            .singleResult();

    if (task != null) {
        taskService.unclaim(task.getId());
        System.out.println("归还成功");
    }
}
  • 如果我获取了任务, 但是不想执行, 我可以把这个任务交接给其他用户(任务交接)
@Test
public void handoverTask() {
    // 1.获取ProcessEngine对象
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    // 2.获取TaskService
    TaskService taskService = processEngine.getTaskService();
    // 3.获取任务
    Task task = taskService.createTaskQuery()
            .processInstanceId("42501")
            .taskAssignee("张三")
            .singleResult();

    if (task != null) {
        taskService.setAssignee(task.getId(), "赵六");
        System.out.println("交接成功");
    }
}

工作流引擎Flowable

3.8 候选人组

当候选人很多的情况下, 我们可以分组来处理

流程:
1.先创建组
2.把用户分配到组中

@Test
public void createUser() {
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    // 通过identityService完成相关的用户和组的管理
    IdentityService identityService = processEngine.getIdentityService();
    User user = identityService.newUser("田佳");
    user.setFirstName("田");
    user.setLastName("佳");
    user.setEmail("844915283@qq.com");
    identityService.saveUser(user);
}

@Test
public void createGroup() {
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    // 通过identityService完成相关的用户和组的管理
    IdentityService identityService = processEngine.getIdentityService();
    // 创建group对象, 并指定相关的信息
    Group group = identityService.newGroup("group1");
    group.setName("销售部");
    group.setType("type1");
    // 创建group对应的表结构数据
    identityService.saveGroup(group);
}

3.8.1 将用户分配给对应的组

@Test
public void userGroup() {
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    IdentityService identityService = processEngine.getIdentityService();
    // 根据组的编号, 找到对应的group
    Group group = identityService.createGroupQuery().groupId("group1").singleResult();
    List<User> list = identityService.createUserQuery().list();
    list.stream().forEach(t -> {
        identityService.createMembership(t.getId(), group.getId());
    });
}

3.8.2 部署和运行

工作流引擎Flowable

@Test
public void testRun() {
    // 1.获取ProcessEngine对象
    ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
    // 2.获取runtimeService, 通过runtimeService来启动流程实例
    RuntimeService runtimeService = engine.getRuntimeService();

    // 获取组
    IdentityService identityService = engine.getIdentityService();
    Group group = identityService.createGroupQuery().groupId("group1").singleResult();

    Map<String, Object> variables = new HashMap<>();
    // 给流程定义中的uel表达式赋值
    variables.put("g1", group.getId());

    ProcessInstance processInstance = runtimeService.startProcessInstanceById("group:1:50004", variables);
    System.out.println("processDefinitionId = " + processInstance.getProcessDefinitionId());
    System.out.println("activityId = " + processInstance.getActivityId());
    System.out.println("id = " + processInstance.getId());
}

3.8.3 任务查询拾取处理

拾取处理

@Test
public void queryTaskCandidateGroup() {
    String userId = "王杰";
    // 1.获取ProcessEngine对象
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    IdentityService identityService = processEngine.getIdentityService();
    // 获取组
    Group group = identityService.createGroupQuery().groupMember(userId).singleResult();

    // 3.获取任务
    TaskService taskService = processEngine.getTaskService();
    Task task = taskService.createTaskQuery()
            .processInstanceId("52501")
            // 候选人
            .taskCandidateGroup(group.getId())
            .singleResult();

    if (task != null) {
        taskService.claim(task.getId(), userId);
    }
}

3.9 网关

控制流程的走向文章来源地址https://www.toymoban.com/news/detail-492651.html

3.9.1 排他网关

3.9.2 并行网关

3.9.3 包容网关

3.9.4

到了这里，关于工作流引擎Flowable的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • Flowable工作流入门&完整SpringBoot案例

    Flowable工作流入门&完整SpringBoot案例

    工作流（Workflow），是指对于一项业务，按照规定的流程，逐级传递、申请、执行等，并且受到了严格控制的一种业务过程。 BPM（Business Process Management）是指对于某项业务的整个生命周期进行全面管理的一种模式，最核心的内容包括了工作流、决策、交互等。在这些管理过程

    2024年02月12日
    浏览(44)
  • 【学习笔记】Flowable - 01 - 工作流 快速上手

    【学习笔记】Flowable - 01 - 工作流 快速上手

    JDK8 Flowable6 (6.3 or 6.7.2) Postgresql (MySQL同样支持) 波哥：2023年Flowable详细讲解 波哥：2022年Flowable教程-基础篇 Flowable BPMN 用户手册 中文 官方网站 官方github源码 IDEA低版本提供一个BPMN解析插件： 但是并没有很好的支持流程的绘制。 存在几个工具： 古老的Eclipse（太老的不推荐 官

    2024年01月19日
    浏览(44)

  • Spring Boot 中动态创建 Flowable 工作流

    在 Spring Boot 中动态创建 Flowable 工作流可以通过以下步骤实现： 1. 创建 Flowable 配置：首先，您需要在 Spring Boot 应用程序中配置 Flowable。您可以使用 Spring Boot 的配置文件或注解来配置 Flowable。 2. 创建工作流定义：接下来，您需要创建工作流定义。您可以使用 Flowable 的 API 来

    2024年02月10日
    浏览(41)
  • Vue+LogicFlow+Flowable 前端+后端实现工作流

    Vue+LogicFlow+Flowable 前端+后端实现工作流

    前端使用LogicFlow框架绘制流程图，可以导出为xml工作流标准格式数据，通过xml文件传递到后端进行Flowable流程注册，并保存到数据库中。 如需添加承办人的话，需要在LogicFlow导出文件的基础上手动添加 xmlns:flowable=\\\"http://flowable.org/bpmn\\\" flowable插件，不然后台无法识别 flowable:ca

    2024年02月04日
    浏览(46)
  • 若依(RuoYi-Vue)+Flowable工作流前后端整合教程

    若依(RuoYi-Vue)+Flowable工作流前后端整合教程

    此教程适合若依前后端分离项目，其他项目可以在扩展列表中进行查找。 近期公司里需要对很久以前的RuoYi-Vue前后端分离项目扩展出flowable的功能，当然这个重任也是落在了我的身上（不然也不会有这篇文章），然后我在官网看到了RuoYi-Vue-Flowable这个项目，按照文档提供的迁

    2023年04月21日
    浏览(58)
  • 工作流Flowable入门教程：flowableUI的安装使用，RepositoryService、RuntimeService、TaskService、HistoryService的使用

    工作流Flowable入门教程：flowableUI的安装使用，RepositoryService、RuntimeService、TaskService、HistoryService的使用

    Flowable是一个使用Java编写的轻量级业务流程引擎。Flowable流程引擎可用于部署BPMN 2.0流程定义（用于定义流程的行业XML标准）， 创建这些流程定义的流程实例，进行查询，访问运行中或历史的流程实例与相关数据，等等。这个章节将用一个可以在你自己的开发环境中使用的例

    2024年01月18日
    浏览(58)
  • Activity工作流引擎

    Activity工作流引擎

    目录 一、了解工作流 1、什么是工作流 2、工作流引擎 3、常见工作流引擎 4、Activiti7概述 4.1、Activiti介绍 4.2、建模语言BPMN 4.3、Activiti使用流程 二、Activiti7 1、Activiti使用 1.1、数据库支持 1.2、Activiti环境 1.3、Activiti常用Service服务接口 1.4、流程设计工具 2、Activiti流程操作 2.1、

    2024年02月13日
    浏览(48)
  • Camunda 7工作流引擎 API 以及与Springboot集成实现工作流配置全纪录

    Camunda 7工作流引擎 API 以及与Springboot集成实现工作流配置全纪录

    项目中需要用到工作流引擎来设计部分业务流程，框架选型最终选择了 Camunda7，关于 Camunda以及 Activity 等其他工作流 引擎的介绍及对比不再介绍，这里只介绍与现有Springboot项目的集成以及具体使用及配置 流程（PROCESS）: 通过工具建模最终生成的BPMN文件，里面有整个流程的定

    2024年02月10日
    浏览(57)
  • Java 3个常用工作流引擎

    Java 3个常用工作流引擎

    一：Java工作流框架是一种用于设计、执行和管理工作流程的技术。以下是几个常见的Java工作流框架： Activiti：Activiti是一款流行的开源Java工作流引擎，它基于BPMN 2.0标准，支持复杂的工作流程设计和管理。Activiti具有高度可扩展性和灵活性，可以与Spring等常见的Java框架集成。

    2023年04月08日
    浏览(40)
  • springboot项目集成activiti工作流引擎

    springboot项目集成activiti工作流引擎

    一、一种较为简单，只需要使用idea的插件来画流程图。（我所使用的的插件是Activiti BPMN visualizer） 二、另一种就是可以使用（在线流程设计器）或者（页面设计器部署到自己项目中）来画流程图。 本文是将流程设计页面部署到了项目中 一、使用idea的插件来画流程图。  二

    2024年02月10日
    浏览(44)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包