Bevezetés az Activiti tavasszal

1. Áttekintés

Egyszerűen fogalmazva, Az Activiti egy munkafolyamat- és üzleti folyamatkezelő platform.

Gyorsan elkezdhetjük a ProcessEngineConfiguration (általában egy konfigurációs fájl alapján). Ebből megszerezhetjük a ProcessEngine - és a ProcessEngine, munkafolyamat- és BPM-műveleteket hajthatunk végre.

Az API különféle szolgáltatásokat nyújt, amelyek felhasználhatók a folyamatok eléréséhez és kezeléséhez. Ezek a szolgáltatások információkat nyújthatnak nekünk a folyamatok történetéről, a jelenleg futó folyamatokról és a telepített, de még nem futó folyamatokról.

A szolgáltatások felhasználhatók a folyamat struktúrájának meghatározására és a folyamat állapotának manipulálására is, azaz futtatásra, felfüggesztésre, törlésre stb.

Ha még nem ismeri az API-t, nézze meg a mi oldalunkat Bevezetés az Activiti API-ba Java-val. Ebben a cikkben megvitatjuk, hogyan állíthatjuk be az Activiti API-t a Spring Boot alkalmazáson belül.

2. Beállítás tavaszi indítással

Nézzük meg, hogyan állíthatjuk be az Activiti-t Spring Boot Maven alkalmazásként, és hogyan kezdhetjük el használni.

2.1. Kezdeti beállítás

Szokás szerint hozzá kell adnunk a maven függőséget:

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

Az API legújabb stabil verziója itt található. A Spring Boot alkalmazással felfelé működik az 1.5.4-es verzióig. Még nem működik a v2.0.0.M1 verzióval.

Generálhatunk egy Spring Boot projektet is a //start.spring.io fájl segítségével, és az Activiti-t választhatjuk függőségként.

Csak hozzáadva ezt a függőséget és a @EnableAutoConfiguration a Spring Boot alkalmazás kommentárja, akkor elvégzi a kezdeti beállítást:

  • Adatforrás létrehozása (Az API létrehozásához adatbázisra van szükség az ProcessEngine)
  • Hozza létre és tegye ki a ProcessEngine bab
  • Hozza létre és tegye közzé az Activiti szolgáltatás babjait
  • Hozza létre a Tavaszi Munka Végrehajtót

2.2. Folyamat létrehozása és futtatása

Készítsünk egy példát egy üzleti folyamat létrehozására és futtatására.

A folyamat definiálásához létre kell hoznunk egy BPMN fájlt. Ehhez a //activiti.alfresco.com/activiti-app/editor fájlt használhatjuk a folyamatdefiníció létrehozásához.

Ezután töltse le a BPMN fájlt. Ezt a fájlt be kell tennünk a src / main / erőforrások / folyamatok mappába. Alapértelmezés szerint a Spring Boot ebben a mappában keresi a folyamatdefiníció telepítését.

Létrehozunk egy bemutató folyamatot, amely egy felhasználói feladatot tartalmaz:

A felhasználói feladat kijelöltje a folyamat kezdeményezőjeként van beállítva. A folyamatdefiníció BPMN-fájlja a következőképpen néz ki:

Most létrehozunk egy REST vezérlőt a folyamat elindításához szükséges kérések kezelésére:

@Autowired private RuntimeService runtimeService; @GetMapping ("/ start-process") public String startProcess () {runtimeService.startProcessInstanceByKey ("my-process"); return "Folyamat elindult. Jelenleg futó" + "folyamatpéldányok száma =" + runtimeService.createProcessInstanceQuery (). count (); }

Itt, runtimeService.startProcessInstanceByKey („saját folyamat”) megkezdi annak a folyamatnak a végrehajtását, amelynek kulcsa van „Én-folyamatom”. runtimeService.createProcessInstanceQuery (). count () megkapja a folyamatpéldányok számát.

Valahányszor eljutunk az ösvényre „/ Start-process”, egy új ProcessInstance létrejön, és növekedést fogunk látni a jelenleg futó folyamatok számában.

Egy JUnit teszteset ezt a viselkedést mutatja meg nekünk:

@Test public void givenProcess_whenStartProcess_thenIncreaseInProcessInstanceCount () dobja a Kivételt {String responseBody = this.mockMvc .perform (MockMvcRequestBuilders.get ("/ start-process")) .andReturn (). GetResponent (As). assertEquals ("Folyamat elindult. Jelenleg futó" + "folyamatpéldányok száma = 1", responseBody); responseBody = this.mockMvc .perform (MockMvcRequestBuilders.get ("/ start-process")) .andReturn (). getResponse (). getContentAsString (); assertEquals ("Folyamat elindult. Jelenleg futó" + "folyamatpéldányok száma = 2", responseBody); responseBody = this.mockMvc .perform (MockMvcRequestBuilders.get ("/ start-process")) .andReturn (). getResponse (). getContentAsString (); assertEquals ("Folyamat elindult. Jelenleg futó" + "folyamatpéldányok száma = 3", responseBody); } 

3. Játék folyamatokkal

Most, hogy az Activiti-n futó folyamatunk van a Spring Boot használatával, bővítsük ki a fenti példát, hogy bemutassuk, hogyan férhetünk hozzá és hogyan kezelhetjük a folyamatot.

3.1. Szerezd meg a listát Feladatok egy adottért ProcessInstance

Két felhasználói feladatunk van A és B. Amikor elindítunk egy folyamatot, az megvárja az első feladatot A befejezni, majd végrehajtani a feladatot B. Hozzunk létre egy kezelő metódust, amely elfogadja az adott feladatok megtekintéséhez szükséges kéréseket processInstance.

A tárgyak, mint például Feladat, nem lehet közvetlenül válaszként elküldeni, ezért létre kell hoznunk egy egyedi objektumot, és meg kell alakítanunk a Feladat egyedi tárgyunkhoz. Hívjuk ezt az osztályt TaskReprezentáció:

osztály FeladatReprezentáció {privát karakterlánc azonosító; privát karakterlánc neve; privát karakterlánc-folyamatInstanceId; // szabványos kivitelezők}

A kezelő módszer a következőképpen fog kinézni:

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

Itt, taskService.createTaskQuery (). processInstanceId (processInstanceId) .list () használ TaskService és megkapja az adott feladatok listáját processInstanceId. Láthatjuk, hogy amikor elkezdjük futtatni az általunk létrehozott folyamatot, megkapjuk a feladatot A kérelmet intézve az imént definiált módszerhez:

@Test public void givenProcess_whenProcessInstance_thenReceivedRunningTask () dobja a Kivételt {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-task /" + pi.getId ())) .andReturn () .getResponse () .getContentAsString (); ObjectMapper mapper = új ObjectMapper (); Feladatok listája = Arrays.asList (mapper .readValue (responseBody, TaskRepresentation []. Osztály)); assertEquals (1, feladatok.méret ()); assertEquals ("A", feladatok.get (0) .getName ()); }

3.2. Teljesítése a Feladat

Most meglátjuk, mi történik, ha elvégezzük a feladatot A. Létrehozunk egy kezelő metódust, amely a feladat végrehajtására vonatkozó kéréseket kezeli A az adott számára processInstance:

@GetMapping ("/ complete-task-A / {processInstanceId}") public void completeTaskA (@PathVariable String processInstanceId) {Feladat task = taskService.createTaskQuery () .processInstanceId (processInstanceId) .singleResult (); taskService.complete (task.getId ()); }

taskService.createTaskQuery (). processInstanceId (processInstanceId) .singleResult () létrehoz egy lekérdezést a feladat szolgáltatáson, és megadja nekünk az adott feladatát processInstance. Ez a A felhasználói feladat. A következő sor taskService.complete (task.getId) elvégzi ezt a feladatot.

Ezért most a folyamat a végéhez ért és a RuntimeService nem tartalmaz semmit ProcessInstances. Ezt a JUnit teszteset segítségével láthatjuk:

@Test public void givenProcess_whenCompleteTaskA_thenNoProcessInstance () dobja a Kivételt {this.mockMvc.perform (MockMvcRequestBuilders.get ("/ start-process")). ProcessInstance pi = runtimeService.createProcessInstanceQuery () .orderByProcessInstanceId () .desc () .list () .get (0); this.mockMvc.perform (MockMvcRequestBuilders.get ("/ complete-task-A /" + pi.getId ())) .andReturn () .getResponse () .getContentAsString (); Lista lista = runtimeService.createProcessInstanceQuery (). List (); assertEquals (0, list.size ()); }

Így használhatjuk az Activiti szolgáltatásokat a folyamatokkal.

4. Következtetés

Ebben a cikkben áttekintettük az Activiti API Spring Boot használatát. További információ az API-ról a felhasználói útmutatóban található. Láttuk azt is, hogyan hozhatunk létre folyamatot és hajthatunk végre rajta különféle műveleteket az Activiti szolgáltatások segítségével.

A Spring Boot megkönnyíti a használatát, mivel nem kell aggódnunk az adatbázis létrehozása, a folyamatok telepítése vagy az ProcessEngine.

Ne feledje, hogy az Activiti és a Spring Boot integrációja még mindig kísérleti szakaszban van, és a Spring Boot 2 még nem támogatja.

Mint mindig, az összes látott példa megvalósítása megtalálható a GitHubon.