Use of rule engine drools

introduce maven

        <dependency>
            <groupId>org.drools</groupId>
            <artifactId>drools-templates</artifactId>
            <version>7.14.0.Final</version>
        </dependency>
        <dependency>
            <groupId>org.kie</groupId>
            <artifactId>kie-spring</artifactId>
            <version>7.14.0.Final</version>
        </dependency>

Tool class encapsulation

import org.kie.api.KieBase;
import org.kie.api.KieBaseConfiguration;
import org.kie.api.builder.Message;
import org.kie.api.builder.Results;
import org.kie.api.conf.EventProcessingOption;
import org.kie.api.io.ResourceType;
import org.kie.api.runtime.KieSession;
import org.kie.internal.utils.KieHelper;
import org.springframework.util.CollectionUtils;

import java.util.List;
import java.util.Map;

/**
 * drools Architecture rule tool 
 *
 * @author  Xiang Zhenhua 
 * @date 2022/06/30 17:29
 */
public class KieUtils {

    /**
     *  Execute all rules 
     *
     * @param entity   Entity classes in rule files 
     * @param globals  Global variables 
     * @param drl      Rules file 
     */
    public static void fireAllRules(Object entity, Map<String, Object> globals, String drl) {
        // Conversation object , Used to interact with the rule engine 
        KieSession kieSession = getKieSession(entity, globals, drl);
        // Activate rule engine , If the rule match is successful, execute the rule 
        kieSession.fireAllRules();
        // Close session 
        kieSession.dispose();
    }

    /**
     *  Execute all rules 
     *
     * @param kSession
     */
    public static void fireAllRules(KieSession kSession) {
        // Activate rule engine , If the rule match is successful, execute the rule 
        kSession.fireAllRules();
        // Close session 
        kSession.dispose();
    }

    /**
     *  obtain KieSession
     *
     * @param entity   Entity classes in rule files 
     * @param globals  Global variables 
     * @param drl      Rules file 
     * @return
     */
    public static KieSession getKieSession(Object entity, Map<String, Object> globals, String drl) {
        KieSession kieSession = getKieSession(drl);
        kieSession.insert(entity);
        if (!CollectionUtils.isEmpty(globals)) {
            for (String key : globals.keySet()) {
                kieSession.setGlobal(key, globals.get(key));
            }
        }
        return kieSession;
    }

    /**
     *  obtain KieSession
     *
     * @param drls  Rules file 
     * @return
     */
    public static KieSession getKieSession(String... drls) {
        KieHelper kieHelper = new KieHelper();
        for (String drl : drls) {
            kieHelper.addContent(drl, ResourceType.DRL);
        }
        verify(kieHelper);
        KieBaseConfiguration config = kieHelper.ks.newKieBaseConfiguration();
        config.setOption(EventProcessingOption.STREAM);
        KieBase kieBase = kieHelper.build(config);
        // establish KieSession
        return kieBase.newKieSession();
    }

    /**
     *  Check rule file 
     *
     * @param drl  Rules file 
     */
    public static void verify(String drl) {
        KieHelper kieHelper = new KieHelper();
        kieHelper.addContent(drl, ResourceType.DRL);
        verify(kieHelper);
    }

    /**
     *  check 
     *
     * @param kieHelper
     */
    private static void verify(KieHelper kieHelper) {
        Results results = kieHelper.verify();
        List<Message> messages = results.getMessages(Message.Level.WARNING, Message.Level.ERROR);
        if (!CollectionUtils.isEmpty(messages)) {
            StringBuilder error = new StringBuilder(" Rule file error  ");
            for (Message message : messages) {
                error.append(message.getText()).append(";");
            }
            throw new RuntimeException(error.toString());
        }
    }
}

Definition entity

/**
 * @author  Xiang Zhenhua 
 * @date 2022/06/30 16:11
 */
public class DemoEntity {

    private String name;
    private String remark;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getRemark() {
        return remark;
    }

    public void setRemark(String remark) {
        this.remark = remark;
    }

    public DemoEntity() {

    }

    public DemoEntity(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "DemoEntity{" +
                "name='" + name + '\'' +
                ", remark='" + remark + '\'' +
                '}';
    }
}

Create a rule file demo.drl

package demo
import com.xzh.drools.entity.DemoEntity

rule "demo"
    when
        $demo:DemoEntity(name contains " Xiao Ming ")
    then
        $demo.setRemark(" hello " + $demo.getName());
        System.out.println(" Rule enforcement  ---> " + $demo.getRemark());
end

test

@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)
public class DemoTest {

    @Test
    public void test1() throws IOException {
        DemoEntity entity = new DemoEntity(" Xiao Ming ");
        ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
        Resource resource = resourcePatternResolver.getResource("classpath:rules/demo.drl");
        byte[] bytes = IOUtils.toByteArray(resource.getInputStream());
        String drl = new String(bytes);
        KieUtils.fireAllRules(entity, null, drl);
    }
}

result

 Rule enforcement  --->  Hello, Xiaoming