easy-rules spring boot集成使用
以下是一个easy-rules 与spring boot集成的一个简单demo，主要目的是简单的集成以及一些集成
上的一些思考
项目准备
- 项目结构
├── pom.xml
└── src
├── main
│ ├── java
│ │ └── com
│ │ └── appdemo
│ │ └── demo
│ │ ├── ConfigRules.java
│ │ ├── DemoApplication.java
│ │ ├── MyRule.java
│ │ ├── MyRuleEngineListener.java
│ │ ├── MyRulesListener.java
│ │ ├── MyService.java
│ │ ├── ProtoRulesEngineFactoryBean.java
│ │ ├── RulesEngineFactoryBean.java
│ │ ├── SimpleBeanResovler.java
│ │ ├── SpringBeanUtil.java
│ │ ├── User.java
│ │ ├── UserApi.java
│ │ └── UserService.java
│ └── resources
│ ├── application.properties
│ ├── rules-json.json
│ ├── rules-json2.json
│ ├── static
│ └── templates
- 简单说明
就是一个基于spring boot 的rest 项目，基于easy-rules 规则处理请求体中的数据，对于请求体中的数据进行重写
代码说明
- pom.xml
主要是依赖包
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.2.6.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.appdemo</groupId>
<artifactId>demo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>demo</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.jeasy</groupId>
<artifactId>easy-rules-core</artifactId>
<version>3.4.0</version>
</dependency>
<dependency>
<groupId>org.jeasy</groupId>
<artifactId>easy-rules-mvel</artifactId>
<version>3.4.0</version>
</dependency>
<dependency>
<groupId>org.jeasy</groupId>
<artifactId>easy-rules-spel</artifactId>
<version>3.4.0</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-simple</artifactId>
<version>1.7.25</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
<exclusions>
<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
- rule 配置
基于json 的配置加载，同时集成了mvel 表达式引擎，可以支持灵活的基于脚本语言的数据操作
rules-json2.json：
[{
"name": "1",
"description": "1",
"priority": 1,
"compositeRuleType": "UnitRuleGroup",
"composingRules": [
{
"name": "2",
"description": "2",
"condition": "user.getAge()<28",
"priority": 2,
"actions": [
"System.out.println(\"UnitRuleGroup rule2 \")"
]
},
{
"name": "3",
"description": "3",
"condition": "user.name.length<10",
"priority": 3,
"actions": [
"System.out.println(\"UnitRuleGroup rule3 \")"
]
},
{
"name": "4",
"description": "4",
"condition": "user.name.length<10",
"priority": 4,
"actions": [
"System.out.println(\"UnitRuleGroup rule4 \")"
]
},
{
"name": "5",
"description": "5",
"condition": "user.name.length<10",
"priority": 5,
"actions": [
"System.out.println(\"UnitRuleGroup rule5 \");UserService.doAction4(user.userinfo)"
]
}
]},
{
"name": "3",
"description": "3",
"condition": "user.name.length<50",
"priority": 3,
"actions": [
"UserService.appendName(user)"
]
},
{
"name": "9",
"description": "9",
"condition": "user.name.length<50",
"priority": 3,
"actions": [
"System.out.println(\"default rule3 \")"
]
}
]
- 实体说明
User 实体，就是一个普通的pojo，同时为了方便基于rule以及规则数据的监控，添加了一个唯一id，
唯一id 的目的是我们可以基于添加的监听事件，可视化以及分析我们的业务流程数据以及状态（类似opentracing）
User.java
package com.appdemo.demo;
import com.fasterxml.jackson.annotation.JsonIgnore;
import java.io.Serializable;
import java.util.Map;
public class User implements Serializable {
private String name;
private int age;
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
", uniqueId='" + uniqueId + '\'' +
", userinfo=" + userinfo +
'}';
}
public String getUniqueId() {
return uniqueId;
}
public void setUniqueId(String uniqueId) {
this.uniqueId = uniqueId;
}
@JsonIgnore
private transient String uniqueId;
public Map<Object, Object> getUserinfo() {
return userinfo;
}
public void setUserinfo(Map<Object, Object> userinfo) {
this.userinfo = userinfo;
}
private Map<Object, Object> userinfo;
public String getName() {
return name;
}
public User() {
}
public User(String name, int age) {
this.name = name;
this.age = age;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
- 数据服务协助类
主要是暴露静态类，方便操作spring bean以及实体模型
UserService.java
package com.appdemo.demo;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.stereotype.Component;
import java.util.Map;
@Component
public class UserService {
static Log log = LogFactory.getLog(UserService.class);
public static void doAction1(User user){
log.info("------------do action1------------");
log.info(user.toString());
}
public static void doAction2(User user){
log.info("------------do action2------------");
user.setName("sssssssssssssssssss");
log.info(user.toString());
}
public static void doAction3(Map user){
log.info("------------do action3------------");
log.info(user.toString());
}
public static void appendName(User user){
/**
* 通过静态全局ApplicationConext 获取bean引用
*/
MyService myService =SpringBeanUtil.getBean(MyService.class);
myService.setInfo(user);
}
public static void doAction4(Object user){
/**
* 基于mvel 修改数据，为了复用doAction4,做了数据兼容处理
*/
if (user instanceof Map ){
log.info("------------do action4------------");
((Map)user).put("name2","rule do action4");
}
if (user instanceof User) {
((User)user).setName("dalong demo appapapappapa");
}
log.info(user.toString());
}
}
- spring beas 工具类
方便引用applicationcontext
SpringBeanUtil.java
package com.appdemo.demo;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
@Component
public class SpringBeanUtil implements ApplicationContextAware {
/**
* 上下文对象实例
*/
private static ApplicationContext applicationContext;
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
this.applicationContext = applicationContext;
}
/**
* 获取applicationContext
*
* @return
*/
public static ApplicationContext getApplicationContext() {
return applicationContext;
}
/**
* 通过name获取 Bean.
*
* @param name
* @return
*/
public static Object getBean(String name) {
return getApplicationContext().getBean(name);
}
/**
* 通过class获取Bean.
*
* @param clazz
* @param <T>
* @return
*/
public static <T> T getBean(Class<T> clazz) {
return getApplicationContext().getBean(clazz);
}
/**
* 通过name,以及Clazz返回指定的Bean
*
* @param name
* @param clazz
* @param <T>
* @return
*/
public static <T> T getBean(String name, Class<T> clazz) {
return getApplicationContext().getBean(name, clazz);
}
}
- 创建的数据操作bean
MyService.java
package com.appdemo.demo;
import org.springframework.stereotype.Component;
/**
* @author dalonng
*
* mybean for ref
*/
@Component
public class MyService {
public void setInfo(User user){
user.setName("rongfengliang");
}
}
- rule 引擎的一些监听方法
主要是MyRuleEngineListener.java以及MyRulesListener.java具体参考下边链接查看源码 - 规则加载
因为方便规则的处理以及与spring 的集成，提取了一个规则配置bean
ConfigRules.java
package com.appdemo.demo;
import org.jeasy.rules.api.Rules;
import org.jeasy.rules.mvel.MVELRuleFactory;
import org.jeasy.rules.support.JsonRuleDefinitionReader;
import org.mvel2.ParserContext;
import org.springframework.stereotype.Component;
import java.io.FileNotFoundException;
import java.io.FileReader;
/**
* @author dalong
* 加载rule文件
*/
@Component
public class ConfigRules {
public Rules fetchConfigRules() throws Exception {
MVELRuleFactory ruleFactory = new MVELRuleFactory(new JsonRuleDefinitionReader());
ParserContext context =new ParserContext();
context.addImport("UserService", UserService.class);
Rules jsonRules = ruleFactory.createRules(new FileReader(DemoApplication.class.getClassLoader().getResource("rules-json2.json").getFile()),context);
return jsonRules;
}
}
- ruleEngine bean
为了方便处理以及线程安全，我们使用了原型bean
ProtoRulesEngineFactoryBean.java
package com.appdemo.demo;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.jeasy.rules.api.RulesEngine;
import org.jeasy.rules.core.DefaultRulesEngine;
import org.springframework.beans.factory.FactoryBean;
/**
* @author dalong
* 原型RulesEngine FactoryBean
*/
public class ProtoRulesEngineFactoryBean implements FactoryBean<RulesEngine> {
Log log = LogFactory.getLog(MyRulesListener.class);
public RulesEngine init() {
log.info("create rule Engine");
DefaultRulesEngine rulesEngine = new DefaultRulesEngine();
rulesEngine.registerRuleListener(new MyRulesListener());
rulesEngine.registerRulesEngineListener(new MyRuleEngineListener());
return rulesEngine;
}
@Override
public RulesEngine getObject() throws Exception {
return this.init();
}
@Override
public Class<?> getObjectType() {
return RulesEngine.class;
}
@Override
public boolean isSingleton() {
return false;
}
}
- spring boot 应用入口
DemoApplication.java
package com.appdemo.demo;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.jeasy.rules.api.RulesEngine;
import org.jeasy.rules.core.DefaultRulesEngine;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Scope;
@SpringBootApplication
public class DemoApplication {
Log log = LogFactory.getLog(MyRulesListener.class);
@Bean(name = "myEngine")
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public RulesEngine myEngine(MyRulesListener myRulesListener,MyRuleEngineListener myRuleEngineListener) {
log.info("create rule Engine");
DefaultRulesEngine rulesEngine = new DefaultRulesEngine();
rulesEngine.registerRuleListener(myRulesListener);
rulesEngine.registerRulesEngineListener(myRuleEngineListener);
return rulesEngine;
}
@Bean("myEngine2")
ProtoRulesEngineFactoryBean rulesEngineFactoryBean()
{
return new ProtoRulesEngineFactoryBean();
}
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}
- 获取rule 结果的帮助rule
rule的目的比较简单，因为很多时候我们需要获取结果数据，所以规则运行的时候会注册一个帮助rule，方便获取结果数据
MyRule.java
package com.appdemo.demo;
import org.jeasy.rules.annotation.Action;
import org.jeasy.rules.annotation.Condition;
import org.jeasy.rules.annotation.Fact;
import org.jeasy.rules.annotation.Rule;
@Rule(name = "100", description = "my rule description", priority = 100)
public class MyRule<T> {
private boolean executed;
private T result;
@Condition
public boolean when(@Fact("user") T fact) {
//my rule conditions
return true;
}
@Action(order = 1)
public void then(@Fact("user") T facts) throws Exception {
try {
System.out.println("my rule has been executed");
result = (T)facts; // assign your result here
executed = true;
} catch (Exception e) {
// executed flag will remain false if an exception occurs
throw e;
}
}
@Action(order = 2)
public void finaly() throws Exception {
try {
System.out.println("all is ok ");
} catch (Exception e) {
// executed flag will remain false if an exception occurs
throw e;
}
}
public boolean isExecuted() {
return executed;
}
public T getResult() {
return result;
}
}
- rest api
一个简单的规则引擎使用的方法
UserApi.java
package com.appdemo.demo;
import org.jeasy.rules.api.Facts;
import org.jeasy.rules.api.Rules;
import org.jeasy.rules.api.RulesEngine;
import org.jeasy.rules.mvel.MVELRuleFactory;
import org.jeasy.rules.support.JsonRuleDefinitionReader;
import org.mvel2.ParserContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import java.util.Random;
import java.util.UUID;
@RestController
public class UserApi {
@Autowired
RulesEngine myEngine;
@Autowired
ConfigRules configRules;
@RequestMapping(value = "/", method = RequestMethod.POST)
public Object info(@RequestBody User user) throws Exception {
Rules rules = configRules.fetchConfigRules();
Facts facts = new Facts();
// 生成一个唯一id，方便基于数据id规则流程查询
user.setUniqueId(UUID.randomUUID().toString());
MyRule<User> rule = new MyRule<User>();
rules.register(rule);
facts.put("user",user);
// 默认模式
// myEngine.fire(rules,facts);
// 应该使用原型模式
SpringBeanUtil.getBean("myEngine",RulesEngine.class).fire(rules,facts);
if(rule.isExecuted()){
User userResult= rule.getResult();
System.out.println("result from final ruls"+userResult.toString());
return userResult;
}
else {
return null;
}
}
}
运行&&效果
- 运行
mvn spring-boot:run
- 访问
curl --location --request POST 'http://localhost:8080' \
--header 'Content-Type: application/json' \
--data-raw '{
"name":"dalonng",
"age":27,
"userinfo":{
"name2":"demo",
"age2":333
}
}' | jq .
效果
{
"name": "rongfengliang",
"age": 27,
"userinfo": {
"name2": "rule do action4",
"age2": 333
}
}
日志： 
说明
以上是一个简单的集成学习，实际上如果我么的业务都是基于此模式开发的，那么我们可以基于配置的规则以及记录的事件，提供一个
便捷的业务状态追踪系统（事件，规则，数据。。。），类似的工作流模式也是一种不错的实践
参考资料
https://github.com/j-easy/easy-rules
https://github.com/rongfengliang/easy-rules-spring-learning
