规则引擎Liteflow可视化形态进阶

LiteFlow入门使用 利用LiteFlow,你可以将瀑布流式的代码,转变成以组件为核心概念的代码结构,这种结构的好处是可以任意编排,组件与组件之间是解耦的,组件可以用脚本来定义,组件之间的流转全靠规则来驱动。LiteFlow拥有开源规则引擎最为简单的DSL语法。十分钟就可上手。组件可实时热更替,也可以给编排好的逻辑流里实时增加一个组件,从而改变你的业务逻辑。LiteFlow的脚本组件,支持众多脚本语言,完全和Java打通,你可以用脚本来实现任何逻辑。 阅读详情
AI摘要

本文介绍如何使用Liteflow实现流程的可视化编排,包括引入Liteflow的基础知识、自定义节点类型、前端画布设计及后端算法实现。

1 引言

Liteflow解决哪些场景的问题呢?通过下面的例子感受一下。

假设有三个组件(或方法)stepOne、stepTwo、stepThree,并且你想要按照顺序打印 “one”、“two”、“three”,通常我们编写代码的方式可能是这样的:

@Component
public class PrintService {
    /**
     * 执行业务代码
     */
    private void doExecute() {
        stepOne();
        stepTwo();
        stepThree();
    }

    private void stepOne() {
        // 业务代码
        System.out.println("one");
    }

    private void stepTwo() {
        // 业务代码
        System.out.println("two");
    }

    private void stepThree() {
        // 业务代码
        System.out.println("three");
    }
}

这样写最简单粗暴,但是如果之后有调整打印顺序的话,例如你想打印two、one、three,或者直接跳过two直接打印one、three,你一定需要修改代码并且重新上线。

	// 打印two、one、three
    public void doExecute() {
        stepTwo();
        stepOne();
        stepThree();
    }
    // 打印one、three
    public void doExecute() {
        stepOne();
        stepThree();
    }

对于需要动态调整执行流程的业务场景,显然不适合将流程硬编码在代码中。

2 Liteflow简介

liteflow是一款编排式的规则引擎框架,可以通过表达式的方式来编排组件或方法的执行流程,并且支持一些高级的流程编排。

上述案例如何通过更高级的方式来实现零代码修改、无需重新上线即可编排流程了呢?我们基于Liteflow做一些改造。

2.1 引入jar包

可以去官网根据需要选择合适的版本,这里用的是最新版本

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

2.2 定义组件

将打印功能分别定义成一个个组件,继承NodeComponent 这个抽象父类并实现其中的方法:

@Component
public class PrintOne extends NodeComponent {

    @Override
    public void process() throws Exception {
        // 业务代码
        System.out.println("one");
    }
}

@Component
public class PrintTwo extends NodeComponent {

    @Override
    public void process() throws Exception {
        // 业务代码
        System.out.println("two");
    }
}

@Component
public class PrintThree extends NodeComponent {

    @Override
    public void process() throws Exception {
        // 业务代码
        System.out.println("three");
    }
}

2.3 执行流程

定义好组件之后,我们就开始编写组件执行的流程表达式了,官方名称叫EL表达式;
上述案例可以这样编写表达式:

THEN(node(“printOne”),node(“printTwo”),node(“pirntThree”));

并给这个流程起个名字(流程唯一标识):print_flow
根据流程名称执行流程:

@Component
public class PrintService {

    @Autowired
    private FlowExecutor flowExecutor;

    /**
     * 执行业务代码
     */
    public void doExecute() {
        // 开始执行流程
        LiteflowResponse response = flowExecutor.execute2Resp("print_flow");
        // 根据执行结果进行后续操作
        // ......
    }
}

一般我们会将流程放到数据库中,如果想改变打印顺序,只需要修改表达式即可,例如:
打印two、one、three

THEN(node(“printTwo”),node(“printOne”),node(“pirntThree”));

打印two、three

THEN(node(“printTwo”),node(“printThree”));

然后Liteflow真正强大的地方远不止如此,它不仅仅支持简单的串行编排,还支持更加复杂的逻辑例如(并行编排)WHEN、(条件编排)IF、(选择编排)SWITCH、(循环编排)FOR等。

2.4 官网

上述的简单示例旨在为不熟悉Liteflow框架的伙伴们提供一个初步的认知。要想真正基于Liteflow将业务流程落地并运用到实际业务场景中,还需要通过官方文档深入了解该框架的运作原理和核心机制。
官网:https://liteflow.cc/

3 可视化编排(需要有Liteflow基础)

3.1 为什么要可视化

官网提供修改表达式的方式只有一个,那就是手写!官网并没有提供配套的可视化工具,手写可能存在诸多问题和不便,例如:

1. 容易出错:表达式少一个字母甚至一个逗号都不行!
2. 流程不可视:我们只能完全依赖大脑去构想这些流程。即使是运营或产品团队想要了解或讨论流程,也只能依赖于其他画图工具来手动绘制和表达;每次去修改表达式都需要去维护绘制的流程图。
3. 节点不可配置:我们的运营会根据不同的场景对节点进行动态配置,没有可视化界面,运营改动配置的需求则无从下手。

所以可视化对于编排流程来说意义重大,对于研发能更准确地理解和设计流程,还能让运营能更便捷地监控和管理流程。

3.2 方案设计

网上有一些网友开源的项目,但对于复杂流程的处理不是很好,所以自己进行了调研和设计;支持普通节点、判断节点、选择节点、并行节点;循环节点目前业务不需要,有需要的可以自己拓展,掌握方案之后拓展节点类型非常简单。
完成可视化编排需要解决两个问题:

1. 一款与用户交互的前端画布(推荐logicFlow,有自己熟悉的也行)
2. 将画布信息转化成EL表达式(手写算法,基于DFS的递归)

3.2.1 整体流程

创建画布
流程的核心在第5步,下面会重点讲解。

1.前端画布
构建流程
2.生成json语
法树传给后端
3.json语法树
合法性校验
4.json画布数据
转化成抽象语法树
5.抽象语法树
生成EL表达式
6.检验EL表达
式有效性
7.入库
8.推拉结合
刷新流程

回显画布
解析EL成本很高,所以我选择不解析表达式,直接将前端传入的画布json数据返回给前端进行回显。

3.2.2 后端抽象语法树设计

节点类型枚举

public enum NodeEnum {
    // 普通节点,对应普通组件
    COMMON,
    // 并行节点,对应并行组件
    WHEN,
    // 判断节点,对应判断组件
    IF,
    // 选择节点,对应选择组件
    SWITCH,
    // 汇总节点(自定义)
    SUMMARY,
    // 开始节点(自定义)
    START,
    // 结束节点(自定义)
    END;
}

COMMON
普通节点,入度和出度都为1
普通节点
WHEN
判断节点,包含一个true分支,一个false分支,入度为1,出度为2
并行节点
IF
根据SWITCH返回的tag,来决定执行后续哪个流程。入度为1,出度大于1。
选择节点
WHEN
官网没有WHEN节点的概念,我这里自定义WHEN节点会避免很多问题。
并行节点
为什么要定义WHEN节点?

WHEN作为一个出度大于1的节点,和IF、SWITCH不同的是WHEN并没有一个前置节点去驱动一个流程。

THEN(
	IF(node("c"), 
		WHEN(
			node("a"),
			node("b"),
			node("d"),
			node("e")
		).ignoreError(true)
	),
	node("f")
)

假设这样一个流程,如果没有WHEN节点的支持,展示到画布上的效果很差。
在这里插入图片描述
SUMMARY
官网没有这种节点,自定义节点,用于汇总所有分支节点,也就是WHEN、IF、SWITCH节点。入度大于1,出度为1
在这里插入图片描述
为什么要定义SUMMARY节点?

构建EL算法是基于递归实现的,参考的是深度优先遍历算法(DFS),这种嵌套方式如果没有一个结束标志会一直执行下去。

举个例子:
在这里插入图片描述
基于图一生成EL表达式

THEN(
	node("c"),
	WHEN(
		THEN(node("b"),node("e")),
		THEN(node("d"),node("e"))
	)
)

基于图二生成EL表达式

THEN(
	node("c"),
	WHEN(node("b"),node("d")),
	node("e")
)

可以看出来图二EL表达式才是正确的。

START
开始节点,一个流程必须有一个开始节点,入度为0,出度为1
END
结束节点,一个流程必须有一个结束节点,入度为1,出度为0
上述节点类型的类定义

// 抽象父类
@Getter
public abstract class Node {

    // node的唯一id
    private final String id;

    // node名称,对应LIteFlow的Bean名称
    private final String name;

    // 入度
    private final List<Node> pre = Lists.newArrayList();

    // 节点类型
    private final NodeEnum nodeEnum;

    // 出度
    private final List<Node> next = Lists.newArrayList();

    protected Node(String id, String name, NodeEnum nodeEnum) {
        this.id = id;
        this.name = name;
        this.nodeEnum = nodeEnum;
    }

    public void addNextNode(Node node) {
        next.add(node);
    }

    public void addPreNode(Node preNode) {
        pre.add(preNode);
    }
}
// 普通节点
public class CommonNode extends Node {

    public CommonNode(@NonNull String id, @NonNull String name) {
        super(id, name, NodeEnum.COMMON);
    }
}
// 并行节点
public class WhenNode extends Node {

    public WhenNode(@NonNull String id, @NonNull String name) {
        super(id, name, NodeEnum.WHEN);
    }
}
// 判断节点
@Getter
public class IfNode extends Node {

    private Node trueNode;

    private Node falseNode;

    public IfNode(@NonNull String id, @NonNull String name) {
        super(id, name, NodeEnum.IF);
    }

    public void setTrueNode(Node trueNode) {
        this.trueNode = trueNode;
        super.addNextNode(trueNode);
    }

    public void setFalseNode(Node falseNode) {
        this.falseNode = falseNode;
        super.addNextNode(falseNode);
    }
}
// 选择节点
@Getter
public class SwitchNode extends Node {

    private final Map<Node, String> nodeTagMap = Maps.newHashMap();

    public SwitchNode(@NonNull String id, @NonNull String name) {
        super(id, name, NodeEnum.SWITCH);
    }

    public void putNodeTag(Node node, String tag) {
        nodeTagMap.put(node, tag);
        super.addNextNode(node);
    }
}
// 开始节点
public class StartNode extends Node {

    public StartNode(@NonNull String id, @NonNull String name) {
        super(id, name, NodeEnum.START);
    }
}
// 结束节点
public class EndNode extends Node {

    public EndNode(@NonNull String id, @NonNull String name) {
        super(id, name, NodeEnum.END);
    }
}
// 汇总节点
public class SummaryNode extends Node {

    public SummaryNode(@NonNull String id, @NonNull String name) {
        super(id, name, NodeEnum.SUMMARY);
    }
}
3.2.3 前端画布JSON数据设计

画布数据最终体现在JSON语法树,数据结构如下:

{
    "nodeEntities": [
        {
            "id": "节点的唯一id,由前端生成。必填",
            "name": "节点名称,对应LiteFlow的节点名称,spring的beanName。必填",
            "label": "前端节点展示名称,到时候给前端。必填",
            "nodeType": "节点的类型,有COMMON、IF、SWITCH、WHEN、START、END和SUMMARY。必填",
            "x": "x坐标。必填",
            "y": "y坐标。必填"
        }
    ],
    "nodeEdges": [
        {
            "source": "源节点。必填",
            "target": "目标节点。必填",
            "ifNodeFlag": "if类型节点的true和false,只有ifNode时必填,其他node随意",
            "tag": "switch类型的下层节点的tag,主机有switchNode时必填,其他node随意"
        }
    ]
}
3.2.4 画布JSON数据合法校验

下面是针对画布json数据的一些简单合法性校验,可以自己根据需要拓展,实现很简单,最后有具体实现代码,需要的可以下载。

  • 校验节点类型,只能是IF、WHEN、COMMON、SWITCH、START、END和SUMMARY
  • IF、WHEN、SWITCH节点的数量总和与SUMMARY类型节点数量总和校验
  • 校验节点和边的source和target是否能对应上
  • 校验SWITCH的出度边是否有tag,且tag不能为空
  • 校验IF节点有没有ifNodeFlag的标识,并且总有一条true分支,总有一条false分支
  • 流程必须有一个开始节点和一个结束节点
3.2.5 画布JSON数据转化为后端抽象语法树

为什么要设计JSON和AST(抽象语法树)两种数据结构?

根据上述JSON数据可以发现,用户编辑画布时,前端只需要维护节点和边两个数组即可;而生成EL表达式的操作在后端,生成方法是利用递归实现的深度优先遍历算法(DFS),显然JSON是不满足递归需求的,所以JSON转换为AST。

设计JSON和AST就是为了方便前后端去各自维护数据。

JSON转化为AST是非常简单的,就和平时写业务代码一样,可以参考文章最后的源码。

3.2.6 后端抽象语法树生成EL表达式

整个流程的核心就在这里,AST生成EL表达式

下面举一个简单例子来模拟生成EL表达式过程,该流程只涉及THEN和WHEN,我们约定把THEN和WHEN当成数组来处理,例如THEN(node("a"),node("b"))对应数组[node("a"),node("b")],同理WHEN。

  1. 流程必须以一个数组开始。
[
    node("a")
]

  1. 遇见WHEN分支节点e,创建一个新数组,并加入上一层数组。

[
    node("a"),
    [
    ]
]

  1. 分支节点之后的每一个分支都要创建一个数组,并且加入到分支节点的数组中。
[
    node("a"),
    [
        [
            node("b")
        ]
    ]
]

  1. 正常的串行,节点直接加入最内层数组。

[
    node("a"),
    [
        [
            node("b"),
            node("d")
        ]
    ]
]

  1. 遇见汇总节点,什么也不处理。
[
    node("a"),
    [
        [
            node("b"),
            node("d")
        ]
    ]
]

  1. 继续向下,将f节点加入WHEN节点所在的数组,到达递归的出口。

[
    node("a"),
    [
        [
            node("b"),
            node("d")
        ]
    ],
    node("f")
]

这可能有疑问,程序是如何定位到WHEN所在的数组在哪呢?

利用栈,遇到WHEN节点的时候会将WHEN节点所在的数组压栈,等遇到汇总节点时将数组出栈,那么可以确定f节点应该加入出栈时的数组了。


  1. 因为是从e节点开始有分支流程的,以b节点开头的分支已经执行完,回溯到另一条分支;同样c节点属于e的一条分支,分支节点之后的每一个分支都要创建一个数组,并且加入到分支节点的数组中。
[
    node("a"),
    [
        [
            node("b"),
            node("d")
        ],
        [
            node("c")
        ]
    ],
    node("f")
]

  1. 到了汇总节点,因为遍历以b节点开头的分支时已经访问了该汇总节点,这次不处理,到达递归的出口。

[
    node("a"),
    [
        [
            node("b"),
            node("d")
        ],
        [
            node("c")
        ]
    ],
    node("f")
]

如何判断汇总节点是否访问过?

用Set,访问过的汇总节点加入Set中,下次再访问先判断Set中有没有该汇总节点,有就不往下执行,到达递归出口。

3.2.7 校验EL表达式的合法性

这是生成EL表达式的最后一步;框架有本身有支持校验EL合法性的方法,在生成EL之后进行校验。

// 校验是否符合EL语法
Boolean isValid = LiteFlowChainELBuilder.validate(el);

进行完最后一步,EL表达式就可以入库了。

3.3 推拉结合刷新流程

3.3.1 拉

框架会定期从数据库(或通过配置指定的任何数据源)中同步最新数据,并将这些数据缓存在内存中;数据同步和缓存的过程是平滑进行的,不会干扰或打断现有流程的执行;该框架还允许用户根据实际需求配置数据刷新的时间间隔,具体配置方法可参照官方文档进行详细了解。

3.3.2 推

如果我们希望改动的EL表达式立即生效而不是等待框架被动刷新,我们可以通过官方提供的api进行主动刷新:

flowExecutor.reloadRule();

需要注意的的是,官方提供的方法只是刷新单个实例节点的流程;如果是集群环境,我们需要借助消息队列以达到通知整个集群的效果。

3.4 源码

目前这套设计方案已在实际业务场景落地并使用。
在这里插入图片描述

目前这套设计方案已在实际业务场景落地并使用;自己进行过很多复杂流程的验证,基于这种规则能百分百保证生成EL表达式的正确性。
点击下载

记录一次LiteFlow使用实战及原理分析 LiteFlow,动态编排创建组件及流程 阅读详情

相关推荐

AI智能体编排实战:从概念到LangGraph实现复杂工作流

在人工智能工程实践中,工作流编排是构建复杂系统的核心技术,它通过定义任务分解、执行顺序和状态传递的规则,将多个独立组件协同组织起来。其原理基于流程调度、状态管理和异常处理三大支柱,能够实现顺序、并行、条件分支等多样化执行模式。这一技术的核心价值在于提升系统整体效能与可靠性,使单一模型的能力得以扩展和互补。在应用场景上,编排技术广泛落地于客服自动化、智能助手、研发流水线等领域,通过将多个AI智能体(如LangChain框架中的组件)有机整合,形成可处理复杂任务的协同系统。本文聚焦于AI智能体编排的实现,详细探

485

规则引擎之LiteFlow讲解

在日常的开发过程中,经常会遇到一些串行或者并行的业务流程问题,而业务之间不必存在相关性。在这样的场景下,使用策略和模板模式的结合可以很好的解决这个问题,但是使用编码的方式会使得文件太多,在业务的部分环节可以这样操作,在项目角度就无法一眼洞穿其中的环节和逻辑。liteflow是一个轻巧而且强大的规则引擎,能够实现开箱即用,可以在短时间内就可以完成复杂的规则编排,下图是liteflow的整体架构。liteflow支持较多的规则文件格式,比如。

上善若泪 3486

SpringBoot中集成LiteFlow(轻量、快速、稳定可编排的组件式规则引擎)实现复杂业务解耦、动态编排、高可扩展

在业务开发中,经常遇到一些串行或者并行的业务流程问题,而业务之间不必存在相关性。使用策略和模板模式的结合可以解决这个问题,但是使用编码的方式会使得文件太多,在业务的部分环节可以这样操作,在项目角度就无法一眼洞穿其中的环节和逻辑。一些拥有复杂业务逻辑的系统,核心业务逻辑冗长,涉及内部逻辑运算,缓存操作,持久化操作,外部资源调取,内部其他系统RPC调用等等。时间一长,维护的成本就会越来越高。各种硬代码判断,分支条件越来越多。代码的抽象,复用率也越来越低,各个模块之间的耦合度很高。

BADAO_LIUMANG_QIZHI的博客 5842

LiteFlow规则引擎的入门

LiteFlow是一个非常强大的现代化的规则引擎框架,融合了编排特性和规则引擎的所有特性。利用LiteFlow,你可以将瀑布流式的代码,转变成以组件为核心概念的代码结构,这种结构的好处是可以任意编排,组件与组件之间是解耦的,组件可以用脚本来定义,组件之间的流转全靠规则来驱动。LiteFlow拥有开源规则引擎最为简单的DSL语法。十分钟就可上手。详细可见官网:https://liteflow.yomahub.com/组件其实就是一个Bean,继承LiteFLow提供的不同NodeComponent。

static_coder的博客 7758

跟着团子学SAP PS:BOM和项目结构的联动-BOM Transfer CN33

关于项目中的物料组件挂接你需要了解的一点功能

Lucas1211的博客 2万+

Snort源代码编译 _ 采坑之旅(for Windows VS2015)

    系统环境:Windows7 sp1 x64     编译环境:VS2015 SP1     Snort版本:2.9.12     daq版本:2.0.6     Snort官网:https://www.snort.org/downloads#snort-downloads 背景     最近需要实现一个类似网络防火墙的产品,主要参考Snort源码,先花了点时间简单读了下网上比较流行的《...

magictong的专栏 8891

规则引擎选型:LiteFlow、Easy-Rules、Aviator与Groovy的定位与组合

规则引擎是软件工程中常被误读的概念,业界常将流程编排、规则匹配、表达式计算与动态语言统称为规则引擎,但它们在架构分层中扮演着截然不同的角色。理解其底层原理对技术选型至关重要:LiteFlow专注流程编排,Easy-Rules实现标准规则匹配,Aviator擅长高性能表达式求值,Groovy则提供完整的脚本自由度。在优惠计算、风控校验、业务流程编排等真实场景中,单一工具往往难以覆盖全部需求,合理组合这些技术才能平衡性能、维护成本与灵活性。本文从概念分层出发,剖析四类引擎的底层设计、适用边界及实战误区,并结合营

weixin_29234509的博客 182

三运放仪表放大器电路设计全解析:从原理到PCB布局避坑指南

本文深度解析三运放仪表放大器电路设计,从差分放大器原理演进到经典三运放架构,详细阐述了其高共模抑制比(CMRR)和高输入阻抗的核心优势。文章重点剖析了电阻匹配、PCB布局对称性等关键设计要点对性能的影响,并提供了基于LTspice的仿真分析与从原理图到PCB布局、焊接调试的全流程实战避坑指南,助力实现高精度信号调理。

redis7keeper的博客 789

RuoYi-Vue-Plus:快速搭建 Java 多租户管理后台的完整实战指南

RuoYi-Vue-Plus 是一个 Java 多租户管理后台框架,后端基于 Spring Boot,官方前端为 Vue 3。多租户隔离、权限体系、审批工作流都是内置能力,适合需要快速交付管理后台、且要考虑多企业或审批场景的团队。 ## 定位与适用场景 这个框架的定位很明确:一套自带多租户(即一套系统服务多个独立企业)能力的完整 Java 管理后台。结合项目实际形态,它适合三类落地场景。 第

gitblog_00569的博客 1032

Zabbix故障排查10051端口无法启动:zabbix-server.service: main process exited, code=exited, status=1/FAILURE

zabbix-server.service: main process exited, code=exited, status=1/FAILURE报错说与数据库失去连接。

" DevOps菜鸟(Xu JieHao)" 的博客 2258

KylinOS 离线安装 MinIO【图文步骤】

在国产操作系统 KylinOS 中安装 MinIO,详细步骤...

甘蓝的专栏 1538

从MCP/CLI到编排层:Agent产品如何从工具集合走向完整工作流

在Agent开发中,MCP(Model Context Protocol)与CLI常被视作连接模型与外部能力的标准接口,它们解决了工具调用的标准化问题,但本身并不包含业务逻辑与流程控制。实际落地时,开发者往往发现单次调用成功并不等于任务稳定跑通,状态管理、分支跳转、失败重试和上下文传递等关键能力缺失,导致从工具集合到产品体验之间存在巨大鸿沟。Agent框架与编排技术正是为此而生,LangChain等框架提供决策层支持,LiteFlow等规则引擎则强化确定性控制,二者与MCP/CLI协同,才能让多步骤任务具备

weixin_34195142的博客 426

RuoYi-Vue-Plus 快速上手:如何一步搭出多租户后台管理系统

RuoYi-Vue-Plus 是一套面向 Java 开发者的开源多租户后台管理框架,基于 Spring Boot 构建。多租户隔离、工作流审批、分布式任务调度开箱即带,适合做 SaaS、企业内部系统,或想快速拿到一套可二次开发后端模板的人。 ## 一、跑起来:三步把 RuoYi-Vue-Plus 跑起来 🚀 **环境清单**(缺一样都启动不了): - **JDK 17 或 21**:项目按

gitblog_00941的博客 892

YOLOv8源码解析与复现:ShuffleAttention:高效的混合注意力机制 实现通道和空间混合注意力

随着深度学习在计算机视觉领域的飞速发展,卷积神经网络(CNNs)已经成为图像分类、目标检测、语义分割等任务的核心。为了进一步提升模型的性能,研究者们引入了“注意力机制”,旨在让网络能够动态地关注输入数据中最具信息量的部分。经典的注意力模块,如SE-Net(Squeeze-and-Excitation Networks)和CBAM(Convolutional Block Attention Module),通过通道注意力或结合通道与空间注意力,显著增强了模型的特征表达能力。

FJN110的博客 556

TRAE智能体开发:TRAE概述

TRAE(/treɪ/)深度融合 AI 能力,是一名能够理解需求、调用工具并独立完成各类开发任务的“AI 开发工程师”,帮助你高效推进每一个项目。

王国平的博客 1288

如何快速上手 RuoYi-Vue-Plus:企业级后台管理系统的完整开发与避坑指南

RuoYi-Vue-Plus 是面向分布式集群场景的多租户后台管理系统,重写自 RuoYi-Vue,内置 Sa-Token 认证、MyBatis-Plus 持久层、Warm-Flow 工作流与 SnailJob 任务调度,一套代码即可覆盖审批流、定时任务与多端登录。 ## 🎯 它解决什么问题 写过 RuoYi 的同学大概都有过两个抱怨:模块之间互相注入,想拆掉一块功能得满项目找引用;登录、权

gitblog_01055的博客 543

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

MAA MaaAssistantArknights 完整教程:一键长草,跑完明日方舟全部日常

打开《明日方舟》要做的第一件事,往往是访问好友、收信用、购物、刷理智、换基建——这一串点完不短,漏了任何一项当天的收益都打折扣。MAA(MaaAssistantArknights)是一款基于图像识别的免费明日方舟自动化助手:勾选一份任务清单,这些机械操作由它替你点完,你只负责验收结果。本文从零讲清如何第一次跑通,再按痛点拆解它的真实能力、底层原理与 CLI 进阶用法,最后附一份排查手册。 它适合

gitblog_01002的博客 184

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

liteFlow开发应用搭建

1.引入依赖2.配置配置文件路径3.配置组件节点 继承 NodeComponent4.配置节点执行顺序 配置 flow.el.xml5.启动流程@Resource。

ftftftf的博客 5610

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

规则引擎——LiteFlow入门

见上文组件nodeName = "XXX拆分实绩数据")log.info("发送给XXX混匀拆分实绩数据:{}",JSON.toJSONString(mixSupActualVOList));nodeName = "发送BBB实绩", nodeType = NodeTypeEnum.COMMON)log.info("发送BBB供料实绩:{}",JSON.toJSONString(supplyActualDTO));

weixin_44420750的博客 3864

规则引擎LiteFlow

LiteFlow是一款基于规则的开源规则引擎,可以帮助开发者快速构建和管理规则,并实现业务逻辑自动化。LiteFlow的设计原则是简单、易用、高效,它提供了一系列功能和API,使得规则的创建和管理变得更加简单和直观。

weixin_42483817的博客 3829

LiteFlow规则引擎入门(结合mysql)

通常在项目开发过程中,对于一个具体的业务流程,可能需要若干个步骤(节点)协同完成,节点间存在上下文依赖,且根据不同的业务要求,节点的逻辑执行顺序可能会发生调整.那么对于可以复用的节点只是因为业务需求不同而发生了执行顺序的不同,为了灵活的满足业务需求,可以使用规则引擎进行灵活调度.比如一件事需要经历5个步骤,每个步骤的逻辑依赖各自的上执行结果(共享上下文),而这5个步骤彼此间做的事情又是独立的,经过执行顺序的变化可以满足一系列的业务要求.那么可以使用规则引擎.工人只需要关心自己的工作内容和工作台上的资源。

jyf13627039090的博客 3987

SpringBoot——LiteFlow引擎框架

LiteFlow是一个轻量且强大的国产规则引擎框架,可用于复杂的组件化业务的编排领域。帮助系统变得更加丝滑且灵活。利用LiteFlow,你可以将瀑布流式的代码,转变成以组件为核心概念的代码结构,这种结构的好处是可以任意编排,组件与组件之间是解耦的,组件可以用脚本来定义,组件之间的流转全靠规则来驱动。LiteFlow拥有开源规则引擎最为简单的DSL语法。LiteFlow官网LiteFlow于2020年正式开源,2021年获得开源中国年度最受欢迎开源软件殊荣。于2022年获得Gitee最有价值开源项目GVP。

程序猿进阶 7907

【LiteFlow】LiteFlow 组件式规则引擎

LiteFlow规则引擎

lushixuan12345的博客 2400

Spring Boot3集成 LiteFlow 实现业务流程编排

LiteFlow 是一个基于 Java 的流程编排框架,它允许开发者定义一系列的节点(Node)和流程(Flow),通过这些节点和流程来控制业务逻辑的执行顺序。LiteFlow 的核心思想是将复杂的业务逻辑分解成多个小的、可管理的部分,每个部分负责处理特定的任务。

江南一点雨的专栏 4639
上一篇: hystrix原理及使用
像风琢磨不住
博客等级 码龄6年 34粉丝 12原创
评论 13
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值