Kogito: De Business Automation Supercharger Die Je Niet Wist Dat Je Nodig Had

Wat is Kogito

Kogito is een cloud-native toolkit voor bedrijfsautomatisering die je leven gemakkelijker maakt. Zie het als de liefdesbaby van business process management (BPM) en decision management, opgevoed in de cloud door zijn toegewijde ouder, Quarkus.

Maar waarom zou jij, een ervaren ontwikkelaar, Kogito een kans geven? Hier is de korte samenvatting:

• Het is cloud-native en klaar voor Kubernetes vanaf het begin
• Het werkt goed samen met Quarkus, waardoor je supersonische, subatomaire Java-krachten krijgt
• Het maakt je bedrijfsprocessen en beslissingen tot eersteklas burgers in je codebase
• Het is open-source en ondersteund door de Apache Software Foundation (momenteel in incubatie)

Duiken in de Kogito Voorbeelden Repository

Nu we je interesse hebben gewekt, laten we een rondleiding maken door de apache/incubator-kie-kogito-examples repository. Deze schat aan voorbeelden is jouw toegang tot Kogito-meesterschap.

Je Kogito Speelplaats Inrichten

Voordat we beginnen, laten we ervoor zorgen dat je alles hebt wat je nodig hebt om deze voorbeelden te draaien:

• Java 11+ (omdat we geen barbaren zijn)
• Maven 3.8.1+
• Docker (voor die containerisatiebehoeften)
• Quarkus CLI (optioneel, maar sterk aanbevolen voor die extra productiviteitsboost)

Heb je alles? Geweldig! Laten we dan aan de slag gaan.

Quarkus: Kogito's Partner in Crime

Je vraagt je misschien af: "Wat heeft Quarkus ermee te maken?" Nou, alles. Quarkus is het supersonische, subatomaire Java-framework dat Kogito zijn cloud-native superkrachten geeft. Het is als Red Bull voor je Java-applicaties, maar dan zonder de cafeïne-nerveusheid.

Kogito maakt gebruik van Quarkus om:

• Bliksemsnelle opstarttijden te bereiken
• Het geheugenverbruik te verminderen (je portemonnee zal je dankbaar zijn)
• Hot reload-mogelijkheden te bieden (want wie heeft er tijd voor herstarts?)
• Naadloze integratie met cloud-native technologieën te bieden

Verkennen van de Kogito Voorbeelden: Een Wervelende Tour

Laten we eens kijken naar enkele van de meest interessante voorbeelden in de repository:

1. Process + Regels: Het Dynamische Duo

Navigeer naar de kogito-quarkus-examples/process-business-rules-quarkus directory. Dit voorbeeld laat zien hoe Kogito processen en regels combineert om een krachtige beslissingsmachine te creëren.

Belangrijke punten:

• Integratie van BPMN2-processen met DMN-beslissingstabellen
• Automatische REST-endpointgeneratie voor je processen
• Naadloze uitvoering van regels binnen procescontexten

2. Serverloze Workflow: Omdat Servers Zo Vorig Decennium Zijn

Bekijk het serverless-workflow-examples/serverless-workflow-greeting-quarkus voorbeeld. Dit is voor alle serverloze enthousiastelingen daarbuiten.

Hoogtepunten:

• YAML-gedefinieerde workflows (want wie houdt er niet van YAML?)
• Event-gedreven architecturen eenvoudig gemaakt
• Integraties met AWS Lambda en Knative

3. DMN: Beslissingen Weer Geweldig Maken

Ga naar kogito-quarkus-examples/dmn-quarkus-example voor een diepgaande duik in Decision Model and Notation (DMN) met Kogito.

Wat je zult leren:

• Complexe beslissingslogica visueel modelleren
• Automatische REST API-generatie voor je beslissingsdiensten
• DMN-modellen testen en debuggen als een pro

Je Eerste Kogito Voorbeeld Uitvoeren: Een Stapsgewijze Gids

Genoeg theorie, laten we aan de slag gaan! We gebruiken het process-business-rules-quarkus voorbeeld om je op weg te helpen.

Zodra het draait, test de API:

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

Bouw en voer het voorbeeld uit:

./mvnw clean compile quarkus:dev

Kloon de 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à! Je hebt zojuist een bedrijfsproces uitgevoerd met ingebedde regels met Kogito. Voel je de kracht door je aderen stromen?

Bedrijfsprocessen Implementeren: BPMN en DMN, Oh My!

Kogito brengt BPMN (Business Process Model and Notation) en DMN (Decision Model and Notation) naar de 21e eeuw. Weg zijn de dagen van logge, zware BPM-engines. Met Kogito zijn je processen en beslissingen eersteklas burgers in je codebase.

BPMN: Stroomdiagrammen op Steroïden

Laten we eens kijken naar een eenvoudig BPMN-proces:

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

Dit eenvoudige proces print gewoon "Hello World", maar stel je de mogelijkheden voor wanneer je begint te integreren met je bedrijfslogica en externe systemen!

DMN: Beslissingen, Beslissingen

Laten we nu een kijkje nemen in een DMN-model:

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

Dit DMN-model beslist over een begroeting op basis van de leeftijd van een persoon. Het is een eenvoudig voorbeeld, maar stel je voor dat je dit opschaalt naar complexe bedrijfsregels en beslissingsprocessen!

Regels en Beslissingen Aanpassen: Jouw Manier of de Snelweg

Kogito geeft je niet alleen kant-en-klare regels en beslissingen. Het laat je ze aanpassen aan jouw unieke bedrijfsbehoeften. Hier zijn een paar manieren om die aanpassingsspieren te flexen:

1. Drools Regel Taal (DRL)

Voor die momenten waarop visuele modellen het gewoon niet doen, kun je de goede oude DRL gebruiken:

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. Beslissingstabellen

Voor zakelijke gebruikers die uitslag krijgen bij het zien van code, zijn beslissingstabellen een zegen:

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. DMN Uitbreiden met Aangepaste Functies

Heb je wat extra kracht nodig in je DMN-modellen? Breid ze uit met aangepaste Java-functies:

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

Nu kun je toUpperCase() gebruiken in je DMN-uitdrukkingen. Handig, toch?

Kogito Integreren met de Buitenwereld

Kogito werkt goed samen met anderen. Laten we eens kijken hoe je het kunt integreren met enkele populaire externe systemen:

REST API's: Omdat SOAP voor het Wassen is

Kogito genereert automatisch REST-endpoints voor je processen en beslissingen. Maar wat als je een externe REST API moet aanroepen? Heel eenvoudig:

@Inject
RestClient myExternalService;

@POST
@Path("/process")
public Response startProcess(ProcessPayload payload) {
    // Start je Kogito-proces
    ProcessInstance<?> processInstance = processService.createProcessInstance(...);
    
    // Roep externe REST API aan
    ExternalData data = myExternalService.getData(payload.getId());
    
    // Werk procesvariabelen bij
    processInstance.updateVariables(Collections.singletonMap("externalData", data));
    
    return Response.ok(processInstance).build();
}

Kafka: Voor Die Event-gedreven Momenten

Kogito en Kafka gaan samen als pindakaas en jam. Hier is een voorproefje:

@Inject
Emitter<PersonEvent> personEventEmitter;

@POST
@Path("/persons")
public Response createPerson(Person person) {
    // Je Kogito-proceslogica hier
    
    // Zend een event naar Kafka
    personEventEmitter.send(new PersonEvent(person));
    
    return Response.ok(person).build();
}

Vergeet niet je Kafka-verbinding te configureren 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

Kogito Debuggen: Wanneer Dingen Misgaan

Zelfs de beste ontwikkelaars vinden zichzelf soms in een debugging-situatie. Hier zijn enkele tips om je gezond te houden:

1. Schakel Debug Logging in

Allereerst, zet die logging aan:

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

2. Gebruik de Kogito Dev UI

Kogito wordt geleverd met een strakke Dev UI. Voeg gewoon deze afhankelijkheid toe:

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

Nu kun je http://localhost:8080/q/dev openen om je processen en beslissingen in actie te zien.

3. Test, Test, Test

Unit tests zijn je vrienden. Hier is een snel voorbeeld:

@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!");
    }
}

Prestatieoptimalisatie: Laat Het Vroom Gaan

Kogito is snel, maar met deze tips kun je het de geluidsbarrière laten doorbreken:

1. Native Compilatie

Quarkus biedt native compilatie, wat de opstarttijd en het geheugenverbruik aanzienlijk kan verminderen:

./mvnw package -Pnative

2. Reactieve Programmering

Omarm het reactieve paradigma voor betere schaalbaarheid:

@Inject
ReactiveProcessService processService;

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

3. Caching

Gebruik de ingebouwde cachingmogelijkheden van Quarkus om frequente bewerkingen te versnellen:

@CacheResult(cacheName = "greeting-cache")
public String getGreeting(String name) {
    // Duurzame operatie hier
    return "Hello, " + name + "!";
}

Best Practices: Do's en Don'ts

Laten we afsluiten met enkele gouden regels voor Kogito-ontwikkeling:

Do:

• Houd je processen en beslissingen eenvoudig en modulair
• Gebruik betekenisvolle namen voor je BPMN- en DMN-elementen
• Maak gebruik van de hot reload van Quarkus voor snelle ontwikkeling
• Documenteer je processen en beslissingen (je toekomstige zelf zal je dankbaar zijn)
• Gebruik versiebeheer voor je BPMN- en DMN-bestanden

Don't:

• Plaats geen bedrijfslogica in je procesdiagrammen (gebruik in plaats daarvan servicetaken)
• Verwaarloos foutafhandeling in je processen niet
• Vergeet monitoring en observatie niet
• Negeer beveiligingsbest practices niet (Kogito is geen magisch beveiligingspoeder)

Kogito in de Echte Wereld: Niet Alleen een Mooi Gezicht

Kogito is niet alleen voor speelgoedvoorbeelden. Het wordt in het wild gebruikt voor serieuze bedrijfsautomatisering. Hier zijn een paar toepassingen in de echte wereld:

• Financiële Diensten: Automatiseren van leninggoedkeuringsprocessen en fraudedetectie
• Gezondheidszorg: Beheren van patiëntworkflows en verzekeringsclaimverwerking
• E-commerce: Orkestreren van ordervervulling en retourprocessen
• Productie: Optimaliseren van supply chain-beslissingen en kwaliteitscontroleprocessen

Bijdragen aan Kogito: Word Lid van de Coole Kinderen Club

Voel je je geïnspireerd? Wil je iets teruggeven aan de gemeenschap? Hier is hoe je kunt bijdragen aan Kogito:

1. Fork de Kogito Voorbeelden repository
2. Kies een issue uit de issue tracker
3. Maak je wijzigingen en dien een pull request in
4. Neem deel aan de gemeenschap op de mailinglijst

Onthoud, geen bijdrage is te klein. Zelfs het corrigeren van een typefout in de documentatie wordt gewaardeerd!

De Finale Aftelling: Afronden

En daar heb je het, mensen! Een wervelende tour van Kogito en zijn superkrachten. We hebben alles behandeld, van het opzetten van je eerste Kogito-project tot bijdragen aan de open-source gemeenschap.

Kogito, aangedreven door Quarkus, verandert het spel in bedrijfsautomatisering. Het brengt de kracht van cloud-native technologieën naar de wereld van bedrijfsprocessen en beslissingen. Of je nu een eenvoudige workflow of een complex beslissingssysteem bouwt, Kogito staat voor je klaar.

Dus, waar wacht je nog op? Duik erin, begin te experimenteren en sluit je aan bij de Kogito-revolutie. Je toekomstige zelf (en je ops-team) zullen je dankbaar zijn.

Onthoud: met grote kracht komt grote verantwoordelijkheid. Gebruik Kogito verstandig, en moge je bedrijfsprocessen altijd in je voordeel zijn!