五、规则引擎设计

一、规则引擎定义(what)

1.业务规则是由一组条件和在该条件下的一个或多个操作组成

2.规则引擎是嵌入在应用程序中的组件(是什么)，将业务决策从应用程序代码中分离出来，并使用预定义的语义模块编写业务决策(做什么)，接受数据输入，解释业务规则，并根据规则做出业务决策(怎么用)

二、规则引擎使用优势(why)

• 告别复杂的if esle语句,提高代码的阅读性

• 规则引擎下，规则便于维护、测试、扩展、更新

三、规则引擎使用场景(who、when、where)

开发系统的过程中，经常需要处理大量的业务规则，主要有以下场景：

1.业务规则频繁变化，需要开发人员自行扩展

2.业务规则支持优先级，有的规则先执行，有的规则后执行

3.业务规则循序排他规则，当执行到某种规则，可以立刻结束

4.业务规则可以重复执行，便于代码复用

四、规则引擎设计原理和流程图

原理

规则引擎组成部分：规则定义、规则管理、规则执行器管理、规则匹配、规则决策

流程图

类图

五、规则引擎实践(how)

/**RuleTest**/
import junit.framework.TestCase;
import java.util.HashMap;

public class RuleTest  extends TestCase {

    public void testTimeRule() {
        TimeRuleHandler timeRuleHandler = new TimeRuleHandler();
        TimeRule rule = new TimeRule();
        HashMap param = null;
        rule.setParam(param);
        timeRuleHandler.setCode(TimeRuleEnum.TIME_RULE_SEPARATE.getType());
        timeRuleHandler.handleMessage(rule);
    }
}


/**TimeRuleEnum**/
public enum TimeRuleEnum {
    //"json time plan"
    TIME_RULE_JSON(0),
    //"separate time plan"
    TIME_RULE_SEPARATE(1);
    private int type;

    TimeRuleEnum(int type) {
        this.type = type;
    }

    public Integer getType() {
        return type;
    }

    public void setType(int type) {
        this.type = type;
    }
}

/**TimeRuleHandler**/

import java.util.HashMap;
import java.util.Optional;

public class TimeRuleHandler extends RuleHandler {

    @Override
    public Boolean apply(ITimeRule rule) {
        int type = rule.getType();
        HashMap params = rule.getParam();
        if (!Optional.ofNullable(params).isPresent()) {
            System.out.println("error:param is null");
            return false;
        }
        if (TimeRuleEnum.TIME_RULE_JSON.getType().equals(this.getCode())) {
            // TODO json数据结构的时间规则
            System.out.println("json数据结构的时间规则 success");
            return true;
        } else if (TimeRuleEnum.TIME_RULE_SEPARATE.getType().equals(this.getCode())){
            // TODO 解析拆分数据结构的时间规则
            System.out.println("拆分数据结构的时间规则 success");
            return true;
        } else {
            System.out.println("error:not such rule");
            // TODO 没有此类时间规则
            return false;
        }

    }
}

/**RuleHandler**/

import java.util.Optional;
public abstract class RuleHandler {
    private Integer code;
    private RuleHandler nextHandler;

    public void handleMessage(ITimeRule rule) {
        if (apply(rule)) {
            if (Optional.ofNullable(this.getNextHandler()).isPresent()) {
                this.getNextHandler().handleMessage(rule);
            } else {
                rule.execute(rule.getParam());
            }
        }
    }

    public void setNextHandler(RuleHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public RuleHandler getNextHandler() {
        return nextHandler;
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public abstract Boolean apply(ITimeRule rule);
}


/**TimeRuleExecutor**/
import lombok.Data;

import java.util.HashMap;

@Data
public class TimeRule implements ITimeRule {
    private Integer type = 0;
    private HashMap param;

    @Override
    public void execute(HashMap params) {
        // TODO do final decision
    }
}

/**ITimeRule**/

import java.util.HashMap;

public interface ITimeRule {
    Integer getType();

    HashMap getParam();

    void execute (HashMap params);
}