Introduzione a Drools

1. Panoramica

Drools è una soluzione BRMS (Business Rule Management System). Fornisce un motore di regole che elabora i fatti e produce output come risultato dell'elaborazione di regole e fatti. La centralizzazione della logica aziendale consente di introdurre modifiche in modo rapido ed economico.

Inoltre, colma il divario tra i team aziendali e tecnici fornendo una struttura per scrivere le regole in un formato facile da capire.

2. Dipendenze di Maven

Per iniziare con Drools, dobbiamo prima aggiungere un paio di dipendenze nel nostro pom.xml :

 org.kie kie-ci 7.1.0.Beta1   org.drools drools-decisiontables 7.1.0.Beta1 

L'ultima versione di entrambe le dipendenze è disponibile su Maven Central Repository come kie-ci e drools-decisiontables.

3. Drools Basics

Vedremo i concetti di base di Drools:

  • Fatti : rappresenta i dati che servono come input per le regole
  • Memoria di lavoro : un archivio con fatti, dove vengono utilizzati per la corrispondenza dei modelli e possono essere modificati, inseriti e rimossi
  • Regola : rappresenta una singola regola che associa i Fatti alle azioni corrispondenti. Può essere scritto in Drools Rule Language neifile .drl o come Decision Table in un foglio di calcolo Excel
  • Knowledge Session - contiene tutte le risorse necessarie per le regole di tiro; tutti i fatti vengono inseriti nella sessione e quindi vengono attivate le regole di corrispondenza
  • Knowledge Base : rappresenta la conoscenza nell'ecosistema Drools, contiene le informazioni sulle risorse in cuisi trovano le regole e crea anche la sessione di conoscenza
  • Modulo : un modulo contiene più Knowledge Base che possono contenere sessioni diverse

4. Configurazione Java

Per attivare le regole su un dato dato, dobbiamo istanziare le classi fornite dal framework con informazioni sulla posizione dei file di regole e sui fatti:

4.1. KieFileSystem

Per prima cosa, dobbiamo impostare il bean KieFileSystem ; questo è un file system in memoria fornito dal framework. Il codice seguente fornisce il contenitore per definire le risorse Drools come file di regole, tabelle decisionali, a livello di codice:

public KieFileSystem kieFileSystem() throws IOException { KieFileSystem kieFileSystem = getKieServices().newKieFileSystem(); for (Resource file : getRuleFiles()) { kieFileSystem.write( ResourceFactory.newClassPathResource( RULES_PATH + file.getFilename(), "UTF-8")); } return kieFileSystem; }

Qui RULES_PATH denota la posizione dei file delle regole sul file system. Qui stiamo leggendo i file dal classpath che è tipicamente / src / main / resources nel caso di un progetto Maven.

4.2. KieContainer

Successivamente, dobbiamo impostare il KieContainer che è un segnaposto per tutti i KieBase per un particolare KieModule. KieContainer è costruito con l'aiuto di altri bean, inclusi KieFileSystem, KieModule e KieBuilder.

Il metodo buildAll () invocato su KieBuilder costruisce tutte le risorse e le lega a KieBase. Viene eseguito correttamente solo quando è in grado di trovare e convalidare tutti i file delle regole:

public KieContainer kieContainer() throws IOException { KieRepository kieRepository = getKieServices().getRepository(); kieRepository.addKieModule(new KieModule() { public ReleaseId getReleaseId() { return kieRepository.getDefaultReleaseId(); } }); KieBuilder kieBuilder = getKieServices() .newKieBuilder(kieFileSystem()) .buildAll(); return getKieServices().newKieContainer(kieRepository.getDefaultReleaseId()); }

4.3. KieSession

Le regole vengono attivate aprendo un bean KieSession , che può essere recuperato da KieContainer:

public KieSession kieSession() throws IOException { return kieContainer().newKieSession(); }

5. Regole di attuazione

Ora che abbiamo finito con la configurazione, diamo un'occhiata a un paio di opzioni per la creazione di regole.

Esploreremo l'implementazione delle regole con un esempio di classificazione di un candidato per un ruolo specifico, in base al suo attuale stipendio e al numero di anni di esperienza che ha.

5.1. File delle regole di sbavatura ( .drl )

In poche parole, il file delle regole Drools contiene tutte le regole aziendali.

Una regola include un costrutto Quando-Allora , qui la sezione Quando elenca la condizione da controllare e la sezione Allora elenca l'azione da intraprendere se la condizione è soddisfatta:

package com.baeldung.drools.rules; import com.baeldung.drools.model.Applicant; global com.baeldung.drools.model.SuggestedRole suggestedRole; dialect "mvel" rule "Suggest Manager Role" when Applicant(experienceInYears > 10) Applicant(currentSalary > 1000000 && currentSalary <= 2500000) then suggestedRole.setRole("Manager"); end

Questa regola può essere attivata inserendo i fatti del candidato e del ruolo suggerito in KieSession:

public SuggestedRole suggestARoleForApplicant( Applicant applicant,SuggestedRole suggestedRole){ KieSession kieSession = kieContainer.newKieSession(); kieSession.insert(applicant); kieSession.setGlobal("suggestedRole",suggestedRole); kieSession.fireAllRules(); // ... }

Verifica due condizioni sull'istanza del richiedente e quindi, in base al soddisfacimento di entrambe le condizioni, imposta il campo Ruolo nell'oggetto SuggestedRole .

Questo può essere verificato eseguendo il test:

@Test public void whenCriteriaMatching_ThenSuggestManagerRole(){ Applicant applicant = new Applicant("David", 37, 1600000.0,11); SuggestedRole suggestedRole = new SuggestedRole(); applicantService.suggestARoleForApplicant(applicant, suggestedRole); assertEquals("Manager", suggestedRole.getRole()); }

In questo esempio, abbiamo utilizzato poche parole chiave fornite da Drools. Capiamo il loro utilizzo:

  • pacchetto - questo è il nome del pacchetto che specifichiamo in kmodule.xml, il file delle regole si trova all'interno di questo pacchetto
  • import - questo è simileall'istruzione import di Java, qui dobbiamo specificare le classi che stiamo inserendo nella KnowledgeSession
  • globale: viene utilizzato per definire una variabile di livello globale per una sessione; questo può essere utilizzato per passare un parametro di input o per ottenere un parametro di output per riepilogare le informazioni per una sessione
  • dialetto : un dialetto specifica la sintassi utilizzata nelle espressioni nella sezione delle condizioni o nella sezione delle azioni. Per impostazione predefinita, il dialetto è Java. Drools supporta anche il dialetto mvel ; è un linguaggio di espressione per applicazioni basate su Java. Supporta l'accesso al campo e al metodo / getter
  • regola : definisce un blocco di regole con un nome di regola
  • quando - questo specifica una condizione della regola, in questo esempio le condizioni che vengono verificate sono Richiedente con esperienza negli anni più di dieci anni e attuale Salario in un certo intervallo
  • then – this block executes the action when the conditions in the when block met. In this example, the Applicant role is set as Manager

5.2. Decision Tables

A decision table provides the capability of defining rules in a pre-formatted Excel spreadsheet. The advantage with Drools provided Decision Table is that they are easy to understand even for a non-technical person.

Also, it is useful when there are similar rules, but with different values, in this case, it is easier to add a new row on excel sheet in contrast to writing a new rule in .drl files. Let's see what the structure of a decision table with an example of applying the label on a product based on the product type:

The Decision Table is grouped in different sections the top one is like a header section where we specify the RuleSet (i.e. package where rule files are located), Import (Java classes to be imported) and Notes (comments about the purpose of rules).

The central section where we define rules is called RuleTable which groups the rules which are applied to the same domain object.

In the next row, we have column types CONDITION and ACTION. Within these columns, we can access the properties of the domain object mentioned in one row and their values in the subsequent rows.

The mechanism to fire the rules is similar to what we have seen with .drl files.

Possiamo verificare il risultato dell'applicazione di queste regole eseguendo il test:

@Test public void whenProductTypeElectronic_ThenLabelBarcode() { Product product = new Product("Microwave", "Electronic"); product = productService.applyLabelToProduct(product); assertEquals("BarCode", product.getLabel()); }

6. Conclusione

In questo rapido articolo, abbiamo esplorato l'utilizzo di Drools come motore di regole aziendali nella nostra applicazione. Abbiamo anche visto i diversi modi in cui possiamo scrivere le regole nel linguaggio delle regole di Drools e in una lingua di facile comprensione nei fogli di calcolo.

Come sempre, il codice completo di questo articolo è disponibile su GitHub.