springboot + easyRules 搭建规则引擎服务
依赖
<dependency>
<groupId>org.jeasy</groupId>
<artifactId>easy-rules-core</artifactId>
<version>4.0.0</version>
</dependency>
<dependency>
<groupId>org.jeasy</groupId>
<artifactId>easy-rules-mvel</artifactId>
<version>4.0.0</version>
</dependency>
<dependency>
<groupId>org.jeasy</groupId>
<artifactId>easy-rules-spel</artifactId>
<version>4.0.0</version>
</dependency>
输入
为更灵活的发挥规则引擎的功能，输入可以使用JSONObject，这样增删改字段无需修改代码。
输出
@Data
public class RuleResult {
/**
* 规则主键
*/
Long ruleId;
/**
* 规则名
* 默认false
*/
boolean isMatch = false;
/**
* 规则名
*/
String value;
/**
* 满足规则后执行
*/
public void setValue(String msg){
this.value = msg;
this.isMatch = true;
}
}
规则引擎本身的目的是为了业务与开发解耦，因此只输出是否满足规则，至于满足规则后要干什么业务，这个就是调用方的事。
简单的测试
@Test
void jsonExpressionTest() {
// 输入项
JSONObject dataSource = new JSONObject();
dataSource.put("name","大帅比");
dataSource.put("age",18);
// 结果
RuleResult result = new RuleResult();
// 规则实例
Facts facts = new Facts();
facts.put("fact",dataSource);
facts.put("result",result);
// when
String when = "fact.get(\"name\")==\"大帅比\"";
// then
String then = "result.setValue(\"确实帅\");";
// 规则内容
Rule testModeRule = new MVELRule()
.name("test rule")
.description("rule for test")
.when(when)
.then(then);
// 规则集合
Rules rules = new Rules();
// 将规则添加到集合
rules.register(testModeRule);
//创建规则执行引擎，并执行规则
RulesEngine rulesEngine = new DefaultRulesEngine();
rulesEngine.fire(rules, facts);
log.info("result:{}",result.toString());
}
完善下，把规则抽象出来，最终的目的就是通过调用方传入的参数，生成when和then表达式；
规则
@Data
@ToString(callSuper = true)
@TableName("EXPRESSION_RULE")
public class ExpressionRule {
/**
* 主键
*/
Long id;
/**
* 规则分组
*/
String ruleGroup;
/**
* 规则标识（英文，且唯一）
*/
String ruleCode;
/**
* 规则名
*/
String ruleName;
/**
* 规则描述
*/
String ruleDescription;
/**
* 满足规则后的消息
*/
String message;
/**
* 规则表达式，通过conditionList生成
*/
String whenExpression;
/**
* 匹配规则操作表达式
*/
String thenExpression;
/**
* 创建人工号
*/
String creatUser;
/**
* 创建时间
*/
Date createTime;
/**
* 最近更新时间
*/
Date lastUpdateTime;
/**
* 最近更新人
*/
String lastUpdateUser;
/**
* 是否启用
*/
boolean isEnable;
/**
* 条件列表
*/
@TableField(exist = false)
List<ExpressionRuleCondition> conditionList;
}
规则下的条件
@Data
@ToString(callSuper = true)
@TableName("EXPRESSION_RULE_CONDITION")
public class ExpressionRuleCondition {
/**
* 主键
*/
Long id;
/**
* 主表ID
*/
Long masterId;
/**
* 左括号
* ( ~ (((((
*/
String leftBrackets;
/**
* 字段
*/
String field;
/**
* 操作
* 大于,小于,等于,不等于,包含,不包含，前缀，后缀
* > , < , ==, != , contains , !contains, startWith, endWith
*
*/
String operator;
/**
* 值字段类型
* 自定义输入 或 实体字段
* input , field
*/
String valueType;
/**
* 字段规则命中值
*/
String value;
/**
* 右括号
* ) ~ )))))
*/
String rightBrackets;
/**
* 多条件连接符号
* && ~ ||
*/
String link;
}
RuleUtils
@Slf4j
public class RuleUtils {
public static RuleResult match(JSONObject dataSource, ExpressionRule rule){
// 结果
RuleResult result = new RuleResult();
// 规则实例
Facts facts = new Facts();
facts.put("fact",dataSource);
facts.put("result",result);
// 规则内容
Rule mvelrule = new MVELRule()
.name(rule.getRuleName())
.description(rule.getRuleDescription())
.when(rule.getWhenExpression())
.then(rule.getThenExpression());
// 规则集合
Rules rules = new Rules();
// 将规则添加到集合
rules.register(mvelrule);
//创建规则执行引擎，并执行规则
RulesEngine rulesEngine = new DefaultRulesEngine();
rulesEngine.fire(rules, facts);
result.setRuleId(rule.getId());
return result;
}
}
新建规则
controller
@PostMapping("/addRule")
@ApiOperation("新增表达式规则")
public ResponseResult<Long> addRule(@RequestBody BaseRuleRo ruleRo){
return ruleService.addRule(ruleRo);
}
serviceImpl
/**
* 新增表达式规则
*/
@Override
@Transactional(rollbackFor = Exception.class)
public ResponseResult<Long> addRule(BaseRuleRo rule) {
ExpressionRule expressionRule = new ExpressionRule();
expressionRule.setId(ruleMapper.nextSque());
expressionRule.setCreateTime(new Date());
expressionRule.setEnable(true);
expressionRule.setRuleGroup(rule.getRuleGroup());
expressionRule.setRuleCode(rule.getRuleCode());
expressionRule.setRuleDescription(rule.getRuleDescription());
expressionRule.setRuleName(rule.getRuleName());
expressionRule.setMessage(rule.getMessage());
// 核心代码段
expressionRule.setWhenExpression(rule.getWhenExpression("fact"));
expressionRule.setThenExpression(rule.getThenExpression("result"));
// TODO 获取用户信息
// expressionRule.setCreatUser(userHandler.getUserName());
ruleMapper.insert(expressionRule);
// 条件表
List<ExpressionRuleCondition> conditionList = new ArrayList<>();
rule.getConditionRoList().forEach(condition->{
ExpressionRuleCondition expressionRuleCondition = new ExpressionRuleCondition();
expressionRuleCondition.setId(conditionMapper.nextSque());
expressionRuleCondition.setMasterId(expressionRule.getId());
expressionRuleCondition.setLeftBrackets(condition.getLeftBrackets());
expressionRuleCondition.setField(condition.getField());
expressionRuleCondition.setOperator(condition.getOperator());
expressionRuleCondition.setValueType(condition.getValueType());
expressionRuleCondition.setValue(condition.getValue());
expressionRuleCondition.setRightBrackets(condition.getRightBrackets());
expressionRuleCondition.setLink(condition.getLink());
conditionList.add(expressionRuleCondition);
});
conditionMapper.insertBatch(conditionList);
return ResponseResult.buildSucc(expressionRule.getId());
}
RO
@Slf4j
@Data
@ToString
public class BaseRuleRo {
/**
* 主键
*/
@ApiModelProperty(value = "id")
Long id;
/**
* 规则组
*/
@ApiModelProperty(value = "ruleGroup",required = true)
String ruleGroup;
/**
* 规则标识（英文，且唯一）
*/
@ApiModelProperty(value = "ruleCode",required = true)
String ruleCode;
/**
* 规则名
*/
@ApiModelProperty(value = "ruleName",required = true)
String ruleName;
/**
* 规则描述
*/
@ApiModelProperty(value = "ruleDescription",required = true)
String ruleDescription;
/**
* 条件
*/
@ApiModelProperty(value = "conditionRoList",required = true)
List<ConditionRo> conditionRoList;
/**
* 满足规则后可以带这个值
*/
@ApiModelProperty(value = "message",required = true)
String message;
/**
* 是否启用
*/
@ApiModelProperty(value = "isEnable")
boolean isEnable = true;
/**
* 条件表达式
*/
@ApiModelProperty(hidden=true)
@JsonIgnore
private String whenExpression;
/**
* 结果表达式
*/
@ApiModelProperty(hidden=true)
@JsonIgnore
private String thenExpression;
/**
* 组装when表达式
*/
public String getWhenExpression(String factAlias) throws UnSupportException {
StringBuilder expression = new StringBuilder();
conditionRoList.forEach(conditionRo -> {
expression
.append(conditionRo.leftBrackets)
.append(factAlias)
// 从JSON中取出字段值
.append(".get(\"")
.append(conditionRo.field)
.append("\")")
.append(conditionRo.getOperatorExpress(factAlias))
.append(conditionRo.rightBrackets)
.append(conditionRo.getLinkExpress());
});
log.info("whenExpression: {}",expression.toString());
return expression.toString();
}
/**
* 组装then表达式
* 不做太过灵活的操作，值返回是否命中规则，至于命中后改干什么业务代码自己实现
*/
public String getThenExpression(String resultAlias){
StringBuilder expression = new StringBuilder();
expression.append(resultAlias).append(".setValue(\"").append(message).append("\");");
log.info("thenExpression: {}",expression.toString());
return expression.toString();
}
}
@Data
@ToString(callSuper = true)
public class ConditionRo {
/**
* 左括号
* ( ~ (((((
*/
@ApiModelProperty(value = "leftBrackets",required = true)
String leftBrackets;
/**
* 字段
*/
@ApiModelProperty(value = "field",required = true)
String field;
/**
* 操作
* 大于,小于,等于,不等于,包含,不包含，前缀，后缀
* > , < , ==, != , contains , !contains, startWith, endWith
*
*/
@ApiModelProperty(value = "operator",required = true)
String operator;
/**
* 值字段类型
* 自定义输入 或 实体字段
* input , field
*/
@ApiModelProperty(value = "valueType",required = true)
String valueType;
/**
* 字段规则命中值
*/
@ApiModelProperty(value = "value",required = true)
String value;
/**
* 右括号
* ) ~ )))))
*/
@ApiModelProperty(value = "rightBrackets",required = true)
String rightBrackets;
/**
* 多条件连接符号
* && ~ ||
*/
@ApiModelProperty(value = "link",required = true)
String link;
/**
* 运算符表达式
*/
String getOperatorExpress(String factAlias) throws UnSupportException {
if(operator.equalsIgnoreCase(RuleOperation.OPERATOR_GREATER_THEN)){
return ">"+getValueExpress(factAlias);
}
if(operator.equalsIgnoreCase(RuleOperation.OPERATOR_LESS_THEN)){
return "<"+getValueExpress(factAlias);
}
if(operator.equalsIgnoreCase(RuleOperation.OPERATOR_QEUAL)){
return "=="+getValueExpress(factAlias);
}
if(operator.equalsIgnoreCase(RuleOperation.OPERATOR_UNQEUAL)){
return "!="+getValueExpress(factAlias);
}
if(operator.equalsIgnoreCase(RuleOperation.OPERATOR_CONTAIN)){
return ".contains("+getValueExpress(factAlias)+")";
}
if(operator.equalsIgnoreCase(RuleOperation.OPERATOR_PREFIX)){
return ".startsWith("+getValueExpress(factAlias)+")";
}
if(operator.equalsIgnoreCase(RuleOperation.OPERATOR_SUFFIX)){
return ".endsWith("+getValueExpress(factAlias)+")";
}
throw new UnSupportException(operator+" is not support ");
}
/**
* 比较值表达式
*/
private String getValueExpress(String factAlias) throws UnSupportException{
if(!valueType.equalsIgnoreCase(RuleOperation.INPUT_VALUE) && !valueType.equalsIgnoreCase(RuleOperation.FIELD_VALUE)){
throw new UnSupportException(valueType+" is not support ");
}
return valueType.equalsIgnoreCase(RuleOperation.INPUT_VALUE)? String.format("\"%s\"", value) : String.format("%s.get(\"%s\")", factAlias, value);
}
/**
* 连接符表达式
*/
String getLinkExpress() throws UnSupportException{
if(StringUtils.isEmpty(link)){
return "";
}
if(link.equalsIgnoreCase(RuleOperation.LINK_AND)){
return "&&";
}
if(link.equalsIgnoreCase(RuleOperation.LINK_OR)){
return "||";
}
throw new UnSupportException(link+" is not support ");
}
}
匹配规则
controller
/**
* 匹配规则
*/
@PostMapping("/match")
@ApiOperation("匹配规则")
public ResponseResult<List<RuleResult>> match(@RequestBody RuleMatchRo matchRo){
return ruleService.match(matchRo);
}
serviceImpl
/**
* 匹配规则
*/
@Override
public ResponseResult<List<RuleResult>> match(RuleMatchRo ruleRo) {
try{
if(CollectionUtils.isEmpty(ruleRo.getRuleIds())) {
return ResponseResult.buildFail("ruleIds为空");
}
// 查询规则,先查redis,再查DB
List<ExpressionRule> rules = getRuleList(ruleRo.getRuleIds());
// 进行规则匹配
List<RuleResult> results = new ArrayList<>();
rules.forEach(rule -> {
RuleResult matchResult = RuleUtils.match(ruleRo.getFact(),rule);
results.add(matchResult);
});
return ResponseResult.buildSucc(results);
}catch (Exception e){
log.error("匹配规则异常",e);
return ResponseResult.buildFail("匹配规则异常！");
}
}
RO
@Data
public class RuleMatchRo {
/**
* 需要匹配的规则ID列表
*/
@ApiModelProperty(value = "ruleIds")
List<Long> ruleIds;
/**
* 数据源
*/
@ApiModelProperty(value = "fact")
JSONObject fact;
}