Introduktion til Flowable

1. Oversigt

Flowable er en forretningsprocesmotor skrevet i Java. I denne vejledning gennemgår vi detaljerne i forretningsprocesser og forstår, hvordan vi kan udnytte Flowable Java API til at oprette og distribuere en prøveforretningsproces.

2. Forståelse af forretningsprocesser

Kort fortalt, en forretningsproces er et sæt opgaver, der, når de er afsluttet i en defineret rækkefølge, opnår et defineret mål. Hver opgave i en forretningsproces har klart definerede input og output. Disse opgaver kan kræve menneskelig indgriben eller være fuldstændigt automatiserede.

OMG (Object Management Group) har defineret en standard kaldet Business Process Model and Notation (BPMN), som virksomheder kan definere og kommunikere deres processer. BPMN er blevet bredt understøttet og accepteret i branchen. Flowable API understøtter fuldt ud oprettelse og implementering af BPMN 2.0-procesdefinitioner.

3. Oprettelse af procesdefinitioner

Lad os antage, at vi har en enkel proces til artikelgennemgang inden udgivelse.

Kernen i denne proces er, at forfattere indsender en artikel, og redaktører enten accepterer eller afviser den. Hvis den accepteres, offentliggøres artiklen med det samme; dog afvises forfatteren via e-mail:

Vi opretter procesdefinitioner som XML-filer ved hjælp af BPMN 2.0 XML-standarden.

Lad os definere vores enkle proces i henhold til BPMN 2.0-standarden:

Nu er der et stort antal elementer her, der er standard XML-ting, mens andre er specifikke for BPMN 2.0:

  • Det hele processen er pakket ind i et mærke kaldet "proces", som igen er en del af et tag kaldet "definitioner"
  • En proces består af begivenheder, strømme, opgaver og gateways
  • En begivenhed er enten en startbegivenhed eller en slutbegivenhed
  • Et flow (i dette eksempel en sekvensflow) forbinder andre elementer som begivenheder og opgaver
  • Opgaver er hvor det faktiske arbejde udføres; disse kan blandt andet være “brugeropgaver” eller “serviceopgaver”
  • En brugeropgave kræver, at en menneskelig bruger interagerer med Flowable API og tager handling
  • En serviceopgave repræsenterer en automatisk opgave, som kan være et opkald til en Java-klasse eller endda et HTTP-opkald
  • En gateway udføres baseret på attributten "godkendt"; dette er kendt som en procesvariabel, og vi får se, hvordan du indstiller dem senere

Mens vi kan oprette procesdefinitionsfiler i enhver teksteditor, er dette ikke altid den mest bekvemme måde. Heldigvis kommer Flowable dog også med brugergrænseflademuligheder til at gøre dette ved hjælp af enten et Eclipse-plugin eller en webapplikation. Hvis du bruger IntelliJ i stedet, er der også et IntelliJ-plugin til rådighed.

4. Arbejde med Flowable API

Nu hvor vi har defineret vores enkle proces i en XML-fil i henhold til BPMN 2.0-standarden, har vi brug for en måde at indsende og køre den på. Flowable leverer Process Engine API til at interagere med Flowable Engines. Flowable er meget fleksibel og tilbyder flere måder at implementere denne API på.

I betragtning af at Flowable er en Java API, kan vi inkludere procesmotoren i enhver Java-applikation ved blot at medtage de nødvendige JAR-filer. Vi kan meget vel udnytte Maven til styring af disse afhængigheder.

Desuden leveres Flowable med bundne API'er til at interagere med Flowable via HTTP. Vi kan bruge disse API'er til stort set at gøre alt andet, der er muligt gennem Flowable API.

Langt om længe, Flowable har fremragende support til integration med Spring og Spring Boot! Vi bruger Flowable og Spring Boot integration i vores tutorial.

5. Oprettelse af en Demo-applikation med Process Engine

Lad os nu oprette en simpel applikation, der omslutter en procesmotor fra Flowable og tilbyder en HTTP-baseret API til at interagere med Flowable API. Der kan lige så godt være en web- eller mobilapplikation, der sidder oven på API'en for at gøre oplevelsen bedre, men vi springer over det til denne tutorial.

Vi opretter vores demo som en Spring Boot-applikation.

5.1. Afhængigheder

Lad os først se de afhængigheder, vi har brug for at trække fra Maven:

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

De afhængigheder, vi har brug for, er alle tilgængelige på Maven Central:

  • Spring Boot Starter til Web - dette er en standard starter til Spring Boot
  • Flowable Starter for Spring Boot - dette er nødvendigt for Spring Boot Flowable Engines
  • H2-database - Flowable kræver en database for at gemme data, og H2 er standard-hukommelsesdatabasen

5.2. Processdefinition

Når vi starter vores Spring Boot-applikation, forsøger den automatisk at indlæse alle procesdefinitioner, der findes under mappen "ressourcer / processer". Lad os derfor oprette en XML-fil med den procesdefinition, vi oprettede ovenfor, med navnet "article-workflow.bpmn20.xml", og placere den i den mappe.

5.3. Konfigurationer

Som vi er klar over, at Spring Boot tager en meget meningsfuld tilgang til applikationskonfiguration, gælder det også for Flowable som en del af Spring Boot. For eksempel, Ved at registrere H2 som den eneste databasedriver på klassestien konfigureres Flowable automatisk til brug.

Naturligvis kan ethvert aspekt, der kan konfigureres, konfigureres på en brugerdefineret måde gennem applikationsegenskaber. Til denne tutorial holder vi os dog til standardindstillingerne!

5.4. Java-delegerede

I vores procesdefinition har vi brugt et par Java-klasser, der formodes at blive påberåbt som dele af serviceopgaver. Disse klasser implementerer JavaDelegate interface og er kendt som Java-delegerede i Flowable. Vi definerer nu dummy-klasser for disse Java-delegerede:

offentlig klasse PublishArticleService implementerer JavaDelegate {public void execute (DelegateExecution executing) {System.out.println ("Publicering af den godkendte artikel."); }}
offentlig klasse SendMailService implementerer JavaDelegate {public void execute (DelegateExecution executing) {System.out.println ("Sender afvisningsmail til forfatter."); }}

Det er klart, at vi skal erstatte disse dummy-klasser med faktiske tjenester for at udgive en artikel eller sende en e-mail.

5.5. HTTP API'er

Lad os endelig oprette nogle slutpunkter for at interagere med procesmotoren og arbejde med den proces, vi har defineret.

Vi begynder med at definere en controller, der udsætter tre slutpunkter:

@RestController offentlig klasse ArticleWorkflowController {@Autowired privat ArticleWorkflowService-tjeneste; @PostMapping ("/ send") offentlig ugyldig indsendelse (@RequestBody artikelartikel) {service.startProcess (artikel); } @GetMapping ("/ opgaver") offentlig liste getTasks (@RequestParam streng tildelte) {return service.getTasks (tildelte); } @PostMapping ("/ review") offentlig ugyldig gennemgang (@RequestBody godkendelsesgodkendelse) {service.submitReview (godkendelse); }}

Vores controller udsætter slutpunkter for at indsende en artikel til gennemgang, hente en liste over artikler til gennemgang og endelig for at indsende en anmeldelse for en artikel. Artikel og Godkendelse er standard POJO'er, der findes i lageret.

Vi delegerer faktisk det meste af arbejdet til ArticleWorkflowService:

@Service offentlig klasse ArticleWorkflowService {@Autowired privat RuntimeService runtimeService; @Autowired privat TaskService taskService; @Transactional public void startProcess (Article article) {Map variables = new HashMap (); variables.put ("forfatter", article.getAuthor ()); variables.put ("url", article.getUrl ()); runtimeService.startProcessInstanceByKey ("articleReview", variabler); } @Transactional public List getTasks (String assignee) {List Tasks = taskService.createTaskQuery () .taskCandidateGroup (assignee) .list (); returner opgaver.stream () .map (opgave -> {Kortvariabler = taskService.getVariables (task.getId ()); returnerer ny artikel (task.getId (), (String) variabler.get ("forfatter"), ( String) variables.get ("url"))}} .collect (Collectors.toList ()); } @Transactional public void submitReview (godkendelsesgodkendelse) {Map variables = new HashMap (); variables.put ("godkendt", godkendelse.isStatus ()); taskService.complete (godkendelse.getId (), variabler); }}

Nu er det meste af koden her ret intuitiv, men lad os forstå de fremtrædende punkter:

  • RuntimeService at starte processen til en bestemt indsendelse
  • TaskService for at forespørge og opdatere opgaver
  • Indpakning af alle databaseopkald i transaktioner, der understøttes af Spring
  • Opbevaring af detaljer som blandt andet forfatter og URL i en Kortog gemme med procesinstansen; disse er kendt som procesvariabler, og vi kan få adgang til dem inden for en procesdefinition, som vi så tidligere

Nu er vi klar til at teste vores applikations- og procesmotor. Når vi starter applikationen, kan vi bare bruge krølle eller en hvilken som helst REST-klient som Postman til at interagere med de slutpunkter, vi har oprettet.

6. Enhedstestprocesser

Flowable understøtter forskellige versioner af JUnit, herunder JUnit 5, til oprettelse af enhedstest til forretningsprocesser. Flydbar integration med Spring har også passende støtte til dette. Lad os se en typisk enhedstest for en proces om foråret:

@ExtendWith (FlowableSpringExtension.class) @ExtendWith (SpringExtension.class) offentlig klasse ArticleWorkflowUnitTest {@Autowired private RuntimeService runtimeService; @Autowired privat TaskService taskService; @Test @Deployment (ressourcer = {"processer / artikel-workflow.bpmn20.xml"}) ugyldig artikelApprovalTest () {Kortvariabler = ny HashMap (); variables.put ("forfatter", "[e-mail-beskyttet]"); variables.put ("url", "//baeldung.com/dummy"); runtimeService.startProcessInstanceByKey ("articleReview", variabler); Opgaveopgave = taskService.createTaskQuery (). SingleResult (); assertEquals ("Gennemgå den indsendte tutorial", task.getName ()); variables.put ("godkendt", sand); taskService.complete (task.getId (), variabler); assertEquals (0, runtimeService.createProcessInstanceQuery (). count ()); }}

Dette skal stort set ligne en standard enhedstest i foråret, bortset fra få kommentarer som @Deployment. Nu, den @Deployment annotering leveres af Flowable for at oprette og slette en procesinstallation omkring testmetoder.

7. Forståelse af implementering af processer

Selvom vi ikke dækker detaljerne i procesinstallationen i denne vejledning, er det umagen værd at dække nogle aspekter, der er vigtige.

Typisk, processer arkiveres som Business Archive (BAR) og implementeres i en applikation. Under arkiveringen scannes dette arkiv for artefakter - som procesdefinitioner - og behandles. Du har muligvis bemærket konventionen med procesdefinitionsfilen, der slutter med “.Bpmn20.xml”.

Mens vi har brugt standard H2-database i hukommelse i vores vejledning, kan dette faktisk ikke bruges i en applikation i den virkelige verden af ​​den enkle grund, at en database i hukommelsen ikke gemmer nogen data på tværs af opstart og er praktisk talt umuligt at bruge i et grupperet miljø! Derfor, vi skal bruge en relationsdatabase af produktionskvalitet og give de nødvendige konfigurationer i applikationen.

Mens BPMN 2.0 i sig selv ikke har nogen forestilling om versionering, Flowable opretter en attribut til version til processen, som distribueres i databasen. Hvis en opdateret version af den samme proces, som identificeret ved attributten "id", distribueres, oprettes en ny post, hvor versionen øges. Når vi prøver at starte en proces med "id", henter procesmotoren den nyeste version af den anvendte procesdefinition.

Hvis vi bruger en af ​​de designere, vi diskuterede tidligere, til at skabe procesdefinitionen, har vi allerede en visualisering til vores proces. Vi kan eksportere procesdiagrammet som et billede og placere det ved siden af ​​XML-procesdefinitionsfilen. Hvis vi holder os til den standard navngivningskonvention, der er foreslået af Flowable, behandles dette billede af procesmotoren sammen med selve processen. Desuden kan vi også hente dette billede via API'er!

8. Gennemse historie af procesinstanser

Det er ofte meget vigtigt i forbindelse med forretningsprocesser at forstå, hvad der skete tidligere. Vi har muligvis brug for dette til simpel fejlretning eller komplekse juridiske revisionsformål.

Flowable registrerer, hvad der sker gennem procesudførelsen og opbevarer det i databasen. Desuden gør Flowable denne historie tilgængelig via API'er til forespørgsel og analyse. Der er seks enheder, hvorunder Flowable registrerer disse og HistoryService har metoder til at forespørge dem alle.

Lad os se en simpel forespørgsel for at hente færdige procesforekomster:

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

Som vi kan se, API'en til at spørge indspillede data er ret sammensat. I dette eksempel forespørger vi færdige procesforekomster efter ID og bestiller dem i stigende rækkefølge efter deres sluttid.

9. Overvågningsprocesser

Overvågning er et nøgleaspekt i enhver forretningskritisk applikation og endnu mere for en applikation, der håndterer forretningsprocesser i en organisation. Flowable har flere muligheder for at lade os overvåge processer i realtid.

Flowable giver specifikke MBeanordninger, som vi kan få adgang til via JMX, for ikke kun at indsamle data til overvågning, men også at udføre mange andre aktiviteter. Vi kan integrere dette med enhver standard JMX-klient, inklusive jconsole, som findes sammen med standard Java-distributioner.

Brug af JMX til overvågning åbner mange muligheder, men er relativt kompliceret og tidskrævende. Men da vi bruger Spring Boot, har vi held og lykke!

Spring Boot tilbyder aktuatorendepunkter til at indsamle applikationsmålinger via HTTP. Vi kan problemfrit integrere dette med en værktøjsstak som Prometheus og Grafana for at skabe et overvågningsværktøj i produktionskvalitet med minimal indsats.

Flowable giver et ekstra aktuatorendepunkt, der afslører oplysninger om de kørende processer. Dette er ikke så godt som at indsamle information via JMX, men det er hurtigt, nemt og mest af alt tilstrækkeligt.

10. Konklusion

I denne vejledning diskuterede vi forretningsprocesser og hvordan man definerede dem i BPMN 2.0-standarden. Derefter diskuterede vi funktionerne i Flowable process engine og API'er til at implementere og udføre processer. Vi så, hvordan man integrerer dette i en Java-applikation, specifikt i Spring Boot.

Fortsat videre diskuterede vi andre vigtige aspekter af processer som deres implementering, visualisering og overvågning. Det er overflødigt at sige, at vi lige har ridset overfladen af ​​forretningsprocessen og en stærk motor som Flowable. Flowable har en meget rig API med tilstrækkelig dokumentation til rådighed. Denne vejledning skulle dog have vækket vores interesse for emnet!

Som altid er koden til eksemplerne tilgængelig på GitHub.