Mastering Spring Reactive Programming for High Performance Web Apps: Revolutionize Your Asynchronous Application Development in Spring with Reactive Programming Principles, Spring WebFlux and Reactor

CHAPTER 1

Introduction to Spring Framework

Introduction

Since the evolution of Java, it has been continuously growing, and the Reactive or functional programming has been now introduced in newer versions of Java. Though it’s not exactly new, it’s quite some time since Java 9 was released. In this book, we will learn about reactive programming from basics to expertise level. At the end of this book, we will be able to implement core concepts of the Reactor framework in our day-to-day work. Here, we will start with the basics of the Spring framework and will end our journey with the Reactive Spring. On the way, we will pick up Reactor Core, Reactor Kafka, Reactor Test, and Netty libraries.

Structure

We will talk about the following topics in this chapter:

Introduction to Spring Framework

Modules in Spring Framework

Spring Boot

Features and Comparison between Spring Framework and Spring Boot

Features of Spring Framework 6

Spring Boot 3.0

Creating a New Application in Spring Boot 3

How to Upgrade an Application to Spring Boot 3 and Spring 6

Sample Project in Spring 6

Reactive in Java

Benefits of Reactive Programming

Introduction to Reactive Spring or WebFlux

Features of Spring WebFlux

Sample Hello-World Project in Reactive Spring

Spring WebFlux versus Spring MVC

Introduction to Spring Framework

The Spring Framework is one of the most popular frameworks for building standalone and production-ready applications that run on the Java Virtual Machine which we call JVM.

The most popular feature of Spring which is called dependency injection handles the dependencies so developers can only focus on the core logic rather than worrying about the required infrastructure. In Spring, we can build applications using "plain old Java objects" (POJOs) and implement enterprise-level services using POJOs. Once the dependencies are defined, Spring container later injects them whenever required. Spring supports modular applications as well, so we can have loosely coupled components that are best suited for microservices and distributed architectures.

It provides built-in libraries, such as Spring Data, Spring AOP, and so on, which can be used to perform different types of tasks in a shorter way. We have a built-in support to perform tasks such as data binding, type conversion, validation, exception handling, resource and event management, internationalization, and more. It integrates with different Java EE technologies such as Remote Method Invocation (RMI), Message Queuing Protocol, Web Services, and others.

In short, the Spring Framework provides developers with all the tools and features they need to create standalone, modular, and loosely coupled, cross-platform Java EE applications that can run in any environment.

Here are some examples of how application developers might utilize the benefits of the Spring Platform:

Without interacting with the Transaction API, you can run a Java function inside a database transaction.

Without requiring to deal with the remote API, turn a local Java method into a remote procedure.

Rather than requiring interaction with the JMX API, turn invoking a local Java method as a management task.

The JMS API allows you to create a message handler without requiring you to deal with a local Java method.

Spring Beans

Beans are the objects that make up the core of your application and are managed by Spring IoC. A bean is a Spring IoC object that is created, instantiated, and otherwise controlled by Spring.

If you annotate a class with the annotation @Configuration, Spring will be able to use the class as a source for bean definitions. The annotation @Bean tells Spring that a class annotated with @Bean method returns an object that Spring will register as a bean in its application context. The most basic class that can be annotated with the attribute @Configuration is the following:

@Configuration

public class BeanConfiguration {

@Bean

public MyBean myBean(){

return new MyBean();

}

}

Inversion of Control (IoC) in Spring

A software engineering concept known as "Inversion of Control transfers control of program elements or objects and their lifecycle from developers/programmers to a container or framework. And hence, it has been named Inversion of Control". The most common usage for it is in relation to object-oriented programming.

The advantages of IoC are:

Decoupling a task’s implementation from its execution to facilitate switching between various implementations

More program modularity

Increased simplicity in testing a program through component isolation, dependency mocking, and contract-based communication between components

Several techniques, including the Strategy design pattern, Service Locator pattern, Factory pattern, and Dependency Injection (DI), can be used to accomplish Inversion of Control.

Dependency Injection

Dependency injection is one of the patterns for implementing IoC in which the control is inverted in the configuration of object dependencies.

An assembler, not the individual objects, performs the function of joining things together, or "injecting" objects into other objects. With the Spring Framework, the Dependency Injection (DI) design pattern is used to accomplish the Inversion of Control (IoC) concept.

Fields, constructors, and setters can all be used in Spring to implement dependency injection.

Modules in Spring Framework

The Spring Framework consists of features organized into about 20 modules. These modules are grouped into Core Container, Data Access/Integration, Web, AOP (Aspect Oriented Programming), Instrumentation, Messaging, and Test, as shown in the following figure:

Figure 1.1: Spring Framework Modules

Core Container

The expression Language, Beans, Context, and Core modules make up the Core Container.

The foundational components of the framework, such as the Dependency Injection and IoC functionalities, are provided by the Core and Beans modules.

Building upon the strong foundation established by the Core and Beans modules, the Context module offers a framework-style object access mechanism akin to a JNDI registry. Additional Java EE capabilities supported by the Context module include EJB, JMX, and simple remoting.

A robust expression language for interacting with and querying an object graph at runtime is offered by the Expression Language module.

Data Access/Integration

The Data Access/Integration layer consists mainly of JDBC, ORM, OXM, JMS, and Transaction modules.

The JDBC module offers a JDBC-abstraction layer that eliminates the need for laborious JDBC coding and error code parsing particular to certain database vendors.

Integration layers for well-known object-relational mapping APIs, such as JPA, JDO, Hibernate, and iBatis, are provided by the ORM module.

JAXB, Castor, XMLBeans, JiBX, and XStream Object/XML mapping implementations are supported by an abstraction layer offered by the OXM module.

Producing and consuming messages is made possible via the Java Messaging Service (JMS) module.

For all of your POJOs (plain old Java objects) and classes that implement special interfaces, the Transaction module offers programmatic and declarative transaction management.

Web

The Web layer contains the Web, Web-Servlet, Web-Struts, and Web-Portlet modules.

Basic web-oriented integration features like multipart file uploading and the creation of the IoC container utilizing servlet listeners and a web-oriented application context are provided by Spring’s Web module. It also includes the web-related components of Spring’s remote assistance.

The model-view-controller (MVC) implementation for web applications using Spring is contained in the Web-Servlet module. The MVC framework from Spring integrates with all other Spring Framework elements and offers a clear division between domain model code and web forms.

The support classes needed to integrate a traditional Struts web layer into a Spring application are included in the Web-Struts module. Take note that as of Spring 3.0, this support has been deprecated. Think about switching to a Spring MVC solution or Struts 2.0 with its Spring integration for your application.

The Web-Portlet module replicates the features of the Web-Servlet module and offers an MVC implementation for usage in a portlet context.

AOP and Instrumentation

Code that implements functionality that should be separated can be neatly decoupled by defining features such as method interceptors and pointcuts using Spring’s AOP module, which offers an aspect-oriented programming implementation conforming with the AOP Alliance.

Integration with AspectJ is provided by the standalone Aspects module.

For usage with specific application servers, the Instrumentation module offers classloader implementations and support for class instrumentation.

Test

TestNG or JUnit testing of Spring components is supported via the Test module. It facilitates the caching of Spring ApplicationContexts and their consistent loading. Additionally, it offers mock objects that you may utilize to isolate and test your code.

Spring Boot

A Java framework called Spring Boot makes it easier to write and launch Java applications and microservices. Its primary goal is to make Java application configuration and setup simpler so that developers may concentrate more on building the apps’ code. The Pivotal Team develops Spring Boot. Setting up, configuring, and deploying web-based and basic apps is made faster, simpler, and more straightforward with Spring Boot, which integrates the Spring Framework with Embedded Servers. Spring Boot eliminates the need for XML configuration and aims to speed up development, unit testing, and integration testing.

Features and Comparison Between Spring Framework and Spring Boot

One of the most widely used Java frameworks worldwide, as you are aware, is the Spring framework. For contemporary enterprise Java-based applications, it provides a comprehensive programming and configuration model. Teams may concentrate on application-level business logic because the Spring framework supports infrastructures at the application level. The cornerstone of the Spring platform is the Spring Framework. With Spring Boot, developers may quickly become proficient with the Spring framework. Building stand-alone, production-quality Spring-based applications is made easier with Spring Boot. Not a fork of the Spring framework; it is a Spring platform project. Spring Boot is a time-saving and productivity-enhancing tool for developers. Let’s examine the feature comparison between Spring Boot and Spring Framework.

Spring framework has the following core features:

Dependency injection, AOP events, resources, i18n, validation, data binding, and type conversion are all included in the Spring core.

Mock objects and the testContext spring MVC test are used in testing.

We have features such as transactions, DAO support, JDBC, and ORM in Spring Data Access.

Email, tasks scheduler, cache, remoting, JMS, JMX, and spring MVC and spring webflux integration.

Whereas Spring Boot’s characteristics are as follows:

Standalone applications with an embedded server that don’t require WAR deployment

First dependencies that facilitate easier dependency setting

Spring and third-party libraries are set up automatically

Metrics, externalized configuration, and health check

There’s no XML setup required.

The following picture depicts the relation between Spring framework and Spring Boot in an application:

Figure 1.2: Spring Boot and Components

An embedded server like Apache Tomcat or an external servlet container could be powering a Spring application. The foundation of Spring Boot is the Spring framework. The code for the application is based on Spring Boot and includes capabilities from the Spring framework, including dependency injection, AOP, ORM, DAO, and