Drools - Guía rápida

Cualquier aplicación Java de nivel empresarial se puede dividir en tres partes:

• UI - Interfaz de usuario (Frontend)
• Capa de servicio que a su vez está conectada a una base de datos
• Capa empresarial

Tenemos varios marcos que manejan la interfaz de usuario y la capa de servicio juntas, por ejemplo, Spring y Struts. Sin embargo, no teníamos una forma estándar de manejar la lógica empresarial hasta que nació Drools.

¿Qué es Drools?

Drools es un Business Logic integration Platform (BLiP). Está escrito en Java. Es un proyecto de código abierto respaldado por JBoss y Red Hat, Inc. Extiende e implementa el algoritmo de coincidencia de patrones Rete.

En términos simples, Drools es una colección de herramientas que nos permiten separar y razonar sobre la lógica y los datos que se encuentran dentro de los procesos comerciales. Las dos palabras clave importantes que debemos tener en cuenta sonLogic y Data.

Drools se divide en dos partes principales: Authoring y Runtime.

• Authoring - El proceso de creación implica la creación de archivos de reglas (archivos .DRL).

• Runtime - Implica la creación de memoria de trabajo y el manejo de la activación.

¿Qué es un motor de reglas?

Drools es un motor de reglas o un sistema de reglas de producción que utiliza el enfoque basado en reglas para implementar un sistema experto. Los sistemas expertos son sistemas basados ​​en el conocimiento que utilizan la representación del conocimiento para procesar el conocimiento adquirido en una base de conocimiento que se puede utilizar para razonar.

Un sistema de reglas de producción es Turing completo con un enfoque en la representación del conocimiento para expresar la lógica proposicional y de primer orden de una manera concisa, no ambigua y declarativa.

El cerebro de un sistema de reglas de producción es un Inference Engineque puede escalar a una gran cantidad de reglas y hechos. El motor de inferencia compara hechos y datos con las reglas de producción, también llamadoProductions o solo Rules - inferir conclusiones que resulten en acciones.

Una regla de producción es una estructura de dos partes que utiliza lógica de primer orden para razonar sobre la representación del conocimiento. Un motor de reglas comerciales es un sistema de software que ejecuta una o más reglas comerciales en un entorno de producción en tiempo de ejecución.

Un motor de reglas le permite definir "What to Do" y no "How to do it. "

¿Qué es una regla?

Las reglas son piezas de conocimiento que a menudo se expresan como: " Cuando ocurran algunas condiciones, entonces realice algunas tareas".

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

La parte más importante de una regla es su whenparte. Si elwhen parte está satisfecha, la then parte se activa.

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

La coincidencia de patrones

El proceso de hacer coincidir los hechos nuevos o existentes con las Reglas de producción se denomina Coincidencia de patrones, y lo realiza el motor de inferencia. Hay una serie de algoritmos utilizados para la coincidencia de patrones que incluyen:

• Linear
• Rete
• Treat
• Leaps

Drools Implementa y extiende el algoritmo Rete. La implementación de Drools Rete se llama ReteOO, lo que significa que Drools tiene una implementación mejorada y optimizada del algoritmo Rete para sistemas orientados a objetos.

Ventajas de un motor de reglas

Programación declarativa

Las reglas facilitan la expresión de soluciones a problemas difíciles y también la verificación de las soluciones. A diferencia de los códigos, las reglas están escritas en un lenguaje menos complejo; Los analistas de negocios pueden leer y verificar fácilmente un conjunto de reglas.

Separación lógica y de datos

Los datos residen en los Objetos de dominio y la lógica empresarial reside en las Reglas. Dependiendo del tipo de proyecto, este tipo de separación puede resultar muy ventajoso.

Velocidad y escalabilidad

El algoritmo Rete OO en el que está escrito Drools ya es un algoritmo probado. Con la ayuda de Drools, su aplicación se vuelve muy escalable. Si hay solicitudes de cambio frecuentes, se pueden agregar nuevas reglas sin tener que modificar las reglas existentes.

Centralización del conocimiento

Al utilizar Reglas, crea un depósito de conocimientos (una base de conocimientos) que es ejecutable. Es un punto único de verdad para la política empresarial. Idealmente, las reglas son tan legibles que también pueden servir como documentación.

Integración de herramientas

Herramientas como Eclipse proporcionan formas de editar y administrar reglas y obtener retroalimentación inmediata, validación y asistencia de contenido. También se encuentran disponibles herramientas de auditoría y depuración.

Estos son los requisitos previos para instalar el complemento Drools:

• Java 1.5 (o superior) SE JDK
• Eclipse 4.2 (o cualquier versión) y el complemento Drools

Como Drools es un BRMS (Business Rule Management System) escrito en Java, cubriremos cómo agregar los complementos deseados en esta sección. Teniendo en cuenta que los usuarios máximos de Java usan Eclipse, veamos cómo agregar el complemento Drools 5.x.0 en Eclipse.

Paso 1: descargue los binarios

Descarga los binarios desde el siguiente enlace -

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

Una vez completada la descarga, extraiga los archivos a su disco duro.

Paso 2: instale el software

Inicie Eclipse y vaya a ayuda → instalar nuevo software. Haga clic en Agregar como se muestra en la siguiente captura de pantalla.

A partir de entonces, haga clic en Local como se muestra aquí y seleccione "… / binaries / org.drools.updatesite".

Seleccione Drools y jBPM y haga clic en Siguiente.

Nuevamente haga clic en Siguiente. A partir de entonces, acepte los términos y el acuerdo de licencia y haga clic en Finalizar.

Al hacer clic en Finalizar, comienza la instalación del software:

Después de la instalación exitosa, obtendrá el siguiente cuadro de diálogo:

Haga clic en sí. Una vez que Eclipse se reinicia, vaya a Windows → Preferencias

Puede ver Drools en sus preferencias. La instalación del complemento Drools está completa ahora.

Se requiere Drools Runtime para indicar al editor que ejecute el programa con una versión específica de Drools jar. Puede ejecutar su programa / aplicación con diferentes Drools Runtime.

Haga clic en Windows → Preferencias → Drools → Tiempo de ejecución de Drools instalado. Luego haga clic en Agregar como se muestra en la siguiente captura de pantalla.

A partir de entonces, haga clic en Crear un nuevo tiempo de ejecución de Drools como se muestra aquí.

Ingrese la ruta hasta la carpeta de binarios donde ha descargado droolsjbpm-tools-distribution-5.3.0.Final.zip

Haga clic en Aceptar y proporcione un nombre para Drools Runtime. Ahora se crea el tiempo de ejecución de Drools.

Para crear un programa Drools básico, abra Eclipse. Vaya a Archivob → Nuevo → Proyecto.

Seleccione Proyecto Drools. Dale un nombre adecuado al proyecto. Por ejemplo, DroolsTest.

La siguiente pantalla le pide que seleccione algunos archivos que desee en su primer proyecto de Drools.

Seleccione los dos primeros archivos. El primer archivo es un archivo .drl (Drools Rule File) y el segundo archivo es una clase Java para cargar y ejecutar la regla HelloWorld.

Haga clic en Siguiente → Finalizar.

Una vez que hace clic en Finalizar, se crea un proyecto <DroolsTest> en su espacio de trabajo. Abra la clase Java y luego haga clic con el botón derecho y ejecútelo como aplicación Java. Vería la salida como se muestra aquí:

A continuación, analizaremos los términos que se utilizan con frecuencia en un motor de reglas.

Reglas

El corazón del motor de reglas donde se especifican las condiciones (si es 'a', entonces 'b').

Hechos

Los hechos son los datos sobre los que actuarán las reglas. Desde la perspectiva de Java, los hechos son el POJO (Objeto simple de Java antiguo).

Sesión

Una sesión de conocimiento en Drools es el componente central para activar las reglas. Es la sesión de conocimiento que contiene todas las reglas y otros recursos. Se crea una sesión de conocimientos a partir de KnowledgeBase.

Para que el motor de reglas funcione, los hechos se insertan en la sesión y, cuando se cumple una condición, se activa la regla subsiguiente. Una sesión es de dos tipos:

• Sesión de conocimientos apátridas
• Sesión de conocimientos estatales

Agenda

Es un concepto lógico. La agenda es el lugar lógico donde las activaciones esperan ser disparadas.

Activaciones

Las activaciones son las thenparte de la regla. Las activaciones se colocan en la agenda donde se dispara la regla apropiada.

Si ve la regla predeterminada que está escrita en el proyecto Hello World (Sample.drl), se utilizan muchas palabras clave que explicaremos ahora.

Sample.drl

• Package- Cada regla comienza con un nombre de paquete. El paquete actúa como un espacio de nombres para las reglas. Los nombres de reglas dentro de un paquete deben ser únicos. Los paquetes en reglas son similares a los paquetes en Java.

• Import statement- Independientemente de los hechos sobre los que desee aplicar la regla, esos hechos deben importarse. Por ejemplo, com.sample.DroolsTest.Message; en el ejemplo anterior.

• Rule Definition- Consiste en el Nombre de la regla, la condición y la Consecuencia. Las palabras clave de Drools sonrule, when, then, y end. En el ejemplo anterior, los nombres de las reglas son "Hola mundo" y "Adiós". loswhen parte es la condición tanto en las reglas como en la thenparte es la consecuencia. En terminología de reglas, elwhen La parte también se llama LHS (lado izquierdo) y la then parte como el RHS (lado derecho) de la regla.

Ahora veamos los términos usados ​​en el archivo Java usado para cargar Drools y ejecutar las reglas.

Base de conocimientos

Knowledge Base es una interfaz que administra una colección de reglas, procesos y tipos internos. Está contenido dentro del paquete.org.drools.KnowledgeBase. En Drools, estos se conocen comúnmente comoknowledge definitions o knowledge. Las definiciones de conocimiento se agrupan enknowledge packages. Se pueden agregar o eliminar definiciones de conocimiento. El objetivo principal de Knowledge Base es almacenarlos y reutilizarlos porque su creación es costosa. La base de conocimientos proporciona métodos para crear sesiones de conocimientos.

Sesión de conocimientos

La sesión de conocimientos se recupera de la base de conocimientos. Es la interfaz principal para interactuar con Drools Engine. La sesión de conocimiento puede ser de dos tipos:

• Sesión de conocimientos apátridas

• Sesión de conocimientos estatales

Sesión de conocimientos apátridas

Stateless Knowledge Session es una sesión sin estado que constituye el caso de uso más simple, sin utilizar inferencias. Una sesión sin estado se puede llamar como una función, pasándole algunos datos y luego recibiendo algunos resultados. Los ejemplos comunes de una sesión sin estado incluyen:

• Validation

  • ¿Esta persona es elegible para una hipoteca?

• Calculation

  • Calcule una prima hipotecaria.

• Routing and Filtering

  • Filtre los mensajes entrantes, como los correos electrónicos, en carpetas.

  • Enviar mensajes entrantes a un destino

Sesión de conocimientos estatales

Las sesiones con estado duran más y permiten cambios iterativos a lo largo del tiempo. Algunos casos de uso comunes para sesiones con estado incluyen:

• Monitoring

  • Seguimiento y análisis bursátil para compra semiautomática.

• Diagnostics

  • Localización de averías, diagnóstico médico

• Logistics

  • Seguimiento de paquetes y aprovisionamiento de entregas

Constructor de conocimiento

La interfaz KnoledgeBuilder es responsable de construir un paquete de conocimientos a partir de definiciones de conocimientos (reglas, procesos, tipos). Está contenido dentro del paquete.org.drools.builder.KnowledgeBuilder. Las definiciones de conocimiento pueden estar en varios formatos. Si hay algún problema con la construcción, KnowledgeBuilder informará los errores a través de estos dos métodos:hasErrors y getError.

El siguiente diagrama explica el proceso

En el ejemplo anterior, como estamos tomando un ejemplo simple de sesión de conocimiento sin estado, hemos insertado el hecho en la sesión y luego se llama al método fireAllRules () y se ve el resultado.

En el caso de una sesión de conocimiento con estado, una vez que se disparan las reglas, el objeto de la sesión de conocimiento con estado debe llamar al método dispose() para liberar la sesión y evitar pérdidas de memoria.

Como vio, el .drl (archivo de reglas) tiene su propia sintaxis, cubriremos parte de la sintaxis de las reglas en este capítulo.

Condiciones en las reglas

Una regla puede contener muchas condiciones y patrones como:

• Cuenta (saldo == 200)
• Cliente (nombre == "Vivek")

Las condiciones anteriores verifican si el saldo de la cuenta es 200 o el nombre del cliente es "Vivek".

Variables en reglas

El nombre de una variable en Drools comienza con un símbolo de dólar ($).

• $ cuenta - Cuenta ()
• $ cuenta es la variable para la clase Account ()

Drools puede trabajar con todos los tipos nativos de Java e incluso con Enum.

Comentarios en las reglas

Los caracteres especiales, # o //, se pueden utilizar para marcar comentarios de una sola línea.

Para comentarios de varias líneas, utilice el siguiente formato:

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

Variables globales

Las variables globales son variables asignadas a una sesión. Se pueden utilizar por varias razones de la siguiente manera:

• Para parámetros de entrada (por ejemplo, valores constantes que se pueden personalizar de una sesión a otra).

• Para los parámetros de salida (por ejemplo, informes: una regla podría escribir algún mensaje en una variable de informe global).

• Puntos de entrada para servicios como el registro, que se pueden utilizar dentro de las reglas.

Funciones en reglas

Las funciones son una característica de conveniencia. Se pueden usar en condiciones y consecuencias. Las funciones representan una alternativa a las clases de utilidad / ayuda. Por ejemplo,

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

Dialecto

Un dialecto especifica la sintaxis utilizada en cualquier expresión de código que esté en una condición o en una consecuencia. Incluye valores de retorno, evaluaciones, evaluaciones en línea, predicados, expresiones de prominencia, consecuencias, etc. El valor predeterminado esJava. Drools actualmente admite un dialecto más llamadoMVEL. El dialecto predeterminado se puede especificar a nivel de paquete de la siguiente manera:

package org.mycompany.somePackage
dialect "mvel"

Dialecto MVEL

MVEL es un lenguaje de expresión para aplicaciones basadas en Java. Admite acceso a campos y métodos / captadores. Está basado en la sintaxis de Java.

Prominencia

La prominencia es una característica muy importante de la sintaxis de reglas. La prominencia es utilizada por la estrategia de resolución de conflictos para decidir qué regla disparar primero. Por defecto, es el criterio principal.

Podemos utilizar la prominencia para definir el orden de las reglas de disparo. La prominencia tiene un atributo, que toma cualquier expresión que devuelva un número de tipo int (los números tanto positivos como negativos son válidos). Cuanto mayor sea el valor, es más probable que se active una regla mediante la estrategia de resolución de conflictos.

salience ($account.balance * 5)

El valor de prominencia predeterminado es 0. Debemos tener esto en cuenta al asignar valores de prominencia solo a algunas reglas.

Hay muchas otras características / parámetros en la sintaxis de reglas, pero aquí solo hemos cubierto los importantes.

Palabras clave de consecuencia de la regla

Las palabras clave de consecuencia de la regla son las palabras clave que se utilizan en el "then”Parte de la regla.

• Modify - Los atributos del hecho se pueden modificar en el then parte de la Regla.

• Insert - Basado en alguna condición, si es verdadero, se puede insertar un nuevo hecho en la sesión actual del motor de reglas.

• Retract - Si una condición particular es verdadera en una regla y no desea actuar de otra manera sobre ese hecho, puede retirar el hecho particular del motor de reglas.

Note- Se considera una muy mala práctica tener una lógica condicional (sentencias if) dentro de una consecuencia de regla. La mayoría de las veces, se debe crear una nueva regla.

En este capítulo, crearemos un proyecto Drools para el siguiente enunciado del problema:

Según la ciudad y el tipo de producto (combinación de ciudad y producto), averigüe el impuesto local relacionado con esa ciudad.

Tendremos dos archivos DRL para nuestro proyecto Drools. Los dos archivos DRL significarán dos ciudades en consideración (Pune y Nagpur) y cuatro tipos de productos (comestibles, medicinas, relojes y artículos de lujo).

• El impuesto a los medicamentos en ambas ciudades se considera cero.

• Para los comestibles, asumimos un impuesto de 2 rupias en Pune y 1 rupias en Nagpur.

Hemos utilizado el mismo precio de venta para demostrar diferentes productos. Tenga en cuenta que todas las reglas se activan en la aplicación.

Aquí está el modelo para contener cada 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;
   }
}

Archivos DRL

Como se sugirió anteriormente, hemos utilizado dos archivos DRL aquí: Pune.drl y Nagpur.drl.

Pune.drl

Este es el archivo DRL que ejecuta las reglas de la ciudad 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

Este es el archivo DRL que ejecuta las reglas de la ciudad 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

Hemos escrito los archivos DRL basados ​​en la ciudad, ya que nos da extensibilidad para agregar cualquier número de archivos de reglas más adelante si se agregan nuevas ciudades.

Para demostrar que todas las reglas se activan desde nuestros archivos de reglas, hemos utilizado dos tipos de elementos (medicamentos y comestibles); y la medicina está libre de impuestos y los alimentos están sujetos a impuestos según la ciudad.

Nuestra clase de prueba carga los archivos de reglas, inserta los hechos en la sesión y produce el resultado.

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 ejecuta este programa, su salida sería la siguiente:

PUNE 0
PUNE 20
NAGPUR 0
NAGPUR 10

Tanto para Pune como para Nagpur, cuando el artículo es un medicamento, el impuesto local es cero; mientras que cuando el artículo es un producto comestible, el impuesto es según la ciudad. Se pueden agregar más reglas en los archivos DRL para otros productos. Este es solo un programa de muestra.

Llamar a una función externa desde un archivo DRL

Aquí demostraremos cómo llamar a una función estática desde un archivo Java dentro de su archivo DRL.

Primero que nada, crea una clase HelloCity.java en el mismo paquete com.sample.

package com.sample;

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

A partir de entonces, agregue la declaración de importación en el archivo DRL para llamar al método writeHello desde el archivo DRL. En el siguiente bloque de código, los cambios en el archivo DRL Pune.drl están resaltados en amarillo.

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

Ejecute el programa nuevamente y su salida sería la siguiente:

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

La diferencia ahora en la salida está marcada en amarillo, lo que muestra la salida del método estático en la clase Java.

La ventaja de llamar a un método Java es que podemos escribir cualquier función de utilidad / ayuda en Java y llamar a la misma desde un archivo DRL.

Hay diferentes formas de depurar un proyecto Drools. Aquí, escribiremos una clase de utilidad para hacerle saber qué reglas se están activando o disparando.

Con este enfoque, puede verificar qué reglas se activan en su proyecto Drools. Aquí está nuestra clase de utilidad

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

El primer método help imprime la regla activada junto con información adicional que puede pasar como Cadena a través del archivo DRL.

La segunda regla helper imprime si la regla en particular se activó o no.

Hemos agregado uno de los métodos de utilidad en cada archivo DRL. También hemos agregado la función de importación en el archivo DRL (Pune.drl). En elthenparte de la regla, hemos agregado la llamada a la función de utilidad. El Pune.drl modificado se muestra a continuación. Los cambios están resaltados en azul.

Pune.drl modificado

//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 manera similar, hemos agregado la otra función de utilidad en el segundo archivo DRL (Nagpur.drl). Aquí está el código modificado:

Nagpur.drl modificado

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

Ejecute el programa nuevamente y debería producir el siguiente resultado:

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

Se llaman a ambas funciones de utilidad y muestra si la regla en particular se llamó o no. En el ejemplo anterior, se están llamando todas las reglas, pero en una aplicación empresarial, esta función de utilidad puede ser realmente útil para depurar y averiguar si una regla en particular se activó o no.

Usando la perspectiva de depuración en Eclipse

Puede depurar las reglas durante la ejecución de su aplicación Drools. Puede agregar puntos de interrupción en las consecuencias de sus reglas, y siempre que se encuentre un punto de interrupción durante la ejecución de las reglas, la ejecución se detiene temporalmente. Luego, puede inspeccionar las variables conocidas en ese punto como lo hace en una aplicación Java y usar las opciones de depuración normales disponibles en Eclipse.

Para crear un punto de interrupción en su archivo DRL, simplemente haga doble clic en la línea donde desea crear un punto de interrupción. Recuerde, solo puede crear un punto de interrupción en elthenparte de una regla. Se puede eliminar un punto de interrupción haciendo doble clic en el punto de interrupción en el editor de DRL.

Después de aplicar los puntos de interrupción, debe depurar su aplicación como una aplicación Drools. Los puntos de interrupción de Drools (puntos de interrupción en el archivo DRL) solo funcionarán si su aplicación se está depurando como una aplicación de Drools. Así es como debe hacer lo mismo:

Una vez que depure su aplicación como una aplicación Drools, verá el control en el archivo DRL como se muestra en la siguiente captura de pantalla:

Puede ver las variables y los valores actuales del objeto en ese punto de depuración. El mismo control de F6 para pasar a la siguiente línea y F8 para saltar al siguiente punto de depuración son aplicables aquí también. De esta manera, puede depurar su aplicación Drools.

Note - La perspectiva de depuración en la aplicación Drools solo funciona si el dialecto es MVEL hasta Drools 5.x.