Drools - Guia rápido

Qualquer aplicativo Java de nível empresarial pode ser dividido em três partes -

  • IU - Interface do usuário (Frontend)
  • Camada de serviço que por sua vez está conectada a um banco de dados
  • Camada de negócios

Temos uma série de estruturas que lidam com a interface do usuário e a camada de serviço juntas, por exemplo, Spring e Struts. Ainda assim, não tínhamos uma maneira padrão de lidar com a lógica de negócios até que o Drools surgisse.

O que é Drools?

Drools é um Business Logic integration Platform (BLiP). Está escrito em Java. É um projeto de código aberto apoiado pela JBoss e Red Hat, Inc. Ele estende e implementa o algoritmo de correspondência de padrões Rete.

Em termos gerais, Drools é uma coleção de ferramentas que nos permite separar e raciocinar sobre a lógica e os dados encontrados nos processos de negócios. As duas palavras-chave importantes que precisamos observar sãoLogic e Data.

O Drools é dividido em duas partes principais: Authoring e Runtime.

  • Authoring - O processo de autoria envolve a criação de arquivos de regras (arquivos .DRL).

  • Runtime - Envolve a criação de memória de trabalho e manipulação da ativação.

O que é um mecanismo de regras?

Drools é o mecanismo de regras ou um sistema de regras de produção que usa a abordagem baseada em regras para implementar um sistema especialista. Sistemas especialistas são sistemas baseados em conhecimento que usam representação de conhecimento para processar o conhecimento adquirido em uma base de conhecimento que pode ser usada para raciocínio.

Um Sistema de Regras de Produção é Turing completo com foco na representação do conhecimento para expressar a lógica proposicional e de primeira ordem de uma maneira concisa, não ambígua e declarativa.

O cérebro de um Sistema de Regras de Produção é um Inference Engineque pode ser dimensionado para um grande número de regras e fatos. O Inference Engine compara fatos e dados com as Regras de Produção - também chamadasProductions ou apenas Rules - inferir conclusões que resultam em ações.

Uma regra de produção é uma estrutura de duas partes que usa lógica de primeira ordem para raciocinar sobre a representação do conhecimento. Um mecanismo de regras de negócios é um sistema de software que executa uma ou mais regras de negócios em um ambiente de produção de tempo de execução.

Um mecanismo de regra permite que você defina “What to Do" e não "How to do it. ”

O que é uma regra?

As regras são pedaços de conhecimento, muitas vezes expressa como: " Quando ocorrer algumas condições, em seguida, fazer algumas tarefas."

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

A parte mais importante de uma regra é sua whenparte. Se owhen parte está satisfeita, o then parte é acionada.

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

Correspondência de padrões

O processo de correspondência de fatos novos ou existentes com as Regras de Produção é chamado de Correspondência de Padrões, que é executado pelo Mecanismo de Inferência. Existem vários algoritmos usados ​​para correspondência de padrões, incluindo -

  • Linear
  • Rete
  • Treat
  • Leaps

O Drools implementa e estende o Algoritmo de Rete. A implementação do Drools Rete é chamada de ReteOO, significando que o Drools tem uma implementação aprimorada e otimizada do algoritmo Rete para sistemas orientados a objetos.

Vantagens de um mecanismo de regras

Programação Declarativa

As regras facilitam a expressão de soluções para problemas difíceis e também a verificação das soluções. Ao contrário dos códigos, as regras são escritas em linguagem menos complexa; Os analistas de negócios podem ler e verificar facilmente um conjunto de regras.

Separação de lógica e dados

Os dados residem nos Objetos de Domínio e a lógica de negócios reside nas Regras. Dependendo do tipo de projeto, esse tipo de separação pode ser muito vantajoso.

Velocidade e escalabilidade

O algoritmo Rete OO no qual o Drools é escrito já é um algoritmo comprovado. Com a ajuda do Drools, seu aplicativo se torna muito escalonável. Se houver solicitações de mudança frequentes, pode-se adicionar novas regras sem ter que modificar as regras existentes.

Centralização do Conhecimento

Usando Regras, você cria um repositório de conhecimento (uma base de conhecimento) que é executável. É um único ponto verdadeiro para a política de negócios. Idealmente, as regras são tão legíveis que também podem servir como documentação.

Integração de ferramentas

Ferramentas como o Eclipse fornecem maneiras de editar e gerenciar regras e obter feedback imediato, validação e assistência de conteúdo. Ferramentas de auditoria e depuração também estão disponíveis.

Aqui estão os pré-requisitos para instalar o plug-in Drools -

  • Java 1.5 (ou superior) SE JDK
  • Eclipse 4.2 (ou qualquer versão) e o plugin Drools

Como o Drools é um BRMS (Business Rule Management System) escrito em Java, iremos abordar como adicionar os plug-ins desejados nesta seção. Considerando que o máximo de usuários de Java usam o Eclipse, vamos ver como adicionar o plugin Drools 5.x.0 no Eclipse.

Etapa 1: Baixe os binários

Baixe os binários a partir do seguinte link -

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

Após a conclusão do download, extraia os arquivos para o disco rígido.

Etapa 2: Instale o software

Inicie o Eclipse e vá para ajuda → instalar novo software. Clique em Adicionar como mostrado na imagem a seguir.

Depois disso, clique em Local conforme mostrado aqui e selecione "… / binaries / org.drools.updatesite".

Selecione Drools e jBPM e clique em Avançar.

Clique novamente em Avançar. Depois disso, aceite os termos e o contrato de licença e clique em Concluir.

Ao clicar em Concluir, a instalação do software começa -

Após a instalação bem-sucedida, você obterá a seguinte caixa de diálogo -

Clique em sim. Assim que o Eclipse for reiniciado, vá para Windows → Preferências

Você pode ver o Drools em suas preferências. A instalação do plugin Drools está completa agora.

O Drools Runtime é necessário para instruir o editor a executar o programa com uma versão específica do jar do Drools. Você pode executar seu programa / aplicativo com diferentes Drools Runtime.

Clique em Windows → Preferência → Drools → Tempo de execução do Drools instalado. Em seguida, clique em Adicionar como mostrado na imagem a seguir.

Depois disso, clique em Create a new Drools Runtime como mostrado aqui.

Digite o caminho até a pasta binários onde você baixou o droolsjbpm-tools-distribution-5.3.0.Final.zip

Clique em OK e forneça um nome para o Drools Runtime. O tempo de execução do Drools agora está criado.

Para criar um programa Drools básico, abra o Eclipse. Vá para Fileb → Novo → Projeto.

Selecione Projeto Drools. Dê um nome adequado para o projeto. Por exemplo, DroolsTest.

A próxima tela solicita que você selecione alguns arquivos que deseja em seu primeiro projeto Drools.

Selecione os dois primeiros arquivos. O primeiro arquivo é um arquivo .drl (arquivo de regra Drools) e o segundo arquivo é uma classe Java para carregar e executar a regra HelloWorld.

Clique em Avançar → Concluir.

Depois de clicar em Concluir, um projeto <DroolsTest> é criado em sua área de trabalho. Abra a classe Java e, a seguir, clique com o botão direito e execute como um aplicativo Java. Você veria a saída conforme mostrado aqui -

A seguir, discutiremos os termos frequentemente usados ​​em um mecanismo de regras.

Regras

O coração do mecanismo de regras onde você especifica as condições (se 'a', então 'b').

Fatos

Fatos são os dados sobre os quais as regras atuarão. Da perspectiva de Java, os fatos são o POJO (Plain Old Java Object).

Sessão

Uma sessão de conhecimento no Drools é o componente principal para disparar as regras. É a sessão de conhecimento que contém todas as regras e outros recursos. Uma Sessão de Conhecimento é criada a partir da Base de Conhecimento.

Para que o mecanismo de regras funcione, fatos são inseridos na sessão e quando uma condição é atendida, a regra subsequente é disparada. Uma sessão é de dois tipos -

  • Sessão de Conhecimento sem Estado
  • Sessão de Conhecimento Stateful

Agenda

É um conceito lógico. A agenda é o lugar lógico onde as ativações estão esperando para serem disparadas.

Ativações

As ativações são o thenparte da regra. As ativações são colocadas na agenda onde a regra apropriada é acionada.

Se você vir a regra padrão que está escrita no projeto Hello World (Sample.drl), há muitas palavras-chave usadas que iremos explicar agora.

Sample.drl

  • Package- Cada regra começa com um nome de pacote. O pacote atua como um namespace para regras. Os nomes das regras em um pacote devem ser exclusivos. Os pacotes em regras são semelhantes aos pacotes em Java.

  • Import statement- Quaisquer que sejam os fatos aos quais você deseja aplicar a regra, esses fatos precisam ser importados. Por exemplo, com.sample.DroolsTest.Message; no exemplo acima.

  • Rule Definition- Consiste no Nome da Regra, na condição e na Consequência. As palavras-chave do Drools sãorule, when, then, e end. No exemplo acima, os nomes das regras são “Hello World” e “GoodBye”. owhen parte é a condição tanto nas regras quanto na thenparte é a consequência. Na terminologia da regra, owhen parte também é chamada de LHS (lado esquerdo) e o then parte como o RHS (lado direito) da regra.

Agora vamos examinar os termos usados ​​no arquivo Java usado para carregar os Drools e executar as regras.

Base de Conhecimento

A Base de Conhecimento é uma interface que gerencia uma coleção de regras, processos e tipos internos. Está contido dentro da embalagemorg.drools.KnowledgeBase. No Drools, eles são comumente chamados deknowledge definitions ou knowledge. As definições de conhecimento são agrupadas emknowledge packages. As definições de conhecimento podem ser adicionadas ou removidas. O principal objetivo da Base de Conhecimento é armazená-los e reutilizá-los porque sua criação é cara. A Base de Conhecimento fornece métodos para criar sessões de conhecimento.

Sessão de Conhecimento

A sessão de conhecimento é recuperada da base de conhecimento. É a principal interface para interagir com o Drools Engine. A sessão de conhecimento pode ser de dois tipos -

  • Sessão de Conhecimento sem Estado

  • Sessão de Conhecimento Stateful

Sessão de Conhecimento sem Estado

Sessão de conhecimento sem estado é uma sessão sem estado que forma o caso de uso mais simples, sem utilizar inferência. Uma sessão sem estado pode ser chamada como uma função, passando alguns dados e recebendo alguns resultados de volta. Exemplos comuns de uma sessão sem estado incluem -

  • Validation

    • Esta pessoa é elegível para uma hipoteca?

  • Calculation

    • Calcule um prêmio de hipoteca.

  • Routing and Filtering

    • Filtre as mensagens recebidas, como e-mails, em pastas.

    • Envie mensagens recebidas para um destino

Sessão de Conhecimento Stateful

Sessões com estado têm vida mais longa e permitem mudanças iterativas ao longo do tempo. Alguns casos de uso comuns para sessões com estado incluem -

  • Monitoring

    • Acompanhamento e análise do mercado de ações para compras semiautomáticas.

  • Diagnostics

    • Detecção de falhas, diagnóstico médico

  • Logistics

    • Rastreamento de encomendas e provisionamento de entrega

Construtor de Conhecimento

A interface KnoledgeBuilder é responsável por construir um KnowledgePackage a partir de definições de conhecimento (regras, processos, tipos). Está contido dentro da embalagemorg.drools.builder.KnowledgeBuilder. As definições de conhecimento podem estar em vários formatos. Se houver algum problema com a construção, o KnowledgeBuilder relatará os erros por meio destes dois métodos:hasErrors e getError.

O diagrama a seguir explica o processo

No exemplo acima, como estamos pegando um exemplo simples de sessão de conhecimento sem estado, inserimos o fato na sessão e, em seguida, o método fireAllRules () é chamado e você vê a saída.

No caso de uma sessão de conhecimento stateful, uma vez que as regras são disparadas, o objeto da sessão de conhecimento stateful deve chamar o método dispose() para liberar a sessão e evitar vazamentos de memória.

Como você viu, o .drl (arquivo de regra) tem sua própria sintaxe, vamos cobrir algumas partes da sintaxe da regra neste capítulo.

Condições nas regras

Uma regra pode conter muitas condições e padrões, como -

  • Conta (saldo == 200)
  • Cliente (nome == “Vivek”)

As condições acima verificam se o saldo da conta é 200 ou o nome do cliente é “Vivek”.

Variáveis ​​em regras

Um nome de variável no Drools começa com um símbolo de dólar ($).

  • $ account - Conta ()
  • $ account é a variável para a classe Account ()

O Drools pode funcionar com todos os tipos nativos de Java e até mesmo com Enum.

Comentários nas regras

Os caracteres especiais, # ou //, podem ser usados ​​para marcar comentários de linha única.

Para comentários de várias linhas, use o seguinte formato:

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

Variáveis ​​globais

Variáveis ​​globais são variáveis ​​atribuídas a uma sessão. Eles podem ser usados ​​por vários motivos, como segue -

  • Para parâmetros de entrada (por exemplo, valores constantes que podem ser personalizados de sessão para sessão).

  • Para parâmetros de saída (por exemplo, relatórios - uma regra poderia gravar alguma mensagem em uma variável de relatório global).

  • Pontos de entrada para serviços como registro, que podem ser usados ​​dentro de regras.

Funções nas regras

As funções são um recurso conveniente. Eles podem ser usados ​​em condições e consequências. As funções representam uma alternativa às classes utilitário / auxiliar. Por exemplo,

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

Dialeto

Um dialeto especifica a sintaxe usada em qualquer expressão de código que está em uma condição ou em uma consequência. Inclui valores de retorno, evals, evals em linha, predicados, expressões de destaque, consequências e assim por diante. o valor padrão éJava. Drools atualmente suporta mais um dialeto chamadoMVEL. O dialeto padrão pode ser especificado no nível do pacote da seguinte forma -

package org.mycompany.somePackage
dialect "mvel"

Dialeto MVEL

MVEL é uma linguagem de expressão para aplicativos baseados em Java. Ele suporta acesso de campo e método / getter. É baseado na sintaxe Java.

Saliência

Saliência é um recurso muito importante da Sintaxe da Regra. Saliência é usada pela estratégia de resolução de conflito para decidir qual regra disparar primeiro. Por padrão, é o critério principal.

Podemos usar a saliência para definir a ordem das regras de disparo. Saliência tem um atributo, que aceita qualquer expressão que retorne um número do tipo int (tanto os números positivos quanto os negativos são válidos). Quanto maior o valor, maior a probabilidade de uma regra ser escolhida pela estratégia de resolução de conflito para disparar.

salience ($account.balance * 5)

O valor de saliência padrão é 0. Devemos ter isso em mente ao atribuir valores de saliência a apenas algumas regras.

Existem muitos outros recursos / parâmetros na Sintaxe da Regra, mas cobrimos apenas os importantes aqui.

Palavras-chave de consequência da regra

Palavras-chave de consequência da regra são as palavras-chave usadas no “then”Parte da regra.

  • Modify - Os atributos do fato podem ser modificados no then parte da regra.

  • Insert - Com base em alguma condição, se verdadeira, pode-se inserir um novo fato na sessão atual do Mecanismo de Regras.

  • Retract - Se uma determinada condição for verdadeira em uma regra e você não quiser agir de outra forma sobre esse fato, poderá retirar o fato específico do mecanismo de regras.

Note- É considerado uma prática muito ruim ter uma lógica condicional (instruções if) dentro de uma consequência de regra. Na maioria das vezes, uma nova regra deve ser criada.

Neste capítulo, criaremos um projeto Drools para a seguinte declaração de problema -

Dependendo da cidade e do tipo de produto (combinação de cidade e produto), informe-se sobre o imposto local referente a essa cidade.

Teremos dois arquivos DRL para nosso projeto Drools. Os dois arquivos DRL significarão duas cidades em consideração (Pune e Nagpur) e quatro tipos de produtos (mantimentos, medicamentos, relógios e bens de luxo).

  • O imposto sobre medicamentos nas duas cidades é considerado zero.

  • Para mantimentos, assumimos uma taxa de Rs 2 em Pune e Rs 1 em Nagpur.

Usamos o mesmo preço de venda para demonstrar resultados diferentes. Observe que todas as regras estão sendo disparadas no aplicativo.

Aqui está o modelo para conter 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;
   }
}

Arquivos DRL

Conforme sugerido anteriormente, usamos dois arquivos DRL aqui: Pune.drl e Nagpur.drl.

Pune.drl

Este é o arquivo DRL que executa as regras para a cidade 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 é o arquivo DRL que executa as regras para a cidade 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

Escrevemos os arquivos DRL com base na cidade, pois nos dá extensibilidade para adicionar qualquer número de arquivos de regras posteriormente, se novas cidades estiverem sendo adicionadas.

Para demonstrar que todas as regras estão sendo acionadas de nossos arquivos de regras, usamos dois tipos de itens (medicamentos e mantimentos); e os remédios são isentos de impostos e os mantimentos são tributados de acordo com a cidade.

Nossa classe de teste carrega os arquivos de regras, insere os fatos na sessão e produz a saída.

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 você executar este programa, sua saída será a seguinte -

PUNE 0
PUNE 20
NAGPUR 0
NAGPUR 10

Para Pune e Nagpur, quando o item é um medicamento, o imposto local é zero; já quando o item é de mercearia, o imposto é o da cidade. Mais regras podem ser adicionadas aos arquivos DRL para outros produtos. Este é apenas um programa de amostra.

Chame uma função externa de um arquivo DRL

Aqui, demonstraremos como chamar uma função estática de um arquivo Java em seu arquivo DRL.

Primeiro de tudo, crie uma classe HelloCity.java no mesmo pacote com.sample.

package com.sample;

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

Depois disso, adicione a instrução de importação no arquivo DRL para chamar o método writeHello do arquivo DRL. No bloco de código a seguir, as alterações no arquivo DRL Pune.drl são destacadas em amarelo.

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

Execute o programa novamente e sua saída será a seguinte -

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

A diferença agora na saída está marcada em amarelo, o que mostra a saída do método estático na classe Java.

A vantagem de chamar um método Java é que podemos escrever qualquer função utilitário / auxiliar em Java e chamar a mesma a partir de um arquivo DRL.

Existem diferentes maneiras de depurar um projeto Drools. Aqui, escreveremos uma classe de utilitário para que você saiba quais regras estão sendo acionadas ou acionadas.

Com essa abordagem, você pode verificar quais regras estão sendo acionadas em seu projeto Drools. Aqui está nossa aula de utilidades

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

O primeiro método help imprime a regra disparada junto com algumas informações extras que você pode passar como String por meio do arquivo DRL.

A segunda regra helper imprime se a regra específica foi acionada ou não.

Adicionamos um dos métodos de utilitário em cada arquivo DRL. Também adicionamos a função de importação no arquivo DRL (Pune.drl). Nothenparte da regra, adicionamos a chamada de função de utilidade. O Pune.drl modificado é fornecido abaixo. As alterações são destacadas em 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

Da mesma forma, adicionamos a outra função de utilitário no segundo arquivo DRL (Nagpur.drl). Aqui está o 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

Execute o programa novamente e ele deve produzir a seguinte saída -

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

Ambas as funções de utilitário são chamadas e mostra se a regra específica foi chamada ou não. No exemplo acima, todas as regras estão sendo chamadas, mas em um aplicativo corporativo, essa função de utilitário pode ser muito útil para depurar e descobrir se uma determinada regra foi disparada ou não.

Usando a perspectiva de depuração no Eclipse

Você pode depurar as regras durante a execução de seu aplicativo Drools. Você pode adicionar pontos de interrupção nas consequências de suas regras e, sempre que tal ponto de interrupção for encontrado durante a execução das regras, a execução será interrompida temporariamente. Você pode então inspecionar as variáveis ​​conhecidas naquele ponto como faz em um aplicativo Java e usar as opções normais de depuração disponíveis no Eclipse.

Para criar um ponto de interrupção em seu arquivo DRL, basta clicar duas vezes na linha onde deseja criar um ponto de interrupção. Lembre-se, você só pode criar um ponto de interrupção nothenparte de uma regra. Um ponto de interrupção pode ser removido clicando duas vezes no ponto de interrupção no editor DRL.

Depois de aplicar os pontos de interrupção, você precisa depurar seu aplicativo como um aplicativo Drools. Os pontos de interrupção do Drools (pontos de interrupção no arquivo DRL) só funcionarão se o seu aplicativo estiver sendo depurado como um aplicativo Drools. Aqui está como você precisa fazer o mesmo -

Depois de depurar seu aplicativo como um aplicativo Drools, você veria o controle no arquivo DRL conforme mostrado na imagem a seguir -

Você pode ver as variáveis ​​e os valores atuais do objeto naquele ponto de depuração. O mesmo controle de F6 para mover para a próxima linha e F8 para pular para o próximo ponto de depuração são aplicáveis ​​aqui também. Desta forma, você pode depurar seu aplicativo Drools.

Note - A perspectiva de depuração no aplicativo Drools funciona apenas se o dialeto for MVEL até o Drools 5.x.