使用centraldogma 作为easy-rules spring boot starter的规则存储
centraldogma 前边有介绍过，同时也说明过部署以及使用，以下是基于centraldogma 扩展easy-rules 的spring boot starter
方便快捷的支持rule 的修改以及实时更新，代码已经push github了，可以参考使用
开发流程
借鉴了以前easy-rules spring boot starter的开发，只是调整添加了对于centraldogma的支持
- 核心代码结构
├── README.md
├── pom.xml
└── src
├── main
│ ├── java
│ │ └── com
│ │ └── github
│ │ └── rongfengliang
│ │ ├── DefaultRuleEngineListener.java
│ │ ├── DefaultRulesListener.java
│ │ ├── EasyRulesAutoConfiguration.java
│ │ ├── EasyRulesEngineConfiguration.java
│ │ ├── EasyRulesEntities.java
│ │ ├── RuleExpressionType.java
│ │ ├── RulesConfig.java
│ │ ├── RulesContentType.java
│ │ ├── SimpleBeanResovler.java
│ │ ├── SpringBeanUtil.java
│ │ └── rulelocator
│ │ ├── RulesLocator.java
│ │ └── impl
│ │ └── FileRulesLocator.java
│ └── resources
│ └── META-INF
│ └── spring.factories
└── test
└── java
└── com
└── github
└── rongfengliang
└── CentraldogmaStringReader.java
- 代码说明
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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.github.rongfengliang</groupId>
<artifactId>easy-rules-centraldogma-spring-boot-starter</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<encoding>UTF-8</encoding>
<java.version>1.8</java.version>
<spring-boot.version>2.2.3.RELEASE</spring-boot.version>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
<easy-rules>4.1.0</easy-rules>
<centraldogma-client>0.51.1</centraldogma-client>
<slf4j-simple>1.7.32</slf4j-simple>
<lombok.version>1.18.20</lombok.version>
</properties>
<scm>
<developerConnection>scm:git:https://github.com/rongfengliang/easy-rules-centraldogma-spring-boot-starer.git</developerConnection>
<tag>HEAD</tag>
</scm>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
<version>${spring-boot.version}</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.jeasy</groupId>
<artifactId>easy-rules-core</artifactId>
<version>${easy-rules}</version>
</dependency>
<dependency>
<groupId>org.jeasy</groupId>
<artifactId>easy-rules-mvel</artifactId>
<version>${easy-rules}</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>${lombok.version}</version>
<optional>true</optional>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>com.linecorp.centraldogma</groupId>
<artifactId>centraldogma-client-spring-boot-starter</artifactId>
<version>${centraldogma-client}</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
<version>${spring-boot.version}</version>
</dependency>
<dependency>
<groupId>org.jeasy</groupId>
<artifactId>easy-rules-spel</artifactId>
<version>${easy-rules}</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<version>${spring-boot.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-simple</artifactId>
<version>${slf4j-simple}</version>
<optional>true</optional>
<scope>provided</scope>
</dependency>
</dependencies>
<distributionManagement>
<repository>
<id>sonatype-releases</id>
<name>sonatype Release Repository</name>
<url>https://oss.sonatype.org/service/local/staging/deploy/maven2</url>
</repository>
<snapshotRepository>
<id>sonatype-snapshots</id>
<name>sonatype Snapshot Repository</name>
<url>https://oss.sonatype.org/content/repositories/snapshots</url>
</snapshotRepository>
</distributionManagement>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-release-plugin</artifactId>
<version>3.0.0-M4</version>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-source-plugin</artifactId>
<version>3.2.0</version>
<configuration>
<attach>true</attach>
</configuration>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>jar-no-fork</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>
配置入口
package com.github.rongfengliang;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.linecorp.centraldogma.client.CentralDogma;
import com.linecorp.centraldogma.client.Watcher;
import com.linecorp.centraldogma.common.Entry;
import com.linecorp.centraldogma.common.Query;
import com.linecorp.centraldogma.common.Revision;
import org.jeasy.rules.api.*;
import org.jeasy.rules.core.DefaultRulesEngine;
import org.jeasy.rules.spel.SpELRuleFactory;
import org.jeasy.rules.support.reader.JsonRuleDefinitionReader;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;
import org.springframework.expression.BeanResolver;
import java.io.StringReader;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.CompletableFuture;
import java.util.function.Consumer;
@Configuration
@EnableConfigurationProperties(EasyRulesEngineConfiguration.class)
public class EasyRulesAutoConfiguration {
private Logger log = LoggerFactory.getLogger(DefaultRulesListener.class);
private final EasyRulesEngineConfiguration properties; // 配置
private Map<String, Rules> easyRules; // 基于map 存储bean 中间状态数据
private EasyRulesEntities easyRulesEntities; // 基于map 存储bean 中间状态数据
EasyRulesAutoConfiguration(EasyRulesEngineConfiguration properties) {
this.properties = properties;
this.easyRules = null;
this.easyRulesEntities =new EasyRulesEntities();
}
@Bean
@ConditionalOnMissingBean
public RuleListener defaultRulesListener() {
return new DefaultRulesListener();
}
@Bean
@ConditionalOnMissingBean
public RulesEngineListener defaultRuleEngineListener() {
return new DefaultRuleEngineListener();
}
@Bean
@ConditionalOnMissingBean
public BeanResolver defaultedResolver(SpringBeanUtil springBeanUtil) {
return new SimpleBeanResovler(SpringBeanUtil.getApplicationContext());
}
@Bean
@ConditionalOnMissingBean
public SpringBeanUtil springBeanUtil() {
return new SpringBeanUtil();
}
@Bean
@ConditionalOnClass(value = {CentralDogma.class, ObjectMapper.class}) // 需要依赖jackson以及CentralDogma bean,此bean 主要实现加载之后的配置加载以及变动数据的实时更新，同时转换为对应的easy-rules
public CommandLineRunner commandLineRunner(CentralDogma dogma, ObjectMapper objectMapper, BeanResolver beanResolver) {
log.info("project:{}, repo:{},filename:{}", properties.getProject(), properties.getRepo(), properties.getConfName());
Watcher watcher = dogma.fileWatcher(properties.getProject(), properties.getRepo(), Query.ofText(properties.getConfName()));
watcher.watch((revision, value) -> {
log.info("Updated to {} at {}", value, revision);
try {
List<RulesConfig> rulesConfigs = objectMapper.readValue(value.toString(), new TypeReference<List<RulesConfig>>() {
});
easyRulesEntities.setRulesConfigs(rulesConfigs);
this.easyRules = rulesContent2EasyRules(beanResolver);
} catch (JsonProcessingException e) {
e.printStackTrace();
log.error("json convert error", e);
}
});
return args -> {
log.info("init CentralDogma load easy rules conf");
};
}
/**
* centralDogmaRules with prototype for fetch new conf rules
* bean name is <b>centralDogmaRules</b>
*
* @param beanResolver
* @param centralDogma
* @return
* @throws Exception
*/
@Bean(name = "centralDogmaRules")
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
@ConditionalOnClass(value = {CentralDogma.class, ObjectMapper.class}) // 为了安全以及实时变动支持，基于了原型模式
public Map<String, Rules> centralDogmaRules(BeanResolver beanResolver, CentralDogma centralDogma, ObjectMapper objectMapper) throws Exception {
Map<String, Rules> rules = new HashMap<>();
if (Objects.isNull(easyRules)) {
CompletableFuture<Entry<String>> future =
centralDogma.getFile(properties.getProject(), properties.getRepo(), Revision.HEAD, Query.ofText(properties.getConfName()));
log.info("load rule content", future.join().content());
List<RulesConfig> rulesConfigs = objectMapper.readValue(future.join().content(), new TypeReference<List<RulesConfig>>() {
});
easyRulesEntities.setRulesConfigs(rulesConfigs);
return getStringRulesMap(beanResolver, rules);
} else {
return this.easyRules;
}
}
/**
* common method for Map<String, Rules> convert
* @param beanResolver
* @param rules
* @return
*/
private Map<String, Rules> getStringRulesMap(BeanResolver beanResolver, Map<String, Rules> rules) {
easyRulesEntities.getRulesConfigs().forEach(new Consumer<RulesConfig>() {
@Override
public void accept(RulesConfig rulesConfig) {
log.info("load rule conf to easy rules engine:{}", rulesConfig.getRulesContent());
StringReader stringReader = new StringReader(rulesConfig.getRulesContent().toPrettyString());
SpELRuleFactory jsonRuleFactory = new SpELRuleFactory(new JsonRuleDefinitionReader(), beanResolver);
Rules jsonRules = null;
try {
jsonRules = jsonRuleFactory.createRules(stringReader);
} catch (Exception e) {
e.printStackTrace();
}
rules.put(rulesConfig.getRulesId(), jsonRules);
}
});
return rules;
}
/**
* convert rulesContent2EasyRules
*
* @param beanResolver
* @return
*/
private Map<String, Rules> rulesContent2EasyRules(BeanResolver beanResolver) {
Map<String, Rules> rules = new HashMap<>();
return getStringRulesMap(beanResolver, rules);
}
/**
* 获取配置额规则列表
*
* @param beanResolver spring beanResolver
* @return Map<String, Rules>
* @throws Exception
*/
/**
* 为了安全使用原型模式
*
* @param defaultRulesListener
* @param defaultRuleEngineListener
* @return RulesEngine
*/
@Bean
@ConditionalOnMissingBean(RulesEngine.class)
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public RulesEngine rulesEngine(RuleListener defaultRulesListener, RulesEngineListener defaultRuleEngineListener) {
log.info("create rule Engine");
RulesEngineParameters parameters = new RulesEngineParameters();
if (this.properties.getPriorityThreshold() > 0) {
parameters.setPriorityThreshold(this.properties.getPriorityThreshold());
}
if (this.properties.isSkipOnFirstAppliedRule()) {
parameters.setSkipOnFirstAppliedRule(this.properties.isSkipOnFirstAppliedRule());
}
if (this.properties.isSkipOnFirstFailedRule()) {
parameters.setSkipOnFirstFailedRule(this.properties.isSkipOnFirstFailedRule());
}
if (this.properties.isSkipOnFirstNonTriggeredRule()) {
parameters.setSkipOnFirstNonTriggeredRule(this.properties.isSkipOnFirstNonTriggeredRule());
}
DefaultRulesEngine rulesEngine = new DefaultRulesEngine(parameters);
rulesEngine.registerRuleListener(defaultRulesListener);
rulesEngine.registerRulesEngineListener(defaultRuleEngineListener);
return rulesEngine;
}
}
EasyRulesEngineConfiguration 配置主要包含了一些通用参数的支持
package com.github.rongfengliang;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
@Data
@ConfigurationProperties(prefix = "easyrules")
public class EasyRulesEngineConfiguration {
private boolean skipOnFirstAppliedRule;
private boolean skipOnFirstNonTriggeredRule;
private boolean skipOnFirstFailedRule;
private int priorityThreshold;
private String project;
private String repo;
private String contentType;
private String confName;
}
规则存储实体定义RulesConfig(因为数据结构的多变，使用了jsonnode，实现灵活扩展)
package com.github.rongfengliang;
import com.fasterxml.jackson.databind.JsonNode;
import lombok.Data;
/**
* @author dalong
* rules文件配置信息
*/
@Data
public class RulesConfig {
private String rulesId;
private JsonNode rulesContent;
}
自定义beanresovler SimpleBeanResovler 主要是spel 需要
package com.github.rongfengliang;
import org.springframework.context.ApplicationContext;
import org.springframework.expression.BeanResolver;
import org.springframework.expression.EvaluationContext;
/**
* @author dalong
* SimpleBeanResovler
*/
public class SimpleBeanResovler implements BeanResolver {
private ApplicationContext applicationContext;
public SimpleBeanResovler(ApplicationContext applicationContext) {
this.applicationContext = applicationContext;
}
@Override
public Object resolve(EvaluationContext context, String beanName) {
return applicationContext.getBean(beanName);
}
}
SpringBeanUtil bean 工具类，主要简化原型的处理
package com.github.rongfengliang;
import org.jeasy.rules.api.Rules;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import java.util.Map;
public class SpringBeanUtil implements ApplicationContextAware {
/**
* 上下文对象实例
*/
private static ApplicationContext applicationContext;
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
this.applicationContext = applicationContext;
}
public static Map<String, Rules> centralDogmaRules(){
return SpringBeanUtil.getBean("centralDogmaRules",Map.class);
}
/**
* 获取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);
}
}
说明
一以上是具体的代码部分，关于使用，后边会有介绍
参考资料
https://github.com/rongfengliang/easy-rules-centraldogma-spring-boot-starter
https://github.com/line/centraldogma
