规则引擎

特性

• 规则配置简单，上手容易
• 屏蔽复杂的数据库，打造一套轻量级的流程引擎
• 支持基于状态机的工作流
• 扩展性高，插件丰富

快速上手

1、 项目的pom.xml中引入maven配置

<dependency>
	<groupId>com.hbasesoft.framework</groupId>
	<artifactId>framework-rule-file</artifactId>
	<version>${project.parent.version}</version>
</dependency>

2、编写规则文件,并存放在src/resources/META-INF/rules/目录下

demo.json

{
    "name": "demo", 
    "version": "1.0",
    "children": [
        {
            "component": "Child01Component"
        },
        {
            "component": "Child02Component"
        },
        {
            "component": "Child03Component"
        }
    ]
}

3、流程组建继承com.hbasesoft.framework.rule.core.FlowComponent， 并注入进Spring 容器

Child01Component.java

@Component("Child01Component")
public class Child01Component implements FlowComponent<FlowBean> {

    @Override
    public boolean process(final FlowBean flowBean, final FlowContext flowContext) throws Exception {
        System.out.println("---------Child01Component----------");
        return true;
    }

}

4、调用com.hbasesoft.framework.rule.core.FlowHelper.flowStart(FlowBean, String)方法启动流程

TestFlow.java

@Test
public void flowStart() {
    FlowBean flowBean = new FlowBean();
    FlowHelper.flowStart(flowBean, "demo");

}

插件使用

规则流程自由定义各种插件，framework-rule-core包中已经包含3个插件

• CodeMatchInterceptor 匹配code的插件，匹配到继续执行，匹配不到跳过
• ConditionInterceptor 条件判断插件，判断规则使用spring的SpelExpressionParser来实现的
• ToolsInterceptor 在规则文件中可以使用各种工具类插件

1、使用前需要将插件注入Spring容器

ConfigBean.java

@Configuration
public class ConfigBean {
    /** 注入Code Match插件*/
    @Bean
    public CodeMatchInterceptor codeMatchInterceptor() {
        return new CodeMatchInterceptor("code", "type");
    }
    ....
}

2、在规则文件中使用插件

demo.json

{
    "name": "demo", 
    "version": "1.0",
    "children": [
        {
            "code": "1001"
            "component": "Child01Component"
        },
        {
            "code": "1002",
            "type": "A",
            "component": "Child02Component"
        },
        {
            "component": "Child03Component"
        }
    ]
}

另外框架中还提供了framework-rule-plugin-event、framework-rule-plugin-transaction、framework-rule-plugin-stateMachine插件模块

插件的编写

插件需要实现com.hbasesoft.framework.rule.core.FlowComponentInterceptor 接口

public interface FlowComponentInterceptor extends Comparable<FlowComponentInterceptor> {

     // 流程执行前扩展
    default boolean before(Serializable flowBean, FlowContext flowContext) {
        return true;
    }
    
    // 流程执行后扩展
    default void after(Serializable flowBean, FlowContext flowContext) {
    }
    
    // 流程执行失败的扩展
    default void error(Exception e, Serializable flowBean, FlowContext flowContext) {
    }

}

基于状态机的工作流

1、引入framework-rule-plugin-stateMachine 状态机模块

<dependency>
	<groupId>com.hbasesoft.framework</groupId>
	<artifactId>framework-rule-plugin-stateMachine</artifactId>
	<version>${project.parent.version}</version>
</dependency>

2、在规则文件上增加stateMachine属性的配置，注意stateMachine可以放在整个规则文件的任何节点上，并不一定要至于最顶层。

stateMachine.json

{
    "name": "stateMachine",
    "version": "1.0",
    "begin": "B",      // 状态机启动时会分配一个初使状态  （必填）
    "end": "D,E",     // 当流程Bean状态为D、E两种时，状态机就会停止，不在执行 （必填）
    "error": "E",      // 当流程里面未定义错误状态，统一状态为E （必填）
    "stateMachine": {
        "A": [{          // 当状态为A时    （必填）
                "event": "e1",    // 当进行e1操作时   （必填）
                "end": "C",       // 成功后状态为C     （必填）
                "children": [{
                        "component": "Child02Component",
                        "children": [{
                            "component": "DemoComponent"
                        }]
                    },
                    {
                        "component": "Child01Component",
                        "children": [{
                            "component": "Child03Component"
                        }]
                    }
                ]
            },
            {
                "event": "e2",     // 当进行e2操作时 （必填）
                "end": "D",         // 成功后状态为D     （必填）
                "error": "1001=C, 1002=D, *=E",    // 错误时，对应1001错误码，状态为转向C；1002错误码，状态会转向D，其他错误转向为E      （选填）
                "component": "Child02Component"
            }
        ],
        "B": [{            // 当状态为B时     （必填）
            "event": "e1",     // 可以执行e1操作     （必填）
            "end": "A",       // 成功后状态为A        （必填）
            "component": "Child02Component"
        }], 
        "C": [{        // 当状态为C时     （必填）
            "event": "e1",     //可以执行e1操作     （必填）
            "end": "D",    //  成功后状态为D       （必填）
            "component": "Child01Component"
        }]
    }
}

3、流程bean必须继承 com.hbasesoft.rule.plugin.statemachine.StateMachineFlowBean

StateMachineFlowBean.java

public interface StateMachineFlowBean extends Serializable {
    String getEvent();   //获取操作事件
    String getState();   // 获取当前状态
    void setState(String state);  // 执行完成后设置状态
}

案例：

TestFlow.java

@Test
public void testStateMachineBean() {
    TestStateMachineBean bean = new TestStateMachineBean();
    bean.setEvent("e1");
    System.out.println(JSONObject.toJSONString(bean));
    int result = FlowHelper.flowStart(bean, "stateMachine");
    System.out.println(result);
    System.out.println(JSONObject.toJSONString(bean));
    result = FlowHelper.flowStart(bean, "stateMachine");
    System.out.println(result);
    System.out.println(JSONObject.toJSONString(bean));
    result = FlowHelper.flowStart(bean, "stateMachine");
    System.out.println(result);
    System.out.println(JSONObject.toJSONString(bean));
}

其他说明

• FlowHelper里面提供多种启动方式，规则可以从文件中读取，也可以执行传入一个json对象，这样就可以把规则存储在数据库中
• stateMachine并未管理状态的存储，实际的场景下大家根据项目需要自己存储状态
• FlowComponent 的process方法包含了一个FlowContext 上下文，里面可以获取规则配置里面的各种属性，为了防止过程参数污染flowbean，多个组件件的消息传递可以通过FlowContext的paramMap来实现