Liste der Rules Engines in Java

Liste der Regelengines in Java

1. Überblick

In diesem Artikel werden einige der beliebtesten Regel-Engines für Java vorgestellt.

In geschäftskritischen Anwendungen kann die Verwaltung der Geschäftslogik im Quellcode zu kompliziert werden. Geschäftsregeln können verwendet werden, um die Entwicklung und Wartung zu vereinfachen, indem die Geschäftslogik vom Quellcode getrennt wird.

In der Java-Welt implementieren die meisten Regelengine-Bibliotheken den JSR94-StandardJava Rule API Engine.

2. Sabber

Drools ist eine BRMS-Lösung (Business Rules Management System). Drools können in jBPM, ein Business Process Management-Tool zur Standardisierung von Prozessen, Ereignisaktivitäten, Aufgaben usw., integriert werden.

Wenn Sie mehr lesen möchten, finden Sie eine Einführung in Droolshere sowie einen Artikel zuintegration with Spring.

3. OpenL Tablets

OpenL Tablets ist ein Geschäftsregelverwaltungssystem und eine Geschäftsregelengine, die auf Excel-Entscheidungstabellen basiert. Da das Format der von diesem Framework verwendeten Tabellen den Geschäftsbenutzern vertraut ist, schließt es die Lücke zwischen Geschäftsbenutzern und Entwicklern.

Hier ist ein einfaches Beispiel, wie das Framework mithilfe einer Excel-Datei mit Entscheidungstabellen funktioniert. Importieren wir zunächst die Abhängigkeiten, die auf den Modulenorg.openl.core undorg.openl.rules basieren:


    org.openl
    org.openl.core
    5.19.4


    org.openl.rules
    org.openl.rules
    5.19.4

Nun einUser POJO:

public class User {
    private String name;
    // getters and setters
}

Und eine Aufzählung, die das Ergebnis der angewandten Regeln darstellt:

public enum Greeting {
    // ...
}

Die KlasseCaseumschließt das ObjektUsermit Variablen, die zu Ergebnissen führen:

public class Case {
    // Variables to infer outcomes
    // getters and setters
}

Die SchnittstelleIRule enthält die von der Excel-Datei eingefügte Regel:

public interface IRule {
    void helloUser(Case aCase, final Response response);
}

Die KlasseResponsebehandelt die Rückgabe der angewendeten Regel:

public class Response {
    private String result;
    private Map map = new HashMap<>();
}

Die Hauptklasse, die die Regelausführung auslöst:

public class Main {
    private IRule instance;

    public static void main(String[] args) {
        Main rules = new Main();
        // setup user and case here
        rules.process(aCase);
    }

    public void process(Case aCase) {
        EngineFactory engineFactory = new RulesEngineFactory(
          getClass().getClassLoader()
            .getResource("openltablets/HelloUser.xls"), IRule.class);
        instance = engineFactory.newEngineInstance();
        instance.helloUser(aCase, new Response());
    }
}

4. Einfache Regeln

Easy Rules ist eine einfache Java-Regel-Engine, die ein einfaches und POJO-basiertes Framework zur Definition von Geschäftsabläufen bietet. Mithilfe des zusammengesetzten Musters können komplexe Regeln aus primitiven Regeln erstellt werden.

Dieses Framework verwendet im Gegensatz zu den meisten herkömmlichen Regelmodulen keine XML-Dateien oder domänenspezifischen Sprachdateien, um Regeln von der Anwendung zu trennen. Es werden annotationsbasierte Klassen und Methoden zum Einfügen von Geschäftslogik in die Anwendung verwendet.

Mit Easy Rules können Entwickler Anwendungen mit Geschäftslogik erstellen und verwalten, die vollständig von der Anwendung selbst getrennt ist. Andererseits müssen alsthis framework doesn’t implement the JSR94 standard und die Geschäftslogik direkt in Java-Code codiert werden.

Hier geben wir ein Beispiel für „Hallo Welt“. Importieren wir die erforderlichen Abhängigkeiten basierend auf dem Moduleasy-rules-core:


    org.jeasy
    easy-rules-core
    3.0.0

Als Nächstes erstellen wir eine Klasse, die eine Regel definiert:

@Rule(name = "Hello World rule", description = "Always say hello world")
public class HelloWorldRule {

    @Condition
    public boolean when() {
        return true;
    }

    @Action
    public void then() throws Exception {
        System.out.println("hello world");
    }
}

Schließlich erstellen wir die Hauptklasse:

public class Launcher {
    public static void main(String... args) {
        // create facts
        Facts facts = new Facts();

        // create rules
        Rules rules = new Rules();
        rules.register(new HelloWorldRule());

        // create a rules engine and fire rules on known facts
        RulesEngine rulesEngine = new DefaultRulesEngine();
        rulesEngine.fire(rules, facts);
    }
}

5. Regelbuch

RuleBook ist ein Java-Framework, das Java 8-Lambdas und das Chain of Responsibility-Muster nutzt, um Regeln mithilfe eines einfachen BDD-Ansatzes zu definieren.

Wie die meisten Regel-Engines verwendet RuleBook das Konzept von „Facts“, dh Daten, die an Regeln geliefert werden. Mit RuleBook können Regeln den Status von Fakten ändern, die dann von Regeln weiter unten in der Kette gelesen und geändert werden können. Für die Regeln, die Daten (Facts) eines Typs einlesen und ein Ergebnis eines anderen Typs ausgeben, hat RuleBookDecisions.

RuleBook kann mithilfe von Java DSL in Spring integriert werden.

Hier stellen wir ein einfaches Beispiel für die Verwendung von RuleBook mit dem Titel "Hallo Welt" vor. Fügen wir die Abhängigkeit hinzu, die vom Modulrulebook-coreabhängt:


    com.deliveredtechnologies
    rulebook-core
    0.6.2

Nun erstellen wir die Regel:

public class HelloWorldRule {
    public RuleBook

TOC