• LiteFlow浅谈

    目录

    1 简述

    2 组件

    2.1 一般组件

    2.2 分支组件

    3 上下文

    4 规则

    1 简述

    LiteFlow是一个组件式开发的框架。目前Gitee Star 2.7K。

    先放上项目地址：https://gitee.com/dromara/liteFlow?_from=gitee_search

    和项目文档：https://liteflow.yomahub.com/pages/5816c5/

    所有的框架，使用过程基本类似——提供注解或者基础包，开发者基于注解或者包+业务流程进行开发。代码写好后，一旦业务流程发生变更，就要改代码。很麻烦。

    所以LiteFlow出现了。当我们以适当的粒度拆分了业务组件，我们就可以基于LiteFlow的规则引擎进行各种各样的编排，以实现业务需求。

    整体来说，LiteFlow可以用以下式子来概括：

            LiteFlow=组件+上下文+规则

    那么下面我们对每一部分进行说明。

    2 组件

    组件是LiteFlow的基础。LiteFlow中有两种组件，分别是

    NodeComponent 一般组件和 NodeSwitchComponent 分支组件。

    分别对应我们程序中使用的顺序结构中的代码和判断结构中的判断代码。

    当需要有条件的决定组件的使用顺序时，NodeSwitchComponent就派上用场了。

    在代码实现上，我们可以基于继承或者仅基于注解两种方式来定义组件，这里我给两个基于继承的例子，基于注解方式的小伙伴们可以看文档。代码里不仅仅是声明，还包含了一些其他的知识点，小伙伴们可以边看代码边查文档，了解下自己感兴趣的部分。

    2.1 一般组件

    1. import com.example.demo.config.MyContext;
    2. import com.example.demo.vo.BasicParam;
    3. import com.yomahub.liteflow.annotation.LiteflowComponent;
    4. import com.yomahub.liteflow.core.NodeComponent;
    5.  
    6. @LiteflowComponent(id = "channelSelector", name = "渠道余量最大选择器")
    7. //失败重试 @LiteflowRetry(retry = 5, forExceptions = {NullPointerException.class,IllegalArgumentException.class})
    8. public class ChannelSelectorCmp extends NodeComponent {
    9.     @Override
    10.     public void process() throws Exception {
    11.         MyContext context = this.getFirstContextBean();
    12.         BasicParam requestData = this.getRequestData();
    13.         context.setInfo(context.getInfo()+":channelSelector:"+requestData.getBula());
    14.         //throw new Exception("test");
    15.  
    16.  
    17.         //隐式流程
    18.         //隐式调用可以完成更为复杂的子流程，比如循环调用，复杂条件判断等等。隐式子流程需要你在组件里通过this.invoke这个语句来调用。
    19.         for(int i=0;i<10;i++){
    20.             this.invoke("channelSelector2","隐式流程的初始参数，可为null");
    21.             //可以使用invoke2Resp进行带返回值的请求
    22.             //隐式流程在组件中拿到传入的请求参数，通过this.getSubChainReqData()去拿，用this.getRequestData()是拿不到的
    23.         }
    24.  
    25.         //私有投递
    26.         for (int i = 0; i < 5; i++) {
    27.             this.sendPrivateDeliveryData("b",i+1);
    28.             //Integer value = this.getPrivateDeliveryData(); //内部使用队列实现
    29.         }
    30.  
    31.     }
    32. }

    2.2 分支组件

    1. import com.example.demo.config.MyContext;
    2. import com.yomahub.liteflow.annotation.LiteflowComponent;
    3. import com.yomahub.liteflow.core.NodeSwitchComponent;
    4. import com.yomahub.liteflow.slot.Slot;
    5.  
    6. import java.util.Random;
    7.  
    8. @LiteflowComponent(id = "if_1", name = "业务判断1")
    9. public class IF1SwitchCmp extends NodeSwitchComponent {
    10.  
    11.     /**
    12.      * 表示是否进入该节点，可以用于业务参数的预先判断
    13.      * @return
    14.      */
    15.     @Override
    16.     public boolean isAccess() {
    17.         return super.isAccess();
    18.     }
    19.  
    20.     @Override
    21.     public String processSwitch() throws Exception {
    22.  
    23.         //获取上下文
    24.         MyContext firstContextBean = (MyContext)getFirstContextBean();
    25.         //获取当前执行流程名称
    26.         String chainName = getChainName();
    27.  
    28.         //是否立即结束整个流程
    29.         setIsEnd(false);
    30.  
    31.         //模拟业务耗时
    32.         int time = new Random().nextInt(1000);
    33.         Thread.sleep(time);
    34.  
    35.         //这里写死跳到并行获取剩余量那条分支，你可以改成其他分支测试
    36.         return "branch1";
    37.     }
    38.  
    39.  
    40.     @Override
    41.     public boolean isContinueOnError() {
    42.         return super.isContinueOnError();
    43.     }
    44.  
    45.  
    46.     @Override
    47.     public  void beforeProcess(String nodeId, Slot slot) {
    48.         super.beforeProcess(nodeId, slot);
    49.     }
    50.  
    51.  
    52.     @Override
    53.     public  void afterProcess(String nodeId, Slot slot) {
    54.         super.afterProcess(nodeId, slot);
    55.     }
    56.  
    57.     @Override
    58.     public void onSuccess() throws Exception {
    59.         super.onSuccess();
    60.     }
    61.  
    62.     @Override
    63.     public void onError() throws Exception {
    64.         super.onError();
    65.     }
    66.  
    67.  
    68.  
    69. }

    3 上下文

    仔细的小伙伴可能注意到了，上面组件定义的代码中有这样一句

    1. //获取上下文
    2. MyContext firstContextBean = (MyContext)getFirstContextBean();

    这个就是获取上下文， MyContext是自定义的一个类，用来存放组件共用的数据，是在工作流刚开始执行的时候定义的。定义的代码如下：

    1. import com.example.demo.config.MyContext;
    2. import com.example.demo.vo.BasicParam;
    3. import com.yomahub.liteflow.core.FlowExecutor;
    4. import com.yomahub.liteflow.enums.FlowParserTypeEnum;
    5. import com.yomahub.liteflow.flow.FlowBus;
    6. import com.yomahub.liteflow.flow.LiteflowResponse;
    7. import com.yomahub.liteflow.flow.entity.CmpStep;
    8. import org.slf4j.Logger;
    9. import org.slf4j.LoggerFactory;
    10. import org.springframework.boot.CommandLineRunner;
    11. import org.springframework.stereotype.Component;
    12.  
    13. import javax.annotation.Resource;
    14. import java.util.Map;
    15. import java.util.Queue;
    16.  
    17. @Component
    18. public class ChainExecute implements CommandLineRunner {
    19.  
    20.     private static final Logger log = LoggerFactory.getLogger(ChainExecute.class);
    21.  
    22.     @Resource
    23.     private FlowExecutor flowExecutor;
    24.  
    25.     @Override
    26.     public void run(String... args) throws Exception {
    27.         //第二个参数为流程入参，示例中没用到，所以传null，实际业务是有值的
    28.         //上下文可以使用多个
    29.         BasicParam basicParam=new BasicParam();
    30.         basicParam.setBula("bula");
    31.         LiteflowResponse response = flowExecutor.execute2Resp("channelSenderChain", basicParam, MyContext.class);
    32.         MyContext context = response.getFirstContextBean();
    33.         /*if (response.isSuccess()){
    34.             log.info("Result{}", context.getInfo());
    35.             System.out.println(context.getInfo());
    36.         }else{
    37.             log.error("执行失败", response.getCause());
    38.             System.out.println(response.getCause().getMessage());
    39.         }*/
    40.  
    41.         //获取执行队列，相同步骤仅有一个定义
    42.         /*Map stepMap = response.getExecuteSteps();
    43.         stepMap.forEach((s, cmpStep) -> {
    44.             System.out.println(s);
    45.         });*/
    46.  
    47.         //相同步骤保留多个定义
    48.         Queue stepQueue = response.getExecuteStepQueue();
    49.  
    50.  
    51.         //获取步骤字符串
    52.         System.out.println(response.getExecuteStepStr());
    53.  
    54.         //平滑热刷新，会按启动时的方式取拉取最新的流程配置信息
    55.         flowExecutor.reloadRule();
    56.  
    57.         //基于规则文件被动刷新
    58.         FlowBus.refreshFlowMetaData(FlowParserTypeEnum.TYPE_EL_XML, "规则文件");
    59.  
    60.         //其实基于动态代码构建的，建议你把动态代码构建的代码封装成一个方法。
    61.         // 有变动时，再重新执行一遍构建就可以了。会重新覆盖的。并且这一过程，也是平滑的。
    62.  
    63.  
    64.     }
    65. }

    注意这里这段代码，就是定义上下文，这里实际上只是传了一个class，如果想在工作流初始就传递一些数据，可以使用代码里basicParam定义的部分。

    flowExecutor.execute2Resp("channelSenderChain", basicParam, MyContext.class);

    4 规则

    这里规则就是LiteFlow的灵魂了。LiteFlow提供了十分灵活的组件定义方式，XML、Json都是支持的。这里给一个截取自官网的例子

    2. <flow>
    3.     <nodes>
    4.         <node id="s1" name="普通脚本" type="script">
    5.             
    6.                 a=3;
    7.                 b=2;
    8.                 defaultContext.setData("s1",a*b);
    9.             ]]>
    10.         node>
    11.  
    12.         <node id="s2" name="条件脚本" type="switch_script">
    13.             
    14.                 count = defaultContext.getData("count");
    15.                 if(count > 100){
    16.                     return "a";
    17.                 }else{
    18.                     return "b";
    19.                 }
    20.             ]]>
    21.         node>
    22.     nodes>
    23.  
    24.     <chain name="chain1">
    25.         THEN(a, b, c, s1)
    26.     chain>
    27.  
    28.     <chain name="chain2">
    29.         THEN(d, SWITCH(s2).to(a, b)
    30.     chain>
    31. flow>

    这里我们注意到里边的THEN和SWICH，分别就是我们在最上面定义的一般组件和分支组件了。

    这里我对LiteFlow提供的规则进行了12条总结：

    1. "#1": "串行 then(a,b,c,d)",
    2. "#2": "并行 when(a,b)",
    3. "#3": "忽视串行中节点错误，c仍然会执行 then(s,when(a,b).ignoreError(true),c)",
    4. "#4": "a,b任意一分支执行完则忽略其他分支，继续执行c then(s,when(a,b).any(true),c)",
    5. "#5": "选择执行 SWITCH(a).to(b,c,d),a的返回值只能取bcd",
    6. "#6": "可以使用.id()来给任意组件设置ID，这在switch和then配合使用时很有用，SWITCH(s).to(a,b,THEN(c,d).id('testId'))",
    7. "#7": "可以使用变量和子流程来简化流程",
    8. "#8": "EL方式中注释和js中相同",
    9. "#9": "可以使用node(特殊标签名)来方便处理自动生成的标签名 then(a,node(b))",
    10. "#10": "前置节点ab会先执行 THEN(PRE(a,b),c)，可以声明在第一层的任意位置，如果在子流程中使用，则只会对子流程生效",
    11. "#11": "后置节点即时节点出错也会执行，THEN(a,b,FINALLY(c))，可以声明在第一层的任意位置，如果在子流程中使用，则只会对子流程生效",
    12. "#12": "相同组件编排时可以使用tag()打标签，在NodeComponent实例.getTag()获取，THEN(a.tag('1'),a.tag('2'))"

    好了，浅谈就到这里。有用的话点个赞呗。

  • 相关阅读:
    实现常驻任务除了避免昙花线程，还需要避免重返线程池
    MySql触发器使用
    Java---Stream进阶
    EXPLIAN查询type
    tomcat部署 虚拟主机配置和多实例部署
    如何把 SAP ABAP 系统里一张数据库表的内容，显示在 Adobe PDF Form 里
    【vue3+ts】@设置别名
    无法加载文件 D:\nodejs\node_global\vue.ps1
    java项目技术方案——书写示例
    基于 selenium 实现网站图片采集
  • 原文地址：https://blog.csdn.net/zcy_wxy/article/details/126353394