Elenco dei motori di regole in Java

1. Panoramica

In questo articolo, esamineremo alcuni dei motori di regole più popolari per Java.

All'interno delle applicazioni mission-critical, il processo di mantenimento della logica aziendale all'interno del codice sorgente può diventare troppo complicato. Le regole aziendali possono essere utilizzate per facilitare lo sviluppo e la manutenzione separando la logica aziendale dal codice sorgente.

Nel mondo Java, la maggior parte delle librerie dei motori di regole implementano lo standard JSR94 noto come Java Rule API Engine.

2. Sbava

Drools è una soluzione BRMS (Business Rules Management System). Drools può integrarsi con jBPM, uno strumento di gestione dei processi aziendali per la standardizzazione del processo, delle attività degli eventi, delle attività, ecc.

Se vuoi saperne di più, un'introduzione a Drools è disponibile qui, insieme a un articolo sull'integrazione con Spring.

3. OpenL Tablets

OpenL Tablets è un sistema di gestione delle regole aziendali e un motore di regole aziendali basato su tabelle decisionali di Excel. Poiché il formato delle tabelle utilizzato da questo framework è familiare agli utenti aziendali, colma il divario tra utenti aziendali e sviluppatori.

Di seguito è riportato un semplice esempio di come funziona il framework utilizzando un file Excel contenente tabelle decisionali. Per prima cosa, importiamo le sue dipendenze che si basano sui moduli org.openl.core e org.openl.rules:

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

Ora, un utente POJO:

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

E un enum che rappresenterà il risultato delle regole applicate:

public enum Greeting { // ... }

La classe Case avvolge l' oggetto User con variabili che portano a risultati:

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

L'interfaccia IRule contiene la regola iniettata dal file Excel:

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

La classe Response gestisce la restituzione della regola applicata:

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

La classe principale, che attiva l'esecuzione della regola:

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. Regole facili

Easy Rules è un semplice motore di regole Java che fornisce un framework leggero e basato su POJO per definire il business. Può creare regole complesse da quelle primitive utilizzando il modello composto.

Questo framework, a differenza dei motori di regole più tradizionali, non utilizza file XML o file di linguaggio specifico del dominio per separare le regole dall'applicazione. Utilizza classi e metodi basati su annotazioni per iniettare la logica di business nell'applicazione.

Easy Rules può essere utile per gli sviluppatori per creare e mantenere applicazioni con una logica aziendale completamente separata dall'applicazione stessa. D'altra parte, poiché questo framework non implementa lo standard JSR94 e la logica aziendale deve essere codificata direttamente in codice Java.

Qui forniamo un esempio "Hello, world". Importiamo le dipendenze richieste in base al modulo easy-rules-core:

 org.jeasy easy-rules-core 3.0.0 

Successivamente, creiamo una classe che definisce una regola:

@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"); } }

Infine, creiamo la classe principale:

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. RuleBook

RuleBook è un framework Java che sfrutta i lambda Java 8 e il pattern Chain of Responsibility per definire regole utilizzando un semplice approccio BDD.

Come la maggior parte dei motori di regole, RuleBook utilizza il concetto di " Fatti ", ovvero i dati forniti alle regole. RuleBook consente alle regole di modificare lo stato dei fatti, che possono quindi essere letti e modificati da regole a valle della catena. Per quelle regole che leggono dati ( Fatti ) di un tipo e producono un risultato di un tipo diverso, RuleBook ha Decisioni .

RuleBook può essere integrato con Spring utilizzando Java DSL.

Qui, forniamo un semplice esempio "Hello, world" utilizzando RuleBook. Aggiungiamo la sua dipendenza che si basa sul modulo core del regolamento:

 com.deliveredtechnologies rulebook-core 0.6.2 

Ora creiamo la regola:

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(); } } 

Infine, la classe principale:

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

6. Conclusione

In questo rapido articolo, abbiamo discusso alcune librerie ben note che forniscono motori per l'astrazione della logica di business.

Come sempre, esempi di questo articolo sono disponibili sul nostro repository GitHub.