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.