Spring Boot集成drools快速入门Demo

1.什么是drools？

原理

1. 正向推理也叫演绎法，由事实驱动，从一个初始的事实出发，不断地从应用规则得出结论。首先在候选队列中选择一条规则作为启用规则进行推理，记录其结论作为下一步推理的证据。如此重复这个过程，直到再无可用规则可被选用或者求得了所要求的解为止。
2. 反向推理也叫归纳法，由目标驱动，首先提出某个假设，然后寻找支持该假设的证据，若所需的证据都能找到，说明原假设是正确的，若无论如何都找不到所需要的证据，则说明原假设不成立，此时需要另作新的假设。

rete算法

Drools相关概念：

• 事实（Fact）：对象之间及对象属性之间的关系
• 规则（rule）：是由条件和结论构成的推理语句，一般表示为if…Then。一个规则的if部分称为LHS，then部分称为RHS。
• 模式（module）：就是指IF语句的条件。这里IF条件可能是有几个更小的条件组成的大条件。模式就是指的不能在继续分割下去的最小的原子条件。

2.代码工程

实验目的

 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">
    <parent>
        <artifactId>springboot-demo</artifactId>
        <groupId>com.et</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>drools</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <drools.version>7.53.0.Final</drools.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <dependency>
            <groupId>org.drools</groupId>
            <artifactId>drools-decisiontables</artifactId>
            <version>${drools.version}</version>
        </dependency>

        <dependency>
            <groupId>org.drools</groupId>
            <artifactId>drools-core</artifactId>
            <version>${drools.version}</version>
        </dependency>

        <dependency>
            <groupId>org.drools</groupId>
            <artifactId>drools-compiler</artifactId>
            <version>${drools.version}</version>
        </dependency>

    </dependencies>
</project>

规则文件

package KieRule

import com.et.drools.Order;
import com.et.drools.OutputDisplay;

global OutputDisplay showResults;
global OutputDisplay sh;

rule "MASTERCARD"
    when
        orderObject : Order(cardType == "MASTERCARD" && price > 10000);
    then
        orderObject.setDiscount(10);
        showResults.showText("showResults MASTERCARD has been added a discount");
        sh.showText("sh MASTERCARD has been added a discount");

end;

rule "VISA"
    when
        orderObject : Order(cardType == "VISA" && price > 5000);
    then
        orderObject.setDiscount(14);
        showResults.showText("showResults VISA has been added a discount");
        sh.showText("sh VISA has been added a discount");
end;

rule "ICICI"
    when
        orderObject : Order(cardType == "ICICI" && price > 7000);
    then
        sh.showText("sh ICICI has been added a discount");
        orderObject.setDiscount(20);
        showResults.showText("showResults ICICI has been added a discount");
end;

• package 与Java语言类似，drl的头部需要有package和import的声明,package不必和物理路径一致。
• import 导出java Bean的完整路径，也可以将Java静态方法导入调用。
• rule 规则名称，需要保持唯一,可以无限次执行。
• no-loop 定义当前的规则是否不允许多次循环执行,默认是 false,也就是当前的规则只要满足条件,可以无限次执行。
• lock-on-active 将lock-on-active属性的值设置为true,可避免因某些Fact对象被修改而使已经执行过的规则再次被激活执行。
• salience 用来设置规则执行的优先级,salience 属性的值是一个数字,数字越大执行优先级越高, 同时它的值可以是一个负数。默认情况下,规则的 salience 默认值为 0。如果不设置规则的 salience 属性,那么执行顺序是随机的。
• when 条件语句，就是当到达什么条件的时候
• then 根据条件的结果，来执行什么动作
• end 规则结束

DroolsConfig

package com.et.drools;

import org.kie.api.KieServices;
import org.kie.api.builder.*;
import org.kie.api.event.rule.ObjectDeletedEvent;
import org.kie.api.event.rule.ObjectInsertedEvent;
import org.kie.api.event.rule.ObjectUpdatedEvent;
import org.kie.api.event.rule.RuleRuntimeEventListener;
import org.kie.api.runtime.KieContainer;
import org.kie.api.runtime.KieSession;
import org.kie.internal.io.ResourceFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.io.IOException;

@Configuration
public class DroolsConfig {

    private static final Logger LOGGER = LoggerFactory.getLogger(DroolsConfig.class);

    private KieServices kieServices = KieServices.Factory.get();

    @Bean
    public KieSession getKieSession() throws IOException {
        LOGGER.info("Session created...");
        KieSession kieSession = getKieContainer().newKieSession();
        kieSession.setGlobal("showResults", new OutputDisplay());
        kieSession.setGlobal("sh", new OutputDisplay());

        kieSession.addEventListener(new RuleRuntimeEventListener() {
            @Override
            public void objectInserted(ObjectInsertedEvent event) {
                System.out.println("Object inserted \n "
                        + event.getObject().toString());
            }

            @Override
            public void objectUpdated(ObjectUpdatedEvent event) {
                System.out.println("Object was updated \n"
                        + "New Content \n"
                        + event.getObject().toString());
            }

            @Override
            public void objectDeleted(ObjectDeletedEvent event) {
                System.out.println("Object retracted \n"
                        + event.getOldObject().toString());
            }
        });
        return kieSession;
    }

    @Bean
    public KieContainer getKieContainer() throws IOException {
        LOGGER.info("Container created...");
        getKieRepository();
        KieBuilder kb = kieServices.newKieBuilder(getKieFileSystem());
        kb.buildAll();
        KieModule kieModule = kb.getKieModule();
        return kieServices.newKieContainer(kieModule.getReleaseId());
    }

    private void getKieRepository() {
        final KieRepository kieRepository = kieServices.getRepository();
        kieRepository.addKieModule(new KieModule() {
            @Override
            public ReleaseId getReleaseId() {
                return kieRepository.getDefaultReleaseId();
            }
        });
    }

    private KieFileSystem getKieFileSystem() throws IOException {
        KieFileSystem kieFileSystem = kieServices.newKieFileSystem();
        kieFileSystem.write(ResourceFactory.newClassPathResource("order.drl"));
        return kieFileSystem;
    }
}

OrderController

package com.et.drools;

import org.kie.api.runtime.KieSession;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class OrderController {

    private final KieSession kieSession;

    public OrderController(KieSession kieSession) {
        this.kieSession = kieSession;
    }

    @PostMapping("/order")
    public Order processRules(@RequestBody Order order) {
        kieSession.insert(order);
        kieSession.fireAllRules();
        return order;
    }
}

以上只是一些关键代码，所有代码请参见下面代码仓库

代码仓库

• https://github.com/Harries/springboot-demo

3.测试

运行controller测试类

package com.et.drools;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockHttpServletRequestBuilder;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

/**
 * Integration-level testing for {@link OrderController} object.
 * Show the result of the Drools engine.
 */
@SpringBootTest
@AutoConfigureMockMvc
public class OrderControllerIT {

    ObjectMapper objectMapper = new ObjectMapper();

    @Autowired
    private MockMvc mockMvc;

    public static final String VISA = "VISA";
    public static final String MASTER_CARD = "MASTERCARD";
    public static final String ICICI = "ICICI";

    @Test
    public void shouldApplyVISARule() throws Exception {
        //given
        Order order = new Order();
        order.setCardType(VISA);
        order.setPrice(11000);

        //when
        MockHttpServletRequestBuilder request = createPostOrder(order);
        String contentAsString = performAction(request);
        Order resultOrder = objectMapper.readValue(contentAsString, Order.class);

        //then
        assertEquals(order.getCardType(), resultOrder.getCardType());
        assertEquals(order.getPrice(), resultOrder.getPrice());
        assertEquals(14, resultOrder.getDiscount());
    }

    @Test
    public void shouldApplyMASTERCARDRule() throws Exception {
        //given
        Order order = new Order();
        order.setCardType(MASTER_CARD);
        order.setPrice(11000);

        //when
        MockHttpServletRequestBuilder request = createPostOrder(order);
        String contentAsString = performAction(request);
        Order resultOrder = objectMapper.readValue(contentAsString, Order.class);

        //then
        assertEquals(order.getCardType(), resultOrder.getCardType());
        assertEquals(order.getPrice(), resultOrder.getPrice());
        assertEquals(10, resultOrder.getDiscount());
    }

    @Test
    public void shouldApplyICICIRule() throws Exception {
        //given
        Order order = new Order();
        order.setCardType(ICICI);
        order.setPrice(11000);

        //when
        MockHttpServletRequestBuilder request = createPostOrder(order);
        String contentAsString = performAction(request);
        Order resultOrder = objectMapper.readValue(contentAsString, Order.class);

        //then
        assertEquals(order.getCardType(), resultOrder.getCardType());
        assertEquals(order.getPrice(), resultOrder.getPrice());
        assertEquals(20, resultOrder.getDiscount());
    }

    private MockHttpServletRequestBuilder createPostOrder(Order order) throws JsonProcessingException {
        return post("/order")
                .content(objectMapper.writeValueAsBytes(order))
                .contentType(MediaType.APPLICATION_JSON_VALUE)
                .accept(MediaType.APPLICATION_JSON_VALUE);

    }

    private String performAction(MockHttpServletRequestBuilder request) throws Exception {
        return mockMvc.perform(request)
                .andExpect(status().isOk())
                .andReturn()
                .getResponse()
                .getContentAsString();
    }

}

Object inserted 
 Order(name=null, cardType=ICICI, discount=0, price=11000)
==================================================
Text: sh ICICI has been added a discount, date: 2024-07-11
==================================================
==================================================
Text: showResults ICICI has been added a discount, date: 2024-07-11
==================================================

4.引用

• 官网：http://www.drools.org/#
• 官方文档：http://www.drools.org/learn/documentation.html