{"id":78042,"date":"2018-06-22T01:00:53","date_gmt":"2018-06-21T22:00:53","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/?p=78042"},"modified":"2023-12-11T12:15:03","modified_gmt":"2023-12-11T10:15:03","slug":"spring-reactor-tutorial","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2018\/06\/spring-reactor-tutorial.html","title":{"rendered":"Spring Reactor Tutorial"},"content":{"rendered":"

In the world of RESTful services where a lot of work actually happens behind the scenes, we often have to do much of the processing in our application which doesn’t actually affect the response which needs to be sent to a real-world user. These business decisions can be taken reactively<\/strong> so that they do not have any impact to a user interacting with the application. Spring Framework provides us with an excellent project, termed as Spring Reactor project which allows us to manage this background processing very well in the background. Before diving into the lesson, one thing we must note is that Reactive Programming is not same as concurrent programming<\/strong>.<\/p>\n

One of the use-cases in RESTful programming for reactive behaviour is that most of the times, services are fundamentally blocking and synchronous. Reactive Programming allows us to expand beyond the scope of synchronous thread and complex orchestrations can be done without demonstrating a blocking behaviour. Let us deep dive into the lesson to understand how this reactive behaviour can be integrated into a Spring Boot-based application.<\/p>\n

\n

Table Of Contents<\/h3>\n
\n
1. Introduction<\/a><\/dt>\n
2. Reactor in the JVM<\/a><\/dt>\n
3. Making the Spring Boot Project with Maven<\/a><\/dt>\n
4. Adding Maven dependencies<\/a><\/dt>\n
5. Project Structure<\/a><\/dt>\n
6. Understanding the sample application<\/a><\/dt>\n
7. Defining the POJO Model<\/a><\/dt>\n
8. Defining the Service<\/a><\/dt>\n
9. Defining the Event Consumer<\/a><\/dt>\n
10. Defining the Java Configuration<\/a><\/dt>\n
11. Defining the Spring Boot class<\/a><\/dt>\n
12. Running the project<\/a><\/dt>\n
13. Conclusion<\/a><\/dt>\n
14. Download the Source Code<\/a><\/dt>\n<\/dl>\n<\/div>\n

1. Introduction<\/h2>\n

In this Spring Reactor lesson, we will learn how we can get started with reactive behaviour in a Spring Boot project and start producing and consuming messages in the same application itself. Apart from a simple project, we will see how Spring Reactive flow works and how requests are managed when there are several handlers for the different type of requests.<\/p>\n

With the uprise of Microservices<\/a>, the necessity of asynchronous communication between the involved services became a mainstream requirement. For communication among various services involved, we can use projects like Apache Kafka<\/a>. Now, asynchronous communication is also desirable for time-consuming requests within the same application as well. This is where the actual use-case of Spring Reactor<\/strong> comes into play.<\/p>\n

Please note that Reactor pattern, as demonstrated in this application is to be used only when a user doesn’t expect a response directly from the application as we only execute background jobs using this Reactor demonstration. Using Reactors are a very good choice when it is possible for developers to assign a little more heap memory to the application (depending on the number of threads this app will use) and they want to execute tasks in parallel<\/strong> and order of execution of tasks<\/strong> doesn’t really matter. This point is important actually so we will say it again by rephrasing it, it is not possible to confirm the order of execution of jobs<\/strong> when they are executed in parallel.<\/p>\n

2. Reactor in the JVM<\/h2>\n

The Reactor, as stated by Spring<\/a> itself, is a foundational framework for asynchronous applications on the JVM which on modest hardware, makes it possible to process over 15,000,000 events per second<\/strong> with the fastest non-blocking Dispatcher<\/code>. As it sounds, the Reactor framework is based on the Reactor design pattern<\/a>.<\/p>\n

The most important thing about Spring Reactor is the level of abstraction this framework provides to a Java Developer developing applications using Spring. This abstraction makes implementing the functionality in our own application very easy. Let’s get started with a sample project to see how we can make use of this framework in a near to reality application. The reactor project also supports non-blocking inter-process communication (IPC) with the reactor-ipc components but its discussion is out of the scope for this lesson.<\/p>\n

3. Making the Spring Boot Project with Maven<\/h2>\n

We will be using one of the many Maven archetypes to create a sample project for our example. To create the project execute the following command in a directory that you will use as workspace:<\/p>\n

Creating a Project<\/em><\/span><\/p>\n

mvn archetype:generate -DgroupId=com.javacodegeeks.example -DartifactId=JCG-BootReactor-Example -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false\n<\/pre>\n
If you are running maven for the first time, it will take a few seconds to accomplish the generate command because maven has to download all the required plugins and artifacts in order to make the generation task. Once we run this project, we will see the following output and the project will be created:<\/p>\n
\"Spring<\/a>
Spring Reactor Project setup<\/figcaption><\/figure><\/p>\n
4. Adding Maven dependencies<\/h2>\n
Once you have created the project, feel free to open it in your favourite IDE. Next step is to add appropriate Maven Dependencies to the project. We will work with following dependencies in our project:<\/p>\n