myherux-drools-springboot

The Left Hand Side (LHS) defines the patterns that must match for a rule to fire.

Pattern Matching Types

• No constraints: Person() (matches any Person fact).
• Field constraints: Person( name == "bob" ).
• Field binding: Person( $name : name == "bob" ) (binds the value of name to variable $name).
• Fact binding: $bob : Person( name == "bob" ) (binds the entire object to $bob).
• Variable constraints: Person( name == $name ).

Comparison Operators

Drools supports: >, >=, <, <=, ==, !=, contains, not contains, memberOf, not memberOf, matches, not matches.

• contains: Checks if a collection or string contains a value.
• memberOf: Checks if a field is a member of a specific variable (collection).
• matches: Performs regex matching (does not require escaping / like Java).
• exists: Activates the rule if at least one matching fact exists (activates at most once).
• not: Activates if no matching facts exist.

You can use the SpreadsheetCompiler to translate Excel-based decision tables into standard DRL rule language. This allows you to manage rules in a user-friendly spreadsheet format and convert them into executable code at runtime.

There are two ways to perform this conversion:

1. From a Classpath Resource: Use ResourceFactory.newClassPathResource if the Excel file is bundled in your application.
2. From an InputStream: Use ResourceFactory.newInputStreamResource if the Excel file is provided via a file upload or external stream.

// Option 1: Compile from a classpath Excel file
public String getRuleTable() {
    SpreadsheetCompiler compiler = new SpreadsheetCompiler();
    String rules = compiler.compile(ResourceFactory.newClassPathResource(RULES_PATH + File.separator + "rule.xlsx", "UTF-8"), "rule-table");
    return rules;
}

// Option 2: Compile from an InputStream (e.g., uploaded file)
public String getRuleTable(InputStream inputStream) {
    SpreadsheetCompiler compiler = new SpreadsheetCompiler();
    String rules = compiler.compile(ResourceFactory.newInputStreamResource(inputStream, "UTF-8"), "rule-table");
    return rules;
}

Drools rules consist of three main parts: the header (package and imports), the condition (LHS - Left Hand Side), and the action (RHS - Right Hand Side).

Key components used in the example:

• salience: Defines rule priority (higher numbers execute first).
• exists( Type() ): A condition that checks if an object of a specific type exists in working memory.
• not( Type() ): A condition that checks if an object of a specific type does NOT exist.
• insertLogical( new Type() ): Inserts a new object into the working memory logically (it will be removed if the condition that triggered it is no longer met).
• modify( object ) { ... }: Updates an existing object in working memory, triggering re-evaluation of rules.
• package: Specifies the namespace for the rules.
• import: Imports the Java bean classes used in the rules.

package com.xu.drools

import com.xu.drools.bean.Politician;
import com.xu.drools.bean.Hope;

rule "We have an honest Politician"
    salience 10
    when
        exists( Politician( honest == true ) )
    then
        insertLogical( new Hope() );
end

rule "Corrupt the Honest"
    when
        politician : Politician( honest == true )
        exists( Hope() )
    then
        System.out.println( "I'm an evil corporation and I have corrupted " + politician.getName() );
        modify( politician ) {
            setHonest( false )
        }
end

You can create a new KieSession at runtime by passing a raw DRL (Drools Rule Language) string. This involves writing the string to a virtual KieFileSystem, building the KieBuilder, and extracting a KieBase.

Note: If the DRL string contains syntax errors, the builder will return error messages. You should check results.hasMessages(Message.Level.ERROR) to handle compilation failures.

public KieSession getKieSession(String rules) {
    KieServices kieServices = KieServices.Factory.get();
    KieFileSystem kfs = kieServices.newKieFileSystem();
    // Write the dynamic rules string to the virtual file system
    kfs.write("src/main/resources/rules/rules.drl", rules.getBytes());
    
    KieBuilder kieBuilder = kieServices.newKieBuilder(kfs).buildAll();
    Results results = kieBuilder.getResults();
    
    if (results.hasMessages(org.kie.api.builder.Message.Level.ERROR)) {
        // Handle compilation errors
        throw new BusinessException(300003, results.getMessages().toString(), 4);
    }
    
    KieContainer kieContainer = kieServices.newKieContainer(kieServices.getRepository().getDefaultReleaseId());
    KieBase kieBase = kieContainer.getKieBase();

    return kieBase.newKieSession();
}

To use the Drools rule engine within a Spring Boot application, include the following Maven dependencies. This project uses Drools version 6.5.0.Final.

<properties>
    <drools.version>6.5.0.Final</drools.version>
</properties>

<!--Drools-->
<dependency>
    <groupId>org.kie</groupId>
    <artifactId>kie-api</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>
<dependency>
    <groupId>org.drools</groupId>
    <artifactId>drools-decisiontables</artifactId>
    <version>${drools.version}</version>
</dependency>
<dependency>
    <groupId>org.drools</groupId>
    <artifactId>drools-templates</artifactId>
    <version>${drools.version}</version>
</dependency>

Drools can be used to solve complex constraint satisfaction problems (like logic puzzles) by defining multiple facts and using the when clause to enforce constraints across them.

You can use pattern matching to ensure that different objects (e.g., different golfers) do not share the same attributes (like position or color) by using inequality operators (!=) and comparing properties of bound variables.

rule "find solution"
    when
        // Define constraints for multiple objects
        $fred : Golfer( name == "Fred" )

        $joe : Golfer( name == "Joe",
                position == 2,
                position != $fred.position,
                color != $fred.color )

        $bob : Golfer( name == "Bob",
                position != $fred.position,
                position != $joe.position,
                color == "plaid",
                color != $fred.color,
                color != $joe.color )

        // Constraint: Fred's neighbor to the right wears blue
        Golfer( position == ( $fred.position + 1 ),
                color == "blue",
                this in ( $joe, $bob, $tom ) )
    then
        System.out.println( "Fred " + $fred.getPosition() + " " + $fred.getColor() );
        // ... print other results
end