Drools - Guide rapide

Toute application Java de niveau entreprise peut être divisée en trois parties:

  • UI - Interface utilisateur (frontend)
  • Couche de service qui est à son tour connectée à une base de données
  • Couche métier

Nous avons un certain nombre de frameworks qui gèrent ensemble l'interface utilisateur et la couche de service, par exemple Spring et Struts. Pourtant, nous n'avions pas de méthode standard pour gérer la logique métier jusqu'à la création de Drools.

Qu'est-ce que Drools?

Drools est un Business Logic integration Platform (BLiP). Il est écrit en Java. Il s'agit d'un projet open source soutenu par JBoss et Red Hat, Inc. Il étend et implémente l'algorithme de correspondance Rete Pattern.

En termes simples, Drools est un ensemble d'outils qui nous permettent de séparer et de raisonner sur la logique et les données trouvées dans les processus métier. Les deux mots clés importants que nous devons remarquer sontLogic et Data.

Drools est divisé en deux parties principales: Authoring et Runtime.

  • Authoring - Le processus de création implique la création de fichiers de règles (fichiers .DRL).

  • Runtime - Cela implique la création d'une mémoire de travail et la gestion de l'activation.

Qu'est-ce qu'un moteur de règles?

Drools est un moteur de règles ou un système de règles de production qui utilise l'approche basée sur des règles pour implémenter un système expert. Les systèmes experts sont des systèmes basés sur les connaissances qui utilisent la représentation des connaissances pour transformer les connaissances acquises en une base de connaissances qui peut être utilisée pour le raisonnement.

Un système de règles de production est Turing complet avec un accent sur la représentation des connaissances pour exprimer la logique propositionnelle et de premier ordre d'une manière concise, non ambiguë et déclarative.

Le cerveau d'un système de règles de production est un Inference Enginequi peut évoluer vers un grand nombre de règles et de faits. Le moteur d'inférence compare les faits et les données aux règles de production - également appeléesProductions ou juste Rules - pour déduire des conclusions qui aboutissent à des actions.

Une règle de production est une structure en deux parties qui utilise la logique du premier ordre pour raisonner sur la représentation des connaissances. Un moteur de règles métier est un système logiciel qui exécute une ou plusieurs règles métier dans un environnement de production d'exécution.

Un moteur de règles vous permet de définir "What to Do" et pas "How to do it. »

Qu'est-ce qu'une règle?

Les règles sont des éléments de connaissance souvent exprimés en « Lorsque certaines conditions se produisent, puis faire quelques tâches. »

When
   <Condition is true>
Then
   <Take desired Action>

La partie la plus importante d'une règle est sa whenpartie. Si lawhen une partie est satisfaite, le then une partie est déclenchée.

rule  <rule_name>
   <attribute> <value>
      
   when
      <conditions>
      
   then
      <actions>
end

Correspondance de motif

Le processus de mise en correspondance des faits nouveaux ou existants avec les règles de production est appelé correspondance de modèles, qui est effectuée par le moteur d'inférence. Il existe un certain nombre d'algorithmes utilisés pour la correspondance de modèles, notamment -

  • Linear
  • Rete
  • Treat
  • Leaps

Drools Implémente et étend l'algorithme Rete. L'implémentation de Drools Rete est appelée ReteOO, ce qui signifie que Drools a une implémentation améliorée et optimisée de l'algorithme Rete pour les systèmes orientés objet.

Avantages d'un moteur de règles

Programmation déclarative

Les règles permettent d'exprimer facilement des solutions à des problèmes difficiles et de vérifier également les solutions. Contrairement aux codes, les règles sont rédigées dans un langage moins complexe; Les analystes commerciaux peuvent facilement lire et vérifier un ensemble de règles.

Séparation logique et données

Les données résident dans les objets de domaine et la logique métier réside dans les règles. Selon le type de projet, ce type de séparation peut être très avantageux.

Vitesse et évolutivité

L'algorithme Rete OO sur lequel Drools est écrit est déjà un algorithme éprouvé. Avec l'aide de Drools, votre application devient très évolutive. S'il y a des demandes de changement fréquentes, on peut ajouter de nouvelles règles sans avoir à modifier les règles existantes.

Centralisation des connaissances

En utilisant Rules, vous créez un référentiel de connaissances (une base de connaissances) qui est exécutable. C'est un point de vérité unique pour la politique commerciale. Idéalement, les règles sont si lisibles qu'elles peuvent également servir de documentation.

Intégration d'outils

Des outils tels qu'Eclipse offrent des moyens de modifier et de gérer les règles et d'obtenir immédiatement des commentaires, une validation et une assistance sur le contenu. Des outils d'audit et de débogage sont également disponibles.

Voici les prérequis pour installer le plugin Drools -

  • Java 1.5 (ou supérieur) SE JDK
  • Eclipse 4.2 (ou toute version) et le plugin Drools

Comme Drools est un BRMS (Business Rule Management System) écrit en Java, nous expliquerons comment ajouter les plugins souhaités dans cette section. Compte tenu du nombre maximum d'utilisateurs Java utilisant Eclipse, voyons comment ajouter le plugin Drools 5.x.0 dans Eclipse.

Étape 1: Téléchargez les binaires

Téléchargez les binaires à partir du lien suivant -

https://download.jboss.org/drools/release/5.3.0.Final/

Une fois le téléchargement terminé, extrayez les fichiers sur votre disque dur.

Étape 2: Installez le logiciel

Lancez Eclipse et accédez à l'aide → installer un nouveau logiciel. Cliquez sur Ajouter comme indiqué dans la capture d'écran suivante.

Ensuite, cliquez sur Local comme indiqué ici et sélectionnez "… / binaries / org.drools.updatesite".

Sélectionnez Drools et jBPM et cliquez sur Suivant.

Cliquez à nouveau sur Suivant. Par la suite, acceptez les termes et le contrat de licence et cliquez sur Terminer.

En cliquant sur Terminer, l'installation du logiciel démarre -

Après l'installation réussie, vous obtiendrez la boîte de dialogue suivante -

Cliquez sur Oui. Une fois Eclipse redémarré, allez dans Windows → Préférences

Vous pouvez voir Drools sous vos préférences. L'installation de votre plugin Drools est maintenant terminée.

Drools Runtime est requis pour demander à l'éditeur d'exécuter le programme avec une version spécifique du jar Drools. Vous pouvez exécuter votre programme / application avec différents Runtime Drools.

Cliquez sur Windows → Préférences → Drools → Installed Drools Runtime. Cliquez ensuite sur Ajouter comme indiqué dans la capture d'écran suivante.

Ensuite, cliquez sur Create a new Drools Runtime comme indiqué ici.

Entrez le chemin jusqu'au dossier binaries où vous avez téléchargé le droolsjbpm-tools-distribution-5.3.0.Final.zip

Cliquez sur OK et donnez un nom à Drools Runtime. Le runtime Drools est maintenant créé.

Pour créer un programme Drools de base, ouvrez Eclipse. Allez dans Fichierb → Nouveau → Projet.

Sélectionnez Projet Drools. Donnez un nom approprié au projet. Par exemple, DroolsTest.

L'écran suivant vous invite à sélectionner certains fichiers que vous souhaitez dans votre premier projet Drools.

Sélectionnez les deux premiers fichiers. Le premier fichier est un fichier .drl (fichier de règles Drools) et le deuxième fichier est une classe Java pour charger et exécuter la règle HelloWorld.

Cliquez sur Suivant → Terminer.

Une fois que vous cliquez sur Terminer, un projet <DroolsTest> est créé dans votre espace de travail. Ouvrez la classe Java, puis cliquez avec le bouton droit et exécutez en tant qu'application Java. Vous verriez la sortie comme indiqué ici -

Ensuite, nous discuterons des termes fréquemment utilisés dans un moteur de règles.

Règles

Le cœur du moteur de règles où vous spécifiez des conditions (si «a» puis «b»).

Les faits

Les faits sont les données sur lesquelles les règles agiront. Du point de vue Java, les faits sont le POJO (Plain Old Java Object).

Session

Une session de connaissances dans Drools est le composant principal pour déclencher les règles. C'est la session de connaissances qui contient toutes les règles et autres ressources. Une session de connaissances est créée à partir de la base de connaissances.

Pour que le moteur de règles fonctionne, les faits sont insérés dans la session et lorsqu'une condition est remplie, la règle suivante est déclenchée. Une session est de deux types -

  • Session de connaissances apatrides
  • Session de connaissances avec état

Ordre du jour

C'est un concept logique. L'agenda est le lieu logique où les activations attendent d'être déclenchées.

Activations

Les activations sont les thenfait partie de la règle. Les activations sont placées dans l'agenda où la règle appropriée est déclenchée.

Si vous voyez la règle par défaut qui est écrite dans le projet Hello World (Sample.drl), il y a beaucoup de mots-clés utilisés que nous allons expliquer maintenant.

Sample.drl

  • Package- Chaque règle commence par un nom de package. Le package agit comme un espace de noms pour les règles. Les noms de règle dans un package doivent être uniques. Les packages dans Rules sont similaires aux packages en Java.

  • Import statement- Quels que soient les faits sur lesquels vous souhaitez appliquer la règle, ces faits doivent être importés. Par exemple, com.sample.DroolsTest.Message; dans l'exemple ci-dessus.

  • Rule Definition- Il se compose du nom de la règle, de la condition et de la conséquence. Les mots-clés Drools sontrule, when, then, et end. Dans l'exemple ci-dessus, les noms de règle sont «Hello World» et «GoodBye». lewhen une partie est la condition dans les règles et le thenune partie est la conséquence. Dans la terminologie des règles, lewhen la partie est également appelée LHS (côté gauche) et le then partie comme le RHS (côté droit) de la règle.

Passons maintenant en revue les termes utilisés dans le fichier Java utilisé pour charger les Drools et exécuter les règles.

Base de connaissances

La base de connaissances est une interface qui gère un ensemble de règles, de processus et de types internes. Il est contenu dans le paquetorg.drools.KnowledgeBase. Dans Drools, ceux-ci sont communément appelésknowledge definitions ou knowledge. Les définitions de connaissances sont regroupées enknowledge packages. Les définitions de connaissances peuvent être ajoutées ou supprimées. Le but principal de la base de connaissances est de les stocker et de les réutiliser car leur création est coûteuse. La base de connaissances fournit des méthodes pour créer des sessions de connaissances.

Session de connaissances

La session de connaissances est extraite de la base de connaissances. C'est l'interface principale pour interagir avec le moteur Drools. La session de connaissances peut être de deux types -

  • Session de connaissances apatrides

  • Session de connaissances avec état

Session de connaissances apatrides

Stateless Knowledge Session est une session sans état qui constitue le cas d'utilisation le plus simple, n'utilisant pas d'inférence. Une session sans état peut être appelée comme une fonction, en lui passant des données et en recevant des résultats. Les exemples courants de session sans état incluent:

  • Validation

    • Cette personne est-elle admissible à une hypothèque?

  • Calculation

    • Calculez une prime hypothécaire.

  • Routing and Filtering

    • Filtrez les messages entrants, tels que les e-mails, dans des dossiers.

    • Envoyer des messages entrants vers une destination

Session de connaissances avec état

Les sessions avec état ont une durée de vie plus longue et permettent des changements itératifs au fil du temps. Certains cas d'utilisation courants des sessions avec état incluent:

  • Monitoring

    • Suivi et analyse boursière pour les achats semi-automatiques.

  • Diagnostics

    • Recherche de pannes, diagnostic médical

  • Logistics

    • Suivi des colis et approvisionnement en livraison

Générateur de connaissances

L'interface KnoledgeBuilder est responsable de la construction d'un KnowledgePackage à partir de définitions de connaissances (règles, processus, types). Il est contenu dans le packageorg.drools.builder.KnowledgeBuilder. Les définitions des connaissances peuvent être dans différents formats. En cas de problème lors de la création, KnowledgeBuilder signale les erreurs via ces deux méthodes:hasErrors et getError.

Le diagramme suivant explique le processus

Dans l'exemple ci-dessus, comme nous prenons un exemple simple de session de connaissances sans état, nous avons inséré le fait dans la session, puis la méthode fireAllRules () est appelée et vous voyez la sortie.

Dans le cas d'une session de connaissance avec état, une fois les règles déclenchées, l'objet de session de connaissance avec état doit appeler la méthode dispose() pour libérer la session et éviter les fuites de mémoire.

Comme vous l'avez vu, le .drl (fichier de règles) a sa propre syntaxe, couvrons une partie de la syntaxe de règle dans ce chapitre.

Conditions dans les règles

Une règle peut contenir de nombreuses conditions et modèles tels que -

  • Compte (solde == 200)
  • Client (nom == «Vivek»)

Les conditions ci-dessus vérifient si le solde du compte est de 200 ou si le nom du client est «Vivek».

Variables dans les règles

Un nom de variable dans Drools commence par un symbole Dollar ($).

  • Compte $ - Compte ()
  • $ account est la variable de la classe Account ()

Drools peut fonctionner avec tous les types Java natifs et même Enum.

Commentaires dans les règles

Les caractères spéciaux, # ou //, peuvent être utilisés pour marquer des commentaires sur une seule ligne.

Pour les commentaires sur plusieurs lignes, utilisez le format suivant:

/*
   Another line
   .........
   .........
*/

Variables globales

Les variables globales sont des variables affectées à une session. Ils peuvent être utilisés pour diverses raisons comme suit -

  • Pour les paramètres d'entrée (par exemple, les valeurs constantes qui peuvent être personnalisées d'une session à l'autre).

  • Pour les paramètres de sortie (par exemple, la création de rapports - une règle peut écrire un message dans une variable de rapport globale).

  • Points d'entrée pour des services tels que la journalisation, qui peuvent être utilisés dans les règles.

Fonctions dans les règles

Les fonctions sont une fonctionnalité pratique. Ils peuvent être utilisés dans des conditions et des conséquences. Les fonctions représentent une alternative aux classes utilitaires / auxiliaires. Par exemple,

function double calculateSquare (double value) {
   return value * value;
}

Dialecte

Un dialecte spécifie la syntaxe utilisée dans toute expression de code qui est dans une condition ou dans une conséquence. Il inclut les valeurs de retour, les évaluations, les évaluations en ligne, les prédicats, les expressions de saillance, les conséquences, etc. La valeur par défaut estJava. Drools prend actuellement en charge un autre dialecte appeléMVEL. Le dialecte par défaut peut être spécifié au niveau du package comme suit -

package org.mycompany.somePackage
dialect "mvel"

Dialecte MVEL

MVEL est un langage d'expression pour les applications basées sur Java. Il prend en charge l'accès aux champs et aux méthodes / getter. Il est basé sur la syntaxe Java.

Saillance

La saillance est une caractéristique très importante de la syntaxe des règles. La saillance est utilisée par la stratégie de résolution de conflit pour décider quelle règle appliquer en premier. Par défaut, c'est le critère principal.

Nous pouvons utiliser la saillance pour définir l'ordre des règles de tir. La saillance a un attribut, qui prend toute expression qui renvoie un nombre de type int (les nombres positifs et négatifs sont valides). Plus la valeur est élevée, plus la stratégie de résolution de conflit aura de chances de déclencher une règle.

salience ($account.balance * 5)

La valeur de saillance par défaut est 0. Nous devons garder cela à l'esprit lorsque vous attribuez des valeurs de saillance à certaines règles uniquement.

Il y a beaucoup d'autres fonctionnalités / paramètres dans la syntaxe des règles, mais nous n'avons couvert que les plus importantes ici.

Mots-clés de conséquence des règles

Les mots clés relatifs aux conséquences des règles sont les mots clés utilisés dans le champ "then”Fait partie de la règle.

  • Modify - Les attributs du fait peuvent être modifiés dans le then partie de la Règle.

  • Insert - Sur la base d'une condition, si elle est vraie, on peut insérer un nouveau fait dans la session courante du moteur de règles.

  • Retract - Si une condition particulière est vraie dans une règle et que vous ne voulez rien agir d'autre sur ce fait, vous pouvez retirer le fait particulier du moteur de règles.

Note- Il est considéré comme une très mauvaise pratique d'avoir une logique conditionnelle (instructions if) dans une conséquence de règle. La plupart du temps, une nouvelle règle doit être créée.

Dans ce chapitre, nous allons créer un projet Drools pour l'énoncé de problème suivant -

En fonction de la ville et du type de produit (combinaison de ville et de produit), renseignez-vous sur la taxe locale liée à cette ville.

Nous aurons deux fichiers DRL pour notre projet Drools. Les deux fichiers DRL signifieront deux villes considérées (Pune et Nagpur) et quatre types de produits (épicerie, médicaments, montres et produits de luxe).

  • La taxe sur les médicaments dans les deux villes est considérée comme nulle.

  • Pour l'épicerie, nous avons supposé une taxe de Rs 2 à Pune et de Rs 1 à Nagpur.

Nous avons utilisé le même prix de vente pour démontrer différents extrants. Notez que toutes les règles sont déclenchées dans l'application.

Voici le modèle pour contenir chaque itemType -

package com.sample;
import java.math.BigDecimal;
public class ItemCity {
   public enum City {
      PUNE, NAGPUR
   }
   public enum Type {
      GROCERIES, MEDICINES, WATCHES, LUXURYGOODS
   }
   private City purchaseCity;
   private BigDecimal sellPrice;
   private Type typeofItem;
   private BigDecimal localTax;
   
   public City getPurchaseCity() {
      return purchaseCity;
   }
   public void setPurchaseCity(City purchaseCity) {
      this.purchaseCity = purchaseCity;
   }
   public BigDecimal getSellPrice() {
      return sellPrice;
   }
   public void setSellPrice(BigDecimal sellPrice) {
      this.sellPrice = sellPrice;
   }
   public Type getTypeofItem() {
      return typeofItem;
   }
   public void setTypeofItem(Type typeofItem) {
      this.typeofItem = typeofItem;
   }
   public BigDecimal getLocalTax() {
      return localTax;
   }
   public void setLocalTax(BigDecimal localTax) {
      this.localTax = localTax;
   }
}

Fichiers DRL

Comme suggéré précédemment, nous avons utilisé deux fichiers DRL ici: Pune.drl et Nagpur.drl.

Pune.drl

Il s'agit du fichier DRL qui exécute les règles de la ville de Pune.

// created on: Dec 24, 2014
package droolsexample

// list any import classes here.
import com.sample.ItemCity;
import java.math.BigDecimal;

// declare any global variables here
dialect "java"
rule "Pune Medicine Item"
   when
      item : ItemCity (purchaseCity == ItemCity.City.PUNE,
         typeofItem == ItemCity.Type.MEDICINES)
   then
      BigDecimal tax = new BigDecimal(0.0);
      item.setLocalTax(tax.multiply(item.getSellPrice()));
end

rule "Pune Groceries Item"
   when
      item : ItemCity(purchaseCity == ItemCity.City.PUNE,
         typeofItem == ItemCity.Type.GROCERIES)
   then
      BigDecimal tax = new BigDecimal(2.0);
      item.setLocalTax(tax.multiply(item.getSellPrice()));
end

Nagpur.drl

Il s'agit du fichier DRL qui exécute les règles pour la ville de Nagpur.

// created on: Dec 26, 2014
package droolsexample

// list any import classes here.
import com.sample.ItemCity;
import java.math.BigDecimal;

// declare any global variables here
dialect "java"
rule "Nagpur Medicine Item"
   when
      item : ItemCity(purchaseCity == ItemCity.City.NAGPUR, 
         typeofItem == ItemCity.Type.MEDICINES)
   then
      BigDecimal tax = new BigDecimal(0.0);
      item.setLocalTax(tax.multiply(item.getSellPrice()));
end

rule "Nagpur Groceries Item"
   when
      item : ItemCity(purchaseCity == ItemCity.City.NAGPUR, 
         typeofItem == ItemCity.Type.GROCERIES)
   then
      BigDecimal tax = new BigDecimal(1.0);
      item.setLocalTax(tax.multiply(item.getSellPrice()));
end

Nous avons écrit les fichiers DRL basés sur la ville, car cela nous donne la possibilité d'ajouter un nombre illimité de fichiers de règles ultérieurement si de nouvelles villes sont ajoutées.

Pour démontrer que toutes les règles sont déclenchées à partir de nos fichiers de règles, nous avons utilisé deux types d'articles (médicaments et épicerie); et les médicaments sont exonérés de taxe et les produits d'épicerie sont taxés selon la ville.

Notre classe de test charge les fichiers de règles, insère les faits dans la session et produit la sortie.

Droolstest.java

package com.sample;

import java.math.BigDecimal;
import org.drools.KnowledgeBase;
import org.drools.KnowledgeBaseFactory;
import org.drools.builder.KnowledgeBuilder;
import org.drools.builder.KnowledgeBuilderError;
import org.drools.builder.KnowledgeBuilderErrors;
import org.drools.builder.KnowledgeBuilderFactory;
import org.drools.builder.ResourceType;
import org.drools.io.ResourceFactory;
import org.drools.runtime.StatefulKnowledgeSession;
import com.sample.ItemCity.City;
import com.sample.ItemCity.Type;

/* 
   *This is a sample class to launch a rule. 
*/

public class DroolsTest {
   public static final void main(String[] args) {
      try {
         // load up the knowledge base
         KnowledgeBase kbase = readKnowledgeBase();
         StatefulKnowledgeSession ksession = kbase.newStatefulKnowledgeSession();
         
         ItemCity item1 = new ItemCity();
         item1.setPurchaseCity(City.PUNE);
         item1.setTypeofItem(Type.MEDICINES);
         item1.setSellPrice(new BigDecimal(10));
         ksession.insert(item1);
         
         ItemCity item2 = new ItemCity();
         item2.setPurchaseCity(City.PUNE);
         item2.setTypeofItem(Type.GROCERIES);
         item2.setSellPrice(new BigDecimal(10));
         ksession.insert(item2);
         
         ItemCity item3 = new ItemCity();
         item3.setPurchaseCity(City.NAGPUR);
         item3.setTypeofItem(Type.MEDICINES);
         item3.setSellPrice(new BigDecimal(10));
         ksession.insert(item3);
         
         ItemCity item4 = new ItemCity();
         item4.setPurchaseCity(City.NAGPUR);
         item4.setTypeofItem(Type.GROCERIES);
         item4.setSellPrice(new BigDecimal(10));         
         ksession.insert(item4);
         
         ksession.fireAllRules();
         
         System.out.println(item1.getPurchaseCity().toString() + " " 
            + item1.getLocalTax().intValue());
         
         System.out.println(item2.getPurchaseCity().toString() + " "
            + item2.getLocalTax().intValue());
         
         System.out.println(item3.getPurchaseCity().toString() + " "
            + item3.getLocalTax().intValue());
         
         System.out.println(item4.getPurchaseCity().toString() + " "
            + item4.getLocalTax().intValue());
                            
      } catch (Throwable t) {
         t.printStackTrace();
      }
   }
   private static KnowledgeBase readKnowledgeBase() throws Exception {
      KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();
      kbuilder.add(ResourceFactory.newClassPathResource("Pune.drl"), ResourceType.DRL);
      kbuilder.add(ResourceFactory.newClassPathResource("Nagpur.drl"), ResourceType.DRL);
      KnowledgeBuilderErrors errors = kbuilder.getErrors();
      
      if (errors.size() > 0) {
         for (KnowledgeBuilderError error: errors) {
            System.err.println(error);
         }
         throw new IllegalArgumentException("Could not parse knowledge.");
      }
      KnowledgeBase kbase = KnowledgeBaseFactory.newKnowledgeBase();
      kbase.addKnowledgePackages(kbuilder.getKnowledgePackages());
      return kbase;
   }
}

Si vous exécutez ce programme, sa sortie serait la suivante -

PUNE 0
PUNE 20
NAGPUR 0
NAGPUR 10

Pour Pune et Nagpur, lorsque l'article est un médicament, la taxe locale est de zéro; alors que lorsque l'article est un produit d'épicerie, la taxe est selon la ville. D'autres règles peuvent être ajoutées dans les fichiers DRL pour d'autres produits. Ceci n'est qu'un exemple de programme.

Appeler une fonction externe depuis un fichier DRL

Ici, nous allons montrer comment appeler une fonction statique à partir d'un fichier Java dans votre fichier DRL.

Tout d'abord, créez une classe HelloCity.java dans le même emballage com.sample.

package com.sample;

public class HelloCity {
   public static void writeHello(String name) {
      System.out.println("HELLO " + name + "!!!!!!");
   }
}

Ensuite, ajoutez l'instruction d'importation dans le fichier DRL pour appeler la méthode writeHello à partir du fichier DRL. Dans le bloc de code suivant, les modifications du fichier DRL Pune.drl sont surlignées en jaune.

// created on: Dec 24, 2014
package droolsexample

// list any import classes here.
import com.sample.ItemCity;
import java.math.BigDecimal;
 
import com.sample.HelloCity;

//declare any global variables here
dialect "java"

rule "Pune Medicine Item"
   when
      item : ItemCity(purchaseCity == ItemCity.City.PUNE, 
         typeofItem == ItemCity.Type.MEDICINES)
   then
      BigDecimal tax = new BigDecimal(0.0);
      item.setLocalTax(tax.multiply(item.getSellPrice()));
      HelloCity.writeHello(item.getPurchaseCity().toString());
end

rule "Pune Groceries Item"
   when
      item : ItemCity(purchaseCity == ItemCity.City.PUNE, 
         typeofItem == ItemCity.Type.GROCERIES)
   then
      BigDecimal tax = new BigDecimal(2.0);
      item.setLocalTax(tax.multiply(item.getSellPrice()));
end

Exécutez à nouveau le programme et sa sortie serait la suivante -

HELLO PUNE!!!!!!
PUNE 0
PUNE 20
NAGPUR 0
NAGPUR 10

La différence maintenant dans la sortie est marquée en jaune, ce qui montre la sortie de la méthode statique dans la classe Java.

L'avantage d'appeler une méthode Java est que nous pouvons écrire n'importe quelle fonction utilitaire / d'assistance en Java et l'appeler à partir d'un fichier DRL.

Il existe différentes manières de déboguer un projet Drools. Ici, nous allons écrire une classe Utility pour vous faire savoir quelles règles sont déclenchées ou déclenchées.

Avec cette approche, vous pouvez vérifier ce que toutes les règles sont déclenchées dans votre projet Drools. Voici notre classe utilitaire

Utility.java

package com.sample;
import org.drools.spi.KnowledgeHelper;

public class Utility {
   public static void help(final KnowledgeHelper drools, final String message){
      System.out.println(message);
      System.out.println("\nrule triggered: " + drools.getRule().getName());
   }
   public static void helper(final KnowledgeHelper drools){
      System.out.println("\nrule triggered: " + drools.getRule().getName());
   }
}

La première méthode help imprime la règle déclenchée avec quelques informations supplémentaires que vous pouvez passer sous forme de chaîne via le fichier DRL.

La deuxième règle helper imprime si la règle particulière a été déclenchée ou non.

Nous avons ajouté l'une des méthodes utilitaires dans chaque fichier DRL. Nous avons également ajouté la fonction d'importation dans le fichier DRL (Pune.drl). dans lethenpartie de la règle, nous avons ajouté l'appel de fonction utilitaire. Le Pune.drl modifié est donné ci-dessous. Les modifications sont surlignées en bleu.

Modifié Pune.drl

//created on: Dec 24, 2014
package droolsexample

//list any import classes here.
import com.sample.ItemCity;
import java.math.BigDecimal;
import com.sample.HelloCity; 
import function com.sample.Utility.helper;

// declare any global variables here
dialect "java"
rule "Pune Medicine Item"
   when
      item : ItemCity(purchaseCity == ItemCity.City.PUNE, 
         typeofItem == ItemCity.Type.MEDICINES)
   
   then
      BigDecimal tax = new BigDecimal(0.0);
      item.setLocalTax(tax.multiply(item.getSellPrice()));
      HelloCity.writeHello(item.getPurchaseCity().toString()); 
      helper(drools);
end

rule "Pune Groceries Item"
   when
      item : ItemCity(purchaseCity == ItemCity.City.PUNE, 
         typeofItem == ItemCity.Type.GROCERIES)
   then
      BigDecimal tax = new BigDecimal(2.0);
      item.setLocalTax(tax.multiply(item.getSellPrice())); 
      helper(drools);
end

De même, nous avons ajouté l'autre fonction utilitaire dans le deuxième fichier DRL (Nagpur.drl). Voici le code modifié -

Nagpur.drl modifié

// created on: Dec 26, 2014
package droolsexample

// list any import classes here.
import com.sample.ItemCity;
import java.math.BigDecimal; 
import function com.sample.Utility.help;

//declare any global variables here
dialect "java"

rule "Nagpur Medicine Item"
   when
      item : ItemCity(purchaseCity == ItemCity.City.NAGPUR, 
         typeofItem == ItemCity.Type.MEDICINES)
   
   then
      BigDecimal tax = new BigDecimal(0.0);
      item.setLocalTax(tax.multiply(item.getSellPrice())); 
      help(drools,"added info");
end

rule "Nagpur Groceries Item"
   when
      item : ItemCity(purchaseCity == ItemCity.City.NAGPUR, 
         typeofItem == ItemCity.Type.GROCERIES)
   then
      BigDecimal tax = new BigDecimal(1.0);
      item.setLocalTax(tax.multiply(item.getSellPrice())); 
      help(drools,"info");
end

Exécutez à nouveau le programme et il devrait produire la sortie suivante -

info

rule triggered: Nagpur Groceries Item
added info

rule triggered: Nagpur Medicine Item

rule triggered: Pune Groceries Item
HELLO PUNE!!!!!!

rule triggered: Pune Medicine Item
PUNE 0
PUNE 20
NAGPUR 0
NAGPUR 10

Les deux fonctions utilitaires sont appelées et il montre si la règle particulière a été appelée ou non. Dans l'exemple ci-dessus, toutes les règles sont appelées, mais dans une application d'entreprise, cette fonction utilitaire peut être vraiment utile pour déboguer et savoir si une règle particulière a été déclenchée ou non.

Utilisation de la perspective de débogage dans Eclipse

Vous pouvez déboguer les règles lors de l'exécution de votre application Drools. Vous pouvez ajouter des points d'arrêt dans les conséquences de vos règles, et chaque fois qu'un tel point d'arrêt est rencontré pendant l'exécution des règles, l'exécution est temporairement arrêtée. Vous pouvez ensuite inspecter les variables connues à ce stade comme vous le faites dans une application Java et utiliser les options de débogage normales disponibles dans Eclipse.

Pour créer un point d'arrêt dans votre fichier DRL, double-cliquez simplement sur la ligne où vous souhaitez créer un point d'arrêt. N'oubliez pas que vous ne pouvez créer un point d'arrêt que dans lethenpartie d'une règle. Un point d'arrêt peut être supprimé en double-cliquant sur le point d'arrêt dans l'éditeur DRL.

Après avoir appliqué les points d'arrêt, vous devez déboguer votre application en tant qu'application Drools. Les points d'arrêt Drools (points d'arrêt dans le fichier DRL) ne fonctionneront que si votre application est en cours de débogage en tant qu'application Drools. Voici comment vous devez faire de même -

Une fois que vous avez débogué votre application en tant qu'application Drools, vous verrez le contrôle sur le fichier DRL comme indiqué dans la capture d'écran suivante -

Vous pouvez voir les variables et les valeurs actuelles de l'objet à ce point de débogage. Le même contrôle de F6 pour passer à la ligne suivante et F8 pour sauter au point de débogage suivant sont également applicables ici. De cette façon, vous pouvez déboguer votre application Drools.

Note - La perspective de débogage dans l'application Drools ne fonctionne que si le dialecte est MVEL jusqu'à Drools 5.x.