Lijst met regelmotoren in Java

1. Overzicht

In dit artikel bespreken we enkele van de meest populaire regelengines voor Java.

Binnen bedrijfskritische applicaties kan het proces van het onderhouden van bedrijfslogica binnen de broncode te gecompliceerd worden. Bedrijfsregels kunnen worden gebruikt om de ontwikkeling en het onderhoud te vergemakkelijken door bedrijfslogica te scheiden van de broncode.

In de Java-wereld implementeren de meeste regelsengines-bibliotheken de JSR94-standaard die bekend staat als Java Rule API Engine.

2. Drools

Drools is een oplossing voor Business Rules Management System (BRMS). Drools kan worden geïntegreerd met jBPM, een Business Process Management-tool voor standaardisatie van processen, evenementen, taken, enz.

Als je meer wilt lezen, kun je hier een inleiding tot Drools vinden, samen met een artikel over integratie met Spring.

3. OpenL-tablets

OpenL Tablets is een beheersysteem voor bedrijfsregels en een engine voor bedrijfsregels op basis van Excel-beslissingstabellen. Aangezien het formaat van tabellen dat door dit raamwerk wordt gebruikt, bekend is bij zakelijke gebruikers, overbrugt het de kloof tussen zakelijke gebruikers en ontwikkelaars.

Hier is een eenvoudig voorbeeld van hoe het raamwerk werkt door een Excel-bestand met beslissingstabellen te gebruiken. Laten we eerst de afhankelijkheden importeren die afhankelijk zijn van de modules org.openl.core en org.openl.rules:

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

Nu, een Gebruiker POJO:

openbare klasse Gebruiker {privé Stringnaam; // getters en setters}

En een opsomming die de uitkomst van de toegepaste regels weergeeft:

openbare opsomming Begroeting {// ...}

De Geval klasse wikkelt de Gebruiker object met variabelen die tot uitkomsten leiden:

public class Case {// Variabelen om uitkomsten af ​​te leiden // getters en setters}

De interface Ik regeer bevat de regel die is geïnjecteerd door het Excel-bestand:

openbare interface IRule {void helloUser (Case aCase, laatste antwoordantwoord); }

De Reactie class behandelt de terugkeer van de toegepaste regel:

public class Response {privé String-resultaat; private Map map = nieuwe HashMap (); }

De hoofdklasse die de uitvoering van de regel activeert:

openbare klasse Hoofd {privé IRule-instantie; public static void main (String [] args) {Main rules = new Main (); // stel hier de gebruiker en het geval in rules.process (aCase); } openbaar ongeldig proces (Case aCase) {EngineFactory engineFactory = nieuwe RulesEngineFactory (getClass (). getClassLoader () .getResource ("openltablets / HelloUser.xls"), IRule.class); instantie = engineFactory.newEngineInstance (); instance.helloUser (aCase, new Response ()); }}

4. Eenvoudige regels

Easy Rules is een eenvoudige Java-regelsengine die een lichtgewicht en op POJO gebaseerd raamwerk biedt om zaken te definiëren. Het kan complexe regels maken op basis van primitieve regels door het samengestelde patroon te gebruiken.

Dit framework maakt, in tegenstelling tot de meest traditionele regelengines, geen gebruik van XML-bestanden of domeinspecifieke taalbestanden om regels van de applicatie te scheiden. Het maakt gebruik van op aantekeningen gebaseerde klassen en methoden om bedrijfslogica in de applicatie te injecteren.

Eenvoudige regels kunnen handig zijn voor ontwikkelaars om applicaties te maken en te onderhouden met bedrijfslogica die volledig gescheiden is van de applicatie zelf. Aan de andere kant, zoals dit framework implementeert de JSR94-standaard niet en de bedrijfslogica moet rechtstreeks naar Java-code worden gecodeerd.

Hier geven we een "Hallo, wereld" voorbeeld. Laten we de vereiste afhankelijkheden importeren op basis van de module easy-rules-core:

 org.jeasy easy-rules-core 3.0.0 

Vervolgens maken we een klasse die een regel definieert:

@Rule (name = "Hello World rule", description = "Zeg altijd hallo wereld") openbare klasse HelloWorldRule {@Condition openbare boolean when () {return true; } @Action public void then () gooit Uitzondering {System.out.println ("hallo wereld"); }}

Ten slotte maken we de hoofdklasse:

public class Launcher {public static void main (String ... args) {// maak feiten Facts facts = new Facts (); // maak regels Rules rules = new Rules (); rules.register (new HelloWorldRule ()); // maak een regels engine en brand regels op bekende feiten RulesEngine rulesEngine = new DefaultRulesEngine (); rulesEngine.fire (regels, feiten); }}

5. Regelboek

RuleBook is een Java-framework dat gebruikmaakt van Java 8 lambdas en het Chain of Responsibility-patroon om regels te definiëren met behulp van een eenvoudige BDD-benadering.

Zoals de meeste regelengines, maakt RuleBook gebruik van het concept van "Feiten”, Dat zijn gegevens die aan regels worden verstrekt. Met RuleBook kunnen regels de stand van zaken wijzigen, die vervolgens kunnen worden gelezen en gewijzigd door regels verderop in de keten. Voor die regels die gegevens inlezen (Feiten) van het ene type en output een resultaat van een ander type, RuleBook heeft Beslissingen.

RuleBook kan worden geïntegreerd met Spring met behulp van Java DSL.

Hier geven we een eenvoudig "Hallo, wereld" -voorbeeld met behulp van RuleBook. Laten we de afhankelijkheid toevoegen die vertrouwt op de rulebook-core-module:

 com.deliveredtechnologies rulebook-core 0.6.2 

Nu maken we de regel:

openbare klasse HelloWorldRule {openbare RuleBook defineHelloWorldRules () {return RuleBookBuilder .create () .addRule (rule -> rule.withNoSpecifiedFactType () .then (f -> System.out.print ("Hallo"))) .addRule (rule - > rule.withNoSpecifiedFactType () .then (f -> System.out.println ("Wereld"))) .build (); }} 

Eindelijk de hoofdklasse:

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

6. Conclusie

In dit korte artikel hebben we enkele bekende bibliotheken besproken die engines bieden voor abstractie van bedrijfslogica.

Zoals altijd zijn voorbeelden uit dit artikel beschikbaar in onze GitHub-repository.