Chapter 10: Reactive Cloud-Native Applications

Up until now, we have mainly talked about traditional cloud-native applications that adopt imperative programming with clearly defined input and output. Imperative programming is the oldest programming paradigm. Applications using this paradigm are built using a clearly defined sequence of instructions making it easier to understand. Its architecture requires that the connection services are predefined.

However, sometimes, a cloud-native application does not know which services it should call. Its purpose might be just sending or receiving messages or events and staying responsive and reactive. Thus, imperative programming no longer applies to these kinds of applications. Under such circumstances, you will need to rely on reactive programing and use an event-driven architecture to achieve reactive, responsive, and message-driven applications. We will discuss reactive cloud-native applications in this chapter.

First, you will learn...

Differentiating between imperative and reactive applications

When developing imperative applications, the application developers define how to perform a task. You may design a synchronous application to start with. However, to deal with heavy loads and improve performance, you might think about switching from synchronous programming to asynchronous programming to speed up by performing multiple tasks in parallel. When using synchronous programming, on hitting block I/O, a thread has to wait, and no other tasks can be performed on that thread. However, in the case of asynchronous programming, multiple threads can be dispatched to perform other tasks if one thread is blocked.

Asynchronous programming dispatches multiple threads but it does not fix the blocking I/O issues. If there are blockages, eventually the application will consume all threads. Consequently, the application will run out of resources. One of the characteristics of imperative programming is that one application needs...

Using MicroProfile Context Propagation to manage context

MicroProfile Context Propagation (https://download.eclipse.org/microprofile/microprofile-context-propagation-1.2/) defines a mechanism for propagating context from the current thread to a new thread. The types of context include the following:

• Application: This normally includes the thread context class loader as well as java:comp, java:module, and java:app.
• CDI: The scope of the CDI context, such as SessionScoped and ConversationScoped, is still active in the new unit of work, such as a new CompeletionStage.
• Security: This includes the credentials that are associated with the current thread.
• Transaction: This is the active transaction scope that is associated with the current thread. This context is not normally expected to be propagated, but cleared instead.

Apart from the aforementioned context, an application can introduce custom context if needed.

To propagate the aforementioned context, this...

Using MicroProfile Reactive Messaging to build a reactive application

MicroProfile Reactive Messaging 2.0 (https://download.eclipse.org/microprofile/microprofile-reactive-messaging-2.0/) provides a mechanism for building event-driven cloud-native applications. It enables decoupling between the services via messaging. MicroProfile Reactive Messaging provides the @Outgoing annotation for publishing messages and @Incoming for consuming messages. The following figure illustrates how messages travel from the publisher (Method A) to the consumer (Method B). The message can be sent to a messaging store, such as Apache Kafka, MQ, and so on, and will then be delivered to a consumer such as Method B:

Figure 10.1 – Messaging flow

In Reactive Messaging, CDI beans are used to produce, process, and consume messages. These messages can be sent and received via remote brokers or various message transport layers such as Apache Kafka, MQ, and so on. Let's discuss...

Summary

In this chapter, we have learned the differences between imperative and reactive applications. We discussed briefly how to use MicroProfile Context Propagation to propagate contexts for asynchronous programming and then covered MicroProfile Reactive Messaging concepts to discuss how to use Reactive Messaging to create a reactive cloud-native application. Through this chapter, you will now be able to connect the built application with your chosen messaging technologies such as Apache Kafka. You also now understand that whenever you need to create a message-driven application, you should consider using MicroProfile Reactive Messaging.

In the next chapter, we will cover MicroProfile GraphQL to learn how to use GraphQL in your cloud-native applications to improve performance if you need to frequently execute queries.