Liste des moteurs de règles en Java

1. Vue d'ensemble

Dans cet article, nous allons passer en revue certains des moteurs de règles les plus populaires pour Java.

Dans les applications critiques, le processus de maintien de la logique métier dans le code source peut devenir trop compliqué. Les règles métier peuvent être utilisées pour faciliter le développement et la maintenance en séparant la logique métier du code source.

Dans le monde Java, la plupart des bibliothèques de moteurs de règles implémentent la norme JSR94 connue sous le nom de Java Rule API Engine.

2. Bave

Drools est une solution BRMS (Business Rules Management System). Drools peut s'intégrer à jBPM, un outil de gestion des processus métier pour la standardisation des processus, des activités d'événements, des tâches, etc.

Si vous souhaitez en savoir plus, une introduction à Drools est disponible ici, ainsi qu'un article sur l'intégration avec Spring.

3. Tablettes OpenL

OpenL Tablets est un système de gestion des règles métier et un moteur de règles métier basé sur des tables de décision Excel. Étant donné que le format des tableaux utilisé par ce cadre est familier aux utilisateurs professionnels, il comble le fossé entre les utilisateurs professionnels et les développeurs.

Voici un exemple simple du fonctionnement du cadre à l'aide d'un fichier Excel contenant des tables de décision. Tout d'abord, importons ses dépendances qui reposent sur les modules org.openl.core et org.openl.rules:

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

Maintenant, un POJO utilisateur :

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

Et une énumération qui représentera le résultat des règles appliquées:

public enum Greeting { // ... }

La classe Case encapsule l' objet User avec des variables qui conduisent à des résultats:

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

L'interface IRule contient la règle injectée par le fichier Excel:

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

La classe Response gère le retour de la règle appliquée:

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

La classe principale, qui déclenche l'exécution de la règle:

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. Règles simples

Easy Rules est un simple moteur de règles Java fournissant un cadre léger et basé sur POJO pour définir les activités. Il peut créer des règles complexes à partir de règles primitives en utilisant le modèle composite.

Ce cadre, contrairement aux moteurs de règles les plus traditionnels, n'utilise pas de fichiers XML ou de fichiers de langage spécifique au domaine pour séparer les règles de l'application. Il utilise des classes et des méthodes basées sur des annotations pour injecter une logique métier dans l'application.

Les règles faciles peuvent être utiles aux développeurs pour créer et gérer des applications avec une logique métier entièrement séparée de l'application elle-même. D'autre part, comme ce framework n'implémente pas le standard JSR94 et la logique métier doit être codée directement en code Java.

Ici, nous fournissons un exemple «Hello, world». Importons les dépendances requises en fonction du module easy-rules-core:

 org.jeasy easy-rules-core 3.0.0 

Ensuite, nous créons une classe qui définit une règle:

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

Enfin, nous créons 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. Livre de règles

RuleBook est un framework Java qui exploite les lambdas Java 8 et le modèle Chain of Responsibility pour définir des règles à l'aide d'une approche BDD simple.

Comme la plupart des moteurs de règles, RuleBook utilise le concept de « faits », qui sont des données fournies aux règles. RuleBook permet aux règles de modifier l'état des faits, qui peuvent ensuite être lus et modifiés par des règles plus bas dans la chaîne. Pour les règles qui lisent des données ( faits ) d'un type et produisent un résultat d'un type différent, RuleBook contient des décisions .

RuleBook peut être intégré à Spring à l'aide de Java DSL.

Ici, nous fournissons un exemple simple «Hello, world» utilisant RuleBook. Ajoutons sa dépendance qui repose sur le module de base du livre de règles:

 com.deliveredtechnologies rulebook-core 0.6.2 

Maintenant, nous créons la règle:

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

Enfin, la classe principale:

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

6. Conclusion

Dans cet article rapide, nous avons discuté de certaines bibliothèques bien connues qui fournissent des moteurs d'abstraction de logique métier.

Comme toujours, des exemples de cet article sont disponibles sur notre référentiel GitHub.