LiteFlow示例项目：完整可运行的示例代码

原创 于 2025-09-01 18:57:40 发布 · 395 阅读 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

LiteFlow示例项目：完整可运行的示例代码

【免费下载链接】liteflow 轻量，快速，稳定，可编排的组件式规则引擎/流程引擎。 【免费下载链接】liteflow 项目地址: https://gitcode.com/dromara/liteflow

概述

LiteFlow是一款轻量级且功能强大的国产规则引擎框架，专为复杂的组件化业务编排而设计。通过独特的DSL（Domain Specific Language）规则驱动整个复杂业务，支持平滑刷新热部署和多种脚本语言嵌入。本文将为您提供完整的LiteFlow示例项目代码，帮助您快速上手并理解其核心概念。

项目结构

一个典型的LiteFlow Spring Boot项目包含以下核心文件结构：

src/main/java/
├── com/example/demo/
│   ├── DemoApplication.java          # Spring Boot启动类
│   ├── config/
│   │   └── LiteflowConfig.java       # LiteFlow配置类
│   └── component/                    # 业务组件目录
│       ├── ACmp.java                 # 组件A
│       ├── BCmp.java                 # 组件B
│       └── CCmp.java                 # 组件C
src/main/resources/
├── application.yml                   # 应用配置文件
└── rules/                           # 规则文件目录
    ├── el.xml                       # XML格式规则文件
    ├── el.json                      # JSON格式规则文件
    └── el.yml                       # YAML格式规则文件

核心组件示例

基础组件定义

// ACmp.java - 基础业务组件
package com.example.demo.component;

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

@Component("a")
public class ACmp extends NodeComponent {

    @Override
    public void process() {
        System.out.println("ACmp executed! - 处理业务逻辑A");
        // 设置业务数据到上下文
        this.getSlot().setData("resultA", "处理结果A");
    }
}

// BCmp.java - 带有业务逻辑的组件
@Component("b")
public class BCmp extends NodeComponent {

    @Override
    public void process() {
        System.out.println("BCmp executed! - 处理业务逻辑B");
        // 从上下文获取数据并处理
        String resultA = this.getSlot().getData("resultA");
        this.getSlot().setData("resultB", resultA + " -> 处理结果B");
    }
}

// CCmp.java - 最终处理组件
@Component("c")
public class CCmp extends NodeComponent {

    @Override
    public void process() {
        System.out.println("CCmp executed! - 最终处理");
        String resultB = this.getSlot().getData("resultB");
        this.getSlot().setData("finalResult", resultB + " -> 最终结果");
    }
}

规则文件配置

XML格式规则 (el.xml)
<?xml version="1.0" encoding="UTF-8"?>
<flow>
    <chain name="chain1">
        <then value="a,b,c"/>
    </chain>
    
    <chain name="chain2">
        <then value="a"/>
        <when value="b,c"/>
        <then value="a"/>
    </chain>
    
    <chain name="conditionalChain">
        <then value="a"/>
        <if value="b" id="condition1">
            <then value="c"/>
            <else value="d"/>
        </if>
    </chain>
</flow>
JSON格式规则 (el.json)
{
  "flow": {
    "chain": [
      {
        "name": "chain1",
        "value": "THEN(a, b, c)"
      },
      {
        "name": "parallelChain",
        "value": "THEN(a, WHEN(b, c), d)"
      },
      {
        "name": "switchChain",
        "value": "SWITCH(x).TO(b, c, d)"
      }
    ]
  }
}
YAML格式规则 (el.yml)
flow:
  chain:
    - name: "chain1"
      value: "THEN(a, b, c)"
    - name: "complexChain"
      value: |
        THEN(
          a,
          IF(x, THEN(b, c), ELSE(d)),
          WHEN(e, f)
        )

配置类示例

// LiteflowConfig.java - 配置类
package com.example.demo.config;

import com.yomahub.liteflow.property.LiteflowConfig;
import com.yomahub.liteflow.spring.ComponentScanner;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScanner("com.example.demo.component")
public class LiteflowConfig {

    @Bean
    public LiteflowConfig liteflowConfig() {
        LiteflowConfig config = new LiteflowConfig();
        config.setRuleSource("rules/el.xml, rules/el.json, rules/el.yml");
        config.setEnableLog(true);
        config.setSupportMultipleType(true);
        return config;
    }
}

应用启动类

// DemoApplication.java
package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

业务服务类

// BusinessService.java - 业务服务
package com.example.demo.service;

import com.yomahub.liteflow.core.FlowExecutor;
import com.yomahub.liteflow.flow.LiteflowResponse;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;

@Service
public class BusinessService {

    @Resource
    private FlowExecutor flowExecutor;

    public String executeBusinessFlow(String chainName, Object param) {
        LiteflowResponse response = flowExecutor.execute2Resp(chainName, param);
        
        if (response.isSuccess()) {
            return "流程执行成功: " + response.getExecuteStepStr();
        } else {
            return "流程执行失败: " + response.getMessage();
        }
    }

    public String executeComplexFlow() {
        // 执行复杂流程
        LiteflowResponse response = flowExecutor.execute2Resp("complexChain", null);
        
        // 获取执行步骤信息
        String stepInfo = response.getExecuteStepStr();
        String stepInfoWithId = response.getExecuteStepStrWithInstanceId();
        
        return String.format("""
            执行结果: %s
            执行步骤: %s
            带实例ID的步骤: %s
            """, response.isSuccess(), stepInfo, stepInfoWithId);
    }
}

控制器示例

// DemoController.java - REST控制器
package com.example.demo.controller;

import com.example.demo.service.BusinessService;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;

@RestController
@RequestMapping("/api/flow")
public class DemoController {

    @Resource
    private BusinessService businessService;

    @GetMapping("/execute/{chainName}")
    public String executeFlow(@PathVariable String chainName) {
        return businessService.executeBusinessFlow(chainName, null);
    }

    @PostMapping("/execute")
    public String executeFlowWithParam(@RequestParam String chainName, 
                                      @RequestBody Object param) {
        return businessService.executeBusinessFlow(chainName, param);
    }

    @GetMapping("/complex")
    public String executeComplexFlow() {
        return businessService.executeComplexFlow();
    }
}

配置文件

application.yml

spring:
  application:
    name: liteflow-demo

liteflow:
  rule-source: rules/el.xml,rules/el.json,rules/el.yml
  enable-log: true
  support-multiple-type: true
  monitor:
    enable: true
    log-enable: true

server:
  port: 8080

logging:
  level:
    com.yomahub.liteflow: DEBUG
    com.example.demo: INFO

测试用例

// FlowTest.java - 单元测试
package com.example.demo;

import com.yomahub.liteflow.core.FlowExecutor;
import com.yomahub.liteflow.flow.LiteflowResponse;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.TestPropertySource;
import javax.annotation.Resource;
import static org.junit.jupiter.api.Assertions.*;

@SpringBootTest
@TestPropertySource("classpath:application-test.yml")
public class FlowTest {

    @Resource
    private FlowExecutor flowExecutor;

    @Test
    public void testSimpleChain() {
        LiteflowResponse response = flowExecutor.execute2Resp("chain1", null);
        assertTrue(response.isSuccess());
        assertEquals("a==>b==>c", response.getExecuteStepStr());
    }

    @Test
    public void testParallelChain() {
        LiteflowResponse response = flowExecutor.execute2Resp("parallelChain", null);
        assertTrue(response.isSuccess());
        // 并行执行的顺序可能不同
        assertTrue(response.getExecuteStepStr().contains("a"));
        assertTrue(response.getExecuteStepStr().contains("b"));
        assertTrue(response.getExecuteStepStr().contains("c"));
    }

    @Test
    public void testConditionalChain() {
        LiteflowResponse response = flowExecutor.execute2Resp("conditionalChain", null);
        assertTrue(response.isSuccess());
        // 根据条件执行不同的分支
        System.out.println("执行步骤: " + response.getExecuteStepStr());
    }
}

高级特性示例

脚本节点支持

// ScriptComponent.java - 脚本组件
@Component("scriptNode")
public class ScriptComponent extends NodeComponent {

    @Override
    public void process() {
        // 执行Groovy脚本
        String script = """
            def result = "处理结果: " + new Date()
            defaultContext.setData("scriptResult", result)
            return result
        """;
        
        Object result = this.getSlot().executeScript("groovy", script);
        System.out.println("脚本执行结果: " + result);
    }
}

自定义上下文

// CustomContext.java - 自定义上下文
public class CustomContext {

    private String businessId;
    private Map<String, Object> data = new HashMap<>();
    private List<String> executionSteps = new ArrayList<>();

    // getters and setters
    public void addStep(String step) {
        executionSteps.add(step);
    }
    
    public String getBusinessId() { return businessId; }
    public void setBusinessId(String businessId) { this.businessId = businessId; }
    
    public Map<String, Object> getData() { return data; }
    public void setData(String key, Object value) { data.put(key, value); }
}

异常处理组件

// ExceptionHandlerCmp.java - 异常处理组件
@Component("exceptionHandler")
public class ExceptionHandlerCmp extends NodeComponent {

    @Override
    public void process() {
        try {
            // 业务逻辑
            System.out.println("执行可能抛出异常的业务");
        } catch (Exception e) {
            // 异常处理
            this.getSlot().setData("error", e.getMessage());
            System.out.println("捕获到异常: " + e.getMessage());
        }
    }
}

部署和运行

Maven依赖配置

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <dependency>
        <groupId>com.yomahub</groupId>
        <artifactId>liteflow-spring-boot-starter</artifactId>
        <version>2.10.0</version>
    </dependency>
    
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

运行命令

# 编译项目
mvn clean compile

# 运行测试
mvn test

# 启动应用
mvn spring-boot:run

# 打包部署
mvn package

总结

通过本文提供的完整示例代码，您可以快速搭建一个功能完善的LiteFlow项目。示例涵盖了：

  1. 基础组件定义 - 如何创建业务组件
  2. 多种规则格式 - XML、JSON、YAML规则文件配置
  3. Spring Boot集成 - 完整的配置和集成示例
  4. 业务服务层 - 如何在实际业务中使用LiteFlow
  5. REST API - 提供外部调用的接口
  6. 测试用例 - 确保流程正确性的单元测试
  7. 高级特性 - 脚本支持、自定义上下文、异常处理

这个示例项目为您提供了一个完整的起点，您可以根据实际业务需求进行扩展和定制。LiteFlow的强大编排能力能够帮助您解耦复杂业务逻辑，提高代码的可维护性和灵活性。

【免费下载链接】liteflow 轻量，快速，稳定，可编排的组件式规则引擎/流程引擎。 【免费下载链接】liteflow 项目地址: https://gitcode.com/dromara/liteflow

创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值