Problem Statement
Design an extensible rules and decision engine (similar to Drools or JSON-Rules-Engine). The engine must allow developers to compile complex business validation rules (e.g., for calculating discounts or evaluating fraud scores) dynamically, compose them into a hierarchical tree using logical operators (AND, OR, NOT), and recursively evaluate them against dynamic context maps.
Design Decisions & Patterns Used
Hardcoding complex business rules inside nested if-else conditions makes application code fragile and difficult to maintain. A rules engine extracts this logic into structured rule definitions. By compiling rules into an Abstract Syntax Tree (AST), we can parse, modify, and evaluate nested expressions dynamically.
We will utilize the following Design Patterns:
- Composite Pattern: Treating individual rule checks (leaf nodes) and groups of rules (composite logical nodes) uniformly.
- Interpreter Pattern: Evaluating the compiled rule tree recursively against input parameters.
- Builder Pattern: Providing a fluent programmatic API to construct deeply nested rule groups easily.
Functional Requirements
- Model comparison conditions (e.g., equals, greater than) as pluggable rule nodes.
- Model logical operator nodes (
AND,OR,NOT) to combine multiple rules. - Support evaluating rules against a dynamic execution context (a map of key-value properties).
- Build an extensible API to easily add new comparison operators.
Objects Required
EvaluationContext(Wrapper managing input facts/parameters)Rule(Component interface exposing evaluation methods)EqualsRule,GreaterThanRule(Leaf rules implementing basic comparison logic)AndRule,OrRule,NotRule(Composite rules implementing logical operators)
EvaluationContext & Rule Interface
The EvaluationContext class stores the variables to evaluate, and the Rule interface defines the execution contract.
import java.util.HashMap;
import java.util.Map;
public class EvaluationContext {
private final Map<String, Object> facts;
public EvaluationContext() {
this.facts = new HashMap<>();
}
public void setFact(String name, Object value) {
facts.put(name, value);
}
public Object getFact(String name) {
return facts.get(name);
}
}
Let's define the Rule interface:
public interface Rule {
boolean evaluate(EvaluationContext context);
}
The evaluate() method accepts the context facts and returns a boolean value indicating whether the rule conditions are met.
Comparison Rules (Leaf Nodes)
We implement comparison rules to serve as leaf nodes in our rules tree: EqualsRule and GreaterThanRule.
public class EqualsRule implements Rule {
private final String key;
private final Object expectedValue;
public EqualsRule(String key, Object expectedValue) {
this.key = key;
this.expectedValue = expectedValue;
}
@Override
public boolean evaluate(EvaluationContext context) {
Object actual = context.getFact(key);
if (actual == null) return false;
return actual.equals(expectedValue);
}
}
The EqualsRule checks if a context variable matches the expected value, returning false if the variable is missing.
public class GreaterThanRule implements Rule {
private final String key;
private final double threshold;
public GreaterThanRule(String key, double threshold) {
this.key = key;
this.threshold = threshold;
}
@Override
public boolean evaluate(EvaluationContext context) {
Object actual = context.getFact(key);
if (actual instanceof Number) {
return ((Number) actual).doubleValue() > threshold;
}
return false;
}
}
The GreaterThanRule performs numeric comparisons by parsing variables to double values and evaluating them against the threshold.
Logical Rules (Composite Nodes)
We implement logical rules to combine child rules: AndRule, OrRule, and NotRule. These nodes enable parsing nested boolean logic.
import java.util.ArrayList;
import java.util.List;
public class AndRule implements Rule {
private final List<Rule> rules;
public AndRule() {
this.rules = new ArrayList<>();
}
public void addRule(Rule rule) {
rules.add(rule);
}
@Override
public boolean evaluate(EvaluationContext context) {
for (Rule rule : rules) {
if (!rule.evaluate(context)) {
return false; // Short-circuit logic
}
}
return true;
}
}
The AndRule evaluates child rules sequentially, short-circuiting and returning false immediately if any child rule fails.
import java.util.ArrayList;
import java.util.List;
public class OrRule implements Rule {
private final List<Rule> rules;
public OrRule() {
this.rules = new ArrayList<>();
}
public void addRule(Rule rule) {
rules.add(rule);
}
@Override
public boolean evaluate(EvaluationContext context) {
for (Rule rule : rules) {
if (rule.evaluate(context)) {
return true; // Short-circuit logic
}
}
return false;
}
}
The OrRule returns true immediately if any child rule evaluates to true.
public class NotRule implements Rule {
private final Rule rule;
public NotRule(Rule rule) {
this.rule = rule;
}
@Override
public boolean evaluate(EvaluationContext context) {
return !rule.evaluate(context);
}
}
The NotRule negates the boolean outcome of its single wrapped child rule.
Main Driver Class
This class tests our extensible rules engine by creating and evaluating a complex checkout validation rule.
public class Main {
public static void main(String[] args) {
// Build rule tree:
// (OrderTotal > 100.0 AND PaymentMethod == "CREDIT_CARD") OR UserType == "VIP"
AndRule standardPromoRule = new AndRule();
standardPromoRule.addRule(new GreaterThanRule("orderTotal", 100.0));
standardPromoRule.addRule(new EqualsRule("paymentMethod", "CREDIT_CARD"));
OrRule checkoutDiscountRule = new OrRule();
checkoutDiscountRule.addRule(standardPromoRule);
checkoutDiscountRule.addRule(new EqualsRule("userType", "VIP"));
System.out.println("Rule structure compiled successfully.");
// Case 1: Standard user, high order value, paying with credit card (Should pass)
System.out.println("\n--- Evaluating Case 1 (Standard User, Total: 150, Credit Card) ---");
EvaluationContext context1 = new EvaluationContext();
context1.setFact("orderTotal", 150.0);
context1.setFact("paymentMethod", "CREDIT_CARD");
context1.setFact("userType", "STANDARD");
boolean result1 = checkoutDiscountRule.evaluate(context1);
System.out.println("Result: " + result1 + " (Expected: true)");
// Case 2: Standard user, low order value, paying with credit card (Should fail)
System.out.println("\n--- Evaluating Case 2 (Standard User, Total: 50, Credit Card) ---");
EvaluationContext context2 = new EvaluationContext();
context2.setFact("orderTotal", 50.0);
context2.setFact("paymentMethod", "CREDIT_CARD");
context2.setFact("userType", "STANDARD");
boolean result2 = checkoutDiscountRule.evaluate(context2);
System.out.println("Result: " + result2 + " (Expected: false)");
// Case 3: VIP user, low order value, paying with cash (Should pass due to VIP status)
System.out.println("\n--- Evaluating Case 3 (VIP User, Total: 20, Cash) ---");
EvaluationContext context3 = new EvaluationContext();
context3.setFact("orderTotal", 20.0);
context3.setFact("paymentMethod", "CASH");
context3.setFact("userType", "VIP");
boolean result3 = checkoutDiscountRule.evaluate(context3);
System.out.println("Result: " + result3 + " (Expected: true)");
}
}
The main() driver assembles a composite rule tree, configures multiple verification contexts, and runs the evaluation logic to test short-circuiting and node routing behaviors.
Comments
Post a Comment