LiteFlow 引擎框架

      if ("618".equals(day)){

            System.out.println("668");

        }else if ("11.11".equals(day)){

            System.out.println("888");

        }else if ("12.12".equals(day)){

            System.out.println("180");

        }else{

            System.out.println("998");

        }

public interface NodeComponent {

  void  process() ;

}

@Component

public class AComponent extends NodeComponent {

    @Override

    public void process() {

        /**

         * 这里逻辑省略
         * 
         */
        System.out.println("618");
    }
}
@Component
public class BComponent extends NodeComponent {
    @Override
    public void process() {
        /**
         * 这里逻辑省略
         * 
         */
        System.out.println("11.11");
    }
}
//下面省略12.12

//主流程

@Component

public class TestFlow {

    @Resource

    private Map<String, NodeComponent> map;

    public void run(String name) throws Exception {

        for (Map.Entry<String, NodeComponent> entry : map.entrySet()) {

            String key = entry.getKey();

            if (StringUtils.equals(name,key)){

                entry.getValue().process();

            }

        }

    }

}

     <dependency>

          <groupId>com.yomahub</groupId>

            <artifactId>liteflow-spring-boot-starter</artifactId>

            <version>${project.parent.version}</version>

        </dependency>

@Component("a")

public class AComponent extends NodeComponent {

    @Override

    public void process() {

        String str = this.getSlot().getRequestData();

        System.out.println(str);

        System.out.println("Acomponent executed!");

        this.getSlot().setOutput(this.getNodeId(), "A component output");

    }

}

@Component("b")

public class BComponent extends NodeComponent {

    @Override

    public void process() {

        try {

            Thread.sleep(400L);

            String[] temp = new String[1000];

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        System.out.println("Bcomponent executed!");

    }

}

@Component

public class TestFlow{

    @Resource

    private FlowExecutor flowExecutor;

    @Override

    public void run(String... args) throws Exception {

        Slot slot = flowExecutor.execute("chain3", "it's a request");

        System.out.println(slot);

    }

}

<?xml version="1.0" encoding="UTF-8"?>

<flow>

    <chain name="chain1">

        <then value="a,cond(b|d)"/> <!-- cond是条件节点，根据cond里的逻辑决定路由到b节点还是d节点,可以配置多个 -->

        <then value="e,f,g"/>

    </chain>

    <chain name="chain2">

        <then value="a,c"/> <!-- then表示串行 -->

        <when value="b,d"/> <!-- when表示串行 -->

        <then value="e,f,g"/>

    </chain>

</flow>

liteflow.rule-source=config/flow.xml

#------以下非必须-------

#slot的数量，默认值为1024

liteflow.slot-size=2048

#异步线程最长的等待时间秒(只用于when)，默认值为15

liteflow.when-max-wait-second=20

#是否开启监控log打印，默认值为false

liteflow.monitor.enable-log=true

#监控队列存储大小，默认值为200

liteflow.monitor.queue-limit=300

#监控一开始延迟多少执行，默认值为300000毫秒，也就是5分钟

liteflow.monitor.delay=10000

#监控日志打印每过多少时间执行一次，默认值为300000毫秒，也就是5分钟

liteflow.monitor.period=10000

1) 引入依赖

2) 定义流程节点继承NodeComponent 

3) 注入:   

      @Resource 

      private FlowExecutor flowExecutor;

4)application.properties:

      liteflow.rule-source=config/flow.xml