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 maintien de la logique métier dans le code source peut devenir trop compliqué. Les règles de gestion peuvent être utilisées pour faciliter le développement et la maintenance en séparant la logique de gestion 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 deJava Rule API Engine.

2. Drools

Drools est une solution BRMS (Business Rules Management System). Drools peut s’intégrer à jBPM, un outil de gestion des processus métier permettant de normaliser les processus, les activités liées aux événements, les tâches, etc.

Si vous voulez en savoir plus, une introduction à Drools est disponiblehere, ainsi qu'un article surintegration with 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 permet de rapprocher les utilisateurs professionnels et les développeurs.

Voici un exemple simple du fonctionnement de la structure en utilisant un fichier Excel contenant des tables de décision. Tout d'abord, importons ses dépendances qui reposent sur les modulesorg.openl.core etorg.openl.rules:


    org.openl
    org.openl.core
    5.19.4


    org.openl.rules
    org.openl.rules
    5.19.4

Maintenant, un POJOUser:

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

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

public enum Greeting {
    // ...
}

La classeCase encapsule l'objetUser avec des variables qui conduisent à des résultats:

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

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

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

La classeResponse 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 faciles

Easy Rules est un moteur de règles Java simple 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 ni de fichiers de langage spécifique à un 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, commethis framework doesn’t implement the JSR94 standard et la logique métier doivent être codés directement en code Java.

Ici, nous fournissons un exemple «Bonjour, le monde». Importons les dépendances requises en fonction du moduleeasy-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 Java 8 lambdas et le modèle de chaîne de responsabilité pour définir des règles utilisant une approche BDD simple.

Comme la plupart des moteurs de règles, RuleBook utilise le concept de «Facts», qui est 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 loin dans la chaîne. Pour les règles qui lisent des données (Facts) d'un type et produisent un résultat d'un type différent, RuleBook aDecisions.

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 modulerulebook-core:


    com.deliveredtechnologies
    rulebook-core
    0.6.2

Maintenant, nous créons la règle:

public class HelloWorldRule {
    public RuleBook

TOC

Liste des moteurs de règles en Java