streamalism.org

1. Overzicht

Flowable is een bedrijfsprocesengine die in Java is geschreven. In deze zelfstudie gaan we door de details van bedrijfsprocessen en begrijpen we hoe we de Flowable Java API kunnen gebruiken om een ​​voorbeeldbedrijfsproces te maken en te implementeren.

2. Inzicht in bedrijfsprocessen

Simpel gezegd, een bedrijfsproces is een reeks taken die, eenmaal voltooid in een gedefinieerde volgorde, een bepaald doel bereiken. Elke taak in een bedrijfsproces heeft duidelijk gedefinieerde inputs en outputs. Deze taken kunnen menselijke tussenkomst vereisen of kunnen volledig geautomatiseerd zijn.

OMG (Object Management Group) heeft een standaard gedefinieerd met de naam Business Process Model and Notation (BPMN) waarmee bedrijven hun processen kunnen definiëren en communiceren. BPMN wordt breed gedragen en geaccepteerd in de branche. De Flowable API ondersteunt het maken en implementeren van BPMN 2.0-procesdefinities volledig.

3. Procesdefinities maken

Laten we aannemen dat we een eenvoudig proces hebben voor het beoordelen van artikelen voordat we publiceren.

De kern van dit proces is dat auteurs een artikel indienen en dat redacteuren het accepteren of afwijzen. Indien geaccepteerd, wordt het artikel onmiddellijk gepubliceerd; indien afgewezen, wordt de auteur hiervan op de hoogte gebracht via e-mail:

We creëren procesdefinities als XML-bestanden met behulp van de BPMN 2.0 XML-standaard.

Laten we ons eenvoudige proces definiëren volgens de BPMN 2.0-standaard:

Nu zijn er nogal wat elementen hier die standaard XML-dingen zijn, terwijl andere specifiek zijn voor BPMN 2.0:

• De het hele proces is verpakt in een tag genaamd "proces", die op zijn beurt deel uitmaakt van een tag met de naam 'definities'
• Een proces bestaat uit gebeurtenissen, stromen, taken en gateways
• Een evenement is een startevenement of een eindgebeurtenis
• Een stroom (in dit voorbeeld een reeksstroom) verbindt andere elementen, zoals gebeurtenissen en taken
• Taken zijn waar het daadwerkelijke werk wordt gedaan; dit kunnen onder meer “gebruikerstaken” of “servicetaken” zijn
• Een gebruikerstaak vereist dat een menselijke gebruiker interactie heeft met de Flowable API en actie onderneemt
• Een servicetaak vertegenwoordigt een automatische taak, die een oproep naar een Java-klasse of zelfs een HTTP-oproep kan zijn
• Een gateway wordt uitgevoerd op basis van het attribuut "goedgekeurd"; dit staat bekend als een procesvariabele, en we zullen zien hoe we ze later kunnen instellen

Hoewel we procesdefinitiebestanden in elke teksteditor kunnen maken, is dit niet altijd de handigste manier. Gelukkig wordt Flowable ook geleverd met gebruikersinterface-opties om dit te doen met behulp van een Eclipse-plug-in of een webtoepassing. Als u in plaats daarvan IntelliJ gebruikt, is er ook een IntelliJ-plug-in beschikbaar.

4. Werken met Flowable API

Nu we ons eenvoudige proces hebben gedefinieerd in een XML-bestand volgens de BPMN 2.0-standaard, hebben we een manier nodig om het in te dienen en uit te voeren. Flowable biedt de Process Engine API om te communiceren met Flowable Engines. Flowable is erg flexibel en biedt verschillende manieren om deze API in te zetten.

Aangezien Flowable een Java-API is, kunnen we de procesengine in elke Java-applicatie opnemen door simpelweg de vereiste JAR-bestanden op te nemen. We kunnen Maven heel goed gebruiken om deze afhankelijkheden te beheren.

Bovendien wordt Flowable geleverd met gebundelde API's voor interactie met Flowable via HTTP. We kunnen deze API's gebruiken om vrijwel alles te doen wat anders mogelijk is via Flowable API.

Tenslotte, Flowable heeft uitstekende ondersteuning voor integratie met Spring en Spring Boot! We maken gebruik van Flowable en Spring Boot-integratie in onze tutorial.

5. Een demo-applicatie maken met Process Engine

Laten we nu een eenvoudige applicatie maken die een procesengine van Flowable omhult en een op HTTP gebaseerde API biedt voor interactie met de Flowable API. Er kan net zo goed een web- of mobiele applicatie bovenop de API zitten om de ervaring te verbeteren, maar dat slaan we over voor deze tutorial.

We maken onze demo als een Spring Boot-applicatie.

5.1. Afhankelijkheden

Laten we eerst eens kijken naar de afhankelijkheden die we uit Maven moeten halen:

 org.springframework.boot spring-boot-starter-web org.flowable flowable-spring-boot-starter 6.4.1 com.h2database h2 runtime 

De afhankelijkheden die we nodig hebben, zijn allemaal beschikbaar bij Maven Central:

• Spring Boot Starter for Web - dit is een standaard starter voor Spring Boot
• Flowable Starter voor Spring Boot - dit is vereist voor Spring Boot Flowable Engines
• H2 Database - Flowable vereist een database om gegevens op te slaan, en H2 is de standaard in-memory database

5.2. Procesdefinitie

Wanneer we onze Spring Boot-applicatie starten, probeert deze automatisch alle procesdefinities te laden die aanwezig zijn in de map "resources / processen". Laten we daarom een ​​XML-bestand maken met de procesdefinitie die we hierboven hebben gemaakt, met de naam “article-workflow.bpmn20.xml”, en het in die map plaatsen.

5.3. Configuraties

Zoals we weten, hanteert Spring Boot een zeer eigenzinnige benadering van applicatieconfiguratie, dat geldt ook voor Flowable als onderdeel van Spring Boot. Bijvoorbeeld, waarbij H2 wordt gedetecteerd als het enige databasestuurprogramma op het klassenpad, configureert Flowable het automatisch voor gebruik.

Het is duidelijk dat elk aspect dat configureerbaar is, op een aangepaste manier kan worden geconfigureerd via applicatie-eigenschappen. Voor deze tutorial houden we ons echter aan de standaardinstellingen!

5.4. Java-afgevaardigden

In onze procesdefinitie hebben we een aantal Java-klassen gebruikt die zouden moeten worden aangeroepen als onderdelen van servicetaken. Deze klassen implementeren het JavaDelegate interface en staan ​​bekend als Java Delegates in Flowable. We gaan nu dummy-klassen definiëren voor deze Java-afgevaardigden:

public class PublishArticleService implementeert JavaDelegate {public void execute (DelegateExecution executie) {System.out.println ("Publiceren van het goedgekeurde artikel."); }}

public class SendMailService implementeert JavaDelegate {public void execute (DelegateExecution execution) {System.out.println ("Weigeringsmail naar auteur verzenden."); }}

Het is duidelijk dat we deze dummy-klassen moeten vervangen door daadwerkelijke services om een ​​artikel te publiceren of een e-mail te verzenden.

5.5. HTTP-API's

Laten we tot slot enkele eindpunten maken om te communiceren met de procesengine en te werken met het proces dat we hebben gedefinieerd.

We beginnen met het definiëren van een controller die drie eindpunten blootlegt:

@RestController openbare klasse ArticleWorkflowController {@Autowired privé ArticleWorkflowService-service; @PostMapping ("/ submit") public void submit (@RequestBody artikel artikel) {service.startProcess (artikel); } @GetMapping ("/ taken") openbare lijst getTasks (@RequestParam String toegewezen) {return service.getTasks (toegewezen persoon); } @PostMapping ("/ review") openbare ongeldige beoordeling (@RequestBody goedkeuring goedkeuring) {service.submitReview (goedkeuring); }}

Onze controller stelt eindpunten bloot om een ​​artikel ter beoordeling in te dienen, een lijst met artikelen op te halen om te beoordelen en tot slot om een ​​recensie voor een artikel in te dienen. Artikel en Goedkeuring zijn standaard POJO's die te vinden zijn in de repository.

We delegeren eigenlijk het meeste werk aan ArtikelWorkflowService:

@Service openbare klasse ArticleWorkflowService {@Autowired private RuntimeService runtimeService; @Autowired privé TaskService taskService; @Transactional public void startProcess (artikel artikel) {Map variables = new HashMap (); variables.put ("auteur", article.getAuthor ()); variables.put ("url", article.getUrl ()); runtimeService.startProcessInstanceByKey ("articleReview", variabelen); } @Transactional openbare lijst getTasks (String toegewezen) {Lijst taken = taskService.createTaskQuery () .taskCandidateGroup (toegewezen) .list (); retourneer taken.stream () .map (task -> {Map variables = taskService.getVariables (task.getId ()); retourneer nieuw artikel (task.getId (), (String) variables.get ("author"), ( String) variables.get ("url"));}) .collect (Collectors.toList ()); } @Transactional public void submitReview (goedkeuring goedkeuring) {Map variables = new HashMap (); variables.put ("goedgekeurd", goedkeuring.isStatus ()); taskService.complete (goedkeuring.getId (), variabelen); }}

Nu is de meeste code hier behoorlijk intuïtief, maar laten we de meest opvallende punten begrijpen:

• RuntimeService om het proces voor een bepaalde inzending te instantiëren
• TaskService om taken op te vragen en bij te werken
• Alle database-oproepen omwikkelen met transacties die worden ondersteund door Spring
• Details zoals auteur en URL opslaan in een Kaart, en opslaan met de procesinstantie; deze staan ​​bekend als procesvariabelen en we hebben er toegang toe binnen een procesdefinitie, zoals we eerder zagen

Nu zijn we klaar om onze applicatie- en procesengine te testen. Zodra we de applicatie starten, kunnen we gewoon gebruiken krullen of een andere REST-client zoals Postman om te communiceren met de eindpunten die we hebben gemaakt.

6. Processen voor het testen van eenheden

Flowable ondersteunt verschillende versies van JUnit, inclusief JUnit 5, voor het maken van unit-tests voor bedrijfsprocessen. Ook hiervoor heeft de vloeiende integratie met Spring passende ondersteuning. Laten we eens kijken naar een typische unit-test voor een proces in het voorjaar:

@ExtendWith (FlowableSpringExtension.class) @ExtendWith (SpringExtension.class) openbare klasse ArticleWorkflowUnitTest {@Autowired private RuntimeService runtimeService; @Autowired privé TaskService taskService; @Test @Deployment (resources = {"processen / artikel-workflow.bpmn20.xml"}) ongeldig articleApprovalTest () {Kaartvariabelen = nieuwe HashMap (); variables.put ("auteur", "[e-mail beveiligd]"); variables.put ("url", "//baeldung.com/dummy"); runtimeService.startProcessInstanceByKey ("articleReview", variabelen); Taak task = taskService.createTaskQuery (). SingleResult (); assertEquals ("Bekijk de ingezonden tutorial", task.getName ()); variables.put ("goedgekeurd", waar); taskService.complete (task.getId (), variabelen); assertEquals (0, runtimeService.createProcessInstanceQuery (). count ()); }}

Dit zou er in het voorjaar ongeveer uit moeten zien als een standaard unit-test, met uitzondering van enkele annotaties zoals @Deployment. Nu de @Deployment annotatie wordt geleverd door Flowable om een ​​procesimplementatie rond testmethoden te maken en te verwijderen.

7. Inzicht in de implementatie van processen

Hoewel we in deze zelfstudie niet de details van procesimplementatie behandelen, is het de moeite waard om enkele aspecten te behandelen die van belang zijn.

Typisch, processen worden gearchiveerd als Business Archive (BAR) en geïmplementeerd in een applicatie. Tijdens de implementatie wordt dit archief gescand op artefacten - zoals procesdefinities - en verwerkt. Je hebt misschien de conventie opgemerkt van het procesdefinitiebestand dat eindigt op ".Bpmn20.xml".

Hoewel we in onze zelfstudie de standaard in-memory H2-database hebben gebruikt, kan deze in feite niet worden gebruikt in een real-world applicatie, om de eenvoudige reden dat een in-memory database geen gegevens bij het opstarten vasthoudt en praktisch onmogelijk te gebruiken in een geclusterde omgeving! Vandaar, we moeten een relationele database van productiekwaliteit gebruiken en de vereiste configuraties in de applicatie leveren.

Hoewel BPMN 2.0 zelf geen idee heeft van versiebeheer, Flowable maakt een versiekenmerk voor het proces, dat wordt geïmplementeerd in de database. Als een bijgewerkte versie van hetzelfde proces, zoals geïdentificeerd door het attribuut "id", wordt geïmplementeerd, wordt een nieuw item gemaakt met de versie die wordt verhoogd. Wanneer we een proces proberen te starten met "id", haalt de procesengine de laatste versie van de geïmplementeerde procesdefinitie op.

Als we een van de ontwerpers gebruiken die we eerder bespraken om de procesdefinitie te maken, hebben we al een visualisatie voor ons proces. We kunnen het processchema als afbeelding exporteren en naast het XML-procesdefinitiebestand plaatsen. Als we ons houden aan de standaard naamgevingsconventie die wordt voorgesteld door Flowable, wordt deze afbeelding samen met het proces zelf verwerkt door de procesengine. Bovendien kunnen we deze afbeelding ook via API's ophalen!

8. Browsegeschiedenis van procesinstances

Bij bedrijfsprocessen is het vaak van groot belang om te begrijpen wat er in het verleden is gebeurd. We hebben dit mogelijk nodig voor eenvoudige foutopsporing of complexe juridische controledoeleinden.

Flowable legt vast wat er tijdens de procesuitvoering gebeurt en bewaart dit in de database. Bovendien stelt Flowable deze geschiedenis beschikbaar via API's om te bevragen en te analyseren. Er zijn zes entiteiten waaronder Flowable deze registreert, en de GeschiedenisService heeft methoden om ze allemaal te doorzoeken.

Laten we eens kijken naar een eenvoudige query om voltooide procesinstanties op te halen:

HistoryService historyService = processEngine.getHistoryService (); Lijstactiviteiten = historyService .createHistoricActivityInstanceQuery () .processInstanceId (processInstance.getId ()) .finished () .orderByHistoricActivityInstanceEndTime () .asc () .list ();

Zoals we kunnen zien, de API voor het opvragen van opgenomen gegevens is redelijk samen te stellen. In dit voorbeeld onderzoeken we voltooide procesinstanties op ID en ordenen we ze in oplopende volgorde van hun eindtijd.

9. Monitoring van processen

Monitoring is een belangrijk aspect van elke bedrijfskritische applicatie, en nog meer voor een applicatie die de bedrijfsprocessen van een organisatie afhandelt. Flowable heeft verschillende opties om ons processen in realtime te laten volgen.

Flowable biedt specifieke MBeans waartoe we toegang hebben via JMX, om niet alleen gegevens te verzamelen voor monitoring, maar ook om vele andere activiteiten uit te voeren. We kunnen dit integreren met elke standaard JMX-client, inclusief jconsole, die aanwezig is naast standaard Java-distributies.

Het gebruik van JMX voor monitoring biedt veel opties, maar is relatief complex en tijdrovend. Maar aangezien we Spring Boot gebruiken, hebben we geluk!

Spring Boot biedt Actuator Endpoints om applicatiestatistieken te verzamelen via HTTP. We kunnen dit naadloos integreren met een toolstack zoals Prometheus en Grafana om met minimale inspanning een monitoringtool van productiekwaliteit te creëren.

Flowable biedt een extra Actuator Endpoint met informatie over de lopende processen. Dit is niet zo goed als het verzamelen van informatie via JMX, maar het is snel, gemakkelijk en vooral voldoende.

10. Conclusie

In deze tutorial hebben we bedrijfsprocessen besproken en hoe deze gedefinieerd kunnen worden in de BPMN 2.0-standaard. Vervolgens hebben we de mogelijkheden van Flowable Process Engine en API's besproken om processen te implementeren en uit te voeren. We hebben gezien hoe we dit kunnen integreren in een Java-applicatie, specifiek in Spring Boot.

We gingen verder en bespraken andere belangrijke aspecten van processen, zoals hun implementatie, visualisatie en bewaking. Onnodig te zeggen dat we zojuist het oppervlak van het bedrijfsproces hebben bekrast en een krachtige motor zoals Flowable. Flowable heeft een zeer rijke API met voldoende documentatie beschikbaar. Deze tutorial had echter onze interesse in het onderwerp moeten wekken!

Zoals altijd is de code voor de voorbeelden beschikbaar op GitHub.