drools规则引擎

<!-- 规则引擎 -->
<dependency>
<groupId>org.kie</groupId>
<artifactId>kie-spring</artifactId>
<version>${drools.version}</version>
<exclusions>
<exclusion>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
</exclusion>
<exclusion>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
</exclusion>
<exclusion>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
</exclusion>
<exclusion>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
</exclusion>
</exclusions>
</dependency>

package com.ityml.drools.config;

import org.kie.api.KieBase;
import org.kie.api.KieServices;
import org.kie.api.builder.*;
import org.kie.api.runtime.KieContainer;
import org.kie.api.runtime.KieSession;
import org.kie.internal.io.ResourceFactory;
import org.kie.spring.KModuleBeanFactoryPostProcessor;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;

import java.io.IOException;

/**
* <p> 规则引擎自动配置类 </p>
* @author ityml
* @date 2019/9/10 11:20
*/
@Configuration
public class DroolsAutoConfiguration {

　　private static final String RULES_PATH = "rules/";

　　private KieServices getKieServices() {

　　　　　return KieServices.Factory.get();
　　}

　　@Bean
　　@ConditionalOnMissingBean(KieFileSystem.class)
　　public KieFileSystem kieFileSystem() throws IOException {
　　　　KieFileSystem kieFileSystem = getKieServices().newKieFileSystem();
　　　　for (Resource file : getRuleFiles()) {
　　　　　　kieFileSystem.write(ResourceFactory.newClassPathResource(RULES_PATH + file.getFilename(), "UTF-8"));
　　　　}
　　　　return kieFileSystem;
　　}

　　private Resource[] getRuleFiles() throws IOException {
　　　　ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
　　　　return resourcePatternResolver.getResources("classpath*:" + RULES_PATH + "**/*.*");
　　}

　　@Bean
　　@ConditionalOnMissingBean(KieContainer.class)
　　public KieContainer kieContainer() throws IOException {
　　　　final KieRepository kieRepository = getKieServices().getRepository();

　　　　kieRepository.addKieModule(() -> kieRepository.getDefaultReleaseId());

　　　　KieBuilder kieBuilder = getKieServices().newKieBuilder(kieFileSystem());
　　　　kieBuilder.buildAll();

　　　　KieContainer kieContainer = getKieServices().newKieContainer(kieRepository.getDefaultReleaseId());

　　　　return kieContainer;
　　}

　　@Bean
　　@ConditionalOnMissingBean(KieBase.class)
　　public KieBase kieBase() throws IOException {
　　　　return kieContainer().getKieBase();
　　}

}

@Data
@Accessors(chain = true)
public class Order {

/**
* 订单原价金额
*/
private int price;

/**
*下单人
*/
private User user;

/**
*积分
*/
private int score;

/**
* 下单日期
*/
private Date bookingDate;
}

package rules

import com.ityml.drools.entity.Order

rule "zero"
no-loop true
lock-on-active true
salience 1
when
$s : Order(amout <= 100)
then
$s.setScore(0);
update($s);
end

rule "add100"
no-loop true
lock-on-active true
salience 1
when
$s : Order(amout > 100 && amout <= 500)
then
$s.setScore(100);
update($s);
end

rule "add500"
no-loop true
lock-on-active true
salience 1
when
$s : Order(amout > 500 && amout <= 1000)
then
$s.setScore(500);
update($s);
end

rule "add1000"
no-loop true
lock-on-active true
salience 1
when
$s : Order(amout > 1000)
then
$s.setScore(1000);
update($s);
end

/**
* 需求
* 计算额外积分金额 规则如下: 订单原价金额
* 100以下, 不加分
* 100-500 加100分
* 500-1000 加500分
* 1000 以上 加1000分
*/
public class DroolsOrderTests extends DroolsApplicationTests {
@Resource
private KieContainer kieContainer;

@Test
public void Test() throws Exception {
List<Order> orderList = getInitData();
for (Order order : orderList) {
if (order.getAmout() <= 100) {
order.setScore(0);
addScore(order);
} else if (order.getAmout() > 100 && order.getAmout() <= 500) {
order.setScore(100);
addScore(order);
} else if (order.getAmout() > 500 && order.getAmout() <= 1000) {
order.setScore(500);
addScore(order);
} else {
order.setScore(1000);
addScore(order);
}
}
}

@Test
public void droolsOrderTest() throws Exception {
KieSession kieSession = kieContainer.newKieSession();
List<Order> orderList = getInitData();
for (Order order: orderList) {
// 1-规则引擎处理逻辑
kieSession.insert(order);
kieSession.fireAllRules();
// 2-执行完规则后, 执行相关的逻辑
addScore(order);
}
kieSession.dispose();
}

private static void addScore(Order o){
System.out.println("用户" + o.getUser().getName() + "享受额外增加积分: " + o.getScore());
}

private static List<Order> getInitData() throws Exception {
List<Order> orderList = new ArrayList<>();
DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
{
Order order = new Order();
order.setAmout(80);
order.setBookingDate(df.parse("2015-07-01"));
User user = new User();
user.setLevel(1);
user.setName("Name1");
order.setUser(user);
order.setScore(111);
orderList.add(order);
}
{
Order order = new Order();
order.setAmout(200);
order.setBookingDate(df.parse("2015-07-02"));
User user = new User();
user.setLevel(2);
user.setName("Name2");
order.setUser(user);
orderList.add(order);
}
{
Order order = new Order();
order.setAmout(800);
order.setBookingDate(df.parse("2015-07-03"));
User user = new User();
user.setLevel(3);
user.setName("Name3");
order.setUser(user);
orderList.add(order);
}
{
Order order = new Order();
order.setAmout(1500);
order.setBookingDate(df.parse("2015-07-04"));
User user = new User();
user.setLevel(4);
user.setName("Name4");
order.setUser(user);
orderList.add(order);
}
return orderList;
}
}