DEV Community: Germano Schneider

Reactive vs Servlet Stack

Germano Schneider — Wed, 10 Apr 2024 12:05:34 +0000

Introduction

Are you wondering what is the best stack to use when creating a new Spring Boot application? Well, if you don't have an answer, I believe I can help you through this article. First, let's establish that the goal of a stack is not to replace another, but to serve it's own unique purpose.

Let's take a look at the main differences between the Reactive and Servlet Stack as well as the ideal uses of each one.

What is a stack?

In the context of a Spring application, a stack is a resource package that determines the specific architecture, framework, etc. that an application requires. The Spring Framework has two different stacks:

Servlet Stack

This is a classic! It was created by Spring and is the most commonly used by developers around the world. It supports some Servlet Containers such as Tomcat, Jetty, and Undertown. For this stack, we develop our code with the Spring MVC Framework.

Synchronous and asynchronous calls can be used, but with the blocking/IO architecture. For every request, the user must wait for a response before proceeding. This model works over a thread pool, which is always incremented when there is a huge API call traffic. Consequently, you will have high hardware consumption when there is a large number of requests.

Reactive Stack

After some years, the Spring Framework 5 released the Reactive Stack. The objective of this stack was to allow the Spring applications to have a higher performance during huge traffic data and large concurrency. But how does it do this? The Reactive Stack possesses new features such as non-blocking/IO architecture, Servlet Container 3.1, Netty Server, Spring WebFlux Framework, etc. It operates on a 'less is more' principle, as it can attend to large concurrency utilizing fewer hardware resources.

What stack should I choose for my Spring application?

The anwser depends on your needs. When designing your application, you must ask yourself (or your team) some questions, such as:

How many requests am I waiting for?
Do I have a team prepared to work with this?
What is my budget?

Finding new professionals with extensive experience in reactive programming can sometimes be challenging. As a result, some companies may opt for alternative strategies or technologies that incur lower operational costs.

Reactive vs Servlet Stack

Let's reiterate that the purpose of these stacks is not to eliminate the other but to attend to specific needs.

Learning Path

The Servlet Stack caters to what developers are accustomed to developing presently, which is imperative code. It is easy to write, read and debug. In constrast, the Reactive Stack uses funcional programming, which requires a deeper understanding and the implementation of a more complex code.

Execution Model

There are two different execution models: The Reactive Stack applies an Event Loop, similar to NodeJS. It has the capacity to handle many requests from the client with only a few threads. All requests are processed in an event queue. When a new request is received, the thread is released and a callback is always registered. For the Servlet stack, however, we implement the Thread per Request Model to handle requests. This model works over a thread pool, blocking each incoming request on the Servlet API. Once the thread’s number runs out, we must wait until one of them is released. There is a significant amount of hardware resource consumption with this model.

Non-Blocking/IO vs Blocking/IO

The Blocking/IO is an architecture type utilized on the Servlet API. Although we are able to execute asynchronous operations with Spring MVC, it is limited when a request arrives at the Servlet API because the server will block all completed remote calls. The Reactive Stack brought the Servlet API 3.1 and the Netty Server, which both support Non-Blocking/IO processes, removing the need for the final user to wait for a response.

Conclusion

This was a short theoretical article written with the intention of emphasizing the importance of distinguishing between both Spring Stacks. Be mindful of data traffic volume as well as concurrency within the application when creating a new Spring application. This is crucial when reducing the cost and number of resources consumed.

References

Spring Conferences:

Official Documentation:

SSE - How to implement it with Spring Boot

Germano Schneider — Mon, 04 Mar 2024 21:47:41 +0000

Introduction

Have you ever heard about SSE (Server-Sent-Events) before? It is a one-way messaging technology that works over the HTTP protocol and you can send messages from the server to the client. So, every time there is available data, the client will receive and update it in real-time.

How it works:

SSE has unidirectional communication, only the server sends events to the client, the events are captured by the EventSource API from JavaScript, which the browser uses to listen to events (we'll discuss this in detail later in the article). Using SSE, it's not possible to send binary data, only messages. We can find some SSE use cases in weather, sports, stock exchange applications, and so on.

Is SSE the only option?

There is more than one option instead of SSE, but neither is better or worse than the other, it depends on your needs. Besides SSE, you can find some alternatives like WebSocket and event data pooling, but if you only need to get some received data from the server, maybe SSE could be the best choice. Let me explain to you the differences between both:

WebSocket
A little bit different from SSE, the WebSocket is a protocol that has bidirectional communication between the client and server. Besides messages, it's also possible to send binaries in the payload. Some WebSocket use cases are chat applications and multiplayer games, which both require full-duplex communication.
Event Data Pooling
Unlike SSE and WebSocket, the client should request data to the server, it usually takes more hardware resources because a lot of requests can be made until the server responds.

How is SSE implemented using Spring Boot?

Considering the article's focus is SSE, we will implement a practice example about how to use it in a Java Application, with the Spring Boot Framework.

We will use the Servlet Stack (MVC) because it's simple to understand and most developers are used to developing with imperative code. But, you can also implement it using the Reactive Stack (WebFlux).

Now, let's go straight to our use case.

Food Delivery

Let's try to understand how it works through a food delivery system. What we want to do is show the order progress to the user, the available statuses are: Order Placed, In the Kitchen, On the Way, and Delivered.

Considering it's only a prototype to illustrate an SSE use case, the system will take care of all order steps automatically.

Creating an SSE entry point

First of all, we need to declare an endpoint in our controller that returns a SseEmitter interface.

private final Collection<SseEmitter> emitters = new CopyOnWriteArrayList<>();

@GetMapping(path = "/order-status", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
SseEmitter orderStatus() {

   SseEmitter emitter = new SseEmitter(Long.MAX_VALUE);

   emitter.onCompletion(() -> emitters.remove(emitter));
   emitter.onTimeout(() -> emitters.remove(emitter));
   emitter.onError(throwable -> {
      emitters.remove(emitter);
      emitter.completeWithError(throwable);
   });

   emitters.add(emitter);

   return emitter;
}

In the interface signature, we put the media type as a TEXT_EVENT_STREAM_VALUE to send real-time events to the client. Our method body is composed of a new SseEmitter added to a concurrent list to make broadcast sending possible. We also declare some events callback whenever a completion, error, or timeout happens.

Declaring who needs to know about the order

Once we have connected users in our endpoint, how can we determine that an order has arrived and needs to be prepared? Well, considering we want to send events to the client when the order changes status, why not apply an observable pattern and notify all listeners after each change?

Let's create a listener and register all observables representing each order status.

@Component
public class OrderFoodListener {

    private final EventService eventService;

    private final Collection<Observer> observers;

    public OrderFoodListener(EventService eventService) {
        this.eventService = eventService;
        this.observers = List.of(
                new OrderObservable(eventService),
                new KitchenObservable(eventService),
                new OnTheWayObservable(eventService),
                new DeliveredObservable(eventService)
        );
    }

   public void notifyAll(OrderFood orderFood) {
        observers.forEach(foodObserver -> foodObserver.update(orderFood));
   }
}

Let me explain to you what is happening here:

Event Service Interface: It's a dependency inversion interface of the way we go to send the events (concrete class should be declared in our infrastructure layer)
Observers Collection: All observers that we want to notify when an order comes.
Notify Method: The notifyAll method will be called to notify all observers about a new order.

Notifying the the customer's order

As we can see in our previous coding block, there are four
observables subscribed, each one with its own business rules.

Let me show you how we are going to notify the customer:

An order is coming

if (orderFood.getStatus() == ORDER_PLACED) {

   sendEvent(orderFood, "order");
}

The order observable checks if the initial status is an order placed, if so it sends an event with the "order" event name.

It's going to the kitchen

if (orderFood.getStatus() == FoodStatus.ORDER_PLACED) {

   orderFood.setStatus(FoodStatus.IN_THE_KITCHEN);
   sendEvent(orderFood, "kitchen");
   waitForProcess();
}

After our order is placed, it goes to the kitchen, so here we need to check if the previous status is still the order placed, then we change it and send a "kitchen" event with the updated status.

OBS. The waitForProcess() method is a thread sleep declaration to simulate a kitchen duration process

Now it's up to the delivery person

if (orderFood.getStatus() == IN_THE_KITCHEN) {

   orderFood.setStatus(ON_THE_WAY);
   sendEvent(orderFood, "on-the-way");
   waitForProcess();
}

Before the order goes out, we need to check if it was in the kitchen, if so the user will be updated with the on-the-way status.

Finally, the order has arrived

if (orderFood.getStatus() == FoodStatus.ON_THE_WAY) {
    orderFood.setStatus(FoodStatus.DELIVERED);
    sendEvent(orderFood, "delivered");
}

Now it's time to celebrate and notify the user that it has arrived.

Receiving events on the client side

On the client side, the user will be waiting for order updates. So, let's implement it.

var eventSource = new EventSource("/order-status");

eventSource.addEventListener("order", (event) => renderEvent(event));

eventSource.addEventListener("kitchen", (event) => renderEvent(event));

eventSource.addEventListener("on-the-way", (event) => renderEvent(event));

eventSource.addEventListener("delivered", (event) => renderEvent(event));
}

We created a simple static HTML file and put some JavaScript to listen to all events from the server and print them on the screen.

Conclusion

I hope that in this article you were able to understand the main SSE concepts and know their differences between similar technologies. Additionally, we saw a practice example of how to implement it using the Spring Boot framework.

If you have any questions, please feel free to leave your comments below and I will try to help you.

I encourage you to check my GitHub repository and take a look at the whole code used in this article: https://github.com/GermanoSchneider/food-delivery-sse-app

Thank you, hope that I can see you next time.

References

https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events
https://www.youtube.com/watch?v=nxakp15CACY&t=2334s
https://www.youtube.com/watch?v=nxakp15CACY&t=2334s

Chunk vs Tasklet, which one should I use?

Germano Schneider — Wed, 07 Feb 2024 22:20:53 +0000

Introduction

Commonly we search for good alternatives when the content is high application data consumption. In Java development, we can use Spring Batch as a light and resilient option to execute daily schedulers to process a huge amount of data. In addition, it's possible to do it in small, medium, or even big batches to optimize the application memory consumption.

Part of the Spring Batch ecosystem is about step executions included in a job. So, there are two definition types for it, they are called Chunk and Tasklet. I will explain both in detail to you.

Chunk

Try to figure out a scenario where your application needs to read a thousand registers from a table that returns integer numbers, then you need to sort all data in ascending order. For example, if the returned number is 54321, it should be sorted to 12345. Finally, the processed data should be updated in the database.

Given this scenario, we can create a job that will execute ten separate batches, each executing a hundred registers each time. This way, the application will manage and process the data with little memory consumption.

@Bean
Step sortNumbersInNaturalOrderStep(JobRepository jobRepository, PlatformTransactionManager platformTransactionManager) {

    return new StepBuilder("sortNumbersInNaturalOrderStep", jobRepository)
     .<Map<Integer, Integer>, Map<Integer, Integer>>chunk(10, platformTransactionManager)
     .reader(cursorItemReader())
     .processor(new SortNumberProcessor())
     .writer(new NumberWriter(dataSource))
     .build();
}

As you can see, we have a step called sortNumbersInNaturalOrderStep, it has a chunk that will receive and process a map of integers, where the key is the ID, and the value will be the processed number. In addition, we are setting the item’s quantity (10) to be processed in each batch and also a transaction manager.

When we work with the chunk concept, we should attribute a reader, processor, and writer. To make it clearer, I will explain how each one works.

1. Reader

A reader should read the data from some specific source, it can be a JSON file or even a database. In our example we are setting a reader implementation from an abstraction offered by Spring Batch, it’s called JdbcCursorItemReader. It reads the data from a specific JDBC data source, which should be informed. In this example, we are getting all data from the numbers table in an H2-embedded database.

@Bean
JdbcCursorItemReader<Map<Integer, Integer>> cursorItemReader() {

    JdbcCursorItemReader<Map<Integer, Integer>> reader = new JdbcCursorItemReader<>();

    reader.setSql("SELECT * FROM numbers");
    reader.setDataSource(dataSource);
    reader.setRowMapper(new DatabaseRowMapper());

    return reader;
}

We are doing a SELECT statement in the database to find all the data. Note that we also set a DatabaseRowMapper, this is to map the received value from the database and transform it into a map of integers.

@Override
public Map<Integer, Integer> mapRow(ResultSet rs, int rowNum) throws SQLException {

      Map<Integer, Integer> map = new HashMap<>();

      map.put(rs.getInt("id"), rs.getInt("number"));

      return map;
}

The mapRow interface returns a map with the ID and number from the numbers table.

2. Processor

This is an optional configuration, we could only read the data and then write it, without having to inform a processor. But, for this example, we are setting a processor to sort each number that we received from the reader step.

@Override
public Map<Integer, Integer> process(Map<Integer, Integer> item) throws Exception {

      final Map<Integer, Integer> newMap = new HashMap<>();

      for (Map.Entry<Integer, Integer> mapValue : item.entrySet()) {

         Integer key = mapValue.getKey();
         Integer value = mapValue.getValue();

         List<String> numbers = new ArrayList<>(stream(value.toString()
                    .split(""))
                    .toList());

         numbers.sort(Comparator.naturalOrder());

         Integer newValue = parseInt(join("", numbers));

         newMap.put(key, newValue);
     }

     return newMap;
}

What we are doing here is getting each map, capturing the ID and number, and then sorting it to return a newly updated map with the all ordered numbers.

3. Writer

After the data is processed, it goes to the writer layer which will be responsible for updating the number on the database according to the given ID. The items are bonded in a list and then we iterate and update the captured value.

@Override
public void write(Chunk<? extends Map<Integer, Integer>> chunk) throws Exception {

        for (Map<Integer, Integer> value : chunk.getItems()) {

           for (Map.Entry<Integer, Integer> mapValue : value.entrySet())
              jdbcTemplate.update("UPDATE numbers SET number = (?) WHERE id = (?)", mapValue.getValue(), mapValue.getKey());
        }
}

Tasklet

Unlike the chunk’s concept, the tasklet step assumes the responsibility to execute a unique task individually. There’s no necessity to process the data in multiple batches. We can use, for example, a tasklet execution if we need to remove duplicated registers from the database.

@Override
public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {

      String sql = "DELETE FROM numbers t1 WHERE t1.id > (SELECT MIN(t2.id) FROM numbers t2 WHERE t1.number = t2.number)";

      jdbcTemplate.execute(sql);

      return RepeatStatus.FINISHED;
}

In the example above, we put a DELETE statement to remove all duplicated data from the database. So, the only thing that we need to do is invoke this step after the previous one.

Conclusion

It's not so difficult, is it? The purpose here was to share a little bit about the main concepts between Chunk and Tasklet. Please note that the task’s execution should be managed by you, the Spring Batch framework usually works with some common schedulers, like the Spring Scheduler, Control-M, and so on.

Do you still have questions or concerns about Chunk and Tasklet? Please, look at the official Spring Batch documentation to complement your knowledge about it, or leave your comment here, and I will try to help you.

To see the whole code used in this article, please take a look at my GitHub:

https://github.com/GermanoSchneider/spring-batch-overview

Thank you, see you next time.

References

https://docs.spring.io/spring-batch/reference/index.html