streamalism.org

1. Overzicht

Simpel gezegd, Activiti is een workflow- en Business Process Management-platform.

We kunnen snel aan de slag door een ProcessEngineConfiguration (meestal gebaseerd op een configuratiebestand). Hieruit kunnen we een ProcessEngine - en via de Process Engine, we kunnen workflow- en BPM-bewerkingen uitvoeren.

De API biedt verschillende services die kunnen worden gebruikt om toegang te krijgen tot processen en deze te beheren. Deze services kunnen ons informatie verschaffen over de geschiedenis van processen, wat er momenteel wordt uitgevoerd en de processen die zijn geïmplementeerd maar nog niet worden uitgevoerd.

De services kunnen ook worden gebruikt om de processtructuur te definiëren en de status van het proces te manipuleren, d.w.z. uitvoeren, opschorten, annuleren, enz.

Als je nieuw bent bij de API, bekijk dan onze Inleiding tot Activiti API met Java. In dit artikel bespreken we hoe we Activiti API kunnen instellen binnen een Spring Boot-applicatie.

2. Installatie met Spring Boot

Laten we eens kijken hoe we Activiti kunnen instellen als een Spring Boot Maven-applicatie en deze kunnen gaan gebruiken.

2.1. Initiële setup

Zoals gewoonlijk moeten we de maven-afhankelijkheid toevoegen:

 org.activiti activiti-spring-boot-starter-basic 

De laatste stabiele versie van de API is hier te vinden. Het werkt met Spring Boot up tot v1.5.4. Het werkt nog niet met v2.0.0.M1.

We kunnen ook een Spring Boot-project genereren met //start.spring.io en Activiti als afhankelijkheid selecteren.

Gewoon door deze afhankelijkheid en de @EnableAutoConfiguration annotatie bij de Spring Boot-applicatie, het zal de eerste installatie uitvoeren:

• Create Datasource (De API vereist een database om het ProcessEngine)
• Maak en stel het ProcessEngine Boon
• Maak en stel de bonen van Activiti-services beschikbaar
• Maak de Spring Job Executor

2.2. Een proces maken en uitvoeren

Laten we een voorbeeld maken van het maken en uitvoeren van een bedrijfsproces.

Om een ​​proces te definiëren, moeten we een BPMN-bestand maken. Hiervoor kunnen we //activiti.alfresco.com/activiti-app/editor gebruiken om een ​​procesdefinitie te maken.

Download dan gewoon het BPMN-bestand. We zullen dit bestand in de src / main / resources / processen map. Spring Boot zoekt standaard in deze map om de procesdefinitie te implementeren.

We maken een demoproces met de taken van één gebruiker:

De toegewezen persoon van de gebruikerstaak wordt ingesteld als de initiator van het proces. Het BPMN-bestand voor deze procesdefinitie ziet er als volgt uit:

Nu gaan we een REST-controller maken om verzoeken om dit proces te starten af ​​te handelen:

@Autowired privé RuntimeService runtimeService; @GetMapping ("/ start-process") openbare String startProcess () {runtimeService.startProcessInstanceByKey ("mijn-proces"); retourneer "Proces gestart. Aantal actieve" + "procesinstanties =" + runtimeService.createProcessInstanceQuery (). count (); }

Hier, runtimeService.startProcessInstanceByKey ("mijn-proces") start de uitvoering van het proces waarvan de sleutel is "Mijn-proces". runtimeService.createProcessInstanceQuery (). count () geeft ons het aantal procesinstanties.

Elke keer dat we op het pad kwamen "/ Start-proces", een nieuwe ProcessInstance wordt gemaakt en we zien een toename in het aantal lopende processen.

Een JUnit-testcase laat ons dit gedrag zien:

@Test openbare ongeldig gegevenProcess_whenStartProcess_thenIncreaseInProcessInstanceCount () genereert uitzondering {String responseBody = this.mockMvc .perform (MockMvcRequestBuilders.get ("/ start-process")) .andReturn (). GetResponse (). GetContentAsString (). GetContentAsString (). GetContentAsString (). GetContentAsString (). assertEquals ("Proces gestart. Aantal actieve" + "procesinstanties = 1", responseBody); responseBody = this.mockMvc .perform (MockMvcRequestBuilders.get ("/ start-process")) .andReturn (). getResponse (). getContentAsString (); assertEquals ("Proces gestart. Aantal actieve" + "procesinstanties = 2", responseBody); responseBody = this.mockMvc .perform (MockMvcRequestBuilders.get ("/ start-process")) .andReturn (). getResponse (). getContentAsString (); assertEquals ("Proces gestart. Aantal actieve" + "procesinstanties = 3", responseBody); } 

3. Spelen met processen

Nu we een lopend proces hebben in Activiti met Spring Boot, laten we het bovenstaande voorbeeld uitbreiden om te demonstreren hoe we het proces kunnen openen en manipuleren.

3.1. Download de lijst met Taken voor een gegeven ProcessInstance

We hebben twee gebruikerstaken EEN en B. Wanneer we een proces starten, wacht het op de eerste taak EEN moet worden voltooid en zal vervolgens de taak uitvoeren B. Laten we een handlermethode maken die verzoeken accepteert om de taken met betrekking tot een gegeven te bekijken processInstance.

De objecten, zoals Taak, kan niet rechtstreeks als antwoord worden verzonden en daarom moeten we een aangepast object maken en het Taak naar ons aangepaste object. We zullen deze klas bellen TaskRepresentation:

klasse TaskRepresentation {privé String-id; private String naam; private String processInstanceId; // standaard constructeurs}

De handlermethode ziet er als volgt uit:

@GetMapping ("/ get-taken / {processInstanceId}") openbare lijst getTasks (@PathVariable String processInstanceId) {List usertasks = taskService.createTaskQuery () .processInstanceId (processInstanceId) .list (); retourneer usertasks.stream () .map (task -> nieuwe TaskRepresentation (task.getId (), task.getName (), task.getProcessInstanceId ())) .collect (Collectors.toList ()); } 

Hier, taskService.createTaskQuery (). processInstanceId (processInstanceId) .list () toepassingen TaskService en geeft ons de lijst met taken die verband houden met het gegeven processInstanceId. We kunnen zien dat wanneer we beginnen met het uitvoeren van het proces dat we hebben gemaakt, we de taak zullen krijgen EEN door een verzoek in te dienen bij de methode die we zojuist hebben gedefinieerd:

@Test openbare ongeldige gegevenProcess_whenProcessInstance_thenReceivedRunningTask () genereert uitzondering {this.mockMvc.perform (MockMvcRequestBuilders.get ("/ start-process")) .andReturn () .getResponse (); ProcessInstance pi = runtimeService.createProcessInstanceQuery () .orderByProcessInstanceId () .desc () .list () .get (0); String responseBody = this.mockMvc .perform (MockMvcRequestBuilders.get ("/ get-taken /" + pi.getId ())) .andReturn () .getResponse () .getContentAsString (); ObjectMapper-mapper = nieuwe ObjectMapper (); Lijsttaken = Arrays.asList (mapper .readValue (responseBody, TaskRepresentation []. Class)); assertEquals (1, taken.size ()); assertEquals ("A", taken.get (0) .getName ()); }

3.2. Een Taak

Nu zullen we zien wat er gebeurt als we de taak voltooien EEN. We maken een handlermethode die verzoeken afhandelt om de taak te voltooien EEN voor het gegeven processInstance:

@GetMapping ("/ complete-task-A / {processInstanceId}") openbare ongeldige completeTaskA (@PathVariable String processInstanceId) {Task task = taskService.createTaskQuery () .processInstanceId (processInstanceId) .singleResult (); taskService.complete (task.getId ()); }

taskService.createTaskQuery (). processInstanceId (processInstanceId) .singleResult () maakt een query op de taakservice en geeft ons de taak van het gegeven processInstance. Dit is de Gebruikerstaak A. De volgende regel taskService.complete (task.getId) voltooit deze taak.

Vandaar dat nu het proces het einde heeft bereikt en het RuntimeService bevat geen Procesomstandigheden. We kunnen dit zien aan de hand van de JUnit-testcase:

@Test openbare ongeldig gegevenProcess_whenCompleteTaskA_thenNoProcessInstance () genereert uitzondering {this.mockMvc.perform (MockMvcRequestBuilders.get ("/ start-process")) .andReturn () .getResponse (); ProcessInstance pi = runtimeService.createProcessInstanceQuery () .orderByProcessInstanceId () .desc () .list () .get (0); this.mockMvc.perform (MockMvcRequestBuilders.get ("/ complete-taak-A /" + pi.getId ())) .andReturn () .getResponse () .getContentAsString (); Lijst lijst = runtimeService.createProcessInstanceQuery (). Lijst (); assertEquals (0, list.size ()); }

Dit is hoe we Activiti-services kunnen gebruiken om met processen te werken.

4. Conclusie

In dit artikel hebben we het overzicht van het gebruik van de Activiti API met Spring Boot doorgenomen. Meer informatie over de API is te vinden in de gebruikershandleiding. We hebben ook gezien hoe we een proces kunnen maken en er verschillende bewerkingen op kunnen uitvoeren met Activiti-services.

Spring Boot maakt het gemakkelijk te gebruiken, omdat we ons geen zorgen hoeven te maken over het maken van de database, het implementeren van de processen of het maken van het ProcessEngine.

Houd er rekening mee dat de integratie van Activiti met Spring Boot zich nog in de experimentele fase bevindt en nog niet wordt ondersteund door Spring Boot 2.

Zoals altijd is de implementatie van alle voorbeelden die we hebben gezien te vinden op GitHub.