création d'un moteur de règles simple en java

implémenter un système d'évaluation simple basé sur des règles en Java n'est pas si difficile à réaliser. Probablement l'analyseur pour l'expression est la chose la plus compliquée. Le code d'exemple ci-dessous utilise quelques modèles pour obtenir la fonctionnalité désirée.

un modèle singleton est utilisé pour stocker chaque opération disponible dans une carte membre. L'opération elle-même utilise un modèle de commande pour fournir l'extensibilité flexible tandis que l'action respective pour une expression valide fait usage de le schéma d'expédition. Dernier buste pas moins, un modèle d'interprète est utilisé pour valider chaque règle.

une expression telle que présentée dans votre exemple ci-dessus se compose d'opérations, de variables et de valeurs. En référence à un wiki-exemple tout ce qui peut être déclarée est un Expression. L'interface, par conséquent, ressemble à ceci:

import java.util.Map;

public interface Expression
{
    public boolean interpret(final Map<String, ?> bindings);
}

alors que l'exemple sur la page wiki renvoie un int (ils implémentent une calculatrice), nous n'avons besoin que d'un retour booléen valeur ici de décider si une expression doit déclencher une action si l'expression est évaluée à true.

Une expression peut, comme indiqué ci-dessus, soit d'une opération comme =,AND,NOT,... ou un Variable ou de ses Value. La définition d'un Variable est enrôlé ci-dessous:

import java.util.Map;

public class Variable implements Expression
{
    private String name;

    public Variable(String name)
    {
        this.name = name;
    }

    public String getName()
    {
        return this.name;
    }

    @Override
    public boolean interpret(Map<String, ?> bindings)
    {
        return true;
    }
}

Validation d'un nom de variable ne fait pas beaucoup de sens, donc true est retourné par défaut. Il en va de même pour une valeur d'une variable qui est conservée aussi générique que possible sur la définition d'un BaseType seulement:

import java.util.Map;

public class BaseType<T> implements Expression
{
    public T value;
    public Class<T> type;

    public BaseType(T value, Class<T> type)
    {
        this.value = value;
        this.type = type;
    }

    public T getValue()
    {
        return this.value;
    }

    public Class<T> getType()
    {
        return this.type;
    }

    @Override
    public boolean interpret(Map<String, ?> bindings)
    {
        return true;
    }

    public static BaseType<?> getBaseType(String string)
    {
        if (string == null)
            throw new IllegalArgumentException("The provided string must not be null");

        if ("true".equals(string) || "false".equals(string))
            return new BaseType<>(Boolean.getBoolean(string), Boolean.class);
        else if (string.startsWith("'"))
            return new BaseType<>(string, String.class);
        else if (string.contains("."))
            return new BaseType<>(Float.parseFloat(string), Float.class);
        else
            return new BaseType<>(Integer.parseInt(string), Integer.class);
    }
}

BaseType class contient une méthode d'usine pour générer des types de valeurs concrètes pour un type Java spécifique.

Operation est maintenant une expression spéciale comme AND,NOT,=,... La classe de base abstraite Operation définit un à gauche et à droite opérande opérande peut se référer à plus d'une expression. F. E. NOT se réfère probablement seulement à son expression de la main droite et nie son validation du résultat, donc true transformer en false et vice versa. Mais AND d'un autre côté, combine logiquement une expression de gauche et de droite, forçant les deux expressions à être vraies lors de la validation.

import java.util.Stack;

public abstract class Operation implements Expression
{
    protected String symbol;

    protected Expression leftOperand = null;
    protected Expression rightOperand = null;

    public Operation(String symbol)
    {
        this.symbol = symbol;
    }

    public abstract Operation copy();

    public String getSymbol()
    {
        return this.symbol;
    }

    public abstract int parse(final String[] tokens, final int pos, final Stack<Expression> stack);

    protected Integer findNextExpression(String[] tokens, int pos, Stack<Expression> stack)
    {
        Operations operations = Operations.INSTANCE;

        for (int i = pos; i < tokens.length; i++)
        {
            Operation op = operations.getOperation(tokens[i]);
            if (op != null)
            {
                op = op.copy();
                // we found an operation
                i = op.parse(tokens, i, stack);

                return i;
            }
        }
        return null;
     }
}

deux opérations sautent probablement dans l'œil. int parse(String[], int, Stack<Expression>); refacteurs la logique de l'analyse de l'opération concrète à la classe opératoire respective car elle sait probablement mieux ce dont elle a besoin pour instancier une opération valide. Integer findNextExpression(String[], int, stack); est utilisé pour trouver le côté droit de la opération lors de l'analyse de la chaîne dans une expression. Il peut sembler étrange de retourner un int ici au lieu d'une expression mais l'expression est poussée sur la pile et la valeur de retour ici retourne juste la position du dernier jeton utilisé par l'expression créée. Ainsi, la valeur int est utilisée pour sauter des jetons déjà traités.

AND opération ne ressembler à ceci:

import java.util.Map;
import java.util.Stack;

public class And extends Operation
{    
    public And()
    {
        super("AND");
    }

    public And copy()
    {
        return new And();
    }

    @Override
    public int parse(String[] tokens, int pos, Stack<Expression> stack)
    {
        Expression left = stack.pop();
        int i = findNextExpression(tokens, pos+1, stack);
        Expression right = stack.pop();

        this.leftOperand = left;
        this.rightOperand = right;

        stack.push(this);

        return i;
    }

    @Override
    public boolean interpret(Map<String, ?> bindings)
    {
        return leftOperand.interpret(bindings) && rightOperand.interpret(bindings);
    }
}

parse vous voyez probablement que l'expression déjà générée de le côté gauche est prise à partir de la pile, puis le côté droit est analysé et repris à partir de la pile pour enfin pousser la nouvelle AND opération contenant à la fois l'expression de la main gauche et celle de la main droite, sur la pile.

NOT est similaire dans ce cas, mais seul le côté droit, comme décrit précédemment:

import java.util.Map;
import java.util.Stack;

public class Not extends Operation
{    
    public Not()
    {
        super("NOT");
    }

    public Not copy()
    {
        return new Not();
    }

    @Override
    public int parse(String[] tokens, int pos, Stack<Expression> stack)
    {
        int i = findNextExpression(tokens, pos+1, stack);
        Expression right = stack.pop();

        this.rightOperand = right;
        stack.push(this);

        return i;
    }

    @Override
    public boolean interpret(final Map<String, ?> bindings)
    {
        return !this.rightOperand.interpret(bindings);
    }    
}

= l'opérateur est utilisé pour vérifier la valeur d'une variable si elle égale en fait une valeur spécifique dans la table de liaisons fournie comme argument dans le interpret méthode.

import java.util.Map;
import java.util.Stack;

public class Equals extends Operation
{      
    public Equals()
    {
        super("=");
    }

    @Override
    public Equals copy()
    {
        return new Equals();
    }

    @Override
    public int parse(final String[] tokens, int pos, Stack<Expression> stack)
    {
        if (pos-1 >= 0 && tokens.length >= pos+1)
        {
            String var = tokens[pos-1];

            this.leftOperand = new Variable(var);
            this.rightOperand = BaseType.getBaseType(tokens[pos+1]);
            stack.push(this);

            return pos+1;
        }
        throw new IllegalArgumentException("Cannot assign value to variable");
    }

    @Override
    public boolean interpret(Map<String, ?> bindings)
    {
        Variable v = (Variable)this.leftOperand;
        Object obj = bindings.get(v.getName());
        if (obj == null)
            return false;

        BaseType<?> type = (BaseType<?>)this.rightOperand;
        if (type.getType().equals(obj.getClass()))
        {
            if (type.getValue().equals(obj))
                return true;
        }
        return false;
    }
}

comme on peut le voir de la parse méthode une valeur est affectée à une variable avec la variable sur le côté gauche de la = symbole et la valeur sur le côté droit.

par Ailleurs, l'interprétation vérifie la disponibilité de la variable nom de la variable liaisons. Si elle n'est pas disponible, nous savons que ce terme ne peut pas évaluer vrai, alors nous pouvons ignorer le processus d'évaluation. Si elle est présente, nous avons extrait les informations du côté droit (=Partie valeur) et vérifiez d'abord si le type de classe est égal et si oui si la valeur de la variable réelle correspond à la reliure.

Comme l'analyse des expressions est remaniée dans les opérations, le parser est plutôt mince:

import java.util.Stack;

public class ExpressionParser
{
    private static final Operations operations = Operations.INSTANCE;

    public static Expression fromString(String expr)
    {
        Stack<Expression> stack = new Stack<>();

        String[] tokens = expr.split("\s");
        for (int i=0; i < tokens.length-1; i++)
        {
            Operation op = operations.getOperation(tokens[i]);
            if ( op != null )
            {
                // create a new instance
                op = op.copy();
                i = op.parse(tokens, i, stack);
            }
        }

        return stack.pop();
    }
}

voici le copy méthode est probablement la chose la plus intéressante. Comme l'analyse est plutôt générique, nous ne savons pas à l'avance quelle opération est actuellement traitée. Au retour d'un l'opération trouvée parmi les inscrits résulte en une modification de cet objet. Si nous n'avons qu'une seule opération de ce genre dans notre expression, cela n'a pas d'importance - si toutefois nous avons plusieurs opérations (F. E. deux ou plusieurs opérations égales) l'opération est réutilisée et donc mise à jour avec la nouvelle valeur. Comme cela change aussi des opérations de ce genre déjà créées, nous devons créer une nouvelle instance de l'opération -copy() parvient.

Operations est un conteneur qui conserve les opérations précédemment enregistrées et les mappe à un symbole spécifié:

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public enum Operations
{
    /** Application of the Singleton pattern using enum **/
    INSTANCE;

    private final Map<String, Operation> operations = new HashMap<>();

    public void registerOperation(Operation op, String symbol)
    {
        if (!operations.containsKey(symbol))
            operations.put(symbol, op);
    }

    public void registerOperation(Operation op)
    {
        if (!operations.containsKey(op.getSymbol()))
            operations.put(op.getSymbol(), op);
    }

    public Operation getOperation(String symbol)
    {
        return this.operations.get(symbol);
    }

    public Set<String> getDefinedSymbols()
    {
        return this.operations.keySet();
    }
}

à côté du motif enum singleton, rien de très fantaisiste ici.

Rule contient maintenant une ou plusieurs expressions qui, lors de l'évaluation, peuvent déclencher une certaine action. La règle doit donc contenir les expressions déjà interprétées et l'action qui doit être déclenchée en cas de succès.

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class Rule
{
    private List<Expression> expressions;
    private ActionDispatcher dispatcher;

    public static class Builder
    {
        private List<Expression> expressions = new ArrayList<>();
        private ActionDispatcher dispatcher = new NullActionDispatcher();

        public Builder withExpression(Expression expr)
        {
            expressions.add(expr);
            return this;
        }

        public Builder withDispatcher(ActionDispatcher dispatcher)
        {
            this.dispatcher = dispatcher;
            return this;
        }

        public Rule build()
        {
            return new Rule(expressions, dispatcher);
        }
    }

    private Rule(List<Expression> expressions, ActionDispatcher dispatcher)
    {
        this.expressions = expressions;
        this.dispatcher = dispatcher;
    }

    public boolean eval(Map<String, ?> bindings)
    {
        boolean eval = false;
        for (Expression expression : expressions)
        {
            eval = expression.interpret(bindings);
            if (eval)
                dispatcher.fire();
        }
        return eval;
    }
}

ici un modèle de bâtiment est utilisé juste pour être possibilité d'ajouter plusieurs expressions si désiré pour la même action. En outre, le Rule définit un NullActionDispatcher par défaut. Si une expression est évaluée avec succès, le dispatcher déclenchera un fire() la méthode, qui traitera l'action qui doit être exécutée sur une validation réussie. Le motif null est utilisé ici pour éviter de traiter avec des valeurs null dans le cas où aucune exécution d'action n'est requise car seulement un true ou false la validation doit être effectuée. L'interface est donc simple trop:

public interface ActionDispatcher
{
    public void fire();
}

Comme je ne sais pas vraiment ce que votre INPATIENT ou OUTPATIENT actions devraient être, le fire() la méthode ne déclenche qu'un System.out.println(...); invocation de la méthode:

public class InPatientDispatcher implements ActionDispatcher
{
    @Override
    public void fire()
    {
        // send patient to in_patient
        System.out.println("Send patient to IN");
    }
}

Dernier point mais non le moindre, une simple méthode main pour tester le comportement du code:

import java.util.HashMap;
import java.util.Map;

public class Main 
{
    public static void main( String[] args )
    {
        // create a singleton container for operations
        Operations operations = Operations.INSTANCE;

        // register new operations with the previously created container
        operations.registerOperation(new And());
        operations.registerOperation(new Equals());
        operations.registerOperation(new Not());

        // defines the triggers when a rule should fire
        Expression ex3 = ExpressionParser.fromString("PATIENT_TYPE = 'A' AND NOT ADMISSION_TYPE = 'O'");
        Expression ex1 = ExpressionParser.fromString("PATIENT_TYPE = 'A' AND ADMISSION_TYPE = 'O'");
        Expression ex2 = ExpressionParser.fromString("PATIENT_TYPE = 'B'");

        // define the possible actions for rules that fire
        ActionDispatcher inPatient = new InPatientDispatcher();
        ActionDispatcher outPatient = new OutPatientDispatcher();

        // create the rules and link them to the accoridng expression and action
        Rule rule1 = new Rule.Builder()
                            .withExpression(ex1)
                            .withDispatcher(outPatient)
                            .build();

        Rule rule2 = new Rule.Builder()
                            .withExpression(ex2)
                            .withExpression(ex3)
                            .withDispatcher(inPatient)
                            .build();

        // add all rules to a single container
        Rules rules = new Rules();
        rules.addRule(rule1);
        rules.addRule(rule2);

        // for test purpose define a variable binding ...
        Map<String, String> bindings = new HashMap<>();
        bindings.put("PATIENT_TYPE", "'A'");
        bindings.put("ADMISSION_TYPE", "'O'");
        // ... and evaluate the defined rules with the specified bindings
        boolean triggered = rules.eval(bindings);
        System.out.println("Action triggered: "+triggered);
    }
}

Rules voici juste une classe de conteneur simple pour les règles et propage le eval(bindings); invocation de chaque règle définie.

je ne comprend pas d'autres opérations que le poste voici déjà longtemps, mais il ne devrait pas être trop difficile à mettre en œuvre sur votre propre si vous le désirez. De plus, je n'ai pas inclus ma structure de paquets car vous utiliserez probablement votre propre structure. Furhtermore, je ne comprend pas toute la gestion des exceptions, je laisse ça à tout le monde qui va copiez et collez le code :)

on pourrait soutenir que l'analyse devrait évidemment se faire dans l'analyseur plutôt que dans les classes concrètes. Je suis conscient de cela, mais d'un autre côté sur l'ajout de nouvelles opérations vous devez modifier l'analyseur ainsi que la nouvelle opération au lieu d'avoir à toucher une seule classe.

au lieu d'utiliser un système basé sur des règles un petri net ou même un BPMN en combinaison avec l'open source Or Le Moteur serait possible d'accomplir cette tâche. Ici les opérations sont déjà définies dans la langue, vous avez seulement besoin de définir les énoncés concrets comme des tâches qui peuvent être exécutées automatiquement - et en fonction du résultat d'une tâche (c'est-à-dire l'énoncé unique), elle passera par le "graphe". La modélisation est donc habituellement effectuée dans un éditeur graphique ou un frontend pour éviter de traiter la nature XML du langage BPMN.