Pengenalan kepada Flowable

1. Gambaran keseluruhan

Flowable adalah mesin proses perniagaan yang ditulis di Jawa. Dalam tutorial ini, kita akan membahas perincian proses perniagaan dan memahami bagaimana kita dapat memanfaatkan Flowable Java API untuk membuat dan menyebarkan contoh proses perniagaan.

2. Memahami Proses Perniagaan

Secara sederhana, Proses Perniagaan adalah sekumpulan tugas yang, setelah selesai dalam urutan yang ditentukan, mencapai objektif yang ditentukan . Setiap tugas dalam Proses Perniagaan mempunyai input dan output yang jelas. Tugas-tugas ini mungkin memerlukan campur tangan manusia atau dapat sepenuhnya automatik.

OMG (Object Management Group) telah menetapkan standard yang disebut Business Process Model and Notation (BPMN) bagi perniagaan untuk menentukan dan menyampaikan prosesnya . BPMN telah disokong dan diterima secara meluas dalam industri ini. Flowable API menyokong penuh membuat dan menggunakan definisi proses BPMN 2.0.

3. Membuat Definisi Proses

Anggaplah kita mempunyai proses mudah untuk semakan artikel sebelum diterbitkan.

Inti dari proses ini ialah pengarang mengemukakan artikel, dan para penyunting sama ada menerima atau menolaknya. Sekiranya diterima, artikel itu segera diterbitkan; namun, jika ditolak, pengarang diberitahu melalui e-mel:

Kami membuat definisi proses sebagai fail XML menggunakan standard BPMN 2.0 XML.

Mari tentukan proses mudah kami mengikut standard BPMN 2.0:

Sekarang, terdapat sebilangan besar elemen di sini yang merupakan item XML standard, sementara yang lain khusus untuk BPMN 2.0:

  • The keseluruhan proses dibalut di dalam tag yang dipanggil "proses", yang seterusnya, adalah sebahagian daripada tag yang dipanggil "definisi"
  • Proses terdiri daripada peristiwa, aliran, tugas, dan pintu masuk
  • Acara adalah acara permulaan atau acara akhir
  • Aliran (dalam contoh ini, aliran urutan) menghubungkan elemen lain seperti peristiwa dan tugas
  • Tugas adalah di mana kerja sebenar dilakukan; ini boleh menjadi "tugas pengguna" atau "tugas perkhidmatan", antara lain
  • Tugas pengguna memerlukan pengguna manusia untuk berinteraksi dengan Flowable API dan mengambil tindakan
  • Tugas perkhidmatan mewakili tugas automatik, yang dapat menjadi panggilan ke kelas Java atau bahkan panggilan HTTP
  • Gerbang dijalankan berdasarkan atribut "disetujui"; ini dikenali sebagai pemboleh ubah proses , dan kita akan melihat cara menetapkannya kemudian

Walaupun kita dapat membuat fail definisi proses di mana-mana editor teks, ini bukan cara yang paling mudah. Nasib baik, Flowable juga dilengkapi dengan pilihan antara muka pengguna untuk melakukan ini menggunakan plugin Eclipse atau Aplikasi Web. Sekiranya anda menggunakan IntelliJ, terdapat juga plugin IntelliJ.

4. Bekerja dengan Flowable API

Sekarang setelah kami menentukan proses mudah kami dalam fail XML mengikut standard BPMN 2.0, kami memerlukan cara untuk mengirimkan dan menjalankannya. Flowable menyediakan Process Engine API untuk berinteraksi dengan Flowable Engines . Flowable sangat fleksibel dan menawarkan beberapa cara untuk menggunakan API ini.

Memandangkan Flowable adalah API Java, kita dapat memasukkan mesin proses dalam aplikasi Java apa pun dengan memasukkan file JAR yang diperlukan. Kami dapat memanfaatkan Maven dengan baik untuk menguruskan pergantungan ini.

Lebih-lebih lagi, Flowable dilengkapi dengan API gabungan untuk berinteraksi dengan Flowable melalui HTTP. Kita boleh menggunakan API ini untuk melakukan apa sahaja yang mungkin dilakukan melalui Flowable API.

Akhirnya, Flowable mempunyai sokongan yang sangat baik untuk penyatuan dengan Spring and Spring Boot! Kami akan menggunakan integrasi Flowable dan Spring Boot dalam tutorial kami.

5. Membuat Aplikasi Demo dengan Process Engine

Sekarang mari kita buat aplikasi mudah yang membungkus mesin proses dari Flowable dan menawarkan API berasaskan HTTP untuk berinteraksi dengan Flowable API. Mungkin ada aplikasi web atau mudah alih yang berada di atas API untuk menjadikan pengalaman lebih baik, tetapi kami akan melupakannya untuk tutorial ini.

Kami akan membuat demo kami sebagai aplikasi Spring Boot.

5.1. Kebergantungan

Pertama, mari kita lihat kebergantungan yang perlu kita tarik dari Maven:

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

Pergantungan yang kami perlukan semuanya boleh didapati di Maven Central:

  • Spring Boot Starter untuk Web - ini adalah starter standard untuk Spring Boot
  • Flowable Starter untuk Spring Boot - ini diperlukan untuk Spring Boot Flowable Engines
  • Pangkalan Data H2 - Flowable memerlukan pangkalan data untuk menyimpan data, dan H2 adalah pangkalan data ingatan lalai

5.2. Definisi Proses

Semasa kami memulakan aplikasi Spring Boot kami, ia akan memuat secara automatik semua definisi proses yang ada di bawah folder "sumber / proses". Oleh itu, mari kita buat fail XML dengan definisi proses yang kita buat di atas, dengan nama "article-workflow.bpmn20.xml", dan letakkan di folder itu.

5.3. Konfigurasi

Seperti yang kita sedia maklum bahawa Spring Boot mengambil pendekatan yang sangat berpengaruh terhadap konfigurasi aplikasi, itu berlaku untuk Flowable sebagai sebahagian dari Spring Boot juga. Sebagai contoh, mengesan H2 sebagai satu-satunya pemacu pangkalan data di classpath, Flowable secara automatik mengkonfigurasinya untuk digunakan .

Jelas, setiap aspek yang dapat dikonfigurasi dapat dikonfigurasi dengan cara tersuai melalui sifat aplikasi. Walau bagaimanapun, untuk tutorial ini, kami akan mematuhi lalai!

5.4. Perwakilan Java

In our process definition, we've used a couple of Java classes that are supposed to be invoked as parts of service tasks. These classes implement the JavaDelegate interface and are known as Java Delegates in Flowable. We'll now define dummy classes for these Java Delegates:

public class PublishArticleService implements JavaDelegate { public void execute(DelegateExecution execution) { System.out.println("Publishing the approved article."); } }
public class SendMailService implements JavaDelegate { public void execute(DelegateExecution execution) { System.out.println("Sending rejection mail to author."); } }

Obviously, we must replace these dummy classes with actual services to publish an article or send an email.

5.5. HTTP APIs

Finally, let's create some endpoints to interact with the process engine and work with the process we've defined.

We'll begin by defining a controller exposing three endpoints:

@RestController public class ArticleWorkflowController { @Autowired private ArticleWorkflowService service; @PostMapping("/submit") public void submit(@RequestBody Article article) { service.startProcess(article); } @GetMapping("/tasks") public List getTasks(@RequestParam String assignee) { return service.getTasks(assignee); } @PostMapping("/review") public void review(@RequestBody Approval approval) { service.submitReview(approval); } }

Our controller exposes endpoints to submit an article for review, fetch a list of articles to review, and finally, to submit a review for an article. Article and Approval are standard POJOs that can be found in the repository.

We are actually delegating most of the work to ArticleWorkflowService:

@Service public class ArticleWorkflowService { @Autowired private RuntimeService runtimeService; @Autowired private TaskService taskService; @Transactional public void startProcess(Article article) { Map variables = new HashMap(); variables.put("author", article.getAuthor()); variables.put("url", article.getUrl()); runtimeService.startProcessInstanceByKey("articleReview", variables); } @Transactional public List getTasks(String assignee) { List tasks = taskService.createTaskQuery() .taskCandidateGroup(assignee) .list(); return tasks.stream() .map(task -> { Map variables = taskService.getVariables(task.getId()); return new Article(task.getId(), (String) variables.get("author"), (String) variables.get("url")); }) .collect(Collectors.toList()); } @Transactional public void submitReview(Approval approval) { Map variables = new HashMap(); variables.put("approved", approval.isStatus()); taskService.complete(approval.getId(), variables); } }

Now, most of the code here is pretty intuitive, but let's understand the salient points:

  • RuntimeService to instantiate the process for a particular submission
  • TaskService to query and update tasks
  • Wrapping all database calls in transactions supported by Spring
  • Storing details like author and URL, among others, in a Map, and saving with the process instance; these are known as process variables, and we can access them within a process definition, as we saw earlier

Now, we're ready to test our application and process engine. Once we start the application, we can simply use curl or any REST client like Postman to interact with the endpoints we've created.

6. Unit Testing Processes

Flowable supports different versions of JUnit, including JUnit 5, for creating unit tests for business processes. Flowable integration with Spring has suitable support for this as well. Let's see a typical unit test for a process in Spring:

@ExtendWith(FlowableSpringExtension.class) @ExtendWith(SpringExtension.class) public class ArticleWorkflowUnitTest { @Autowired private RuntimeService runtimeService; @Autowired private TaskService taskService; @Test @Deployment(resources = { "processes/article-workflow.bpmn20.xml" }) void articleApprovalTest() { Map variables = new HashMap(); variables.put("author", "[email protected]"); variables.put("url", "//baeldung.com/dummy"); runtimeService.startProcessInstanceByKey("articleReview", variables); Task task = taskService.createTaskQuery().singleResult(); assertEquals("Review the submitted tutorial", task.getName()); variables.put("approved", true); taskService.complete(task.getId(), variables); assertEquals(0, runtimeService.createProcessInstanceQuery().count()); } }

This should pretty much look like a standard unit test in Spring, except for few annotations like @Deployment. Now, the @Deployment annotation is provided by Flowable to create and delete a process deployment around test methods.

7. Understanding the Deployment of Processes

While we'll not cover the details of process deployment in this tutorial, it is worthwhile to cover some aspects that are of importance.

Typically, processes are archived as Business Archive (BAR) and deployed in an application. While being deployed, this archive is scanned for artifacts — like process definitions — and processed. You may have noticed the convention of the process definition file ending with “.bpmn20.xml”.

While we've used the default in-memory H2 database in our tutorial, this actually cannot be used in a real-world application, for the simple reason that an in-memory database will not retain any data across start-ups and is practically impossible to use in a clustered environment! Hence, we must use a production-grade relational database and provide the required configurations in the application.

While BPMN 2.0 itself does not have any notion of versioning, Flowable creates a version attribute for the process, which is deployed in the database. If an updated version of the same process, as identified by the attribute “id”, is deployed, a new entry is created with the version being incremented. When we try to start a process by “id”, the process engine fetches the latest version of the process definition deployed.

If we use one of the designers we discussed earlier to create the process definition, we already have a visualization for our process. We can export the process diagram as an image and place it alongside the XML process definition file. If we stick to the standard naming convention suggested by Flowable, this image will be processed by the process engine along with the process itself. Moreover, we can fetch this image through APIs as well!

8. Browsing History of Process Instances

It is often of key importance in the case of business processes to understand what happened in the past. We may need this for simple debugging or complex legal auditing purposes.

Flowable records what happens through the process execution and keeps it in the database. Moreover, Flowable makes this history available through APIs to query and analyze. There are six entities under which Flowable records these, and the HistoryService has methods to query them all.

Let's see a simple query to fetch finished process instances:

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

As we can see, the API to query recorded data is pretty composable. In this example, we're querying finished process instances by ID and ordering them in ascending order of their end time.

9. Monitoring Processes

Monitoring is a key aspect of any business-critical application, and even more so for an application handling business processes of an organization. Flowable has several options to let us monitor processes in real time.

Flowable provides specific MBeans that we can access over JMX, to not only gather data for monitoring but to perform many other activities as well. We can integrate this with any standard JMX client, including jconsole, which is present alongside standard Java distributions.

Using JMX for monitoring opens a lot of options but is relatively complex and time-consuming. However, since we're using Spring Boot, we're in luck!

Spring Boot offers Actuator Endpoints to gather application metrics over HTTP. We can seamlessly integrate this with a tool stack like Prometheus and Grafana to create a production-grade monitoring tool with minimal effort.

Flowable provides an additional Actuator Endpoint exposing information about the running processes. This is not as good as gathering information through JMX, but it is quick, easy and, most of all, sufficient.

10. Conclusion

In this tutorial, we discussed business processes and how to define them in the BPMN 2.0 standard. Then, we discussed the capabilities of Flowable process engine and APIs to deploy and execute processes. We saw how to integrate this in a Java application, specifically in Spring Boot.

Melanjutkan lebih jauh, kami membincangkan aspek penting proses lain seperti penyebaran, visualisasi, dan pemantauannya. Tidak perlu dikatakan, kami baru sahaja menggaru permukaan proses perniagaan dan mesin yang kuat seperti Flowable. Flowable mempunyai API yang sangat kaya dengan dokumentasi yang mencukupi. Tutorial ini, bagaimanapun, seharusnya menarik minat kita terhadap subjek ini!

Seperti biasa, kod untuk contoh boleh didapati di GitHub.