Introduksjon til flytbar

1. Oversikt

Flowable er en forretningsprosessmotor skrevet på Java. I denne veiledningen vil vi gå gjennom detaljene i forretningsprosesser og forstå hvordan vi kan utnytte Flowable Java API for å opprette og distribuere en eksempelprosessprosess.

2. Forstå forretningsprosesser

For å si det enkelt, en forretningsprosess er et sett med oppgaver som, når de er fullført i en definert rekkefølge, oppnår et definert mål. Hver oppgave i en forretningsprosess har klart definerte innganger og utganger. Disse oppgavene kan kreve menneskelig inngripen eller være fullstendig automatiserte.

OMG (Object Management Group) har definert en standard kalt Business Process Model and Notation (BPMN) for bedrifter å definere og kommunisere sine prosesser. BPMN har blitt bredt støttet og akseptert i bransjen. Flowable API støtter fullt ut opprettelse og distribusjon av BPMN 2.0 prosessdefinisjoner.

3. Opprette prosessdefinisjoner

La oss anta at vi har en enkel prosess for artikkelgjennomgang før publisering.

Kjernen i denne prosessen er at forfattere sender inn en artikkel, og redaktører godtar eller avviser den. Hvis akseptert, publiseres artikkelen umiddelbart; hvis avvist, blir forfatteren imidlertid varslet via e-post:

Vi lager prosessdefinisjoner som XML-filer ved hjelp av BPMN 2.0 XML-standarden.

La oss definere vår enkle prosess i henhold til BPMN 2.0-standarden:

Nå er det ganske mange elementer her som er standard XML-ting, mens andre er spesifikke for BPMN 2.0:

  • De hele prosessen er pakket inn i en merkelapp som heter “prosess”, som igjen er en del av en kode kalt “definisjoner”
  • En prosess består av hendelser, flyter, oppgaver og gateways
  • En begivenhet er enten en startbegivenhet eller en sluttbegivenhet
  • En flyt (i dette eksemplet en sekvensflyt) kobler andre elementer som hendelser og oppgaver
  • Oppgaver er der faktisk arbeid blir utført; disse kan blant annet være “brukeroppgaver” eller “serviceoppgaver”
  • En brukeroppgave krever at en menneskelig bruker skal samhandle med Flowable API og iverksette tiltak
  • En tjenesteoppgave representerer en automatisk oppgave, som kan være en samtale til en Java-klasse eller til og med en HTTP-samtale
  • En gateway kjøres basert på attributtet “godkjent”; dette er kjent som en prosessvariabel, og vi får se hvordan du setter dem inn senere

Selv om vi kan lage prosessdefinisjonsfiler i hvilken som helst teksteditor, er dette ikke alltid den mest praktiske måten. Heldigvis kommer Flowable imidlertid også med brukergrensesnittalternativer for å gjøre dette ved hjelp av enten et Eclipse-plugin eller en webapplikasjon. Hvis du bruker IntelliJ i stedet, er det også et IntelliJ-plugin tilgjengelig.

4. Arbeide med Flowable API

Nå som vi har definert vår enkle prosess i en XML-fil i henhold til BPMN 2.0-standarden, trenger vi en måte å sende inn og kjøre den på. Flowable tilbyr Process Engine API for å samhandle med Flowable Engines. Flowable er veldig fleksibel og tilbyr flere måter å distribuere denne API-en på.

Gitt at Flowable er et Java API, kan vi inkludere prosessmotoren i alle Java-applikasjoner ved ganske enkelt å inkludere de nødvendige JAR-filene. Vi kan veldig godt utnytte Maven for å håndtere disse avhengighetene.

Videre kommer Flowable med medfølgende API-er for å samhandle med Flowable via HTTP. Vi kan bruke disse API-ene til å gjøre mye annet ellers mulig gjennom Flowable API.

Endelig, Flowable har utmerket støtte for integrasjon med Spring and Spring Boot! Vi bruker Flowable og Spring Boot-integrering i opplæringen vår.

5. Opprette et demo-program med prosessmotor

La oss nå lage et enkelt program som omslutter en prosessmotor fra Flowable og tilbyr en HTTP-basert API for å samhandle med Flowable API. Det kan like godt være en web- eller mobilapplikasjon som sitter på toppen av API-en for å gjøre opplevelsen bedre, men vi hopper over det for denne opplæringen.

Vi lager vår demo som en Spring Boot-applikasjon.

5.1. Avhengigheter

La oss først se avhengighetene vi trenger å trekke fra Maven:

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

Avhengighetene vi trenger er alle tilgjengelige på Maven Central:

  • Spring Boot Starter for Web - dette er en standard starter for Spring Boot
  • Flowable Starter for Spring Boot - dette er nødvendig for Spring Boot Flowable Engines
  • H2 Database - Flowable krever en database for å lagre data, og H2 er standard in-memory database

5.2. Prosessdefinisjon

Når vi starter vår Spring Boot-applikasjon, prøver den å laste inn alle prosessdefinisjoner som er tilstede under mappen "ressurser / prosesser" automatisk. La oss derfor opprette en XML-fil med prosessdefinisjonen vi opprettet ovenfor, med navnet "article-workflow.bpmn20.xml", og plassere den i den mappen.

5.3. Konfigurasjoner

Som vi er klar over at Spring Boot tar en svært meningsfull tilnærming til applikasjonskonfigurasjon, gjelder det også Flowable som en del av Spring Boot. For eksempel, For å oppdage H2 som den eneste databasedriveren på klassestien, konfigurerer Flowable den automatisk for bruk.

Åpenbart kan alle aspekter som kan konfigureres konfigureres på en tilpasset måte gjennom applikasjonsegenskaper. For denne opplæringen holder vi oss imidlertid til standardinnstillingene!

5.4. Java-delegater

I prosessdefinisjonen vår har vi brukt et par Java-klasser som skal påberopes som deler av serviceoppgaver. Disse klassene implementerer JavaDelegate grensesnitt og er kjent som Java Delegates i Flowable. Vi definerer nå dummy-klasser for disse Java-delegatene:

offentlig klasse PublishArticleService implementerer JavaDelegate {public void execute (DelegateExecution executing) {System.out.println ("Publisering av godkjent artikkel."); }}
offentlig klasse SendMailService implementerer JavaDelegate {public void execute (DelegateExecution executing) {System.out.println ("Sending avvisningspost til forfatter."); }}

Åpenbart må vi erstatte disse dummy-klassene med faktiske tjenester for å publisere en artikkel eller sende en e-post.

5.5. HTTP APIer

Til slutt, la oss lage noen sluttpunkter for å samhandle med prosessmotoren og jobbe med prosessen vi har definert.

Vi begynner med å definere en kontroller som avslører tre sluttpunkter:

@RestController offentlig klasse ArticleWorkflowController {@Autowired privat ArticleWorkflowService-tjeneste; @PostMapping ("/ send") offentlig ugyldig innlevering (@RequestBody-artikkel) {service.startProcess (artikkel); } @GetMapping ("/ oppgaver") offentlig liste getTasks (@RequestParam String overdrager) {return service.getTasks (oppdragsgiver); } @PostMapping ("/ review") offentlig ugyldig gjennomgang (@RequestBody godkjenning godkjenning) {service.submitReview (godkjenning); }}

Vår kontroller avslører sluttpunkter for å sende inn en artikkel for gjennomgang, hente en liste over artikler som skal gjennomgås, og til slutt for å sende inn en anmeldelse for en artikkel. Artikkel og Godkjenning er standard POJOer som finnes i depotet.

Vi delegerer faktisk det meste av arbeidet til ArticleWorkflowService:

@Service offentlig klasse ArticleWorkflowService {@Autowired private 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 (); return Tasks.stream () .map (task -> {Map variables = taskService.getVariables (task.getId ()); returner ny artikkel (task.getId (), (String) variables.get ("author"), ( Streng) variabler.get ("url"));}) .collect (Collectors.toList ()); } @Transactional public void submitReview (Approval godkjenning) {Map variables = new HashMap (); variables.put ("godkjent", godkjenning.isStatus ()); taskService.complete (godkjenning.getId (), variabler); }}

Nå er det meste av koden her ganske intuitiv, men la oss forstå de viktigste punktene:

  • RuntimeService for å starte prosessen for et bestemt innlevering
  • TaskService for å spørre og oppdatere oppgaver
  • Innpakning av alle databasesamtaler i transaksjoner som støttes av Spring
  • Lagring av detaljer som blant annet forfatter og URL, i en Kart, og lagring med prosessforekomsten; disse er kjent som prosessvariabler, og vi kan få tilgang til dem i en prosessdefinisjon, som vi så tidligere

Nå er vi klare til å teste applikasjons- og prosessmotoren vår. Når vi starter applikasjonen, kan vi bare bruke den krølle eller en hvilken som helst REST-klient som Postman for å samhandle med endepunktene vi har opprettet.

6. Enhetstestprosesser

Flowable støtter forskjellige versjoner av JUnit, inkludert JUnit 5, for å lage enhetstester for forretningsprosesser. Flytbar integrasjon med Spring har også passende støtte for dette. La oss se en typisk enhetstest for en prosess på våren:

@ExtendWith (FlowableSpringExtension.class) @ExtendWith (SpringExtension.class) offentlig klasse ArticleWorkflowUnitTest {@Autowired private RuntimeService runtimeService; @Autowired privat TaskService taskService; @Test @Deployment (resources = {"prosesser / artikkel-arbeidsflyt.bpmn20.xml"}) ugyldig articleApprovalTest () {Mapvariabler = ny HashMap (); variables.put ("forfatter", "[e-postbeskyttet]"); variables.put ("url", "//baeldung.com/dummy"); runtimeService.startProcessInstanceByKey ("articleReview", variabler); Oppgaveoppgave = taskService.createTaskQuery (). SingleResult (); assertEquals ("Gå gjennom den innsendte veiledningen", task.getName ()); variables.put ("godkjent", sant); taskService.complete (task.getId (), variabler); assertEquals (0, runtimeService.createProcessInstanceQuery (). count ()); }}

Dette skal stort sett se ut som en standard enhetstest om våren, bortsett fra få merknader som @Utplassering. Nå, den @Utplassering kommentar er gitt av Flowable for å opprette og slette en prosessutplassering rundt testmetoder.

7. Forstå distribusjon av prosesser

Selv om vi ikke dekker detaljene i prosessutplassering i denne opplæringen, er det verdt å dekke noen aspekter som er viktige.

Typisk, prosesser arkiveres som Business Archive (BAR) og distribueres i en applikasjon. Mens det blir distribuert, skannes dette arkivet for gjenstander - som prosessdefinisjoner - og behandles. Du har kanskje lagt merke til konvensjonen for prosessdefinisjonsfilen som slutter med “.Bpmn20.xml”.

Mens vi har brukt standard H2-database i minnet i opplæringen vår, kan dette faktisk ikke brukes i en applikasjon fra den virkelige verden, av den enkle årsaken at en database i minnet ikke vil beholde noen data på tvers av oppstart og er praktisk talt umulig å bruke i et klynget miljø! Derfor, vi må bruke en produksjonsgrad relasjonsdatabase og oppgi de nødvendige konfigurasjonene i applikasjonen.

Mens BPMN 2.0 i seg selv ikke har noen forestilling om versjonering, Flowable oppretter et versjonsattributt for prosessen, som distribueres i databasen. Hvis en oppdatert versjon av den samme prosessen, som identifisert av attributtet "id", distribueres, opprettes en ny oppføring med versjonen som økes. Når vi prøver å starte en prosess med “id”, henter prosessmotoren den nyeste versjonen av prosessdefinisjonen som er distribuert.

Hvis vi bruker en av designerne vi diskuterte tidligere for å lage prosessdefinisjonen, har vi allerede en visualisering for prosessen vår. Vi kan eksportere prosessdiagrammet som et bilde og plassere det ved siden av XML-prosessdefinisjonsfilen. Hvis vi holder oss til standard navngivningskonvensjon foreslått av Flowable, vil dette bildet bli behandlet av prosessmotoren sammen med selve prosessen. Videre kan vi også hente dette bildet gjennom APIer!

8. Bla gjennom historikken til prosessforekomster

Det er ofte viktig når det gjelder forretningsprosesser å forstå hva som skjedde tidligere. Vi kan trenge dette for enkel feilsøking eller komplekse juridiske revisjonsformål.

Flowable registrerer hva som skjer gjennom prosessutførelsen og oppbevarer det i databasen. Videre gjør Flowable denne historikken tilgjengelig gjennom APIer for å spørre og analysere. Det er seks enheter under hvilke Flowable registrerer disse, og HistoryService har metoder for å spørre dem alle.

La oss se et enkelt spørsmål for å hente ferdige prosessforekomster:

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

Som vi kan se, API for å spørre innspilte data er ganske komponerbar. I dette eksemplet spør vi etter ferdige prosessforekomster etter ID og bestiller dem i stigende rekkefølge av sluttiden.

9. Overvåkingsprosesser

Overvåking er et sentralt aspekt av enhver virksomhetskritisk applikasjon, og enda mer for en applikasjon som håndterer forretningsprosesser i en organisasjon. Flowable har flere muligheter for å la oss overvåke prosesser i sanntid.

Flowable gir spesifikke MB-midler som vi kan få tilgang til over JMX, for ikke bare å samle inn data for overvåking, men også å utføre mange andre aktiviteter. Vi kan integrere dette med hvilken som helst standard JMX-klient, inkludert jconsole, som er tilstede sammen med standard Java-distribusjoner.

Å bruke JMX for overvåking åpner mange alternativer, men er relativt komplisert og tidkrevende. Siden vi bruker Spring Boot, har vi imidlertid hell!

Spring Boot tilbyr Actuator Endpoints for å samle applikasjonsberegninger over HTTP. Vi kan sømløst integrere dette med en verktøystabel som Prometheus og Grafana for å lage et overvåkingsverktøy av produksjonsklasse med minimal innsats.

Flowable gir et ekstra Actuator Endpoint som avslører informasjon om prosessene som kjører. Dette er ikke så bra som å samle informasjon gjennom JMX, men det er raskt, enkelt og, mest av alt, tilstrekkelig.

10. Konklusjon

I denne opplæringen diskuterte vi forretningsprosesser og hvordan vi kan definere dem i BPMN 2.0-standarden. Deretter diskuterte vi mulighetene til Flowable process engine og APIer for å distribuere og utføre prosesser. Vi så hvordan vi kan integrere dette i et Java-program, spesielt i Spring Boot.

Fortsatt videre diskuterte vi andre viktige aspekter av prosesser som distribusjon, visualisering og overvåking. Det er unødvendig å si at vi nettopp har skrapet overflaten av forretningsprosessen og en kraftig motor som Flowable. Flowable har en veldig rik API med tilstrekkelig dokumentasjon tilgjengelig. Denne veiledningen burde imidlertid ha vekket vår interesse for emnet!

Som alltid er koden for eksemplene tilgjengelig på GitHub.