Livro gratuito sobre Wildfly

A comunidade brasileira de JBoss, o JBug Brasil, se organizou no nosso grupo do telegram para escrever um livro em português sobre o servidor de aplicação Wildfly!

:Logo do grupo JBug Brasil

O código do livro está disponível no github e você pode ler o mesmo online e até contribuir!

Regras de negócios com Drools: Usando planilhas

Veja postagens anteriores:

• KIE: Conhecimento é tudo
• Regras de negócios com Drools: Introdução
• Regras de negócios com Drools: Olá Mundo!
• Regras de negócios com Drools: Atualização em tempo real com KieScanner  

 Há diversas maneiras de escrever regras de negócios com Drools e até agora só mostramos a linguagem de script. A ferramenta drools é uma motor de regras que também disponibiliza várias formas de criarmos nossas regras e vamos explorar todas aqui. Hoje vamos mostrar como escrever regras com uma planilha eletrônica!

Do script para planilhas

Você pode ensinar pessoas habituadas com negócio a escrever regras drools, mas não é esse tipo de ferramenta que usualmente quem entende de negócios se sente mais confortável utilizando.
Entre diversas alternativas que iremos mostrar nesse blog, o uso de planilhas é, talvez, o modo que mais se aproxima de quem escreve regras de negócio.
Afinal, o que seria mais atraente, um script como na imagem 1 ou uma planilha como na imagem 2:

Imagem 1

Imagem 2

Com o projeto decision tables, O drools consegue transformar compilar planilhas para regras como as mostradas na imagem 1. Mas qual a mágica por trás disso?

Palavras-chaves que fazem toda a diferença

Omitimos algumas coisas na planilha da imagem 2! Na verdade ela tem algumas linhas escondidas. Veja na imagem 3 o que foi escondido:

Imagem 3

 As linhas em rosa e amarelo são especiais para o drools e é com elas que é possível transformar simples planilhas em regras que terão acesso aos fatos da memória do Drools. Em outras palavras, quem lidar com a planilha estará tomando decisões  sobre os fatos da memória diretamente, mas sem conhecer Java ou Drools.

A mágica está nas seguintes palavras-chave e suas posições

• RuleSet: A célula seguinte à célula(imediatamente à direita) com o conteúdo da palavra RuleSet define o pacote dessas regras. É obrigatório o seu uso.
• Import: A célula à direita deverá conter os imports de classes para serem usadas nas regras. Os imports são separados por vírgulas;
• Notes: A célula a direita deverá conter uma nota "humana" sobre aquele conjunto de regras;
• RuleTable: O início da parte da planilha onde se define as regras em sí. A célula abaixo dessa deverá ser uma CONDITION(ou outra palavra-chave de uma rule table). Devemos ter pelo menos uma RuleTable na nossa planilha, mas podemos definir diversas RuleTable. Note que a célula com RuleTable é seguido pelo nome dessa RuleTable;
• Condition: As condições para uma determinada regra. Uma RuleTable deve pelo menos ter uma Condition. As células abaixo dessa deverão ter a expressão para a condição da regra:
• A primeira linha é a declaração de objetos;
• As linhas abaixo são os testes para os atributos desse objeto. Se os atributos pertecem ao mesmo objeto declarado você deve fazer um merge das linhas acima;
• Na próxima célula abaixo podemos ter um cabeçalho para a coluna e assim informar o valor "de forma humana" que deve ser entrado;
• As células  abaixo serão os valores de teste. Para referenciar eles na condição você usa $param para um único parâmetro ou $1, $2... para múltiplos parâmetros;
• Veja a Imagem 3 para um exemplo;
• Action: A action é o que deve ser feito se as condições forem satisfeitas. As linhas abaixo de action são os pedaços de código que serão executados usando os possíveis parâmetros passados nas células abaixo. Para referenciar os parâmetros usamos os já mencionados $param e $1, $2...

Notem que somente a primeira planilha é considerada e o que fazemos  no restante da planilha não importa para o drools, o que ele quer é o exposto acima e mais algumas palavras chaves que não iremos abordar hoje, mas estão na documentação do Drools.
Um outro ponto interessante é que se a gente altera um fato (fato pode ser entendido como objetos da memória do Drools) e essa alteração faz com que as condições satisfaçam outra linha na planilha, a outra linha será executada. Isso não é novidade para quem conhece motor de regras e isso acontece já com as regras que escrevemos na mão, o ponto é que com planilhas eletrônicas isso fica muito claro! Veja na Imagem 4, as linhas 13,14,15 mudam o status do ticket para Escalate fazendo com que a linha 16 seja acionada, por fim, enviando um email de escalação do ticket. Bacana, não?

Imagem 4

Agora ficou muito fácil entender o nosso exemplo. Primeiramente, o Candidato é um simplesmente objeto Java(veja a imagem 5), a planilha é um arquivo comum dentro do nosso kjar e o código que podemos usar para executar os fatos já são muito conhecidos dos que estão lendo essa sério, veja na imagem 6.

Imagem 5

Imagem 6

Ao executar esse código com o nosso kjar as regras são disparadas e os fatos atualizados como mostrado abaixo:

Candidato [nome=William, idade=28, fundos=1600.0, analise=Habilitado para investidor nível Bronze]
Candidato [nome=Luana, idade=27, fundos=5000.0, analise=Habilitado para investidor nível Prata]
Candidato [nome=Antônio, idade=1, fundos=0.0, analise=Não atingiu idade mínima para investir]


O código desse projeto está no github.



As planilhas, conforme já falado, ficam dentro do kjar, ou seja, outras ferramentas do drools, como o KieScanner e o Kie Server, funcionam normalmente com essas planilhas. Em breve abordaremos o Kie Server aqui e usaremos esse mesmo projeto, fique ligado!

Mais sobre Decision Tables

Em drools-examples você encontra mais algumas planilhas de exemplo. Na documentação você descobre tudo o que pode fazer com elas. Importante que com o tempo você vai entendendo e digerindo o conceito até que uma hora você enxerga todo o poder dessa abordagem!

Conclusão

Introduzimos a ideia de decision tables utilizando planilhas. Claro que há diversas outras formas de criarmos regra drools e iremos explorar todas em postagens futuras!

Regras de negócios com Drools: Atualização em tempo real com KieScanner

Veja postagens anteriores:

• KIE: Conhecimento é tudo
• Regras de negócios com Drools: Introdução
• Regras de negócios com Drools: Olá Mundo!

Chegou a hora de deixar as coisas um pouco mais empolgantes e mostrar como podemos modificar as regras de negócio, ver as mesmas ser aplicadas em tempo real sem reinicializar a aplicação Java!

KieScanner

Toda a ideia é possível por causa das implementações de KieScanner e da API kie-ci. O objetivo é utilizar as APIs do maven para atualizar a KieBase quando o artefato maven é atualizado. Para que tudo funcione bem, temos que usar uma das seguintes formas de gerenciar versões(veja esse artigo da Oracle para mais informações):

• SNAPSHOT: Quando uma versão termina em SNAPSHOT, o artifato é atualizado automaticamente baseado na última instalação no repositório;
• Faixa de versões: Podemos usar uma faixa de versão que queremos executar na nossa aplicação. Por exemplo, podemos querer somente somente versões entre 1.0 (inclusive) e 2.0. Assim, podemos usar o seguinte: [1.0,2.0), ou seja, versões que obedeçam a seguinte regra serão usadas: 1.0 <= x < 2.0;
• Há também o uso de LATEST, mas como está sendo um pouco colocado de lado pelos desenvolvedores do Maven, não é recomendado o uso. O LATEST escanearia a última versão.

O uso do KieScanner requer o seguinte:

• É obrigatório ter kie-ci no classpath;
• Temos que configurar o settings.xml do maven local (ou apontar uma configuração) que tenha os dados do repositório remoto caso queiramos ler de um repositório remoto;
• Adicionar o código Java para adicionar o KieScanner;

O código Java é bem simples. Ao criar o container, você precisa simplesmente "ligar" o scanner para ele. Em outras palavras, adicione as seguintes linhas de código:

KieScanner kScanner = kServices.newKieScanner(kContainer);

kScanner.start(5000);


Pra evitar que isso tudo fique abstrado, eu criei um exemplo que está no nosso github e também um vídeo explicando um pouco melhor, vejam o vídeo:



O código dos projetos utilizados acima podem ser encontrado no nosso github:

Regras de negócios
https://github.com/AprendendoJava/regras-de-negocio-com-drools/tree/master/drools-analise-fundos

Código com Kie Scanner
https://github.com/AprendendoJava/regras-de-negocio-com-drools/tree/master/kie-scanner-test

Regras de negócios com Drools: Olá Mundo!

KIE: Conhecimento é tudo

Regras de negócios com Drools: Introdução

Continuando nossa série de artigos sobre Drools, hoje iremos mostrar como carregar as regras utilizando Java, para isso precisamos introduzir a API utilizada pelo Drools! Não ficaremos na teoria dessa vez, iremos mostrar três formas de carregar regras para fazermos um Olá Mundo!
Notem que embora não seja obrigatório, é altamente recomendável ler o artigo KIE: Conhecimento é tudo

Configurando o projeto

Os projetos que iremos apresentar são baseados em Maven. Assim, o primeiro passo é inicializar o projeto e adicionar as dependências do Drools 6.4.0.Final:

 <dependency>

  <groupId>org.kie</groupId>

  <artifactId>kie-api</artifactId>

  <version>${versao}</version>

 </dependency>

 <dependency>

  <groupId>org.drools</groupId>

  <artifactId>drools-compiler</artifactId>

  <version>${versao}</version>

 </dependency>

 <dependency>

  <groupId>org.drools</groupId>

<artifactId>drools-core</artifactId>

<version>${versao}</version>

 </dependency>

Uma simples regra

Para realizar nosso Olá Mundo, iremos precisar entender o nosso negócio: dizer Olá Mundo. Um olá mundo precisa ser dito para alguém ,certo? Vamos dizer isso para uma Pessoa, assim temos um objeto Pessoa:

Quando colocarmos um objeto do tipo pessoa na Working Memory, onde ficam nossos dados, a regra abaixo é ativa e... fala "Olá NOME, bem vindo ao mundo Drools!"

Como sabemos, o ponto de entrada runtime  das coisas dentro dos projetos KIE é a KieSession(uhum... KIE: Conhecimento é tudo), mas para chegar na KieSession, temos que antes programar (ou configurar) a aplicação de forma que podemos ter uma KieSession que está "ciente" dessas regras. Em seguidas mostraremos formas simples de fazer isso!

Formas simples de carregar as regras de uma aplicação Java

Vamos mostrar como carregar essa regra só utilizando as dependências acima, as formas mais simples possíveis!

Carregando só o arquivo DRL

A forma mais básica é criar um KieContainer (uhum... KIE: Conhecimento é tudo) com os arquivos de regras que queremos. Assim, logo após criar o projeto maven com as dependências mencionadas acima, modificamos a classe principal do projeto com o seguinte código(o código está no github):

Ao executar o código, você deverá ver a regra sendo executada! Veja que essa é uma forma muito, muito verbosa de se executar regras, mas permite uma flexibilida imensa! Não é nosso objetivo explorar a API inteiramente, mas com essa forma de carregar regras, podemos até ter regras geradas a partir de Strings definidas em runtime! Importante é sempre mostrar as alternativas, né!

Carregando todas as regras do Classpath

Essa segunda forma é muito mais simples, pois simplesmente lê o kmodule.xml (uhum... KIE: Conhecimento é tudo) do classpath e carrega todas os arquivos KIE para serem usados na sua aplicação, tornando o seu projeto também um kJAR. Toda simplicidade infelizmente vêm acompanhada de menor flexibilidade. Nesse caso, quase nunca queremos misturar regras com o código Java, é até antagônico! No entanto, não podemos deixar passar em branco essa outra possibilidade. Veja o código:

Para executar o mesmo, criamos um kmodule.xml em META-INF:

Careegando um kJAR do Maven

Agora vamos deixar tudo isso profissional! Essa é a forma de carregar regras mais utilizada uma vez que projetos com arquivos drools criados no console Web são projetos Maven (veremos isso em artigos futuros).
A ideia é separar o KieContainer em um kJAR que ficará instalado em um repositório Maven. Notem que podemos usar nosso maven local (padrão) ou configurar o settings.xml para acessar um repositório maven remoto! Assim, dessa forma ficaria o fluxo de trabalho:

Para utilizamos essa belezura em nosso projeto de teste, vamos primeiro mover o arquivo Drools e o objeto de negócio para um novo projeto que será instalado no nosso repositório local usando o comando mvn install. Em seguida, declaramos o plugin kie-maven-plugin no pom.xml (uhum... KIE: Conhecimento é tudo). Veja a estrutura desse projeto:

Para usarmos esse projeto, precisamos saber o release ID, que é formado a partir do GAV(Group, ArtifactID e Version) do kJAR(no nosso caso é org.aprendendojboss.drools:ola-regras:1.0). Sabendo isso, rodamos carregamos esse kJAR diretamente do Maven no nosso projeto Java. Mas há um problema, como movemos a classe Pessoa para o kJAR, agora temos erro de compilação no projeto Java. Para resolver isso, simplesmente adicionamos uma dependência nova no projeto java para apontar para o kJAR.
Outra dependência que precisamos é o kie-ci(ci de Continuous Integration, integração contínua), que irá trazer as classes necessárias para que o Drools busque módulos no maven. Um projeto sem essa dependência não verifica no maven, acelerando a execução, mas nesse caso precisamos do maven.
Veja como ficou nosso código:

Agora, nesse momento,e você prestou atenção em tudo, deve estar meio triste, pois há um problema chato: temos que ficar atualizando o código Java para trocar a versão do kJAR toda vez que criamos uma nova versão... Segura o faniquito que no próximo artigo mostramos como resolver isso!

Conclusão

Apresentamos diversas formas de carregar regras Drools de uma aplicação Java e brevemente discutimos vantagem de cada uma! Falta muito para explorarmos o mundo Drools, mas hoje demos um grande passo para começar a fazer coisas mais empolgantes. O código está no nosso github.