Drools - Guida rapida

Qualsiasi applicazione Java a livello aziendale può essere suddivisa in tre parti:

  • UI - Interfaccia utente (frontend)
  • Livello di servizio che a sua volta è connesso a un database
  • Livello aziendale

Abbiamo una serie di framework che gestiscono insieme l'interfaccia utente e il livello di servizio, ad esempio Spring e Struts. Tuttavia, non avevamo un modo standard per gestire la logica aziendale fino a quando non è nato Drools.

Cos'è Drools?

Drools è un Business Logic integration Platform (BLiP). È scritto in Java. È un progetto open source supportato da JBoss e Red Hat, Inc. Estende e implementa l'algoritmo di corrispondenza di Rete Pattern.

In parole povere, Drools è una raccolta di strumenti che ci consentono di separarci e ragionare sulla logica e sui dati presenti all'interno dei processi aziendali. Le due parole chiave importanti che dobbiamo notare sonoLogic e Data.

Drools è suddiviso in due parti principali: Authoring e Runtime.

  • Authoring - Il processo di creazione prevede la creazione di file di regole (file .DRL).

  • Runtime - Implica la creazione della memoria di lavoro e la gestione dell'attivazione.

Cos'è un motore di regole?

Drools è un motore di regole o un sistema di regole di produzione che utilizza l'approccio basato su regole per implementare un sistema esperto. I sistemi esperti sono sistemi basati sulla conoscenza che utilizzano la rappresentazione della conoscenza per elaborare la conoscenza acquisita in una base di conoscenza che può essere utilizzata per il ragionamento.

Un sistema di regole di produzione è Turing completo di un focus sulla rappresentazione della conoscenza per esprimere la logica proposizionale e del primo ordine in modo conciso, non ambiguo e dichiarativo.

Il cervello di un sistema di regole di produzione è un file Inference Engineche può scalare a un gran numero di regole e fatti. Il motore di inferenza confronta fatti e dati con le regole di produzione, chiamate ancheProductions o semplicemente Rules - inferire conclusioni che si traducono in azioni.

Una regola di produzione è una struttura in due parti che utilizza la logica del primo ordine per ragionare sulla rappresentazione della conoscenza. Un motore di regole aziendali è un sistema software che esegue una o più regole aziendali in un ambiente di produzione runtime.

Un motore di regole ti consente di definire "What to Do" e non "How to do it. "

Cos'è una regola?

Le regole sono pezzi di conoscenza spesso espressi come, " quando si verificano alcune condizioni, quindi fare alcuni compiti."

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

La parte più importante di una regola è la sua whenparte. Se lawhen parte è soddisfatta, il then parte viene attivata.

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

Pattern Matching

Il processo di corrispondenza dei fatti nuovi o esistenti con le regole di produzione è chiamato Pattern Matching, che viene eseguito dal motore di inferenza. Esistono numerosi algoritmi utilizzati per la corrispondenza dei modelli, tra cui:

  • Linear
  • Rete
  • Treat
  • Leaps

Drools Implementa ed estende l'algoritmo di Rete. L'implementazione di Drools Rete si chiama ReteOO, a significare che Drools ha un'implementazione migliorata e ottimizzata dell'algoritmo Rete per i sistemi orientati agli oggetti.

Vantaggi di un motore di regole

Programmazione dichiarativa

Le regole facilitano l'espressione di soluzioni a problemi difficili e anche la verifica delle soluzioni. A differenza dei codici, le regole sono scritte in un linguaggio meno complesso; Gli analisti aziendali possono leggere e verificare facilmente una serie di regole.

Logica e separazione dei dati

I dati risiedono negli oggetti di dominio e la logica di business risiede nelle regole. A seconda del tipo di progetto, questo tipo di separazione può essere molto vantaggioso.

Velocità e scalabilità

L'algoritmo Rete OO su cui è scritto Drools è già un algoritmo collaudato. Con l'aiuto di Drools, la tua applicazione diventa molto scalabile. Se ci sono frequenti richieste di modifica, è possibile aggiungere nuove regole senza dover modificare le regole esistenti.

Centralizzazione della conoscenza

Utilizzando le regole, crei un repository di conoscenza (una knowledge base) che è eseguibile. È un unico punto di verità per la politica aziendale. Idealmente, le regole sono così leggibili da poter servire anche come documentazione.

Integrazione degli strumenti

Strumenti come Eclipse forniscono modi per modificare e gestire le regole e ottenere feedback immediati, convalida e assistenza sui contenuti. Sono disponibili anche strumenti di controllo e debug.

Ecco i prerequisiti per installare Drools Plugin -

  • Java 1.5 (o superiore) SE JDK
  • Eclipse 4.2 (o qualsiasi versione) e il plug-in Drools

Poiché Drools è un BRMS (Business Rule Management System) scritto in Java, in questa sezione tratteremo come aggiungere i plug-in desiderati. Considerando che il numero massimo di utenti Java utilizza Eclipse, vediamo come aggiungere il plug-in Drools 5.x.0 in Eclipse.

Passaggio 1: scarica i file binari

Scarica i binari dal seguente link -

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

Al termine del download, estrai i file sul tuo disco rigido.

Passaggio 2: installa il software

Avvia Eclipse e vai ad aiuto → installa nuovo software. Fare clic su Aggiungi come mostrato nello screenshot seguente.

Successivamente, fare clic su Locale come mostrato qui e selezionare "… / binaries / org.drools.updatesite".

Seleziona Drools e jBPM e fai clic su Avanti.

Fare nuovamente clic su Avanti. Successivamente, accetta i termini e il contratto di licenza e fai clic su Fine.

Facendo clic su Fine, viene avviata l'installazione del software:

Dopo l'installazione con successo, verrà visualizzata la seguente finestra di dialogo:

Fare clic su Sì. Una volta riavviato Eclipse, vai su Windows → Preferenze

Puoi vedere Drools sotto le tue preferenze. L'installazione del tuo plug-in Drools è ora completa.

Drools Runtime è necessario per indicare all'editor di eseguire il programma con una versione specifica del jar Drools. Puoi eseguire il tuo programma / applicazione con diversi Drools Runtime.

Fare clic su Windows → Preferenze → Drools → Installed Drools Runtime. Quindi fare clic su Aggiungi come mostrato nello screenshot seguente.

Successivamente, fai clic su Crea un nuovo runtime Drools come mostrato qui.

Inserisci il percorso fino alla cartella dei binari in cui hai scaricato droolsjbpm-tools-distribution-5.3.0.Final.zip

Fare clic su OK e fornire un nome per Drools Runtime. Il runtime Drools è ora creato.

Per creare un programma Drools di base, apri Eclipse. Vai a Fileb → Nuovo → Progetto.

Seleziona Progetto Drools. Dai un nome adatto al progetto. Ad esempio, DroolsTest.

La schermata successiva ti chiede di selezionare alcuni file che desideri nel tuo primo progetto Drools.

Seleziona i primi due file. Il primo file è un file .drl (Drools Rule File) e il secondo file è una classe Java per il caricamento e l'esecuzione della regola HelloWorld.

Fare clic su Avanti → Fine.

Dopo aver fatto clic su Fine, viene creato un progetto <DroolsTest> nell'area di lavoro. Apri la classe Java, quindi fai clic con il pulsante destro del mouse ed esegui come applicazione Java. Vedresti l'output come mostrato qui -

Successivamente, discuteremo i termini usati di frequente in un motore di regole.

Regole

Il cuore del motore delle regole in cui si specificano le condizioni (se "a", quindi "b").

Fatti

I fatti sono i dati su cui agiranno le regole. Dal punto di vista di Java, i fatti sono il POJO (Plain Old Java Object).

Sessione

Una sessione di conoscenza in Drools è il componente principale per attivare le regole. È la sessione di conoscenza che contiene tutte le regole e altre risorse. Una sessione di conoscenza viene creata dalla KnowledgeBase.

Affinché il motore delle regole funzioni, i fatti vengono inseriti nella sessione e quando una condizione viene soddisfatta, la regola successiva viene attivata. Una sessione è di due tipi:

  • Sessione di conoscenza apolidi
  • Stateful Knowledge Session

Agenda

È un concetto logico. L'agenda è il luogo logico in cui le attivazioni attendono di essere licenziate.

Attivazioni

Le attivazioni sono i file thenparte della regola. Le attivazioni vengono inserite nell'agenda in cui viene attivata la regola appropriata.

Se vedi la regola predefinita scritta nel progetto Hello World (Sample.drl), ci sono molte parole chiave utilizzate che spiegheremo ora.

Sample.drl

  • Package- Ogni regola inizia con un nome di pacchetto. Il pacchetto funge da spazio dei nomi per le regole. I nomi delle regole all'interno di un pacchetto devono essere univoci. I pacchetti nelle regole sono simili ai pacchetti in Java.

  • Import statement- Qualunque sia il fatto su cui si desidera applicare la regola, tali fatti devono essere importati. Ad esempio, com.sample.DroolsTest.Message; nell'esempio sopra.

  • Rule Definition- Consiste nel nome della regola, la condizione e la conseguenza. Le parole chiave di Drools sonorule, when, then, e end. Nell'esempio precedente, i nomi delle regole sono "Hello World" e "GoodBye". Ilwhen parte è la condizione sia nelle regole che in thenparte è la conseguenza. Nella terminologia delle regole, ilwhen parte è anche chiamata LHS (lato sinistro) e il then parte come l'RHS (lato destro) della regola.

Esaminiamo ora i termini utilizzati nel file Java utilizzato per caricare i Drools ed eseguire le regole.

base di conoscenza

Knowledge Base è un'interfaccia che gestisce una raccolta di regole, processi e tipi interni. È contenuto all'interno della confezioneorg.drools.KnowledgeBase. In Drools, questi sono comunemente indicati comeknowledge definitions o knowledge. Le definizioni della conoscenza sono raggruppate inknowledge packages. Le definizioni della conoscenza possono essere aggiunte o rimosse. Lo scopo principale della Knowledge Base è archiviarli e riutilizzarli perché la loro creazione è costosa. Knowledge Base fornisce metodi per creare sessioni di conoscenza.

Sessione di conoscenza

La sessione della conoscenza viene recuperata dalla base della conoscenza. È l'interfaccia principale per interagire con Drools Engine. La sessione di conoscenza può essere di due tipi:

  • Sessione di conoscenza apolidi

  • Stateful Knowledge Session

Sessione di conoscenza apolidi

Stateless Knowledge Session è una sessione senza stato che costituisce il caso d'uso più semplice, senza utilizzare l'inferenza. Una sessione senza stato può essere chiamata come una funzione, passandole alcuni dati e quindi ricevendo indietro alcuni risultati. Esempi comuni di una sessione senza stato includono:

  • Validation

    • Questa persona ha diritto a un mutuo?

  • Calculation

    • Calcola un premio ipotecario.

  • Routing and Filtering

    • Filtra i messaggi in arrivo, come le e-mail, nelle cartelle.

    • Invia messaggi in arrivo a una destinazione

Stateful Knowledge Session

Le sessioni stateful durano più a lungo e consentono modifiche iterative nel tempo. Alcuni casi d'uso comuni per sessioni con stato includono:

  • Monitoring

    • Monitoraggio e analisi del mercato azionario per acquisti semiautomatici.

  • Diagnostics

    • Ricerca guasti, diagnostica medica

  • Logistics

    • Tracciamento dei pacchi e provisioning delle consegne

Generatore di conoscenze

L'interfaccia KnoledgeBuilder è responsabile della creazione di un KnowledgePackage dalle definizioni della conoscenza (regole, processi, tipi). È contenuto all'interno della confezioneorg.drools.builder.KnowledgeBuilder. Le definizioni della conoscenza possono essere in vari formati. Se ci sono problemi con la costruzione, il KnowledgeBuilder segnalerà gli errori attraverso questi due metodi:hasErrors e getError.

Il diagramma seguente spiega il processo

Nell'esempio precedente, poiché stiamo prendendo un semplice esempio di sessione di conoscenza senza stato, abbiamo inserito il fatto nella sessione, quindi viene chiamato il metodo fireAllRules () e viene visualizzato l'output.

In caso di una sessione di conoscenza con stato, una volta attivate le regole, l'oggetto sessione di conoscenza con stato deve chiamare il metodo dispose() per rilasciare la sessione ed evitare perdite di memoria.

Come hai visto, il .drl (file di regole) ha la sua sintassi, esaminiamo alcune parti della sintassi delle regole in questo capitolo.

Condizioni nelle regole

Una regola può contenere molte condizioni e modelli come:

  • Conto (saldo == 200)
  • Cliente (nome == "Vivek")

Le condizioni di cui sopra verificano se il saldo del conto è 200 o il nome del cliente è "Vivek".

Variabili nelle regole

Il nome di una variabile in Drools inizia con un simbolo di dollaro ($).

  • $ account - Account ()
  • $ account è la variabile per la classe Account ()

Drools può funzionare con tutti i tipi Java nativi e persino con Enum.

Commenti nelle regole

I caratteri speciali, # o //, possono essere utilizzati per contrassegnare i commenti su una sola riga.

Per i commenti su più righe, utilizza il seguente formato:

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

Variabili globali

Le variabili globali sono variabili assegnate a una sessione. Possono essere utilizzati per vari motivi come segue:

  • Per i parametri di input (ad esempio, valori costanti che possono essere personalizzati da sessione a sessione).

  • Per i parametri di output (ad esempio, report: una regola potrebbe scrivere un messaggio in una variabile di report globale).

  • Punti di ingresso per servizi come la registrazione, che possono essere utilizzati all'interno delle regole.

Funzioni nelle regole

Le funzioni sono una caratteristica comoda. Possono essere utilizzati in condizioni e conseguenze. Le funzioni rappresentano un'alternativa alle classi utility / helper. Per esempio,

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

Dialetto

Un dialetto specifica la sintassi utilizzata in qualsiasi espressione di codice che si trova in una condizione o in una conseguenza. Include valori di ritorno, valutazioni, valutazioni inline, predicati, espressioni di salienza, conseguenze e così via. Il valore predefinito èJava. Drools attualmente supporta un altro dialetto chiamatoMVEL. Il dialetto predefinito può essere specificato a livello di pacchetto come segue:

package org.mycompany.somePackage
dialect "mvel"

Dialetto MVEL

MVEL è un linguaggio di espressione per applicazioni basate su Java. Supporta l'accesso al campo e al metodo / getter. Si basa sulla sintassi Java.

Rilevanza

La salienza è una caratteristica molto importante della sintassi delle regole. La salienza viene utilizzata dalla strategia di risoluzione dei conflitti per decidere quale regola attivare per prima. Per impostazione predefinita, è il criterio principale.

Possiamo usare la salienza per definire l'ordine delle regole di tiro. Salience ha un attributo, che accetta qualsiasi espressione che restituisca un numero di tipo int (i numeri positivi e negativi sono validi). Più alto è il valore, più è probabile che la strategia di risoluzione dei conflitti rilevi una regola da attivare.

salience ($account.balance * 5)

Il valore di salienza predefinito è 0. Dobbiamo tenerlo presente quando si assegnano valori di salienza solo ad alcune regole.

Ci sono molte altre caratteristiche / parametri nella sintassi delle regole, ma qui abbiamo trattato solo quelli importanti.

Parole chiave di conseguenza della regola

Le parole chiave di conseguenza della regola sono le parole chiave utilizzate nella sezione "then"Parte della regola.

  • Modify - Gli attributi del fatto possono essere modificati nel file then parte della Regola.

  • Insert - In base a qualche condizione, se vera, si può inserire un nuovo fatto nella sessione corrente del Rule Engine.

  • Retract - Se una particolare condizione è vera in una regola e non vuoi agire diversamente su quel fatto, puoi ritirare il fatto particolare dal motore delle regole.

Note- È considerata una pessima pratica avere una logica condizionale (istruzioni if) all'interno di una conseguenza della regola. La maggior parte delle volte dovrebbe essere creata una nuova regola.

In questo capitolo, creeremo un progetto Drools per la seguente dichiarazione del problema:

A seconda della città e del tipo di prodotto (combinazione di città e prodotto), scopri la tassa locale relativa a quella città.

Avremo due file DRL per il nostro progetto Drools. I due file DRL indicheranno due città in considerazione (Pune e Nagpur) e quattro tipi di prodotti (generi alimentari, medicinali, orologi e beni di lusso).

  • L'imposta sui medicinali in entrambe le città è considerata pari a zero.

  • Per i generi alimentari, abbiamo ipotizzato una tassa di Rs 2 a Pune e Rs 1 a Nagpur.

Abbiamo utilizzato lo stesso prezzo di vendita per dimostrare risultati diversi. Nota che tutte le regole vengono attivate nell'applicazione.

Ecco il modello per contenere ogni oggetto

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

File DRL

Come suggerito in precedenza, abbiamo utilizzato due file DRL qui: Pune.drl e Nagpur.drl.

Pune.drl

Questo è il file DRL che esegue le regole per la città di 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

Questo è il file DRL che esegue le regole per la città di 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

Abbiamo scritto i file DRL in base alla città, in quanto ci offre l'estensibilità per aggiungere un numero qualsiasi di file di regole in un secondo momento se vengono aggiunte nuove città.

Per dimostrare che tutte le regole vengono attivate dai nostri file di regole, abbiamo utilizzato due tipi di articoli (medicinali e generi alimentari); e la medicina è esentasse e la spesa è tassata come per la città.

La nostra classe di test carica i file delle regole, inserisce i fatti nella sessione e produce l'output.

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

Se esegui questo programma, il suo output sarà il seguente:

PUNE 0
PUNE 20
NAGPUR 0
NAGPUR 10

Sia per Pune che per Nagpur, quando l'articolo è un medicinale, la tassa locale è zero; mentre quando l'articolo è un prodotto alimentare, l'imposta è come per la città. È possibile aggiungere più regole nei file DRL per altri prodotti. Questo è solo un programma di esempio.

Chiama una funzione esterna da un file DRL

Qui mostreremo come chiamare una funzione statica da un file Java all'interno del tuo file DRL.

Prima di tutto, crea una classe HelloCity.java nello stesso pacchetto com.sample.

package com.sample;

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

Successivamente, aggiungi l'istruzione import nel file DRL per chiamare il metodo writeHello dal file DRL. Nel seguente blocco di codice, le modifiche nel file DRL Pune.drl sono evidenziate in giallo.

// 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

Esegui di nuovo il programma e il suo output sarà il seguente:

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

La differenza ora nell'output è contrassegnata in giallo che mostra l'output del metodo statico nella classe Java.

Il vantaggio di chiamare un metodo Java è che possiamo scrivere qualsiasi funzione di utilità / aiuto in Java e chiamare lo stesso da un file DRL.

Esistono diversi modi per eseguire il debug di un progetto Drools. Qui, scriveremo una classe Utility per farti sapere quali regole vengono attivate o attivate.

Con questo approccio, puoi verificare quali sono tutte le regole che vengono attivate nel tuo progetto Drools. Ecco la nostra classe di utilità

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

Il primo metodo help stampa la regola attivata insieme ad alcune informazioni extra che puoi passare come stringa tramite il file DRL.

La seconda regola helper stampa se la regola particolare è stata attivata o meno.

Abbiamo aggiunto uno dei metodi di utilità in ogni file DRL. Abbiamo anche aggiunto la funzione di importazione nel file DRL (Pune.drl). Nelthenparte della regola, abbiamo aggiunto la chiamata alla funzione di utilità. Di seguito viene fornito il Pune.drl modificato. Le modifiche sono evidenziate in blu.

Modificato 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

Allo stesso modo, abbiamo aggiunto l'altra funzione di utilità nel secondo file DRL (Nagpur.drl). Ecco il codice modificato -

Nagpur.drl modificato

// 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

Esegui di nuovo il programma e dovrebbe produrre il seguente output:

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

Vengono chiamate entrambe le funzioni di utilità e mostra se la regola particolare è stata chiamata o meno. Nell'esempio precedente, tutte le regole vengono chiamate, ma in un'applicazione aziendale questa funzione di utilità può essere davvero utile per eseguire il debug e scoprire se una determinata regola è stata attivata o meno.

Utilizzo della prospettiva di debug in Eclipse

Puoi eseguire il debug delle regole durante l'esecuzione dell'applicazione Drools. È possibile aggiungere punti di interruzione nelle conseguenze delle regole e ogni volta che si incontra un tale punto di interruzione durante l'esecuzione delle regole, l'esecuzione viene temporaneamente interrotta. È quindi possibile ispezionare le variabili note a quel punto come si fa in un'applicazione Java e utilizzare le normali opzioni di debug disponibili in Eclipse.

Per creare un punto di interruzione nel file DRL, fai doppio clic sulla riga in cui desideri creare un punto di interruzione. Ricorda, puoi creare solo un punto di interruzione nel filethenparte di una regola. Un punto di interruzione può essere rimosso facendo doppio clic sul punto di interruzione nell'editor DRL.

Dopo aver applicato i punti di interruzione, è necessario eseguire il debug dell'applicazione come applicazione Drools. I punti di interruzione di Drools (punti di interruzione nel file DRL) funzioneranno solo se l'applicazione viene sottoposta a debug come applicazione Drools. Ecco come devi fare lo stesso:

Dopo aver eseguito il debug dell'applicazione come applicazione Drools, vedrai il controllo sul file DRL come mostrato nella seguente schermata:

Puoi vedere le variabili ei valori correnti dell'oggetto in quel punto di debug. Lo stesso controllo di F6 per passare alla riga successiva e F8 per passare al punto di debug successivo sono applicabili anche qui. In questo modo, puoi eseguire il debug della tua applicazione Drools.

Note - La prospettiva di debug nell'applicazione Drools funziona solo se il dialetto è MVEL fino a Drools 5.x.