EVRete: A Modern Java Rule Engine

EVRete is a high-performance, lightweight, and open-source rule engine designed for Java applications. It offers a flexible and expressive way to implement rule-based logic, making it a compelling alternative to traditional rule engines like Drools. This article delves into EVRete’s features, focusing on its annotation-based approach to rule definition.

Why EVRete?

EVRete stands out due to several key characteristics:

• Speed and Efficiency: EVRete boasts impressive performance, often surpassing other rule engines in benchmarks. Its optimized implementation of the Rete algorithm ensures efficient rule evaluation.
• Lightweight: With a small footprint, EVRete is easily integrated into various applications without significant overhead.
• Expressive API: EVRete provides a fluent API and supports both lambda expressions and annotations for defining rules, catering to different coding styles.
• Java-Centric: Built purely in Java, EVRete seamlessly integrates with Java projects and leverages familiar language constructs.

Rule Definition with Annotations

EVRete’s annotation-based approach provides a structured and organized way to define rules. Here’s a breakdown of the key annotations:

• @Rule: This annotation marks a method as a rule. It allows you to specify the rule’s name and activation mode (e.g., FIRE_ONCE, FIRE_EVERY_TIME).
• @Where: This annotation designates a method that defines the rule’s condition. It evaluates to a boolean value, determining whether the rule should fire.
• @Fact: This annotation is used to inject facts (data objects) into the rule method.

Example: Discount Rule

Let’s illustrate with a classic discount rule:

import org.evrete.api.ActivationMode;
import org.evrete.dsl.annotation.Rule;
import org.evrete.dsl.annotation.Where;

public class DiscountRules {

    @Rule(activationMode = ActivationMode.FIRE_EVERY_TIME)
    public void applyDiscount(Order $order) {
        $order.applyDiscount(0.1);
    }

    @Where
    public boolean condition(Order $order) {
        return $order.getTotalPrice() > 100;
    }
}

In this example:

• applyDiscount is marked as a rule that fires every time its condition is met.
• condition defines the condition: the order’s total price must exceed 100.
• The Order object is implicitly injected into both methods.

Integrating with Spring Boot

EVRete smoothly integrates with Spring Boot. Here’s a basic service example:

import org.evrete.KnowledgeService;
import org.evrete.api.StatelessSession;
import org.springframework.stereotype.Service;

@Service
public class OrderService {

    private final KnowledgeService knowledgeService = new KnowledgeService();
    private final StatelessSession session;

    public OrderService() {
        this.session = knowledgeService
                .newStatelessSession()
                .add(DiscountRules.class); 
    }

    public Order applyRules(Order order) {
        session.fire(order);
        return order;
    }
}

This service creates a stateless session, adds the DiscountRules class, and fires the session with the provided Order object.

Benefits of Annotations

Using annotations offers several advantages:

• Improved Readability: Annotations clearly separate rules and conditions, enhancing code organization.
• Reduced Boilerplate: Annotations minimize the need for manual rule registration and configuration.
• Type Safety: Annotations provide compile-time checks for rule parameters.

Beyond the Basics

EVRete provides a rich set of features beyond basic rule definitions:

• Complex Event Processing (CEP): Handle streams of events and detect patterns over time.
• Type Declarations: Define custom data types and their properties for use in rules.
• Stateful Sessions: Maintain session state between rule executions.

Conclusion

EVRete is a powerful and modern rule engine that empowers Java developers to implement complex logic in a clear and efficient manner. Its annotation-based approach further enhances its usability and maintainability. Whether you’re building a simple rule-based system or a sophisticated event-driven application, EVRete offers a compelling toolkit for managing your business logic.