Drools - Kurzanleitung

Jede Java-Anwendung auf Unternehmensebene kann in drei Teile unterteilt werden:

• Benutzeroberfläche - Benutzeroberfläche (Frontend)
• Serviceschicht, die wiederum mit einer Datenbank verbunden ist
• Geschäftsschicht

Wir haben eine Reihe von Frameworks, die die Benutzeroberfläche und die Service-Schicht gemeinsam verwalten, z. B. Spring und Struts. Wir hatten jedoch keine Standardmethode, um mit der Geschäftslogik umzugehen, bis Drools ins Leben gerufen wurde.

Was ist Drools?

Drools ist ein Business Logic integration Platform (BLiP). Es ist in Java geschrieben. Es ist ein Open-Source-Projekt, das von JBoss und Red Hat, Inc. unterstützt wird. Es erweitert und implementiert den Rete-Pattern-Matching-Algorithmus.

Für Laien ist Drools eine Sammlung von Tools, mit denen wir Logik und Daten in Geschäftsprozessen trennen und überlegen können. Die zwei wichtigen Schlüsselwörter, die wir beachten müssen, sindLogic und Data.

Drools ist in zwei Hauptteile unterteilt: Authoring und Runtime.

• Authoring - Der Authoring-Prozess umfasst die Erstellung von Regeldateien (DRL-Dateien).

• Runtime - Es beinhaltet die Erstellung eines Arbeitsspeichers und die Handhabung der Aktivierung.

Was ist eine Regelengine?

Drools ist eine Regelengine oder ein Produktionsregelsystem, das den regelbasierten Ansatz zur Implementierung und zum Expertensystem verwendet. Expertensysteme sind wissensbasierte Systeme, die mithilfe der Wissensrepräsentation erworbenes Wissen zu einer Wissensbasis verarbeiten, die zum Denken verwendet werden kann.

Ein Produktionsregelsystem ist vollständig mit einem Fokus auf Wissensrepräsentation, um Aussagenlogik und Logik erster Ordnung in einer prägnanten, nicht mehrdeutigen und deklarativen Weise auszudrücken.

Das Gehirn eines Produktionsregelsystems ist ein Inference Enginedas kann auf eine große Anzahl von Regeln und Fakten skaliert werden. Die Inference Engine vergleicht Fakten und Daten mit Produktionsregeln - auch genanntProductions oder nur Rules - Schlussfolgerungen zu ziehen, die zu Handlungen führen.

Eine Produktionsregel ist eine zweiteilige Struktur, die Logik erster Ordnung verwendet, um über die Wissensrepräsentation nachzudenken. Eine Geschäftsregel-Engine ist ein Softwaresystem, das eine oder mehrere Geschäftsregeln in einer Laufzeitproduktionsumgebung ausführt.

Mit einer Regel-Engine können Sie „What to Do" und nicht "How to do it. ”

Was ist eine Regel?

Die Regeln werden Stücke von Wissen oft ausgedrückt als „ Wenn einige Bedingungen auftreten, dann tun einige Aufgaben.“

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

Der wichtigste Teil einer Regel ist ihre whenTeil. Wenn diewhen Teil ist zufrieden, die then Teil wird ausgelöst.

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

Mustervergleich

Der Prozess des Abgleichs der neuen oder vorhandenen Fakten mit den Produktionsregeln wird als Pattern Matching bezeichnet und von der Inference Engine durchgeführt. Es gibt eine Reihe von Algorithmen für die Mustererkennung, darunter -

• Linear
• Rete
• Treat
• Leaps

Drools Implementiert und erweitert den Rete-Algorithmus. Die Drools Rete-Implementierung heißt ReteOO, was bedeutet, dass Drools eine verbesserte und optimierte Implementierung des Rete-Algorithmus für objektorientierte Systeme hat.

Vorteile einer Regelengine

Deklarative Programmierung

Regeln machen es einfach, Lösungen für schwierige Probleme auszudrücken und die Lösungen zu überprüfen. Im Gegensatz zu Codes werden Regeln in einer weniger komplexen Sprache geschrieben. Business Analysten können eine Reihe von Regeln leicht lesen und überprüfen.

Logik- und Datentrennung

Die Daten befinden sich in den Domänenobjekten und die Geschäftslogik in den Regeln. Je nach Art des Projekts kann diese Art der Trennung sehr vorteilhaft sein.

Geschwindigkeit und Skalierbarkeit

Der Rete OO-Algorithmus, auf dem Drools geschrieben ist, ist bereits ein bewährter Algorithmus. Mit Hilfe von Drools wird Ihre Anwendung sehr skalierbar. Bei häufigen Änderungsanforderungen können neue Regeln hinzugefügt werden, ohne dass die vorhandenen Regeln geändert werden müssen.

Zentralisierung des Wissens

Mithilfe von Regeln erstellen Sie ein Wissensrepository (eine Wissensbasis), das ausführbar ist. Es ist ein einziger Punkt der Wahrheit für die Geschäftspolitik. Im Idealfall sind Regeln so lesbar, dass sie auch als Dokumentation dienen können.

Werkzeugintegration

Tools wie Eclipse bieten Möglichkeiten zum Bearbeiten und Verwalten von Regeln sowie zum sofortigen Feedback, zur Validierung und zur Unterstützung von Inhalten. Prüf- und Debugging-Tools sind ebenfalls verfügbar.

Hier sind die Voraussetzungen für die Installation des Drools Plugins:

• Java 1.5 (oder höher) SE JDK
• Eclipse 4.2 (oder eine beliebige Version) und das Drools-Plugin

Da Drools ein in Java geschriebenes BRMS (Business Rule Management System) ist, wird in diesem Abschnitt erläutert, wie Sie die gewünschten Plugins hinzufügen. In Anbetracht der Tatsache, dass maximal Java-Benutzer Eclipse verwenden, sehen wir uns an, wie das Drools 5.x.0-Plugin in Eclipse hinzugefügt wird.

Schritt 1: Laden Sie die Binärdateien herunter

Laden Sie die Binärdateien über den folgenden Link herunter:

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

Extrahieren Sie nach Abschluss des Downloads die Dateien auf Ihre Festplatte.

Schritt 2: Installieren Sie die Software

Starten Sie Eclipse und gehen Sie zu Hilfe → Installieren Sie neue Software. Klicken Sie auf Hinzufügen, wie im folgenden Screenshot gezeigt.

Klicken Sie anschließend wie hier gezeigt auf Lokal und wählen Sie "… / binaries / org.drools.updatesite".

Wählen Sie Drools und jBPM und klicken Sie auf Weiter.

Klicken Sie erneut auf Weiter. Akzeptieren Sie anschließend die Bedingungen und die Lizenzvereinbarung und klicken Sie auf Fertig stellen.

Wenn Sie auf Fertig stellen klicken, wird die Softwareinstallation gestartet.

Nach erfolgreicher Installation wird das folgende Dialogfeld angezeigt:

Klicken Sie auf Ja. Wechseln Sie nach dem Neustart von Eclipse zu Windows → Einstellungen

Sie können Drools unter Ihren Einstellungen sehen. Die Installation Ihres Drools-Plugins ist jetzt abgeschlossen.

Drools Runtime ist erforderlich, um den Editor anzuweisen, das Programm mit einer bestimmten Version von Drools jar auszuführen. Sie können Ihr Programm / Ihre Anwendung mit verschiedenen Drools Runtime ausführen.

Klicken Sie auf Windows → Einstellungen → Drools → Installed Drools Runtime. Klicken Sie dann auf Hinzufügen, wie im folgenden Screenshot gezeigt.

Klicken Sie anschließend wie hier gezeigt auf Neue Drools-Laufzeit erstellen.

Geben Sie den Pfad bis zum Binärordner ein, in den Sie die Datei droolsjbpm-tools-distribution-5.3.0.Final.zip heruntergeladen haben

Klicken Sie auf OK und geben Sie einen Namen für die Drools Runtime ein. Die Drools-Laufzeit wird jetzt erstellt.

Öffnen Sie Eclipse, um ein grundlegendes Drools-Programm zu erstellen. Gehen Sie zu Dateib → Neu → Projekt.

Wählen Sie Drools Project. Geben Sie einen geeigneten Namen für das Projekt an. Zum Beispiel DroolsTest.

Im nächsten Bildschirm werden Sie aufgefordert, einige Dateien auszuwählen, die Sie in Ihrem ersten Drools-Projekt verwenden möchten.

Wählen Sie die ersten beiden Dateien aus. Die erste Datei ist eine DRL-Datei (Drools Rule File) und die zweite Datei ist eine Java-Klasse zum Laden und Ausführen der HelloWorld-Regel.

Klicken Sie auf Weiter → Fertig stellen.

Sobald Sie auf Fertig stellen klicken, wird in Ihrem Arbeitsbereich ein <DroolsTest> -Projekt erstellt. Öffnen Sie die Java-Klasse, klicken Sie mit der rechten Maustaste und führen Sie sie als Java-Anwendung aus. Sie würden die Ausgabe wie hier gezeigt sehen -

Als nächstes werden wir die Begriffe diskutieren, die häufig in einer Regelengine verwendet werden.

Regeln

Das Herzstück der Rules Engine, in der Sie Bedingungen angeben (wenn 'a', dann 'b').

Fakten

Fakten sind die Daten, auf die die Regeln einwirken. Aus Java-Sicht sind Fakten das POJO (Plain Old Java Object).

Session

Eine Wissenssitzung in Drools ist die Kernkomponente zum Auslösen der Regeln. Es ist die Wissenssitzung, die alle Regeln und andere Ressourcen enthält. Aus der KnowledgeBase wird eine Wissenssitzung erstellt.

Damit die Regelengine funktioniert, werden Fakten in die Sitzung eingefügt. Wenn eine Bedingung erfüllt ist, wird die nachfolgende Regel ausgelöst. Es gibt zwei Arten von Sitzungen:

• Zustandslose Wissenssitzung
• Stateful Knowledge Session

Agenda

Es ist ein logisches Konzept. Die Agenda ist der logische Ort, an dem Aktivierungen darauf warten, ausgelöst zu werden.

Aktivierungen

Aktivierungen sind die thenTeil der Regel. Aktivierungen werden auf die Tagesordnung gesetzt, wenn die entsprechende Regel ausgelöst wird.

Wenn Sie die Standardregel sehen, die im Hello World-Projekt (Sample.drl) geschrieben ist, werden viele Schlüsselwörter verwendet, die wir jetzt erläutern werden.

Sample.drl

• Package- Jede Regel beginnt mit einem Paketnamen. Das Paket fungiert als Namespace für Regeln. Regelnamen innerhalb eines Pakets müssen eindeutig sein. Pakete in Regeln ähneln Paketen in Java.

• Import statement- Unabhängig davon, auf welche Fakten Sie die Regel anwenden möchten, müssen diese Fakten importiert werden. Zum Beispiel com.sample.DroolsTest.Message; im obigen Beispiel.

• Rule Definition- Es besteht aus dem Regelnamen, der Bedingung und der Konsequenz. Drools Schlüsselwörter sindrule, when, then, und end. Im obigen Beispiel lauten die Regelnamen "Hello World" und "GoodBye". Daswhen Teil ist die Bedingung sowohl in den Regeln als auch in der thenTeil ist die Folge. In der Regelterminologie ist diewhen Teil wird auch als LHS (linke Seite) und als bezeichnet then Teil als RHS (rechte Seite) der Regel.

Lassen Sie uns nun die Begriffe durchgehen, die in der Java-Datei verwendet werden, mit der die Drools geladen und die Regeln ausgeführt werden.

Wissensbasis

Knowledge Base ist eine Schnittstelle, die eine Sammlung von Regeln, Prozessen und internen Typen verwaltet. Es ist in der Verpackung enthaltenorg.drools.KnowledgeBase. In Drools werden diese üblicherweise als bezeichnetknowledge definitions oder knowledge. Wissensdefinitionen werden in gruppiertknowledge packages. Wissensdefinitionen können hinzugefügt oder entfernt werden. Der Hauptzweck der Knowledge Base besteht darin, sie zu speichern und wiederzuverwenden, da ihre Erstellung teuer ist. Die Knowledge Base bietet Methoden zum Erstellen von Wissenssitzungen.

Wissenssitzung

Die Wissenssitzung wird aus der Wissensdatenbank abgerufen. Es ist die Hauptschnittstelle für die Interaktion mit der Drools Engine. Es gibt zwei Arten von Wissenssitzungen:

• Zustandslose Wissenssitzung

• Stateful Knowledge Session

Zustandslose Wissenssitzung

Stateless Knowledge Session ist eine zustandslose Sitzung, die den einfachsten Anwendungsfall darstellt und keine Inferenz verwendet. Eine zustandslose Sitzung kann wie eine Funktion aufgerufen werden, indem einige Daten übergeben und dann einige Ergebnisse zurückgegeben werden. Häufige Beispiele für eine zustandslose Sitzung sind:

• Validation

  • Ist diese Person für eine Hypothek berechtigt?

• Calculation

  • Berechnen Sie eine Hypothekenprämie.

• Routing and Filtering

  • Filtern Sie eingehende Nachrichten wie E-Mails in Ordner.

  • Senden Sie eingehende Nachrichten an ein Ziel

Stateful Knowledge Session

Stateful-Sitzungen haben eine längere Lebensdauer und ermöglichen iterative Änderungen im Laufe der Zeit. Einige häufige Anwendungsfälle für zustandsbehaftete Sitzungen sind:

• Monitoring

  • Börsenüberwachung und -analyse für den halbautomatischen Kauf.

• Diagnostics

  • Fehlersuche, medizinische Diagnostik

• Logistics

  • Paketverfolgung und Zustellung

Knowledge Builder

Die KnoledgeBuilder-Oberfläche ist für die Erstellung eines KnowledgePackage aus Wissensdefinitionen (Regeln, Prozesse, Typen) verantwortlich. Es ist in der Verpackung enthaltenorg.drools.builder.KnowledgeBuilder. Die Wissensdefinitionen können in verschiedenen Formaten vorliegen. Wenn beim Erstellen Probleme auftreten, meldet der KnowledgeBuilder Fehler mithilfe der beiden folgenden Methoden:hasErrors und getError.

Das folgende Diagramm erläutert den Vorgang

Im obigen Beispiel haben wir, da wir ein einfaches Beispiel für eine zustandslose Wissenssitzung nehmen, die Tatsache in die Sitzung eingefügt. Anschließend wird die Methode fireAllRules () aufgerufen und Sie sehen die Ausgabe.

Im Falle einer Stateful-Knowledge-Sitzung muss das Stateful-Knowledge-Session-Objekt nach dem Auslösen der Regeln die Methode aufrufen dispose() um die Sitzung freizugeben und Speicherlecks zu vermeiden.

Wie Sie gesehen haben, hat die DRL (Regeldatei) eine eigene Syntax. Lassen Sie uns einen Teil der Regelsyntax in diesem Kapitel behandeln.

Bedingungen in Regeln

Eine Regel kann viele Bedingungen und Muster enthalten, wie z.

• Konto (Kontostand == 200)
• Kunde (Name == "Vivek")

Die oben genannten Bedingungen prüfen, ob der Kontostand 200 beträgt oder der Kundenname "Vivek" lautet.

Variablen in Regeln

Ein Variablenname in Drools beginnt mit einem Dollarsymbol ($).

• $ account - Account ()
• $ account ist die Variable für die Klasse Account ()

Drools können mit allen nativen Java-Typen und sogar mit Enum arbeiten.

Kommentare in Regeln

Mit den Sonderzeichen # oder // können einzeilige Kommentare markiert werden.

Verwenden Sie für mehrzeilige Kommentare das folgende Format:

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

Globale Variablen

Globale Variablen sind Variablen, die einer Sitzung zugewiesen sind. Sie können aus verschiedenen Gründen wie folgt verwendet werden:

• Für Eingabeparameter (z. B. konstante Werte, die von Sitzung zu Sitzung angepasst werden können).

• Für Ausgabeparameter (z. B. Berichterstellung - eine Regel kann eine Nachricht in eine globale Berichtsvariable schreiben).

• Einstiegspunkte für Dienste wie die Protokollierung, die innerhalb von Regeln verwendet werden können.

Funktionen in Regeln

Funktionen sind eine praktische Funktion. Sie können unter Bedingungen und Konsequenzen eingesetzt werden. Funktionen stellen eine Alternative zu den Dienstprogramm- / Hilfsklassen dar. Zum Beispiel,

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

Dialekt

Ein Dialekt gibt die Syntax an, die in einem Code-Ausdruck verwendet wird, der sich in einer Bedingung oder in einer Konsequenz befindet. Es enthält Rückgabewerte, Auswertungen, Inline-Auswertungen, Prädikate, Salience-Ausdrücke, Konsequenzen usw. Der Standardwert istJava. Drools unterstützt derzeit einen weiteren Dialekt namensMVEL. Der Standarddialekt kann auf Paketebene wie folgt angegeben werden:

package org.mycompany.somePackage
dialect "mvel"

MVEL Dialekt

MVEL ist eine Ausdruckssprache für Java-basierte Anwendungen. Es unterstützt den Zugriff auf Felder und Methoden / Getter. Es basiert auf der Java-Syntax.

Salience

Salience ist ein sehr wichtiges Merkmal der Regelsyntax. Salience wird von der Konfliktlösungsstrategie verwendet, um zu entscheiden, welche Regel zuerst ausgelöst werden soll. Standardmäßig ist dies das Hauptkriterium.

Wir können Salience verwenden, um die Reihenfolge der Zündregeln zu definieren. Salience hat ein Attribut, das jeden Ausdruck akzeptiert, der eine Anzahl vom Typ int zurückgibt (sowohl positive als auch negative Zahlen sind gültig). Je höher der Wert, desto wahrscheinlicher wird eine Regel von der Konfliktlösungsstrategie erfasst.

salience ($account.balance * 5)

Der Standardwert für die Salience ist 0. Wir sollten dies berücksichtigen, wenn wir nur einigen Regeln Salience-Werte zuweisen.

Es gibt viele andere Funktionen / Parameter in der Regelsyntax, aber wir haben hier nur die wichtigen behandelt.

Regelfolge-Schlüsselwörter

Regelkonsequenz Schlüsselwörter sind die Schlüsselwörter, die im „thenTeil der Regel.

• Modify - Die Attribute der Tatsache können in der geändert werden then Teil der Regel.

• Insert - Wenn eine Bedingung erfüllt ist, kann eine neue Tatsache in die aktuelle Sitzung der Regelengine eingefügt werden.

• Retract - Wenn eine bestimmte Bedingung in einer Regel erfüllt ist und Sie nichts anderes auf diese Tatsache anwenden möchten, können Sie die bestimmte Tatsache aus der Regelengine zurückziehen.

Note- Es wird als sehr schlechte Praxis angesehen, eine bedingte Logik (if-Anweisungen) innerhalb einer Regelfolge zu haben. In den meisten Fällen sollte eine neue Regel erstellt werden.

In diesem Kapitel erstellen wir ein Drools-Projekt für die folgende Problemstellung:

Informieren Sie sich je nach Stadt und Art des Produkts (Kombination aus Stadt und Produkt) über die lokale Steuer für diese Stadt.

Wir werden zwei DRL-Dateien für unser Drools-Projekt haben. Die beiden DRL-Dateien kennzeichnen zwei betrachtete Städte (Pune und Nagpur) und vier Arten von Produkten (Lebensmittel, Medikamente, Uhren und Luxusgüter).

• Die Steuer auf Arzneimittel in beiden Städten wird als Null angesehen.

• Für Lebensmittel haben wir eine Steuer von Rs 2 in Pune und Rs 1 in Nagpur angenommen.

Wir haben den gleichen Verkaufspreis verwendet, um unterschiedliche Ergebnisse zu demonstrieren. Beachten Sie, dass alle Regeln in der Anwendung ausgelöst werden.

Hier ist das Modell für jeden 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;
   }
}

DRL-Dateien

Wie bereits erwähnt, haben wir hier zwei DRL-Dateien verwendet: Pune.drl und Nagpur.drl.

Pune.drl

Dies ist die DRL-Datei, die Regeln für Pune City ausführt.

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

Dies ist die DRL-Datei, die Regeln für die Stadt Nagpur ausführt.

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

Wir haben die DRL-Dateien basierend auf der Stadt geschrieben, da wir später beliebig viele Regeldateien hinzufügen können, wenn neue Städte hinzugefügt werden.

Um zu demonstrieren, dass alle Regeln aus unseren Regeldateien ausgelöst werden, haben wir zwei Artikeltypen verwendet (Medikamente und Lebensmittel). und Medizin ist steuerfrei und Lebensmittel werden nach Stadt besteuert.

Unsere Testklasse lädt die Regeldateien, fügt die Fakten in die Sitzung ein und erzeugt die Ausgabe.

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

Wenn Sie dieses Programm ausführen, lautet die Ausgabe wie folgt:

PUNE 0
PUNE 20
NAGPUR 0
NAGPUR 10

Sowohl für Pune als auch für Nagpur beträgt die lokale Steuer Null, wenn es sich bei dem Artikel um ein Arzneimittel handelt. Wenn es sich bei dem Artikel um ein Lebensmittel handelt, richtet sich die Steuer nach der Stadt. Weitere Regeln können in den DRL-Dateien für andere Produkte hinzugefügt werden. Dies ist nur ein Beispielprogramm.

Rufen Sie eine externe Funktion aus einer DRL-Datei auf

Hier zeigen wir, wie Sie eine statische Funktion aus einer Java-Datei in Ihrer DRL-Datei aufrufen.

Erstellen Sie zunächst eine Klasse HelloCity.java im gleichen Paket com.sample.

package com.sample;

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

Fügen Sie anschließend die import-Anweisung in die DRL-Datei ein, um die writeHello-Methode aus der DRL-Datei aufzurufen. Im folgenden Codeblock werden die Änderungen in der DRL-Datei Pune.drl gelb hervorgehoben.

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

Führen Sie das Programm erneut aus, und die Ausgabe lautet wie folgt:

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

Der Unterschied in der Ausgabe ist jetzt gelb markiert, wodurch die Ausgabe der statischen Methode in der Java-Klasse angezeigt wird.

Der Vorteil des Aufrufs einer Java-Methode besteht darin, dass wir jede Dienstprogramm- / Hilfsfunktion in Java schreiben und diese aus einer DRL-Datei aufrufen können.

Es gibt verschiedene Möglichkeiten, ein Drools-Projekt zu debuggen. Hier schreiben wir eine Utility-Klasse, um Ihnen mitzuteilen, welche Regeln ausgelöst oder ausgelöst werden.

Mit diesem Ansatz können Sie überprüfen, welche Regeln in Ihrem Drools-Projekt ausgelöst werden. Hier ist unsere Utility-Klasse

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

Die erste Methode help Gibt die ausgelöste Regel zusammen mit einigen zusätzlichen Informationen aus, die Sie als String über die DRL-Datei übergeben können.

Die zweite Regel helper Gibt aus, ob die bestimmte Regel ausgelöst wurde oder nicht.

Wir haben jeder DRL-Datei eine der Utility-Methoden hinzugefügt. Wir haben auch die Importfunktion in die DRL-Datei (Pune.drl) aufgenommen. In demthenAls Teil der Regel haben wir den Funktionsaufruf des Dienstprogramms hinzugefügt. Die modifizierte Pune.drl ist unten angegeben. Änderungen werden blau hervorgehoben.

Geänderte 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

In ähnlicher Weise haben wir die andere Dienstprogrammfunktion in die zweite DRL-Datei (Nagpur.drl) aufgenommen. Hier ist der geänderte Code -

Geänderte Nagpur.drl

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

Führen Sie das Programm erneut aus und es sollte die folgende Ausgabe erzeugen -

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

Beide Dienstprogrammfunktionen werden aufgerufen und es wird angezeigt, ob die bestimmte Regel aufgerufen wurde oder nicht. Im obigen Beispiel werden alle Regeln aufgerufen. In einer Unternehmensanwendung kann diese Dienstprogrammfunktion jedoch sehr nützlich sein, um zu debuggen und herauszufinden, ob eine bestimmte Regel ausgelöst wurde oder nicht.

Verwenden der Debug-Perspektive in Eclipse

Sie können die Regeln während der Ausführung Ihrer Drools-Anwendung debuggen. Sie können Haltepunkte zu den Konsequenzen Ihrer Regeln hinzufügen. Wenn während der Ausführung der Regeln ein solcher Haltepunkt auftritt, wird die Ausführung vorübergehend gestoppt. Sie können dann die zu diesem Zeitpunkt bekannten Variablen wie in einer Java-Anwendung überprüfen und die in Eclipse verfügbaren normalen Debugging-Optionen verwenden.

Um einen Haltepunkt in Ihrer DRL-Datei zu erstellen, doppelklicken Sie einfach auf die Zeile, in der Sie einen Haltepunkt erstellen möchten. Denken Sie daran, dass Sie nur einen Haltepunkt in der erstellen könnenthenTeil einer Regel. Ein Haltepunkt kann durch Doppelklicken auf den Haltepunkt im DRL-Editor entfernt werden.

Nach dem Anwenden der Haltepunkte müssen Sie Ihre Anwendung als Drools-Anwendung debuggen. Drools-Haltepunkte (Haltepunkte in der DRL-Datei) funktionieren nur, wenn Ihre Anwendung als Drools-Anwendung debuggt wird. Hier ist, wie Sie dasselbe tun müssen -

Sobald Sie Ihre Anwendung als Drools-Anwendung debuggen, wird das Steuerelement in der DRL-Datei angezeigt (siehe folgenden Screenshot).

Sie können die Variablen und die aktuellen Werte des Objekts an diesem Debugpunkt anzeigen. Die gleiche Steuerung von F6, um zur nächsten Zeile zu gelangen, und F8, um zum nächsten Debug-Punkt zu springen, gilt auch hier. Auf diese Weise können Sie Ihre Drools-Anwendung debuggen.

Note - Die Debug-Perspektive in der Drools-Anwendung funktioniert nur, wenn der Dialekt MVEL bis Drools 5.x ist.