SpringBoot集成LiteFlow实现轻量级工作流引擎的详细过程

LiteFlow 是一款专注于逻辑驱动流程编排的轻量php级框架，它以组件化方式快速构建和执行业务流程，有效解耦复杂业务逻辑。通过支持热加载规则配置，开发者能够即时调整流程步骤，将复杂的业务如价格计算、下单流程等拆分为独立且可复用的组件，从而实现系统的高度灵活性与扩展性。

一、基础概念

1.1 组件（Component）

LiteFlow 的核心概念是组件，组件是业务逻辑的最小单元。每个组件都对应一个具体的业务操作，例如“发送邮件”“计算价格”等。组件之间通过规则进行编排，形成完整的业务流程。

liteflow 的组件在规则文件中即对应的节点，组件对应的种类有很多，具体的如下所示：

普通组件

普通组件需要集成的是 NodeComponent, 可以用在 when 和 then 逻辑中，具体的业务需要在 process 中去执行。同时在 node 节点中，可以覆盖 iaAccess 方法，表示是否进入该节点执行业务逻辑，isContinueOnError 判断在出错的情况下是否继续执行下一个组件，默认为 false。 isEnd 方法表示是否终止流程，默认为true。

选择组件

选择组件是通过业务逻辑来判断接下来的动作要执行哪一个节点，类似于 Java中的 switch , 在代码中则需要继承 NodeSwitchComponent 实现 processWitch 方法来处理业务。

# flow 规则表达式 选择组件
SWITCH(a).to(b, c);
# processWitch 表达式需要返回的是 b 或者 c 字符串来执行相应的业务逻辑
# flow 规则表达式 条件组件
IF(x, a, b);

条件组件

条件组件称之为 if 组件，返回的结果是 true 或者 false, 代码需要集成 NodeIfComponent 重写 processIf 方法，返回对应的业务节点，这个和选择组件类似。

在官方文档中，还有次数循环组件，条件循环组件，循环迭代组件，和退出循环组件，其应用场景比较复杂，可以使用简单的普通组件来替代，毕竟是轻量级的规则引擎，主要作用就是为了编排流程顺序，复杂的场景就升级使用工作流了

1.2 规则（Rule）

规则定义了组件之间的执行顺序和条件。LiteFlow 支持多种规则文件格式，如 XML、jsON、YAML 等，也支持从本地文件系统、数据库、ZooKeeper、Nacos、Apollo 等多种方式加载规则。

在我上一段实习中，就是通过Apollo配置不同场景下的多种任务编排实现实时生效

# 文件编排， then 代表串行执行  when 表示并行执行
# 串行编排示例
THEN(a, b, c, d);
# 并行编排示例
WHEN(a, b, c);
# 串行和并行嵌套结合
THEN( a, WHEN(b, c, d), e);
# 选择编排示例
SWITCH(a).to(b, c, d);
# 条件编排示例
THEN(IF(x, a),b );

1.3 上下文（Context）

上下文用于在组件之间传递数据。LiteFlow 提供了灵活的上下文机制，可以在流程执行过程中存储和共享数据。这里实际上在代码里定义一个全局变量在整个流程中进行流传即可

1.4 参数配置

在 liteflow 中，需要配置的内容有规则文件地址，节点重试（执行报错时可以进行重试，类似于 spring-retry）, 流程并行执行线程池参数配置，流程的请求ID配置。

liteflow:
  # 规则文件 失败重试次数 打印执行日志 监控日志
  ruleSource : liteflow/*.el.xml
  retry-count: 0
  print-execution-log: true
  monitor:
    enable-log: true
    period: 300000
  request-id-generator-class: com.platform.orderserver.config.AppRequestIdGenerator
  # 上下文的最大数量槽
  slot-size : 10240
python  # 线程数，默认为64
  main-executor-works: 64
  # 异步线程最长等待时间 秒
  when-max-wait-seconds: 15
  # when 节点全局异步线程池最大线程数
  when-max-workers: 16
  # when 节点全局异步线程池队列数
  when-queue-limit: 5120
  # 在启动的时候就解析规则
  parse-on-start: true
  enable: true

二、基础用法

2.1 引入依赖

在 Spring Boot 项目中，可以通过以下方式引入 LiteFlow 依赖：

<dependency>
    <groupId>com.yomahub</groupId>
    <artifactId>liteflow-spring-boot-starter</artifactId>
    <version>2.10.6</version>
</dependency>

2.2 定义组件

通过 @LiteflowComponent 注解定义组件，并实现具体的业务逻辑

@LiteflowComponent("sendEmail")
public class SendEmailComponent extends NodeComponent {
    @Override
    public void process() throws Exception {
        System.out.println("发送邮件");
    }
}

2.3 编写规则文件

在 flow.xml 文件中定义规则，也可以在代码中自定义实现EL规则

xml定义方式

<flow>
    <chain name="test_flow">
        THEN(prepareTrade, grantScore, sendMq, WHEN(sendEmail, sendPhone));
    </chain>
</flow>

代码中定义方式

import com.yomahub.liteflow.core.NodeComponent;
import com.yomahub.liteflow.el.ELBus;
import com.yomahub.liteflow.el.ThenELWrapper;
import com.yomahub.liteflow.flow.LiteflowResponse;
import com.yomahub.liteflow.slot.DefaultContext;
import com.yomahub.liteflow.spring.SpringFlowExecutor;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
public class LiteFlowDemo {
    @Autowired
    private SpringFlowExecutor flowExecutor;
    public void buildAndExecuteFlow() {
        // 假设有一个配置列表，每个配置项对应一个处理器
        List<Map<String, Object>> configList = new ArrayList<>();
        configList.add(Map.of("name", "processor1"));
        configList.add(Map.of("name", "processor2"));
        // 假设有一个处理器名称映射表
        Map<String, String> processorNameMap = Map.of(
                "processor1", "component1",
                "processor2", "component2"
        );
        // 构建 EL 表达式
        ThenELWrapper finalEL = ELBus.then();
        for (int i = 0; i < configList.size(); i++) {
            Map<String, Object> config = configList.get(i);
            String name = (String) config.get("name");
            if (!processorNameMap.containsKey(name)) {
                System.out.println("No component exists for name: " + name);
                continue;
            }
            String processor = processorNameMap.get(name);
            finalEL.then(ELBus.node(processor).data("param" + i, "data" + i));
        }
        // 执行流程
        LiteflowResponse response = flowExecutor.execute2Resp("mainFlow", new DefaultContext());
        if (response.isSuccess()) {
            System.out.println("Flow executed successfully");
        } else {
            System.out.println("Flow execution failed");
        }
    }
}

2.4 执行流程

通过 FlowExecutor 执行流程：

LiteflowResponse response = flowExecutor.execute2Resp("test_flow", new DataRequest());

三、适用场景

LiteFlow 适用于拥有复杂逻辑的业务场景，例如：

• 电商下单流程：包括订单创建、库存扣减、支付处理、通知发送等多个步骤。
• 价格计算引擎：根据不同的规则和条件计算商品价格。
• 数据处理流程：在数据处理中，需要按顺序执行多个步骤。

四、与 Java 设计模式的相似性

4.1 策略模式

LiteFlow 的组件类似于策略模式中的策略类，可以根据不同的规则动态选择执行的组件。

4.2 模板方法模式

LiteFlow 的流程定义类似于模板方法模式中的模板方法，定义了业务流程的骨架，而具体的组件实现则类似于模板方法中的具体步骤。

4.3 责任链模式

LiteFlow 的组件可以通过规则进行串联，类似于责任链模式中的责任链，每个组件负责处理一部分逻辑。

五、实战使用

5.1 电商订单处理案例

假设在一个电商系统中，订单完成后需要进行积分发放、消息发送，并行发送短信和邮件。可以通过以下方式实现：

xml

<flow>
    <chain name="orderCompleteFlow">
python        THEN(prepareTrade, grantScore, sendMq, WHEN(sendEmail, sendPhone));
    </chain>
</flow>

5.2 动态规则更新

LiteFlow 支持热加载规则文件，可以在不重启应用的情况下更新规则。例如，将规则文件存储在数据库或配置中心（如 Nacos），修改规则后可以实时生效。

5.3 监控与日志

LiteFlow 提供了详细的执行日志和监控功能，可以记录每个组件的执行时间、执行结果等信息，方便排查问题。

5.4 高级特性

• 组件降级：在某些组件执行失败时，可以选择降级处理。
• 组件继承：可以通过继承的方式复用组件逻辑。
• 组件回滚：在流程执行失败时，可以选择回滚到之前的步骤。

六、总结

LiteFlow 是一个功能强大且灵活的规则引擎框架，适用于复杂的业务流程编排。通过组件化的方式，可以将复杂的业务逻辑拆分为独立的组件，通过规则进行编排，实现系统的高度灵活性和扩展性。同时，LiteFlow 提供了丰富的功能，如热加载、监控、日志等，方便开发者使用。

扩展问题自测

1. LiteFlow 的核心概念是什么？它是如何实现规则编排的？

LiteFlow 是将复杂逻辑抽解为一个个可复用的组件化，通过组件间的自由搭配实现灵活编排。以及利用Apollo或Nacos这些注册中心进行实时热更新

组件间的自由搭配是通过规则链实现的

{
    "chainId": "recommendChain",
    "name": "推荐链路",
    "condition": "A > B > C "
}

总结：通过 组件化 + 规则链 实现编排，通过注册中心监听配置变更实现热更新

2. LiteFlow 规则节点（Component）的执行机制是怎样的？支持哪些执行模式？

执行机制

• 初始化组件，通过@LiteflowComponent 组件进行组件注册
• 解析规则链：解析规则链中组件执行链路
• 执行规则链

执行模式

• 顺序模式："condition": "A > B > C" ABC顺序执行
• 并行执行："cojsndition": "A && B && C" 我们的业务中，对商品的多路召回就是并行的
• 选择执行 "condition": "A | B | C" 只执行多个流程中最先完成的组件
• 条件执行 "condition": "A WHEN(B > C)"A 先执行，然后判断是否执行 B > C 这条链路。

适用于 根据外部参数动态决定执行路径。

• FOR 循环 "condition": "FOR(A, 3)" 适用于 重复性任务，如轮询、批量处理等
• WHILE 循环 "condition": "WHILE(A, isContinue())" 适用于 动态决策的业务场景，如轮询、流式处理
• 失败处理js "condition": "A THEN(B) A 失败后，会执行 B 作为补偿措施。适用于 容错、降级、回滚等场景

3. LiteFlow 的规则是如何定义和加载的？

三种方式进行规则定义与加载

• json格式，在配置文件进行配置
• xml格式，同上
• java代码中动态注册规则链（推荐系统目前使用方式）

4. LiteFlow 规则流转时，如何保证数据在多个节点之间的传递？

LiteFlow实际上也是参考了责任链模式，通过一个全局变量作为上下文进行数据流转。LiteFlow里这个上下文变量叫做Slot（上下文容器）

LiteFlow 的 Slot 是一个 线程隔离的上下文容器，用于存储和管理整个流程中的数据，类似于 ThreadLocal，但更适用于 流程级别的数据共享。

每次执行规则链时，LiteFlow 都会为当前执行实例创建一个 独立的 Slot，不同的请求不会相互影响。

LiteFlow 通过 ThreadLocal + 对象池 机制来管理 Slot，确保：

• 每个请求拥有独立的 Slot 实例，数据不会互相污染。
• Slot 复用机制 提高性能，避免频繁创建对象。

总结

LiteFlow 通过 Slot（数据槽）在多个节点之间传递数据，相当于流程级别的全局上下文。

Slot 的作用类似责任链模式中的 Context，存储数据供整个规则链使用。

每个请求拥有独立的 Slot，避免线程安全问题，同时通过对象池优化性能。

5. LiteFlow 支持哪些异步执行模式？如何处理异步任务之间的依赖？

到此这篇关于SpringBoot集成LiteFlow实现轻量级工作流引擎的文章就介绍到这了,更多相关SpringBoot集成LiteFlow工作流引擎内容请搜索China编程(www.chinasem.cn)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程China编程(www.chinasem.cn)！