01: Drools tutorial with Maven and Eclipse

Posted on October 27, 2014 by

Drools is an open source rules engine that allows you to externalize the business rules.

This tutorial assumes that you have gone through “Setting up Java, Maven, and Eclipse.” Once you have gone through the following steps, you should have a project structure as shown below.

Step 1: Create a new Maven project

C:\Temp\Java\projects>mvn archetype:generate -DgroupId=com.mytutorial -DartifactId=simpleDrools

1	C:\Temp\Java\projects>mvn archetype:generate -DgroupId=com.mytutorial -DartifactId=simpleDrools

Note: press “enter” through all prompts. The project will be created under C:\Temp\Java\projects\simpleDrools with a default pom.xml file.

Step 2: Import it into eclipse as a Maven project. File –> Import –> Existing Maven Projects, and select the folder where the pom.xml file is.

Step 3: Update the pom.xml file as shown below.

<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.mytutorial</groupId>
  <artifactId>simpleDrools</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>simpleDrools</name>
  <url>http://maven.apache.org</url>

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

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>

    <!-- drools library -->
    <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>
    <!-- required for drools and spring integration -->
    <dependency>
      <groupId>org.drools</groupId>
      <artifactId>drools-spring</artifactId>
      <version>${drools.version}</version>
    </dependency>
    <dependency>
      <groupId>com.thoughtworks.xstream</groupId>
      <artifactId>xstream</artifactId>
      <version>1.2.2</version>
    </dependency>
    
  </dependencies>
</project>

<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">

<groupId>com.mytutorial</groupId>

<artifactId>simpleDrools</artifactId>

<version>1.0-SNAPSHOT</version>

<name>simpleDrools</name>

<url>http://maven.apache.org</url>

<drools.version>5.3.1.Final</drools.version>

</properties>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

</dependency>

<groupId>org.drools</groupId>

<artifactId>drools-core</artifactId>

<version>${drools.version}</version>

</dependency>

<groupId>org.drools</groupId>

<artifactId>drools-compiler</artifactId>

<version>${drools.version}</version>

</dependency>

<groupId>org.drools</groupId>

<artifactId>drools-spring</artifactId>

<version>${drools.version}</version>

</dependency>

<groupId>com.thoughtworks.xstream</groupId>

<artifactId>xstream</artifactId>

</dependency>

</dependencies>

</project>

Step 4: The OrderItem domain object class with getter and setter methods.

package com.mytutorial;
import java.math.BigDecimal;

public class OrderItem {

  public enum PROD_TYPE {
    BASIC, LUXURY
  }

  private PROD_TYPE type;
  private int units;
  private BigDecimal unitPrice;
  private BigDecimal effectiveDiscountRate;
  private BigDecimal discountedUnitPrice;

  public PROD_TYPE getType() {
    return type;
  }

  public void setType(PROD_TYPE type) {
    this.type = type;
  }

  public int getUnits() {
    return units;
  }

  public void setUnits(int units) {
    this.units = units;
  }

  public BigDecimal getUnitPrice() {
    return unitPrice;
  }

  public void setUnitPrice(BigDecimal unitPrice) {
    this.unitPrice = unitPrice;
  }

  public BigDecimal getEffectiveDiscountRate() {
    return effectiveDiscountRate;
  }

  public void setEffectiveDiscountRate(BigDecimal effectiveDiscountRate) {
    this.effectiveDiscountRate = effectiveDiscountRate;
  }

  public BigDecimal getDiscountedUnitPrice() {
    return discountedUnitPrice;
  }

  public void setDiscountedUnitPrice(BigDecimal discountedUnitPrice) {
    this.discountedUnitPrice = discountedUnitPrice;
  }

  @Override
  public String toString() {
    return "OrderItem [type=" + type + ", units=" + units + ", unitPrice=" + unitPrice + ", effectiveDiscountRate="
        + effectiveDiscountRate + ", discountedUnitPrice=" + discountedUnitPrice + "]";
  }

}

package com.mytutorial;

import java.math.BigDecimal;

public class OrderItem {

public enum PROD_TYPE {

BASIC, LUXURY

}

private PROD_TYPE type;

private int units;

private BigDecimal unitPrice;

private BigDecimal effectiveDiscountRate;

private BigDecimal discountedUnitPrice;

public PROD_TYPE getType() {

return type;

}

public void setType(PROD_TYPE type) {

this.type = type;

}

public int getUnits() {

return units;

}

public void setUnits(int units) {

this.units = units;

}

public BigDecimal getUnitPrice() {

return unitPrice;

}

public void setUnitPrice(BigDecimal unitPrice) {

this.unitPrice = unitPrice;

}

public BigDecimal getEffectiveDiscountRate() {

return effectiveDiscountRate;

}

public void setEffectiveDiscountRate(BigDecimal effectiveDiscountRate) {

this.effectiveDiscountRate = effectiveDiscountRate;

}

public BigDecimal getDiscountedUnitPrice() {

return discountedUnitPrice;

}

public void setDiscountedUnitPrice(BigDecimal discountedUnitPrice) {

this.discountedUnitPrice = discountedUnitPrice;

}

@Override

public String toString() {

return "OrderItem [type=" + type + ", units=" + units + ", unitPrice=" + unitPrice + ", effectiveDiscountRate="

+ effectiveDiscountRate + ", discountedUnitPrice=" + discountedUnitPrice + "]";

}

Step 5: The RuleMap class, which is Map extension to store rules.

package com.mytutorial;

import java.util.HashMap;

public class RuleMap<K, V> extends HashMap<String, Object> {

  private static final long serialVersionUID = 1L;

  @Override
  public Object put(String key, Object value) {
    return super.put(key, value);
  }
}

package com.mytutorial;

import java.util.HashMap;

public class RuleMap<K, V> extends HashMap<String, Object> {

private static final long serialVersionUID = 1L;

@Override

public Object put(String key, Object value) {

return super.put(key, value);

}

Step 6: The TemplateExpander utility class.

package com.mytutorial;

import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
import java.util.Collection;

import org.drools.io.Resource;
import org.drools.io.ResourceFactory;
import org.drools.template.ObjectDataCompiler;

public final class TemplateExpander {
   
    private TemplateExpander() {}

    public static Resource expand(Resource template, Collection<?> rules) throws IOException {

        ObjectDataCompiler converter = new ObjectDataCompiler();
        String drl = converter.compile(rules, template.getInputStream());
        Reader rdr = new StringReader(drl);
        return ResourceFactory.newReaderResource(rdr);
    }
}

package com.mytutorial;

import java.io.IOException;

import java.io.Reader;

import java.io.StringReader;

import java.util.Collection;

import org.drools.io.Resource;

import org.drools.io.ResourceFactory;

import org.drools.template.ObjectDataCompiler;

public final class TemplateExpander {

private TemplateExpander() {}

public static Resource expand(Resource template, Collection<?> rules) throws IOException {

ObjectDataCompiler converter = new ObjectDataCompiler();

String drl = converter.compile(rules, template.getInputStream());

Reader rdr = new StringReader(drl);

return ResourceFactory.newReaderResource(rdr);

}

Step 7: The KnowledgeBaseBuilder that binds the classes defined above.

package com.mytutorial;

import java.io.IOException;
import java.util.List;

import org.drools.KnowledgeBase;
import org.drools.KnowledgeBaseFactory;
import org.drools.builder.KnowledgeBuilder;
import org.drools.builder.KnowledgeBuilderError;
import org.drools.builder.KnowledgeBuilderFactory;
import org.drools.builder.ResourceType;
import org.drools.io.Resource;
import org.drools.io.ResourceFactory;

public class KnowledgeBaseBuilder {

  public static KnowledgeBase build(List<RuleMap<String, Object>> ruleAttributes) throws IOException {

    KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();
    KnowledgeBase kbase = KnowledgeBaseFactory.newKnowledgeBase();

    Resource rules = loadRuleFile("product.drl");
    rules = TemplateExpander.expand(rules, ruleAttributes);
    kbuilder.add(rules, ResourceType.DRL);

    // handle errors
    if (kbuilder.hasErrors()) {
      for (KnowledgeBuilderError err : kbuilder.getErrors()) {
        System.out.println("Errors: " + err);
      }
      throw new IllegalArgumentException("Could not parse knowledge.");
    }

    kbase = KnowledgeBaseFactory.newKnowledgeBase();
    // add packages to the knowledgebase
    kbase.addKnowledgePackages(kbuilder.getKnowledgePackages());

    return kbase;

  }

  protected static Resource loadRuleFile(String ruleFile) {
    if (ruleFile.contains("://")) {
      return ResourceFactory.newUrlResource(ruleFile);
    } else {
      return ResourceFactory.newClassPathResource(ruleFile, KnowledgeBaseBuilder.class);
    }
  }

}

package com.mytutorial;

import java.io.IOException;

import java.util.List;

import org.drools.KnowledgeBase;

import org.drools.KnowledgeBaseFactory;

import org.drools.builder.KnowledgeBuilder;

import org.drools.builder.KnowledgeBuilderError;

import org.drools.builder.KnowledgeBuilderFactory;

import org.drools.builder.ResourceType;

import org.drools.io.Resource;

import org.drools.io.ResourceFactory;

public class KnowledgeBaseBuilder {

public static KnowledgeBase build(List<RuleMap<String, Object>> ruleAttributes) throws IOException {

KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();

KnowledgeBase kbase = KnowledgeBaseFactory.newKnowledgeBase();

Resource rules = loadRuleFile("product.drl");

rules = TemplateExpander.expand(rules, ruleAttributes);

kbuilder.add(rules, ResourceType.DRL);

// handle errors

if (kbuilder.hasErrors()) {

for (KnowledgeBuilderError err : kbuilder.getErrors()) {

System.out.println("Errors: " + err);

}

throw new IllegalArgumentException("Could not parse knowledge.");

}

kbase = KnowledgeBaseFactory.newKnowledgeBase();

// add packages to the knowledgebase

kbase.addKnowledgePackages(kbuilder.getKnowledgePackages());

return kbase;

}

protected static Resource loadRuleFile(String ruleFile) {

if (ruleFile.contains("://")) {

return ResourceFactory.newUrlResource(ruleFile);

} else {

return ResourceFactory.newClassPathResource(ruleFile, KnowledgeBaseBuilder.class);

}

Step 8: The “product.drl” contains the rules to calculate the discounts and apply to each item. The extension “drl” stands for Drools Rule Language. For example, different products have different bulk discount in addition to the normal discount.

Read this along with Step: 9 which supplies the rule data “id, normalDiscountRate, productType, bulkDiscountQty, and bulkDiscountRate ” via the values created from the createDummyRuleMap() method. In commercial projects, these rule map or data is supplied via database tables or a excel spreadsheets. The business users maintain this rule data. They could modify the bulk discount quantity from time to time. The whole beauty of drools is that rules are maintained separately. These values are referred within the drl file with “@“. Each item from the “getOrderItems()” is validated against the rule map. The items are prefixed with “$”

template header
id
normalDiscountRate
productType
bulkDiscountQty
bulkDiscountRate

package com.mytutorial

import com.mytutorial.*;
import java.math.*;
import java.text.*;
import java.util.*;

template "product-discount"


rule "@{id}"
    when $item : OrderItem(type == OrderItem.PROD_TYPE.@{productType});

    then
      BigDecimal disc = new BigDecimal("@{normalDiscountRate}");
      if($item.getUnits() >= @{bulkDiscountQty}){
           disc = disc.add(BigDecimal.valueOf(@{bulkDiscountRate}));
      }
    
      $item.setEffectiveDiscountRate(disc);
      $item.setDiscountedUnitPrice($item.getUnitPrice().multiply(BigDecimal.ONE.subtract(disc)));
end
end template

template header

normalDiscountRate

productType

bulkDiscountQty

bulkDiscountRate

package com.mytutorial

import com.mytutorial.*;

import java.math.*;

import java.text.*;

import java.util.*;

template "product-discount"

rule "@{id}"

when $item : OrderItem(type == OrderItem.PROD_TYPE.@{productType});

then

BigDecimal disc = new BigDecimal("@{normalDiscountRate}");

if($item.getUnits() >= @{bulkDiscountQty}){

disc = disc.add(BigDecimal.valueOf(@{bulkDiscountRate}));

}

$item.setEffectiveDiscountRate(disc);

$item.setDiscountedUnitPrice($item.getUnitPrice().multiply(BigDecimal.ONE.subtract(disc)));

end

end template

Step 9: Finally the “App” class with the main method to run. In commercial applications, the actual rules will be stored in a database server table or a an Excel spreadsheet. This allows the business to view and maintain the rules. If the rules change, the database table or spreadsheet can be modified. In this tutorial, for simplicity supplied as dummy rules via createDummyRuleMap() method.

package com.mytutorial;

import java.io.IOException;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;

import org.drools.KnowledgeBase;
import org.drools.runtime.StatefulKnowledgeSession;

public class App {
  private static final String KEY_ID = "id";
  private static final String KEY_PRODUCT_TYPE = "productType";
  private static final String KEY_DISCOUNT_RATE = "normalDiscountRate";
  private static final String KEY_BULK_DISCOUNT_QTY = "bulkDiscountQty";
  private static final String KEY_BULK_DISCOUNT_RATE = "bulkDiscountRate";

  public static void main(String[] args) throws IOException {
    List<RuleMap<String, Object>> ruleAttributes = createDummyRuleMap();
    KnowledgeBase kbase = KnowledgeBaseBuilder.build(ruleAttributes);

    StatefulKnowledgeSession ksession = kbase.newStatefulKnowledgeSession();

    List<OrderItem> orderItems = getOrderItems();

    for (OrderItem orderItem : orderItems) {
      System.out.println("Before firing the rules:" + orderItem);

      ksession.insert(orderItem);
      ksession.fireAllRules();
      System.out.println("After firing the rules:" + orderItem);
    }

    ksession.dispose();

  }

  /**
   * In commercial apps, can be read from a database table or Excel spreadsheet
   * @return
   */
  private static List<RuleMap<String, Object>> createDummyRuleMap() {
    RuleMap<String, Object> ruleSet1 = new RuleMap<String, Object>();
    ruleSet1.put(KEY_ID, 1);
    ruleSet1.put(KEY_PRODUCT_TYPE, OrderItem.PROD_TYPE.BASIC);
    ruleSet1.put(KEY_DISCOUNT_RATE, 0.1);
    ruleSet1.put(KEY_BULK_DISCOUNT_QTY, 5);
    ruleSet1.put(KEY_BULK_DISCOUNT_RATE, 0.2);

    RuleMap<String, Object> ruleSet2 = new RuleMap<String, Object>();
    ruleSet2.put(KEY_ID, 2);
    ruleSet2.put(KEY_PRODUCT_TYPE, OrderItem.PROD_TYPE.LUXURY);
    ruleSet2.put(KEY_DISCOUNT_RATE, 0.2);
    ruleSet2.put(KEY_BULK_DISCOUNT_QTY, 10);
    ruleSet2.put(KEY_BULK_DISCOUNT_RATE, 0.3);

    List<RuleMap<String, Object>> rules = new ArrayList<RuleMap<String, Object>>();
    rules.add(ruleSet1);
    rules.add(ruleSet2);

    return rules;
  }

  /**
   * Create some OrderItems 
   * @return
   */
  private static List<OrderItem> getOrderItems() {
    OrderItem orderItem1 = new OrderItem();
    orderItem1.setType(OrderItem.PROD_TYPE.BASIC);
    orderItem1.setUnits(3);
    orderItem1.setUnitPrice(BigDecimal.valueOf(2.50));

    OrderItem orderItem2 = new OrderItem();
    orderItem2.setType(OrderItem.PROD_TYPE.LUXURY);
    orderItem2.setUnits(12);
    orderItem2.setUnitPrice(BigDecimal.valueOf(5.00));

    List<OrderItem> listOfItems = new ArrayList<OrderItem>();
    listOfItems.add(orderItem1);
    listOfItems.add(orderItem2);

    return listOfItems;
  }
}

package com.mytutorial;

import java.io.IOException;

import java.math.BigDecimal;

import java.util.ArrayList;

import java.util.List;

import org.drools.KnowledgeBase;

import org.drools.runtime.StatefulKnowledgeSession;

public class App {

private static final String KEY_ID = "id";

private static final String KEY_PRODUCT_TYPE = "productType";

private static final String KEY_DISCOUNT_RATE = "normalDiscountRate";

private static final String KEY_BULK_DISCOUNT_QTY = "bulkDiscountQty";

private static final String KEY_BULK_DISCOUNT_RATE = "bulkDiscountRate";

public static void main(String[] args) throws IOException {

List<RuleMap<String, Object>> ruleAttributes = createDummyRuleMap();

KnowledgeBase kbase = KnowledgeBaseBuilder.build(ruleAttributes);

StatefulKnowledgeSession ksession = kbase.newStatefulKnowledgeSession();

List<OrderItem> orderItems = getOrderItems();

for (OrderItem orderItem : orderItems) {

System.out.println("Before firing the rules:" + orderItem);

ksession.insert(orderItem);

ksession.fireAllRules();

System.out.println("After firing the rules:" + orderItem);

}

ksession.dispose();

}

/**

* In commercial apps, can be read from a database table or Excel spreadsheet

* @return

private static List<RuleMap<String, Object>> createDummyRuleMap() {

RuleMap<String, Object> ruleSet1 = new RuleMap<String, Object>();

ruleSet1.put(KEY_ID, 1);

ruleSet1.put(KEY_PRODUCT_TYPE, OrderItem.PROD_TYPE.BASIC);

ruleSet1.put(KEY_DISCOUNT_RATE, 0.1);

ruleSet1.put(KEY_BULK_DISCOUNT_QTY, 5);

ruleSet1.put(KEY_BULK_DISCOUNT_RATE, 0.2);

RuleMap<String, Object> ruleSet2 = new RuleMap<String, Object>();

ruleSet2.put(KEY_ID, 2);

ruleSet2.put(KEY_PRODUCT_TYPE, OrderItem.PROD_TYPE.LUXURY);

ruleSet2.put(KEY_DISCOUNT_RATE, 0.2);

ruleSet2.put(KEY_BULK_DISCOUNT_QTY, 10);

ruleSet2.put(KEY_BULK_DISCOUNT_RATE, 0.3);

List<RuleMap<String, Object>> rules = new ArrayList<RuleMap<String, Object>>();

rules.add(ruleSet1);

rules.add(ruleSet2);

return rules;

}

/**

* Create some OrderItems

* @return

private static List<OrderItem> getOrderItems() {

OrderItem orderItem1 = new OrderItem();

orderItem1.setType(OrderItem.PROD_TYPE.BASIC);

orderItem1.setUnits(3);

orderItem1.setUnitPrice(BigDecimal.valueOf(2.50));

OrderItem orderItem2 = new OrderItem();

orderItem2.setType(OrderItem.PROD_TYPE.LUXURY);

orderItem2.setUnits(12);

orderItem2.setUnitPrice(BigDecimal.valueOf(5.00));

List<OrderItem> listOfItems = new ArrayList<OrderItem>();

listOfItems.add(orderItem1);

listOfItems.add(orderItem2);

return listOfItems;

}

When you run the above “App.java”

Output:

Before firing the rules:OrderItem [type=BASIC, units=3, unitPrice=2.5, effectiveDiscountRate=null, discountedUnitPrice=null]
After firing the rules:OrderItem [type=BASIC, units=3, unitPrice=2.5, effectiveDiscountRate=0.1, discountedUnitPrice=2.25]
Before firing the rules:OrderItem [type=LUXURY, units=12, unitPrice=5.0, effectiveDiscountRate=null, discountedUnitPrice=null]
After firing the rules:OrderItem [type=LUXURY, units=12, unitPrice=5.0, effectiveDiscountRate=0.5, discountedUnitPrice=2.50]

Before firing the rules:OrderItem [type=BASIC, units=3, unitPrice=2.5, effectiveDiscountRate=null, discountedUnitPrice=null]

After firing the rules:OrderItem [type=BASIC, units=3, unitPrice=2.5, effectiveDiscountRate=0.1, discountedUnitPrice=2.25]

Before firing the rules:OrderItem [type=LUXURY, units=12, unitPrice=5.0, effectiveDiscountRate=null, discountedUnitPrice=null]

After firing the rules:OrderItem [type=LUXURY, units=12, unitPrice=5.0, effectiveDiscountRate=0.5, discountedUnitPrice=2.50]

300+ Big Data Interview FAQs

Big Data Tutorials

300+ Java Interview FAQs

Java Code Quality FAQs

16+ Java Key Areas to go places

800+ Java Interview Q&As

Java Tutorials

Java Architect FAQs

Java Coding Q&As

01: Drools tutorial with Maven and Eclipse

Output:

Java Interview FAQs

Big Data Interview FAQs

800+ Java Interview Q&As

Reviews

More reviews

Disclaimer