Liste der Regel-Engines in Java

1. Übersicht

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

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

In der Java-Welt implementieren die meisten Regelengine-Bibliotheken den JSR94-Standard, der als Java Rule API Engine bekannt ist.

2. Sabbern

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

Wenn Sie mehr lesen möchten, finden Sie hier eine Einführung in Drools sowie einen Artikel zur Integration in Spring.

3. OpenL Tablets

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

Hier ist ein einfaches Beispiel für die Funktionsweise des Frameworks mithilfe einer Excel-Datei mit Entscheidungstabellen. Importieren wir zunächst die Abhängigkeiten, die auf den Modulen org.openl.core und org.openl.rules basieren:

 org.openl org.openl.core 5.19.4   org.openl.rules org.openl.rules 5.19.4 

Nun ein Benutzer 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 Case- Klasse umschließt das User- Objekt mit Variablen, die zu Ergebnissen führen:

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

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

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

Die Response- Klasse behandelt 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 leichtes und POJO-basiertes Framework zur Definition des Geschäfts bietet. Mithilfe des zusammengesetzten Musters können komplexe Regeln aus primitiven Regeln erstellt werden.

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

Mit Easy Rules können Entwickler Anwendungen mit Geschäftslogik erstellen und verwalten, die vollständig von der Anwendung selbst getrennt ist. Andererseits, da dieses Framework den JSR94-Standard nicht implementiert und die Geschäftslogik direkt in Java-Code codiert werden muss.

Hier geben wir ein Beispiel für "Hallo Welt". Importieren wir die erforderlichen Abhängigkeiten basierend auf dem Easy-Rules-Core-Modul:

 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 der „ Fakten “ , 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 ( Fakten ) eines Typs einlesen und ein Ergebnis eines anderen Typs ausgeben, verfügt RuleBook über Entscheidungen .

RuleBook kann mit Java DSL in Spring integriert werden.

Hier bieten wir ein einfaches Beispiel für "Hallo Welt" mit RuleBook. Fügen wir die Abhängigkeit hinzu, die auf dem Regelbuch-Kernmodul beruht:

 com.deliveredtechnologies rulebook-core 0.6.2 

Nun erstellen wir die Regel:

public class HelloWorldRule { public RuleBook defineHelloWorldRules() { return RuleBookBuilder .create() .addRule(rule -> rule.withNoSpecifiedFactType() .then(f -> System.out.print("Hello "))) .addRule(rule -> rule.withNoSpecifiedFactType() .then(f -> System.out.println("World"))) .build(); } } 

Schließlich die Hauptklasse:

public static void main(String[] args) { HelloWorldRule ruleBook = new HelloWorldRule(); ruleBook .defineHelloWorldRules() .run(new FactMap()); } 

6. Fazit

In diesem kurzen Artikel haben wir einige bekannte Bibliotheken besprochen, die Engines für die Abstraktion von Geschäftslogik bereitstellen.

Beispiele aus diesem Artikel finden Sie wie immer in unserem GitHub-Repository.