Drools - Szybki przewodnik

Dowolną aplikację Java na poziomie przedsiębiorstwa można podzielić na trzy części -

• UI - interfejs użytkownika (frontend)
• Warstwa usług, która z kolei jest połączona z bazą danych
• Warstwa biznesowa

Mamy wiele frameworków, które obsługują razem interfejs użytkownika i warstwę usług, na przykład Spring i Struts. Jednak nie mieliśmy standardowego sposobu radzenia sobie z logiką biznesową, dopóki nie powstał Drools.

Co to jest Drools?

Drools to Business Logic integration Platform (BLiP). Jest napisany w Javie. Jest to projekt open source wspierany przez JBoss i Red Hat, Inc. Rozszerza i implementuje algorytm dopasowywania wzorców Rete.

Mówiąc prościej, Drools to zbiór narzędzi, które pozwalają nam oddzielać i analizować logikę i dane znalezione w procesach biznesowych. Dwa ważne słowa kluczowe, na które musimy zwrócić uwagę, toLogic i Data.

Drools jest podzielony na dwie główne części: Authoring i Runtime.

• Authoring - Proces tworzenia obejmuje tworzenie plików reguł (pliki .DRL).

• Runtime - Obejmuje tworzenie pamięci roboczej i obsługę aktywacji.

Co to jest mechanizm reguł?

Drools to silnik reguł lub system reguł produkcyjnych, który wykorzystuje podejście oparte na regułach do wdrożenia i system ekspercki. Systemy ekspertowe to systemy oparte na wiedzy, które wykorzystują reprezentację wiedzy do przetwarzania zdobytej wiedzy w bazę wiedzy, którą można wykorzystać do wnioskowania.

System reguł produkcyjnych jest kompletny Turing, z naciskiem na reprezentację wiedzy, aby wyrazić logikę zdań i pierwszego rzędu w zwięzły, jednoznaczny i deklaratywny sposób.

Mózgiem systemu reguł produkcyjnych jest plik Inference Enginektóre można skalować do wielu zasad i faktów. Silnik wnioskowania dopasowuje fakty i dane do reguł produkcyjnych - zwanych równieżProductions Lub tylko Rules - wyciągać wnioski, które skutkują działaniami.

Reguła produkcyjna to dwuczęściowa struktura wykorzystująca logikę pierwszego rzędu do rozumowania zamiast reprezentacji wiedzy. Silnik reguł biznesowych to system oprogramowania, który wykonuje jedną lub więcej reguł biznesowych w produkcyjnym środowisku wykonawczym.

Mechanizm reguł pozwala zdefiniować „What to Do" i nie "How to do it. ”

Co to jest reguła?

Reguły są kawałki wiedzy często wyrażane jako „ Kiedy występują pewne warunki, a następnie wykonać kilka zadań.”

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

Najważniejszą częścią reguły jest jej whenczęść. Jeśliwhen część jest spełniona, plik then część jest wyzwalana.

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

Dopasowywanie wzorców

Proces dopasowywania nowych lub istniejących faktów do reguł produkcyjnych nazywa się dopasowywaniem wzorców, które jest wykonywane przez mechanizm wnioskowania. Istnieje wiele algorytmów używanych do dopasowywania wzorców, w tym -

• Linear
• Rete
• Treat
• Leaps

Drools Implementuje i rozszerza algorytm Rete. Implementacja Drools Rete nazywa się ReteOO, co oznacza, że ​​Drools ma ulepszoną i zoptymalizowaną implementację algorytmu Rete dla systemów obiektowych.

Zalety mechanizmu reguł

Programowanie deklaratywne

Reguły ułatwiają wyrażanie rozwiązań trudnych problemów, a także weryfikację rozwiązań. W przeciwieństwie do kodów, Reguły są napisane w mniej złożonym języku; Analitycy biznesowi mogą łatwo odczytać i zweryfikować zestaw reguł.

Logika i separacja danych

Dane znajdują się w obiektach domeny, a logika biznesowa znajduje się w regułach. W zależności od rodzaju projektu ten rodzaj oddzielenia może być bardzo korzystny.

Szybkość i skalowalność

Algorytm Rete OO, na którym napisano Drools, jest już sprawdzonym algorytmem. Z pomocą Drools Twoja aplikacja staje się bardzo skalowalna. W przypadku częstych żądań zmiany można dodawać nowe reguły bez konieczności modyfikowania istniejących.

Centralizacja wiedzy

Korzystając z Reguł, tworzysz repozytorium wiedzy (bazę wiedzy), która jest wykonywalna. To pojedynczy punkt prawdy dotyczący polityki biznesowej. W idealnym przypadku Reguły są tak czytelne, że mogą również służyć jako dokumentacja.

Integracja narzędzi

Narzędzia takie jak Eclipse zapewniają sposoby edytowania reguł i zarządzania nimi oraz uzyskiwania natychmiastowych informacji zwrotnych, walidacji i pomocy w zakresie treści. Dostępne są również narzędzia do inspekcji i debugowania.

Oto wymagania wstępne do zainstalowania wtyczki Drools -

• Java 1.5 (lub nowsza) SE JDK
• Eclipse 4.2 (lub dowolna wersja) i wtyczka Drools

Ponieważ Drools to BRMS (Business Rule Management System) napisany w Javie, w tej sekcji omówimy, jak dodać żądane wtyczki. Biorąc pod uwagę maksymalną liczbę użytkowników Javy korzystających z Eclipse, zobaczmy, jak dodać wtyczkę Drools 5.x.0 w Eclipse.

Krok 1: Pobierz pliki binarne

Pobierz pliki binarne z poniższego linku -

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

Po zakończeniu pobierania wypakuj pliki na dysk twardy.

Krok 2: Zainstaluj oprogramowanie

Uruchom Eclipse i przejdź do pomocy → zainstaluj nowe oprogramowanie. Kliknij Dodaj, jak pokazano na poniższym zrzucie ekranu.

Następnie kliknij Lokalne, jak pokazano tutaj, i wybierz „… / binaries / org.drools.updatesite”.

Wybierz Drools i jBPM i kliknij Dalej.

Ponownie kliknij Dalej. Następnie zaakceptuj warunki i umowę licencyjną, a następnie kliknij przycisk Zakończ.

Po kliknięciu przycisku Zakończ rozpocznie się instalacja oprogramowania -

Po pomyślnej instalacji pojawi się następujące okno dialogowe -

Kliknij tak. Po ponownym uruchomieniu Eclipse przejdź do Windows → Preferencje

Możesz zobaczyć Drools w swoich preferencjach. Twoja instalacja wtyczki Drools została zakończona.

Drools Runtime jest wymagane, aby poinstruować edytora, aby uruchomił program z określoną wersją Drools jar. Możesz uruchomić swój program / aplikację z innym Drools Runtime.

Kliknij Windows → Preferencje → Drools → Zainstalowane środowisko wykonawcze Drools. Następnie kliknij Dodaj, jak pokazano na poniższym zrzucie ekranu.

Następnie kliknij Utwórz nowe środowisko wykonawcze Drools, jak pokazano tutaj.

Wprowadź ścieżkę do folderu plików binarnych, do którego pobrałeś plik droolsjbpm-tools-distribution-5.3.0.Final.zip

Kliknij OK i podaj nazwę Drools Runtime. Środowisko wykonawcze Drools zostało utworzone.

Aby utworzyć podstawowy program Drools, otwórz Eclipse. Idź do Fileb → New → Project.

Wybierz Projekt Drools. Nadaj projektowi odpowiednią nazwę. Na przykład DroolsTest.

Na następnym ekranie zostaniesz poproszony o wybranie plików, które chcesz umieścić w swoim pierwszym projekcie Drools.

Wybierz pierwsze dwa pliki. Pierwszy plik to plik .drl (plik reguł Drools), a drugi plik to klasa Java służąca do ładowania i wykonywania reguły HelloWorld.

Kliknij Dalej → Zakończ.

Po kliknięciu przycisku Zakończ w obszarze roboczym zostanie utworzony projekt <DroolsTest>. Otwórz klasę Java, a następnie kliknij prawym przyciskiem myszy i uruchom jako aplikację Java. Zobaczysz dane wyjściowe, jak pokazano tutaj -

Następnie omówimy terminy często używane w silniku reguł.

Zasady

Serce silnika reguł, w którym określasz warunki (jeśli „a” to „b”).

Fakty

Fakty to dane, na podstawie których będą działać przepisy. Z punktu widzenia Javy, Fakty to POJO (zwykły stary obiekt Java).

Sesja

Sesja wiedzy w Drools jest podstawowym elementem odpalania reguł. To sesja wiedzy zawiera wszystkie zasady i inne zasoby. Sesja wiedzy jest tworzona z bazy wiedzy.

Aby silnik reguł działał, do sesji wstawiane są fakty, a po spełnieniu warunku uruchamiana jest kolejna reguła. Sesja jest dwojakiego rodzaju -

• Sesja wiedzy bezstanowej
• Sesja wiedzy stanowej

Program

To logiczna koncepcja. Agenda jest logicznym miejscem, w którym aktywacje czekają na odpalenie.

Aktywacje

Aktywacje to thenczęść reguły. Aktywacje są umieszczane w agendzie, gdzie odpalana jest odpowiednia reguła.

Jeśli widzisz domyślną regułę zapisaną w projekcie Hello World (Sample.drl), użyto wielu słów kluczowych, które teraz wyjaśnimy.

Sample.drl

• Package- Każda reguła zaczyna się od nazwy pakietu. Pakiet działa jako przestrzeń nazw dla reguł. Nazwy reguł w pakiecie muszą być unikalne. Pakiety w regułach są podobne do pakietów w Javie.

• Import statement- Niezależnie od faktów, do których chcesz zastosować regułę, należy je zaimportować. Na przykład com.sample.DroolsTest.Message; w powyższym przykładzie.

• Rule Definition- Składa się z nazwy reguły, warunku i konsekwencji. Słowa kluczowe Drools torule, when, then, i end. W powyższym przykładzie nazwy reguł to „Hello World” i „GoodBye”. Plikwhen część jest warunkiem zarówno w zasadach, jak i w thenczęść jest konsekwencją. W terminologii regułwhen część jest również nazywana LHS (lewa strona) i then część jako RHS (prawa strona) reguły.

Przejdźmy teraz przez terminy używane w pliku Java używanym do ładowania Drools i wykonywania reguł.

Baza wiedzy

Baza wiedzy to interfejs zarządzający zbiorem reguł, procesów i typów wewnętrznych. Znajduje się w opakowaniuorg.drools.KnowledgeBase. W Drools są one powszechnie określane jakoknowledge definitions lub knowledge. Definicje wiedzy są pogrupowane wknowledge packages. Definicje wiedzy można dodawać lub usuwać. Głównym celem bazy wiedzy jest ich przechowywanie i ponowne wykorzystanie, ponieważ ich tworzenie jest kosztowne. Baza wiedzy zawiera metody tworzenia sesji wiedzy.

Sesja wiedzy

Sesja wiedzy jest pobierana z bazy wiedzy. Jest to główny interfejs do interakcji z silnikiem Drools. Sesja wiedzy może być dwojakiego rodzaju -

• Sesja wiedzy bezstanowej

• Sesja wiedzy stanowej

Sesja wiedzy bezstanowej

Sesja wiedzy bezstanowej to sesja bezstanowa, która tworzy najprostszy przypadek użycia, nie wykorzystując wnioskowania. Sesję bezstanową można wywołać jak funkcję, przekazując jej pewne dane, a następnie otrzymując z powrotem pewne wyniki. Typowe przykłady sesji bezstanowych obejmują -

• Validation

  • Czy ta osoba kwalifikuje się do kredytu hipotecznego?

• Calculation

  • Oblicz premię za kredyt hipoteczny.

• Routing and Filtering

  • Filtruj przychodzące wiadomości, takie jak e-maile, do folderów.

  • Wysyłaj wiadomości przychodzące do miejsca docelowego

Sesja wiedzy stanowej

Sesje stanowe są dłuższe i pozwalają na iteracyjne zmiany w czasie. Niektóre typowe przypadki użycia sesji stanowych obejmują -

• Monitoring

  • Monitorowanie i analiza giełdy pod kątem zakupów półautomatycznych.

• Diagnostics

  • Wyszukiwanie usterek, diagnostyka medyczna

• Logistics

  • Śledzenie przesyłek i dostarczanie przesyłek

Kreator wiedzy

Interfejs KnoledgeBuilder jest odpowiedzialny za tworzenie pakietu wiedzy na podstawie definicji wiedzy (reguł, procesów, typów). Znajduje się w opakowaniuorg.drools.builder.KnowledgeBuilder. Definicje wiedzy mogą mieć różne formaty. Jeśli wystąpią jakiekolwiek problemy z budowaniem, KnowledgeBuilder zgłosi błędy za pomocą tych dwóch metod:hasErrors i getError.

Poniższy diagram wyjaśnia ten proces

W powyższym przykładzie, ponieważ bierzemy prosty przykład bezstanowej sesji wiedzy, wstawiliśmy fakt do sesji, a następnie wywołano metodę fireAllRules () i zobaczysz wynik.

W przypadku sesji wiedzy stanowej, po uruchomieniu reguł, obiekt sesji wiedzy stanowej musi wywołać metodę dispose() aby zwolnić sesję i uniknąć wycieków pamięci.

Jak widzieliście, plik .drl (plik reguł) ma własną składnię, w tym rozdziale omówimy część składni reguł.

Warunki w zasadach

Reguła może zawierać wiele warunków i wzorców, takich jak -

• Konto (saldo == 200)
• Klient (nazwa == „Vivek”)

Powyższe warunki sprawdzają, czy saldo konta wynosi 200 lub czy nazwa klienta to „Vivek”.

Zmienne w regułach

Nazwa zmiennej w Drools zaczyna się od symbolu dolara ($).

• Konto $ - Konto ()
• $ account jest zmienną dla klasy Account ()

Drools może współpracować ze wszystkimi natywnymi typami Javy, a nawet z Enum.

Komentarze w zasadach

Do oznaczania komentarzy jednowierszowych można używać znaków specjalnych # lub //.

W przypadku komentarzy wielowierszowych użyj następującego formatu:

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

Zmienne globalne

Zmienne globalne to zmienne przypisane do sesji. Mogą być używane z różnych powodów w następujący sposób -

• Dla parametrów wejściowych (na przykład wartości stałych, które można dostosowywać między sesjami).

• W przypadku parametrów wyjściowych (na przykład raportowanie - reguła może zapisać komunikat do globalnej zmiennej raportu).

• Punkty wejścia do usług, takich jak logowanie, z których można korzystać w ramach reguł.

Funkcje w regułach

Funkcje to wygoda. Mogą być używane w warunkach i konsekwencjach. Funkcje stanowią alternatywę dla klas narzędziowych / pomocniczych. Na przykład,

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

Dialekt

Dialekt określa składnię używaną w każdym wyrażeniu kodu, które jest w stanie lub w konsekwencji. Obejmuje wartości zwracane, ewaluacje, ewaluacje wbudowane, predykaty, wyrażenia istotne, konsekwencje i tak dalej. Wartość domyślna toJava. Drools obsługuje obecnie jeszcze jeden dialekt o nazwieMVEL. Domyślny dialekt można określić na poziomie pakietu w następujący sposób -

package org.mycompany.somePackage
dialect "mvel"

Dialekt MVEL

MVEL to język wyrażeń dla aplikacji opartych na Javie. Obsługuje dostęp do pól i metod / pobierających. Opiera się na składni Java.

Występ

Salience jest bardzo ważną cechą składni reguł. Salience jest używany przez strategię rozwiązywania konfliktów, aby zdecydować, która reguła zostanie uruchomiona jako pierwsza. Domyślnie jest to główne kryterium.

Możemy użyć znaczenia, aby zdefiniować kolejność reguł strzelania. Salience ma jeden atrybut, który przyjmuje dowolne wyrażenie zwracające liczbę typu int (prawidłowe są zarówno liczby dodatnie, jak i ujemne). Im wyższa wartość, tym większe prawdopodobieństwo, że reguła zostanie wychwycona przez strategię rozwiązywania konfliktów.

salience ($account.balance * 5)

Domyślna wartość istotności to 0. Powinniśmy o tym pamiętać, przypisując wartości istotności tylko do niektórych reguł.

Składnia reguł zawiera wiele innych funkcji / parametrów, ale omówiliśmy tutaj tylko te ważne.

Słowa kluczowe konsekwencji reguł

Słowa kluczowe związane z regułą to słowa kluczowe używane w „then”Część reguły.

• Modify - Atrybuty faktu można modyfikować w pliku then częścią Reguły.

• Insert - Na podstawie pewnego warunku, jeśli jest prawdziwy, można wstawić nowy fakt do bieżącej sesji silnika reguł.

• Retract - Jeśli określony warunek w regule jest spełniony i nie chcesz robić nic innego w związku z tym faktem, możesz wycofać ten konkretny fakt z silnika reguł.

Note- Uważa się, że bardzo złą praktyką jest stosowanie logiki warunkowej (jeśli stwierdzenia) w ramach konsekwencji reguły. W większości przypadków należy utworzyć nową regułę.

W tym rozdziale utworzymy projekt Drools dla następującego stwierdzenia problemu -

W zależności od miasta i rodzaju produktu (połączenie miasta i produktu) sprawdź podatek lokalny związany z tym miastem.

Będziemy mieć dwa pliki DRL dla naszego projektu Drools. Dwa pliki DRL będą oznaczać dwa rozważane miasta (Pune i Nagpur) oraz cztery rodzaje produktów (artykuły spożywcze, leki, zegarki i towary luksusowe).

• Podatek od leków w obu miastach jest zerowy.

• W przypadku artykułów spożywczych przyjęliśmy podatek w wysokości 2 Rs w Pune i 1 Rs w Nagpur.

Użyliśmy tej samej ceny sprzedaży, aby zademonstrować różne wyniki. Zwróć uwagę, że wszystkie reguły są uruchamiane w aplikacji.

Oto model do przechowywania każdego przedmiotu -

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

Pliki DRL

Jak sugerowano wcześniej, użyliśmy tutaj dwóch plików DRL: Pune.drl i Nagpur.drl.

Pune.drl

To jest plik DRL, który wykonuje reguły dla miasta 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

To jest plik DRL, który wykonuje reguły dla miasta 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

Napisaliśmy pliki DRL w oparciu o miasto, ponieważ daje nam to możliwość dodania dowolnej liczby plików reguł później, jeśli dodawane są nowe miasta.

Aby zademonstrować, że wszystkie reguły są uruchamiane z naszych plików reguł, użyliśmy dwóch typów pozycji (lekarstwa i artykuły spożywcze); a lekarstwa są wolne od podatku, a artykuły spożywcze są opodatkowane według obowiązującego w mieście podatku.

Nasza klasa testowa ładuje pliki reguł, wstawia fakty do sesji i generuje wynik.

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

Jeśli uruchomisz ten program, jego dane wyjściowe będą następujące -

PUNE 0
PUNE 20
NAGPUR 0
NAGPUR 10

W przypadku Pune i Nagpur, gdy produkt jest lekiem, lokalny podatek wynosi zero; podczas gdy gdy artykuł jest produktem spożywczym, podatek jest według miasta. Więcej reguł można dodać w plikach DRL dla innych produktów. To tylko przykładowy program.

Wywołaj funkcję zewnętrzną z pliku DRL

Tutaj pokażemy, jak wywołać funkcję statyczną z pliku Java w pliku DRL.

Przede wszystkim utwórz klasę HelloCity.java w tym samym opakowaniu com.sample.

package com.sample;

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

Następnie dodaj instrukcję importu w pliku DRL, aby wywołać metodę writeHello z pliku DRL. W poniższym bloku kodu zmiany w pliku DRL Pune.drl są podświetlone na żółto.

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

Uruchom program ponownie, a jego wyjście będzie wyglądać następująco -

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

Różnica w wynikach jest teraz oznaczona na żółto, co pokazuje wynik metody statycznej w klasie Java.

Zaletą wywołania metody Java jest to, że możemy napisać dowolną funkcję narzędzia / pomocniczą w Javie i wywołać ją z pliku DRL.

Istnieją różne sposoby debugowania projektu Drools. Tutaj napiszemy klasę Utility, aby poinformować Cię, które reguły są wyzwalane lub uruchamiane.

Dzięki takiemu podejściu możesz sprawdzić, jakie reguły są uruchamiane w Twoim projekcie Drools. Oto nasza klasa użytkowa

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

Pierwsza metoda help wypisuje wyzwoloną regułę wraz z dodatkowymi informacjami, które można przekazać jako ciąg znaków w pliku DRL.

Druga zasada helper wypisuje, czy dana reguła została wyzwolona, ​​czy nie.

Dodaliśmy jedną z metod narzędziowych w każdym pliku DRL. Dodaliśmy również funkcję importu w pliku DRL (Pune.drl). wthenczęścią reguły, dodaliśmy wywołanie funkcji narzędziowej. Zmodyfikowany plik Pune.drl podano poniżej. Zmiany są zaznaczone na niebiesko.

Zmodyfikowany 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

Podobnie, dodaliśmy drugą funkcję narzędzia w drugim pliku DRL (Nagpur.drl). Oto zmodyfikowany kod -

Zmodyfikowany plik 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

Uruchom program ponownie i powinien wygenerować następujące dane wyjściowe -

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

Obie funkcje narzędziowe są wywoływane i pokazuje, czy dana reguła została wywołana, czy nie. W powyższym przykładzie wywoływane są wszystkie reguły, ale w aplikacji korporacyjnej ta funkcja narzędziowa może być naprawdę przydatna do debugowania i sprawdzania, czy dana reguła została uruchomiona, czy nie.

Korzystanie z perspektywy debugowania w środowisku Eclipse

Możesz debugować reguły podczas wykonywania aplikacji Drools. Możesz dodać punkty przerwania w konsekwencjach swoich reguł, a za każdym razem, gdy taki punkt przerwania zostanie napotkany podczas wykonywania reguł, wykonanie jest tymczasowo zatrzymywane. Następnie można sprawdzić znane w tym momencie zmienne, podobnie jak w aplikacji Java, i użyć zwykłych opcji debugowania dostępnych w Eclipse.

Aby utworzyć punkt przerwania w pliku DRL, po prostu kliknij dwukrotnie wiersz, w którym chcesz utworzyć punkt przerwania. Pamiętaj, że możesz utworzyć punkt przerwania tylko wthenczęść reguły. Punkt przerwania można usunąć, klikając dwukrotnie punkt przerwania w edytorze DRL.

Po zastosowaniu punktów przerwania należy debugować aplikację jako aplikację Drools. Punkty przerwania Drools (punkty przerwania w pliku DRL) będą działać tylko wtedy, gdy aplikacja jest debugowana jako aplikacja Drools. Oto, jak musisz zrobić to samo -

Po debugowaniu aplikacji jako aplikacji Drools zobaczysz kontrolkę w pliku DRL, jak pokazano na poniższym zrzucie ekranu -

Możesz zobaczyć zmienne i bieżące wartości obiektu w tym punkcie debugowania. Ta sama funkcja F6, aby przejść do następnego wiersza i F8, aby przejść do następnego punktu debugowania, ma również zastosowanie tutaj. W ten sposób możesz debugować swoją aplikację Drools.

Note - Perspektywa debugowania w aplikacji Drools działa tylko wtedy, gdy dialektem jest MVEL do wersji Drools 5.x.