Cos'è Kogito

Kogito è un toolkit di automazione aziendale nativo per il cloud che rende la tua vita più semplice. Pensalo come il frutto dell'amore tra la gestione dei processi aziendali (BPM) e la gestione delle decisioni, cresciuto nel cloud dal suo affettuoso genitore, Quarkus.

Ma perché dovresti, tu che sei uno sviluppatore esperto, dedicare del tempo a Kogito? Ecco il riassunto:

  • È nativo per il cloud e pronto per Kubernetes fin da subito
  • Si integra perfettamente con Quarkus, offrendoti poteri Java supersonici e subatomici
  • Trasforma i tuoi processi aziendali e le decisioni in cittadini di prima classe nel tuo codice
  • È open-source e supportato dalla Apache Software Foundation (attualmente in incubazione)

Esplorando il Repository degli Esempi di Kogito

Ora che abbiamo suscitato il tuo interesse, facciamo un tour del repository apache/incubator-kie-kogito-examples. Questo tesoro di esempi è il tuo biglietto per padroneggiare Kogito.

Impostare il Tuo Spazio di Gioco con Kogito

Prima di immergerci, assicuriamoci che tu abbia tutto il necessario per eseguire questi esempi:

  • Java 11+ (perché non siamo selvaggi)
  • Maven 3.8.1+
  • Docker (per quelle voglie di containerizzazione)
  • Quarkus CLI (opzionale, ma altamente raccomandato per un aumento della produttività)

Hai tutto? Ottimo! Ora mettiamoci al lavoro.

Quarkus: Il Compagno di Crimine di Kogito

Potresti chiederti, "Cosa c'entra Quarkus?" Beh, tutto. Quarkus è il framework Java supersonico e subatomico che conferisce a Kogito i suoi superpoteri nativi per il cloud. È come Red Bull per le tue applicazioni Java, ma senza i tremori da caffeina.

Kogito sfrutta Quarkus per:

  • Raggiungere tempi di avvio fulminei
  • Ridurre l'uso della memoria (il tuo portafoglio ti ringrazierà)
  • Fornire capacità di ricarica a caldo (perché chi ha tempo per i riavvii?)
  • Offrire un'integrazione senza soluzione di continuità con le tecnologie native per il cloud

Esplorando gli Esempi di Kogito: Un Tour Vorticoso

Diamo un'occhiata ad alcuni degli esempi più succosi nel repository:

1. Processi + Regole: Il Duo Dinamico

Vai alla directory kogito-quarkus-examples/process-business-rules-quarkus. Questo esempio mostra come Kogito combina processi e regole per creare un potente motore decisionale.

Punti chiave:

  • Integrazione dei processi BPMN2 con le tabelle decisionali DMN
  • Generazione automatica di endpoint REST per i tuoi processi
  • Esecuzione senza soluzione di continuità delle regole all'interno dei contesti di processo

2. Workflow Serverless: Perché i Server Sono Così del Decennio Scorso

Dai un'occhiata all'esempio serverless-workflow-examples/serverless-workflow-greeting-quarkus. Questo è per tutti voi appassionati di serverless là fuori.

Punti salienti:

  • Workflow definiti in YAML (perché chi non ama YAML?)
  • Architetture guidate dagli eventi rese facili
  • Integrazioni con AWS Lambda e Knative

3. DMN: Rendere le Decisioni di Nuovo Grandi

Vai a kogito-quarkus-examples/dmn-quarkus-example per un'immersione profonda nel Decision Model and Notation (DMN) con Kogito.

Cosa imparerai:

  • Modellazione visiva della logica decisionale complessa
  • Generazione automatica di API REST per i tuoi servizi decisionali
  • Test e debug dei modelli DMN come un professionista

Eseguire il Tuo Primo Esempio di Kogito: Una Guida Passo-Passo

Basta teoria, mettiamoci al lavoro! Useremo l'esempio process-business-rules-quarkus per iniziare.

Una volta in esecuzione, testa l'API:

curl -X POST -H 'Content-Type: application/json' -H 'Accept: application/json' -d '{"person": {"name":"John Doe", "age": 25}}' http://localhost:8080/persons

Compila ed esegui l'esempio:

./mvnw clean compile quarkus:dev

Clona il repository:

git clone https://github.com/apache/incubator-kie-kogito-examples.git
cd incubator-kie-kogito-examples/kogito-quarkus-examples/process-business-rules-quarkus

Voilà! Hai appena eseguito un processo aziendale con regole incorporate usando Kogito. Senti il potere scorrere nelle tue vene?

Implementare Processi Aziendali: BPMN e DMN, Oh Mio!

Kogito porta BPMN (Business Process Model and Notation) e DMN (Decision Model and Notation) nel 21° secolo. Sono finiti i giorni dei motori BPM pesanti e ingombranti. Con Kogito, i tuoi processi e decisioni sono cittadini di prima classe nel tuo codice.

BPMN: Diagrammi di Flusso Potenziati

Diamo un'occhiata a un semplice processo BPMN:

<?xml version="1.0" encoding="UTF-8"?>
<bpmn2:definitions xmlns:bpmn2="http://www.omg.org/spec/BPMN/20100524/MODEL" id="_6063f3a1-5ba3-4f0e-b1f2-ad49e8e6f2a7" targetNamespace="http://www.omg.org/bpmn20">
  <bpmn2:process id="greeting" name="Greeting Process" isExecutable="true">
    <bpmn2:startEvent id="_1" name="StartProcess">
      <bpmn2:outgoing>_1-_2</bpmn2:outgoing>
    </bpmn2:startEvent>
    <bpmn2:scriptTask id="_2" name="Hello" scriptFormat="http://www.java.com/java">
      <bpmn2:incoming>_1-_2</bpmn2:incoming>
      <bpmn2:outgoing>_2-_3</bpmn2:outgoing>
      <bpmn2:script>System.out.println("Hello World");</bpmn2:script>
    </bpmn2:scriptTask>
    <bpmn2:endEvent id="_3" name="EndProcess">
      <bpmn2:incoming>_2-_3</bpmn2:incoming>
    </bpmn2:endEvent>
    <bpmn2:sequenceFlow id="_1-_2" sourceRef="_1" targetRef="_2"/>
    <bpmn2:sequenceFlow id="_2-_3" sourceRef="_2" targetRef="_3"/>
  </bpmn2:process>
</bpmn2:definitions>

Questo semplice processo stampa solo "Hello World", ma immagina le possibilità quando inizi a integrarlo con la tua logica aziendale e i sistemi esterni!

DMN: Decisioni, Decisioni

Ora, diamo un'occhiata a un modello DMN:

<?xml version="1.0" encoding="UTF-8"?>
<dmn:definitions xmlns:dmn="http://www.omg.org/spec/DMN/20180521/MODEL/" xmlns="https://kiegroup.org/dmn/_52CEF9FD-9943-4A89-96D5-6F66810CA4C1" xmlns:di="http://www.omg.org/spec/DMN/20180521/DI/" xmlns:kie="http://www.drools.org/kie/dmn/1.2" xmlns:dmndi="http://www.omg.org/spec/DMN/20180521/DMNDI/" xmlns:dc="http://www.omg.org/spec/DMN/20180521/DC/" id="_4F7C97F9-EA35-4CB5-8E4C-C40C91B5F729" name="Greeting" typeLanguage="http://www.omg.org/spec/DMN/20180521/FEEL/" namespace="https://kiegroup.org/dmn/_52CEF9FD-9943-4A89-96D5-6F66810CA4C1">
  <dmn:decision id="_23B84E59-33C6-4D3A-9314-CF0724714606" name="Greeting Message">
    <dmn:extensionElements/>
    <dmn:variable id="_078A6F79-1861-47A1-8921-C9E7F2B728D1" name="Greeting Message" typeRef="string"/>
    <dmn:informationRequirement id="_2066A270-2A88-4B77-9F90-1F683FDF852C">
      <dmn:requiredInput href="#_C7ED7EFC-9F7F-4FBE-81DB-57A32A56502C"/>
    </dmn:informationRequirement>
    <dmn:decisionTable id="_5A25D948-34E0-4527-9EE2-7A9C0DC663A5" hitPolicy="UNIQUE" preferredOrientation="Rule-as-Row">
      <dmn:input id="_79ECD1F2-E11E-4F6D-9038-C47AE6EC1C9C">
        <dmn:inputExpression id="_E17A0C1D-A0F0-4C5F-8A0E-8B5F9A1BAB08" typeRef="number">
          <dmn:text>Age</dmn:text>
        </dmn:inputExpression>
      </dmn:input>
      <dmn:output id="_EC6A4902-BD03-4D48-AA45-9AD2AEB83E8B"/>
      <dmn:annotation name="annotation-1"/>
      <dmn:rule id="_C3F28427-2608-4ACE-98EE-C5C2F0AEF7A7">
        <dmn:inputEntry id="_0FBE3F3C-5F3A-4A21-A4A5-D207B2BA7808">
          <dmn:text>< 18</dmn:text>
        </dmn:inputEntry>
        <dmn:outputEntry id="_C05BE7BB-BDA0-4C45-9ED1-4F5B17B2A3E6">
          <dmn:text>"Hello young person!"</dmn:text>
        </dmn:outputEntry>
        <dmn:annotationEntry>
          <dmn:text/>
        </dmn:annotationEntry>
      </dmn:rule>
      <dmn:rule id="_C3B07D74-0354-4C44-9587-9B44C67F5AE0">
        <dmn:inputEntry id="_8A9B0EEC-5CB9-4D31-BB56-0A723CEABFBC">
          <dmn:text>>= 18</dmn:text>
        </dmn:inputEntry>
        <dmn:outputEntry id="_42C4EB7F-3F00-4A19-9F43-D2E246F378F9">
          <dmn:text>"Hello adult!"</dmn:text>
        </dmn:outputEntry>
        <dmn:annotationEntry>
          <dmn:text/>
        </dmn:annotationEntry>
      </dmn:rule>
    </dmn:decisionTable>
  </dmn:decision>
  <dmn:inputData id="_C7ED7EFC-9F7F-4FBE-81DB-57A32A56502C" name="Age">
    <dmn:extensionElements/>
    <dmn:variable id="_F0B70F13-94CB-4FB9-BD89-4AB84F8BDB07" name="Age" typeRef="number"/>
  </dmn:inputData>
  <dmndi:DMNDI>
    <dmndi:DMNDiagram>
      <di:extension>
        <kie:ComponentsWidthsExtension>
          <kie:ComponentWidths dmnElementRef="_5A25D948-34E0-4527-9EE2-7A9C0DC663A5">
            <kie:width>50</kie:width>
            <kie:width>100</kie:width>
            <kie:width>100</kie:width>
            <kie:width>100</kie:width>
          </kie:ComponentWidths>
        </kie:ComponentsWidthsExtension>
      </di:extension>
      <dmndi:DMNShape id="dmnshape-_23B84E59-33C6-4D3A-9314-CF0724714606" dmnElementRef="_23B84E59-33C6-4D3A-9314-CF0724714606" isCollapsed="false">
        <dmndi:DMNStyle>
          <dmndi:FillColor red="255" green="255" blue="255"/>
          <dmndi:StrokeColor red="0" green="0" blue="0"/>
          <dmndi:FontColor red="0" green="0" blue="0"/>
        </dmndi:DMNStyle>
        <dc:Bounds x="364" y="227" width="100" height="50"/>
        <dmndi:DMNLabel/>
      </dmndi:DMNShape>
      <dmndi:DMNShape id="dmnshape-_C7ED7EFC-9F7F-4FBE-81DB-57A32A56502C" dmnElementRef="_C7ED7EFC-9F7F-4FBE-81DB-57A32A56502C" isCollapsed="false">
        <dmndi:DMNStyle>
          <dmndi:FillColor red="255" green="255" blue="255"/>
          <dmndi:StrokeColor red="0" green="0" blue="0"/>
          <dmndi:FontColor red="0" green="0" blue="0"/>
        </dmndi:DMNStyle>
        <dc:Bounds x="365" y="94" width="100" height="50"/>
        <dmndi:DMNLabel/>
      </dmndi:DMNShape>
      <dmndi:DMNEdge id="dmnedge-_2066A270-2A88-4B77-9F90-1F683FDF852C" dmnElementRef="_2066A270-2A88-4B77-9F90-1F683FDF852C">
        <di:waypoint x="415" y="119"/>
        <di:waypoint x="414" y="252"/>
      </dmndi:DMNEdge>
    </dmndi:DMNDiagram>
  </dmndi:DMNDI>
</dmn:definitions>

Questo modello DMN decide un saluto in base all'età di una persona. È un esempio semplice, ma immagina di scalarlo a regole aziendali complesse e processi decisionali!

Personalizzare Regole e Decisioni: A Modo Tuo o Niente

Kogito non ti offre solo regole e decisioni pronte all'uso. Ti permette di personalizzarle per adattarle alle tue esigenze aziendali uniche. Ecco alcuni modi per esercitare quei muscoli di personalizzazione:

1. Linguaggio di Regole Drools (DRL)

Per quei momenti in cui i modelli visivi non bastano, puoi usare il buon vecchio DRL:

package org.acme.rules

import org.acme.model.Person

rule "Greet adults"
when
    $person: Person(age >= 18)
then
    System.out.println("Hello, responsible adult!");
end

rule "Greet children"
when
    $person: Person(age < 18)
then
    System.out.println("Hi, youngster! Where are your parents?");
end

2. Tabelle Decisionali

Per gli utenti aziendali che si sentono male alla vista del codice, le tabelle decisionali sono una manna dal cielo:

RuleSet,org.acme.rules
RuleSetName,Greeting Rules

RuleTable Greeting
CONDITION,ACTION
Person.age,System.out.println
>=18,"Hello, responsible adult!"
<18,"Hi, youngster! Where are your parents?"

3. Estendere DMN con Funzioni Personalizzate

Hai bisogno di un po' di potenza extra nei tuoi modelli DMN? Estendili con funzioni Java personalizzate:

@DMNFunction(name = "toUpperCase")
public static String toUpperCase(String input) {
    return input.toUpperCase();
}

Ora puoi usare toUpperCase() nelle tue espressioni DMN. Bello, vero?

Integrare Kogito con il Mondo Esterno

Kogito si integra bene con gli altri. Vediamo come integrarlo con alcuni sistemi esterni popolari:

API REST: Perché SOAP è per Lavare

Kogito genera automaticamente endpoint REST per i tuoi processi e decisioni. Ma cosa succede se devi chiamare un'API REST esterna? Facile:

@Inject
RestClient myExternalService;

@POST
@Path("/process")
public Response startProcess(ProcessPayload payload) {
    // Avvia il tuo processo Kogito
    ProcessInstance<?> processInstance = processService.createProcessInstance(...);
    
    // Chiama l'API REST esterna
    ExternalData data = myExternalService.getData(payload.getId());
    
    // Aggiorna le variabili del processo
    processInstance.updateVariables(Collections.singletonMap("externalData", data));
    
    return Response.ok(processInstance).build();
}

Kafka: Per Quei Momenti Guidati dagli Eventi

Kogito e Kafka vanno insieme come burro di arachidi e marmellata. Ecco un assaggio:

@Inject
Emitter<PersonEvent> personEventEmitter;

@POST
@Path("/persons")
public Response createPerson(Person person) {
    // La tua logica di processo Kogito qui
    
    // Emetti un evento a Kafka
    personEventEmitter.send(new PersonEvent(person));
    
    return Response.ok(person).build();
}

Non dimenticare di configurare la tua connessione Kafka in application.properties:

mp.messaging.outgoing.person-events.connector=smallrye-kafka
mp.messaging.outgoing.person-events.topic=person-events
mp.messaging.outgoing.person-events.value.serializer=io.quarkus.kafka.client.serialization.JsonbSerializer

Debugging Kogito: Quando le Cose Vanno Storte

Anche i migliori sviluppatori a volte si trovano in difficoltà con il debugging. Ecco alcuni consigli per mantenerti sano di mente:

1. Abilita il Logging di Debug

Prima di tutto, aumenta il livello di logging:

quarkus.log.category."org.kie".level=DEBUG
quarkus.log.category."org.drools".level=DEBUG
quarkus.log.category."org.jbpm".level=DEBUG

2. Usa la Dev UI di Kogito

Kogito viene fornito con una Dev UI elegante. Basta aggiungere questa dipendenza:

<dependency>
    <groupId>org.kie.kogito</groupId>
    <artifactId>kogito-addons-quarkus-process-management</artifactId>
</dependency>

Ora puoi accedere a http://localhost:8080/q/dev per vedere i tuoi processi e decisioni in azione.

3. Testa, Testa, Testa

I test unitari sono i tuoi amici. Ecco un esempio rapido:

@QuarkusTest
public class GreetingProcessTest {

    @Inject
    ProcessService processService;

    @Test
    public void testGreetingProcess() {
        ProcessInstance<?> processInstance = processService.createProcessInstance(
            "greeting",
            Collections.singletonMap("name", "John")
        );
        
        assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_COMPLETED);
        assertThat(processInstance.variables()).containsEntry("greeting", "Hello, John!");
    }
}

Ottimizzazione delle Prestazioni: Fai Andare Veloce

Kogito è veloce, ma con questi consigli, puoi farlo andare ancora più veloce:

1. Compilazione Nativa

Quarkus offre la compilazione nativa, che può ridurre significativamente il tempo di avvio e l'uso della memoria:

./mvnw package -Pnative

2. Programmazione Reattiva

Abbraccia il paradigma reattivo per una migliore scalabilità:

@Inject
ReactiveProcessService processService;

@POST
@Path("/process")
public Uni<ProcessInstance<?>> startProcess(ProcessPayload payload) {
    return processService.createProcessInstance("myProcess", payload.toMap());
}

3. Caching

Usa le capacità di caching integrate di Quarkus per velocizzare le operazioni frequenti:

@CacheResult(cacheName = "greeting-cache")
public String getGreeting(String name) {
    // Operazione costosa qui
    return "Hello, " + name + "!";
}

Best Practices: Cosa Fare e Cosa Non Fare

Concludiamo con alcune regole d'oro per lo sviluppo con Kogito:

Fai:

  • Mantieni i tuoi processi e decisioni semplici e modulari
  • Usa nomi significativi per i tuoi elementi BPMN e DMN
  • Sfrutta il ricaricamento a caldo di Quarkus per uno sviluppo rapido
  • Documenta i tuoi processi e decisioni (il tuo futuro te stesso ti ringrazierà)
  • Usa il controllo di versione per i tuoi file BPMN e DMN

Non Fare:

  • Inserire la logica aziendale nei tuoi diagrammi di processo (usa invece i task di servizio)
  • Trascurare la gestione degli errori nei tuoi processi
  • Dimenticare il monitoraggio e l'osservabilità
  • Ignorare le best practice di sicurezza (Kogito non è una polvere magica di sicurezza)

Kogito nel Mondo Reale: Non Solo una Bella Faccia

Kogito non è solo per esempi giocattolo. Viene utilizzato nel mondo reale per alcune automazioni aziendali serie. Ecco alcune applicazioni reali:

  • Servizi Finanziari: Automazione dei processi di approvazione dei prestiti e rilevamento delle frodi
  • Sanità: Gestione dei flussi di lavoro dei pazienti e elaborazione delle richieste di assicurazione
  • E-commerce: Orchestrazione dei processi di evasione degli ordini e resi
  • Produzione: Ottimizzazione delle decisioni della catena di approvvigionamento e dei processi di controllo qualità

Contribuire a Kogito: Unisciti al Club dei Fighi

Ti senti ispirato? Vuoi restituire alla comunità? Ecco come puoi contribuire a Kogito:

  1. Fai un fork del repository degli Esempi di Kogito
  2. Scegli un problema dal tracker dei problemi
  3. Apporta le tue modifiche e invia una pull request
  4. Interagisci con la comunità sulla mailing list

Ricorda, nessun contributo è troppo piccolo. Anche correggere un errore di battitura nella documentazione è apprezzato!

Il Conto alla Rovescia Finale: Concludendo

Ecco fatto, gente! Un tour vorticoso di Kogito e dei suoi superpoteri. Abbiamo coperto tutto, dall'impostazione del tuo primo progetto Kogito al contributo alla comunità open-source.

Kogito, alimentato da Quarkus, sta cambiando il gioco nell'automazione aziendale. Porta la potenza delle tecnologie native per il cloud nel mondo dei processi aziendali e delle decisioni. Che tu stia costruendo un semplice flusso di lavoro o un sistema decisionale complesso, Kogito è al tuo fianco.

Allora, cosa stai aspettando? Immergiti, inizia a sperimentare e unisciti alla rivoluzione Kogito. Il tuo futuro te stesso (e il tuo team operativo) ti ringrazieranno.

Ricorda: con grande potere viene grande responsabilità. Usa Kogito saggiamente, e che i tuoi processi aziendali siano sempre a tuo favore!