Spring 5.0 Cookbook

Spring 5.0 Cookbook

By : Sherwin John C. Tragura

Buy this Book

Spring 5.0 Cookbook

By: Sherwin John C. Tragura

Buy this Book

Overview of this book

The Spring framework has been the go-to framework for Java developers for quite some time. It enhances modularity, provides more readable code, and enables the developer to focus on developing the application while the underlying framework takes care of transaction APIs, remote APIs, JMX APIs, and JMS APIs. The upcoming version of the Spring Framework has a lot to offer, above and beyond the platform upgrade to Java 9, and this book will show you all you need to know to overcome common to advanced problems you might face. Each recipe will showcase some old and new issues and solutions, right from configuring Spring 5.0 container to testing its components. Most importantly, the book will highlight concurrent processes, asynchronous MVC and reactive programming using Reactor Core APIs. Aside from the core components, this book will also include integration of third-party technologies that are mostly needed in building enterprise applications. By the end of the book, the reader will not only be well versed with the essential concepts of Spring, but will also have mastered its latest features in a solution-oriented manner.

Title Page

Credits

About the Author

About the Reviewer

www.PacktPub.com

Customer Feedback

Preface

Free Chapter

Getting Started with Spring

Installing Java Development Kit 1.8

Installing Tomcat 9 and configuring HTTP/2

Installing STS Eclipse 3.8 IDE

Creating Eclipse projects using Maven

Creating Spring STS Eclipse projects using Gradle

Deploying Spring projects using Maven

Deploying Spring projects using Gradle

Installing the MySQL 5.7 database server

Installing the MongoDB 3.2 database server

Learning Dependency Injection (DI)

Implementing a Spring container using XML

Implementing a Spring container using JavaConfig

Managing beans in an XML-based container

Managing beans in the JavaConfig container

Creating Singleton and Prototype beans

Defining eager and lazy spring beans

Creating an inner bean

Injecting Collections and Properties

Creating a Spring MVC using an XML-based approach

Creating a Spring MVC using the JavaConfig approach

Generating multiple ApplicationContexts

Using ResourceBundleMessageSource for Views

Implementing MVC Design Patterns

Creating the simple @Controller

Creating a simple @Controller with method-level URL mapping

Designing a simple form @Controller

Creating a multi-action @Controller

Form validation and parameter type conversion

Creating request- and session-scoped beans

Implementing page redirection and Flash-scoped beans

Creating database connection pooling

Implementing the DAO layer using the Spring JDBC Framework

Creating a service layer in an MVC application

Securing Spring MVC Applications

Configuring Spring Security 4.2.2

Mapping sessions to channels and ports

Customizing the authentication process

Implementing authentication filters, login success, and failure handlers

Creating user details

Generating encrypted passwords

Applying Security to MVC methods

Creating roles and permissions from the database

Managing and storing sessions

Solving Cross-Site Request Forgery (CSRF) and session fixation attacks

Solving Cross-Site Scripting (XSS) and clickjacking attacks

Creating interceptors for login data validation

Cross-Cutting the MVC

Logging and auditing service methods

Managing DAO transactions

Monitoring services and request handlers

Validating parameters and arguments

Managing exceptions

Implementing the caching mechanism

Intercepting request transactions

Implementing user authentication

Accessing with restrictions

Controlling concurrent user access

Implementing a mini-workflow using AOP

Functional Programming

Implementing lambda expressions using anonymous inner classes

Implementing lambda expression using @FunctionInterface

Applying the built-in functional interfaces

Applying method and constructor references

Using the Stream API

Applying streams to collections

Applying streams to NIO 2.0

Using parallel streams

Reactive Programming

Applying the observer design pattern using Reactive Streams

Creating Mono<T> and Flux<T> publishers

Implementing the Subscriber<T> interface

Applying backpressure to Mono<T> and Flux<T>

Managing task executions using Schedulers

Creating concurrent and parallel emissions

Managing continuous data emission

Implementing Stream manipulation and transformation

Testing Reactive data transactions

Implementing Reactive events using RxJava 2.x

Reactive Web Applications

Configuring the TaskExecutor

Implementing @Async services

Creating asynchronous controllers

Creating @Scheduled services

Using Future<T> and CallableFuture<T>

Using Mono<T> and Flux<T> publishers for services

Creating Mono<T> and Flux<T> HTTP response

Integrating RxJava 2.0

Using FreeMarker to render Publisher<T> stream

Using Thymeleaf to render a Publisher<T> stream

Applying security on TaskExecutors

Spring Boot 2.0

Building a non-reactive Spring MVC application

Configuring Logging

Adding JDBC Connectivity

Building a reactive Spring MVC application

Configuring Spring Security 5.x

Using reactive view resolvers

Using RouterFunction and HandlerFunction

Implementing Spring Data with JPA

Implementing REST services using @RestController and Spring REST

Applying Spring Cache

The Microservices

Exposing RESTful services in Spring 5

Using the actuator REST endpoints

Building a client-side application with RestTemplate, AsyncRestTemplate and, WebClient

Configuring the Eureka server for service registration

Implementing the Eureka service discovery and client-side load balancing

Applying resiliency to client applications

Consuming endpoints using a declarative method

Using Docker for deployment

Batch and Message-Driven Processes

Building synchronous batch processes

Implementing batch processes with a database

Constructing asynchronous batch processes

Building synchronous interprocess communication using AMQP

Creating asynchronous send-receive communication

Creating an event-driven asynchronous communication using AMQP

Creating stream communication with Spring Cloud Stream

Implementing batch processes using Spring Cloud Task

Other Spring 5 Features

Using Hibernate 5 object-relational mapping

Applying Hazelcast distributed caching

Building client-server communications with WebSocket

Implementing Reactive WebSocket communication

Implementing asynchronous Spring Data JPA properties

Implementing Reactive Spring Data JPA repositories

Using Spring Data MongoDB

Building applications for big data storage

Building a Spring 5 application using Kotlin

Testing Spring 5 Components

Creating tests for Spring MVC components

Building standalone controller tests

Creating tests for DAO and service layers

Creating tests on secured applications

Creating tests using Spring Boot 2.0

Creating tests for Spring Data JPA

Building tests for blocking, asynchronous and reactive RESTful services

Building tests for Kotlin components

Customer Reviews

5 star

4 star

3 star

2 star

1 star

Creating Eclipse projects using Maven

One option for creating our Spring 5.0 projects is through Maven. The STS Eclipse 3.8 has built-in Maven plugins that will create Maven-ready Eclipse projects easily.

Getting started

Before creating the first Maven project, check first the JRE workspace configuration of your IDE. As noted in the previous recipe, the JRE of your Eclipse must be set to the JDK's JRE. Moreover, check the embedded version of Maven installed in STS Eclipse 3.8 through the Windows | Preferences panel. STS 3.8 will be using its embedded Maven 3.0 for the deployment operations. The list of Maven versions is available at https://maven.apache.org/.

How to do it...

Follow the steps to create Maven Projects for our succeeding code snippets as follows:

There are two ways that we can create a Maven project from scratch in STS. One option is to right-click the Project Explorer of the IDE in order to choose New | Other... from the pop-up window (or Ctrl-N). The other option is to click the File menu option then choose the New | Other... . Both of these operations will lead us to our New project wizard as shown as follows:

On the menu wizard, click the Maven Module and then the Maven Project option. The New Maven project wizard will pop-up anew. Just click Create Simple Project (skip archetype selection) to create a clean project from scratch:

Afterwards, the next wizard will require you to fill out the necessary Group Id and Artifact Id for your project. In the following example, the Group ID is org.packt.recipe.core and the Artifact Id is, let us say, ch01. The next important field that needs to be filled is Packaging and it must be set to war in our case:

Click Finish. Look for the file pom.xml and insert below it the following lines to correct some Maven bugs:

<build> 
  <finalName>ch01-spring5-cookbook</finalName> 
  <plugins> 
    <plugin> 
      <artifactId>maven-war-plugin</artifactId> 
      <version>2.3</version> 
      <configuration> 
        <failOnMissingWebXml>false</failOnMissingWebXml> 
      </configuration> 
    </plugin> 
  </plugins> 
</build>

Finally, you must have the directory structure as follows in your own project explorer:

How it works...

Apache Maven is already a built-in plugin in Eclipse and helps developers manage projects and use some build tools to clean, install, and deploy Eclipse projects. It has the main configuration file which is called the Project Object Model (POM) file.

POM is the fundamental unit of work in Maven that contains information and configuration details about the project. Some core information in POM is <modelVersion>, which currently must be set to 4.0.0, <groupId>, that identifies the project uniquely together with <projectId> and <versionId> across all projects in the Maven repository, <artifactId>, which is the name of the WAR file without the version, and <packaging>, which is WAR.

Later in this book, we will be adding <properties> and <dependencies> and <plugins> for our Spring 5.0 code recipes in our pom.xml file.

Spring 5.0 Cookbook

By : Sherwin John C. Tragura

Spring 5.0 Cookbook

By: Sherwin John C. Tragura

Overview of this book

Related Content you might be interested in

Current Title:

Spring 5.0 Cookbook

Hands-On High Performance with Spring 5

Hands-On Spring Security 5 for Reactive Applications

Learning Spring 5.0

Creating Eclipse projects using Maven

Getting started

How to do it...

How it works...