别再写“又臭又长”的 if-else 了！LiteFlow 给你的项目来点魔力

最新推荐文章于 2025-09-01 15:47:56 发布

原创最新推荐文章于 2025-09-01 15:47:56 发布 · 1.1k 阅读

21 ·

CC 4.0 BY-SA版权

文章标签：

#java #规则引擎 #spring boot

规则引擎专栏收录该内容

1 篇文章

订阅专栏

嘿，兄弟！还在维护那坨像意大利面条一样的代码吗？是不是每次产品经理提个小需求，你都得在成百上千行的 if-else 屎山里小心翼翼地“刨坑”，生怕一不小心就挖塌了整个项目？

别慌，今天介绍一个能让你“得道升天”的神器——LiteFlow。

它是一个轻量、高性能的国产规则引擎框架，能把你的业务逻辑像搭乐高积木一样，一块块拆开，再随心所欲地拼装起来。最酷的是，你可以把这些“拼装图纸”（也就是规则）放到配置中心（比如 Nacos），想改就改，还不用重启服务！想象一下，当着产品经理的面，在线改逻辑，是不是瞬间感觉自己像个魔法师？

废话不多说，上车，咱们发车！

一、LiteFlow 能干啥？

简单来说，LiteFlow 干两件事：

定义组件（Component）：把你的业务逻辑拆分成一个个独立的、可复用的 Java 类。比如“检查用户是否是 VIP”、“查询商品库存”、“计算优惠券”等等，每个都是一个组件。
编排流程（DSL）：用一种非常直观的脚本语言（DSL），告诉程序这些组件应该按什么顺序、什么条件执行。这玩意儿就是咱们的“乐高图纸”。

这样一来，业务逻辑（组件）和流程控制（DSL）就彻底分开了。代码变得清爽，逻辑一目了然。

二、3分钟上手：一个简单的订单处理流程

咱们来模拟一个简单的下单场景：

检查库存
选择优惠券
计算最终价格

1. 准备工作（Maven 依赖）

假设你用的是 Spring Boot，先在 pom.xml 里把 LiteFlow 的家伙事儿都请过来：

<dependency>
    <groupId>com.yomahub</groupId>
    <artifactId>liteflow-spring-boot-starter</artifactId>
    <version>2.13.2</version> <!-- 建议使用最新稳定版 -->
</dependency>

2. 编写逻辑组件

现在，我们来创建三个组件，分别对应上面的三个步骤。每个组件就是一个普通的 Spring Bean，只不过要继承 NodeComponent 并加上 @Component 注解。

组件A：检查库存 (CheckStockCmp)

import com.yomahub.liteflow.core.NodeComponent;
import org.springframework.stereotype.Component;

@Component("checkStock") // "checkStock" 是这个组件的ID，后面编排要用
public class CheckStockCmp extends NodeComponent {

    @Override
    public void process() {
        // 模拟检查库存的逻辑
        System.out.println("组件[checkStock]: 检查库存...通过！");
        // 你可以在这里通过 this.getRequestData() 获取请求参数
        // 通过 this.getSlot().setData("key", value) 向下传递数据
    }
}

组件B：选择优惠券 (SelectCouponCmp)

import com.yomahub.liteflow.core.NodeComponent;
import org.springframework.stereotype.Component;

@Component("selectCoupon")
public class SelectCouponCmp extends NodeComponent {

    @Override
    public void process() {
        // 模拟选择优惠券
        System.out.println("组件[selectCoupon]: 根据用户标签和商品，选择了一张满100减10的券");
    }
}

组件C：计算最终价格 (CalcPriceCmp)

import com.yomahub.liteflow.core.NodeComponent;
import org.springframework.stereotype.Component;

@Component("calcPrice")
public class CalcPriceCmp extends NodeComponent {

    @Override
    public void process() {
        // 模拟计算价格
        System.out.println("组件[calcPrice]: 计算最终价格...128元！");
    }
}

3. 用 DSL 编排流程

组件写好了，现在轮到我们的“乐高图纸”——DSL 出场了。

在 src/main/resources/config/ 目录下创建一个 flow.el.xml 文件（文件名和路径可以自定义）。

<?xml version="1.0" encoding="UTF-8"?>
<flow>
    <!-- 定义一个名叫 'orderChain' 的流程 -->
    <chain name="orderChain">
        <!-- THEN代表串行执行，像流水线一样 -->
        THEN(
            checkStock,
            selectCoupon,
            calcPrice
        );
    </chain>
</flow>

看到了吗？THEN 关键字把我们刚才定义的三个组件ID checkStock, selectCoupon, calcPrice 串了起来，意思就是“按顺序执行”。是不是超级直观？

4. 配置文件和启动

在 application.properties 或 application.yml 里告诉 LiteFlow 我们的规则文件在哪：

liteflow:
  # 规则文件的路径，支持多种路径写法，这里用classpath
  rule-source: config/flow.el.xml

5. 测试一下

写个 Controller 来触发这个流程：

import com.yomahub.liteflow.core.FlowExecutor;
import com.yomahub.liteflow.flow.LiteflowResponse;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;

@RestController
public class OrderController {

    @Resource
    private FlowExecutor flowExecutor;

    @GetMapping("/placeOrder")
    public String placeOrder() {
        // 执行 'orderChain' 这条流程，可以传入初始参数
        LiteflowResponse response = flowExecutor.execute2Resp("orderChain", "your_order_id");
        if (response.isSuccess()) {
            return "下单成功！";
        } else {
            return "下单失败：" + response.getMessage();
        }
    }
}

启动项目，访问 http://localhost:8080/placeOrder，你会在控制台看到：

组件[checkStock]: 检查库存...通过！
组件[selectCoupon]: 根据用户标签和商品，选择了一张满100减10的券
组件[calcPrice]: 计算最终价格...128元！

恭喜！你已经完成了第一个 LiteFlow 应用！

三、王炸功能：Nacos 热部署

现在，好戏开场了。如果产品经理突然说：“咱们先算价格，再选优惠券吧！”。按照传统方式，你得改代码、重新编译、打包、部署...黄花菜都凉了。

但有了 Nacos + LiteFlow，你只需要动动手指。

1. 添加 Nacos 依赖

<!-- LiteFlow的Nacos配置源扩展 -->
<dependency>
    <groupId>com.yomahub</groupId>
    <artifactId>liteflow-rule-nacos</artifactId>
    <version>2.13.2.1</version>
</dependency>

<!-- Spring Cloud Alibaba Nacos 依赖 -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
    <version>2021.0.4.0</version>
</dependency>

2. 修改 application.yml

把规则来源从本地文件指向 Nacos。

server:
  port: 8080

spring:
  application:
    name: liteflow-nacos-example
  cloud:
    nacos:
      config:
        server-addr: 127.0.0.1:8848 # 你的Nacos地址

liteflow:
  # 规则来源改为nacos
  rule-source-ext-data-map:
    nacos: liteflow-rule.el.xml # 这个key是固定的，value是你在Nacos里的Data ID

3. 在 Nacos 中创建规则

登录你的 Nacos 控制台，进入“配置管理” -> “配置列表”，点击“+”创建新配置。

Data ID: liteflow-rule.el.xml (必须和 application.yml 里的一致)
Group: DEFAULT_GROUP (或者你自定义的组)
配置格式: XML
配置内容: 把我们之前 flow.el.xml 文件的内容整个复制进去。

点击“发布”。

4. 见证奇迹的时刻

现在，把本地的 flow.el.xml 文件删掉（或者改名），重启你的 Spring Boot 项目。

再次访问 http://localhost:8080/placeOrder，流程正常执行。这说明 LiteFlow 已经从 Nacos 读取到规则了。

现在，我们来满足产品经理的需求。回到 Nacos，编辑 liteflow-rule.el.xml 的内容，把 selectCoupon 和 calcPrice 的顺序换一下：

<!-- 原来的 -->
<!-- THEN(checkStock, selectCoupon, calcPrice); -->

<!-- 修改后 -->
THEN(
    checkStock,
    calcPrice,
    selectCoupon
);

点击“发布”。不要重启应用！

再次访问 http://localhost:8080/placeOrder，看控制台输出：

组件[checkStock]: 检查库存...通过！
组件[calcPrice]: 计算最终价格...128元！
组件[selectCoupon]: 根据用户标签和商品，选择了一张满100减10的券

顺序变了！整个过程不到 10 秒，无需重启，业务流程在线更新！

四、DSL 还能怎么玩？

LiteFlow 的 DSL 非常强大，THEN 只是冰山一角。

WHEN (并行执行): WHEN(a, b, c) 会同时执行 a, b, c 三个组件，等它们都执行完了再往下走。适合处理没有依赖关系的业务，比如同时调用多个外部 API。

SWITCH (条件选择): 这就是 if-else 的终结者！

<!-- 如果 isVip 组件返回 "yes", 就执行 vipDiscount -->
<!-- 否则，执行 normalDiscount -->
SWITCH(isVip).to(
    vipDiscount: "yes",
    normalDiscount
);

FOR / WHILE (循环)
BREAK (中断)
IF (三元判断)

你可以组合这些关键字，构建出任何复杂的业务流程。

总结

怎么样，LiteFlow 是不是有点东西？它把我们从繁琐的流程代码中解放出来，让我们更专注于业务逻辑本身。通过结合 Nacos 等配置中心，更是实现了动态、可观测、可编排的“代码魔法”。

如果你还在被 if-else 搞得头皮发麻，不妨试试 LiteFlow，它绝对能让你的项目焕然一新，也能让你在团队里脱颖而出。

赶紧动手试试吧！