Spring 5 Design Patterns

Best practices for concurrency module

Thread-specific storage pattern

Reactor pattern

Leader/follower pattern

Half-Sync/Half-Async patterns

Monitor object pattern

Active object pattern

Implementing Concurrency Patterns

Summary

Request and response body conversion

Implementing a Reactive Client-Side application

The functional programming model

The Annotation-based programming model

Implementing a reactive web application at the server side

Spring Web reactive module

Reactive Streams

Implementing reactive with the Spring 5 Framework

Back-pressure

Non-blocking calls

Blocking calls

Message-driven architecture

Scalable

Resilience

Responsiveness

The reactive pattern traits

Understanding the reactive pattern

Understanding application requirement over the years

Implementing Reactive Design Patterns

Summary

Best practices for web application design

Configuring a Tiles ViewResolver

Composite View pattern using Apache tile view resolver

The View Helper pattern

Register ViewResolver with Spring MVC

Implement the View

Defining ViewResolver in the Spring MVC

Implementing View in the MVC pattern

Validating forms input parameters

Using @ModelAttributes for customizing data binding

Data binding with Command Design pattern

Implementing a form handling controller

Processing forms of a web page

Taking request parameters via path variables

Taking query parameters

Accepting request parameters

Passing model data to the view

Defining @RequestMapping handler methods

@RequestMapping at the class level

@RequestMapping at method level

Mapping requests with @RequestMapping

Defining a controller with @Controller

Implementing controllers

Enabling the Spring MVC

Defined by Java configuration

Defined by XML configuration

Configuring DispatcherServlet as the Front Controller

Processing the life of a request

The Front Controller design pattern

Model 2 architecture MVC pattern with Spring

Implementing the MVC pattern in a web application

Implementing the MVC Pattern in a Web Application using Spring

Summary

Top caching best practices to be used in a web application

Creating custom caching annotations

XML-based configuration

Ehcache-based cache

Third-party cache implementations

Setting up the CacheManager

Configuring the cache storage

Declarative XML-based caching

The @CacheConfig annotation

The @Caching annotation

The @CacheEvict annotation

Conditional caching

Customizing the cache key

The @CachePut annotation

The @Cacheable annotation

Declarative Annotation-based caching

Enabling the Caching Proxy using the XML namespace

Enabling the caching proxy using Annotation

Enabling caching via the Proxy pattern

Understanding cache abstraction

Where do we use caching?

What is cache?

Improving Application Performance Using Caching Patterns

Summary

Best practices for Spring ORM and transaction module in an application

Programmatic transaction demarcation and implementation

Step 2 - Declaring the transaction demarcation

Step 1 - Implementing the transaction manager

Deploying the transaction manager

Declarative transaction demarcation and implementation

Transaction management strategies in Spring

Implementing DAOs based on the plain Hibernate API

Configuring Hibernate's SessionFactory in a Spring container

Integrating Hibernate with Spring

Spring's Hibernate template pattern

Proxy for the lazy loading pattern

The domain model pattern

The Data Mapper pattern

Creating DAOs using the Factory design pattern in Spring

The data access object pattern

Consistent exception handling and translation

Resource and transaction management

ORM Framework and the patterns used

Accessing Database with Spring ORM and Transactions Implementing Patterns

Summary

Best practices for Jdbc and configuring JdbcTemplate

Implementing ResultSetExtractor

Implementing RowCallbackHandler

Creating a RowMapper class

Jdbc callback interfaces

Implementing a JDBC-based repository

Creating a JdbcTemplate in an application

When to use JdbcTemplate

Working with JdbcTemplate

The DAO pattern with the Spring Framework

Abstracting database access using the DAO pattern

Implementing the Builder pattern to create an embedded data source

Configuring the data source using pool connections

Configuring a data source using a JDBC driver

Configuring the data source and object pool pattern

Solving problems with Spring's JdbcTemplate

Problems with the traditional JDBC

Implementing the template design pattern

The resource management problem

The best approach to designing your data-access

Accessing a Database with Spring and JDBC Template Patterns

Summary

Understanding AOP proxies

Define aspects using XML configuration

Around Advice example

Advice Types - Around

After Advice example

Advice Types: After

After Throwing Advice example

Advice Types: After Throwing

After Returning Advice example

Advice Types: After Returning

Before Advice example

Advice type - Before

Implementing Advice

Define aspects using Annotation

Creating aspects

Writing pointcuts

Defining pointcuts

Weaving

Aspect

Pointcut

Join Point

Advice

Core AOP terminology and concepts

How AOP Works to solve problems

Code scattering

Code tangling

Problems resolved by AOP

What is Aspect-Oriented Programming?

What are cross-cutting concerns?

Proxying classes using Decorator pattern in Spring

Proxy pattern in Spring

Spring Aspect Oriented Programming with Proxy and Decorator pattern

Summary

Creating custom scopes

Custom scopes

Other scopes in Spring

The request bean scope

The session bean scope

The prototype bean scope

The singleton bean scope

Understanding bean scopes

The destruction phase of the beans

Implementing the Decorator and Proxy patterns in Spring using Proxies

The Use phase of beans

The Initializer extension point

Customizing beans using a BeanPostProcessor

Initializing bean instances

Load bean definitions

Creating the application context from configuration

The initialization phase

The Spring bean life cycle and its phases

Understanding the Bean Life Cycle and Used Patterns

Summary

Best practices for configuring the DI pattern

Sample implementation of FactoryBean interface

Implementation of FactoryBean interface in Spring

Implementing the Abstract Factory Pattern in Spring (FactoryBean interface)

Resolving disambiguation in Autowiring DI pattern

The Autowiring DI pattern and disambiguation

Using @Autowired with the fields

Using @Autowired with setter method

Annotating beans for autowiring

Searching beans using component scanning

Creating auto searchable beans using Stereotype annotations

What are Stereotype annotations?

Dependency injection pattern with Annotation-based configuration

Using setter injection

Using constructor injection

Injecting Spring beans

Declaring Spring beans in an XML file

Creating an XML configuration file

Dependency injection pattern with XML-based configuration

Best approach to configure the dependency injection pattern with Java

Injecting Spring beans

Declaring Spring beans into configuration class

Creating a Java configuration class - AppConfig.java

Dependency injection pattern with Java-based configuration

Configuring the dependency injection pattern with Spring

Setter-based dependency injection

Constructor-based dependency injection pattern

Types of dependency injection patterns

With dependency injection pattern

Without dependency injection

Solving problems using the dependencies injection pattern

The dependency injection pattern

Wiring Beans using the Dependency Injection Pattern

Summary

JEE design patterns

Template Design Pattern

Observer pattern in the Spring Framework

Iterator design pattern in the Spring Framework

Iterator Design Pattern

Interpreter design pattern in the Spring Framework

Interpreter Design pattern

Command design pattern in the Spring Framework

Command design pattern

Chain of Responsibility pattern in the Spring Framework

Chain of Responsibility design pattern

Behavioral design patterns

Proxy pattern in the Spring Framework

Implementing the Proxy design pattern

UML structure for the Proxy design pattern

Purpose of the Proxy pattern

Proxy design pattern

Facade Pattern in the Spring Framework

The UML structure for the Facade design pattern

Implementing the Facade design pattern

Knowing when to use the Facade Pattern

Facade Design Pattern

Decorator design pattern in the Spring Framework

Implementing the Decorator pattern

Common problems solved by the Decorator pattern

Decorator design pattern

Sample implementation of the Composite design pattern

UML structure of the Composite design pattern

Common problems solved by the composite pattern

Composite design pattern

Sample implementation of the Bridge design pattern

Implementing the Bridge design pattern in the Spring Framework

Common problems solved by the Bridge design pattern

Benefits of the Bridge pattern

The Bridge design pattern

Sample implementation of the adapter design pattern

Implementation of the adapter design pattern in the Spring Framework

Common requirements for the adapter pattern

Benefits of the adapter pattern

The adapter design pattern

Structural design patterns

Examining the core design patterns

Consideration of Structural and Behavioral Patterns

Summary

Sample implementation of the Builder design pattern

Common problems where you should apply Builder pattern

Implementing the Builder pattern in the Spring Framework

UML class structure

Benefits of the Builder pattern:

Builder design pattern

Sample implementation of the Prototype design pattern

UML class structure

Benefits of the Prototype design pattern

Prototype design pattern

Sample implementation of the Singleton design pattern

Singleton design pattern implementation in the Spring Framework

Common problems where you should apply Singleton pattern

Singleton design pattern

Sample implementation of the Abstract Factory design pattern

Implementing the Abstract factory design pattern in the Spring Framework

Common problems where you should apply the Abstract factory design pattern

Abstract factory design pattern

Sample implementation of the Factory design pattern

Implementing the Factory design pattern in Spring Framework

Factory design pattern

Creational design patterns

Common GoF Design Pattern overview

Introducing the power of design patterns

Overview of GOF Design Patterns - Core Design Patterns

Summary

New features in Spring Framework 5.0

Spring web MVC

Spring's ORM

Spring DAO - data access and integration

Spring's AOP module

Core Spring container

Spring modules

Life of a bean in the container

Creating a container with an application context

Application contexts

Bean factory

Using a Spring container to manage beans with the Factory pattern

The Template Design pattern in Spring

Applying the template pattern to eliminate boilerplate code

How Spring AOP works

Applying aspects for cross cutting concerns

Using DI pattern for dependent components

Using factory helper pattern for dependent components

How DI works and makes things easy for development and testing

Injecting dependencies between POJOs

Using the power of the POJO pattern

Simplifying application development using Spring and its pattern

Introducing Spring Framework

Getting Started with Spring Framework 5.0 and Design Patterns

Questions

Piracy

Errata

Downloading the example code

Customer support

Reader feedback

Conventions

Who this book is for

What you need for this book

What this book covers

Preface

Dedication

Customer Feedback

Why subscribe?

www.PacktPub.com

About the Reviewer

About the Author

Credits

Spring 5 Design Patterns

Copyright

Title Page

coverpage

coverpage

Title Page

Copyright

Spring 5 Design Patterns

Credits

About the Author

About the Reviewer

www.PacktPub.com

Why subscribe?

Customer Feedback

Dedication

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Downloading the example code

Errata

Piracy

Questions

Getting Started with Spring Framework 5.0 and Design Patterns

Introducing Spring Framework

Simplifying application development using Spring and its pattern

Using the power of the POJO pattern

Injecting dependencies between POJOs

How DI works and makes things easy for development and testing

Using factory helper pattern for dependent components

Using DI pattern for dependent components

Applying aspects for cross cutting concerns

How Spring AOP works

Applying the template pattern to eliminate boilerplate code

The Template Design pattern in Spring

Using a Spring container to manage beans with the Factory pattern

Bean factory

Application contexts

Creating a container with an application context

Life of a bean in the container

Spring modules

Core Spring container

Spring's AOP module

Spring DAO - data access and integration

Spring's ORM

Spring web MVC

New features in Spring Framework 5.0

Summary

Overview of GOF Design Patterns - Core Design Patterns

Introducing the power of design patterns

Common GoF Design Pattern overview

Creational design patterns

Factory design pattern

Implementing the Factory design pattern in Spring Framework

Sample implementation of the Factory design pattern

Abstract factory design pattern

Common problems where you should apply the Abstract factory design pattern

Implementing the Abstract factory design pattern in the Spring Framework

Sample implementation of the Abstract Factory design pattern

Singleton design pattern

Common problems where you should apply Singleton pattern

Singleton design pattern implementation in the Spring Framework

Sample implementation of the Singleton design pattern

Prototype design pattern

Benefits of the Prototype design pattern

UML class structure

Sample implementation of the Prototype design pattern

Builder design pattern

Benefits of the Builder pattern:

UML class structure

Implementing the Builder pattern in the Spring Framework

Common problems where you should apply Builder pattern

Sample implementation of the Builder design pattern

Summary

Consideration of Structural and Behavioral Patterns

Examining the core design patterns

Structural design patterns

The adapter design pattern

Benefits of the adapter pattern

Common requirements for the adapter pattern

Implementation of the adapter design pattern in the Spring Framework

Sample implementation of the adapter design pattern

The Bridge design pattern

Benefits of the Bridge pattern

Common problems solved by the Bridge design pattern

Implementing the Bridge design pattern in the Spring Framework

Sample implementation of the Bridge design pattern

Composite design pattern

Common problems solved by the composite pattern

UML structure of the Composite design pattern

Sample implementation of the Composite design pattern

Decorator design pattern

Common problems solved by the Decorator pattern

Implementing the Decorator pattern

Decorator design pattern in the Spring Framework

Facade Design Pattern

Knowing when to use the Facade Pattern

Implementing the Facade design pattern

The UML structure for the Facade design pattern

Facade Pattern in the Spring Framework

Proxy design pattern

Purpose of the Proxy pattern

UML structure for the Proxy design pattern

Implementing the Proxy design pattern

Proxy pattern in the Spring Framework

Behavioral design patterns

Chain of Responsibility design pattern

Chain of Responsibility pattern in the Spring Framework

Command design pattern

Command design pattern in the Spring Framework

Interpreter Design pattern

Interpreter design pattern in the Spring Framework

Iterator Design Pattern

Iterator design pattern in the Spring Framework

Observer pattern in the Spring Framework

Template Design Pattern

JEE design patterns

Summary

Wiring Beans using the Dependency Injection Pattern

The dependency injection pattern

Solving problems using the dependencies injection pattern

Without dependency injection

With dependency injection pattern

Types of dependency injection patterns

Constructor-based dependency injection pattern

Setter-based dependency injection

Configuring the dependency injection pattern with Spring

Dependency injection pattern with Java-based configuration

Creating a Java configuration class - AppConfig.java

Declaring Spring beans into configuration class

Injecting Spring beans

Best approach to configure the dependency injection pattern with Java

Dependency injection pattern with XML-based configuration

Creating an XML configuration file

Declaring Spring beans in an XML file

Injecting Spring beans

Using constructor injection

Using setter injection

Dependency injection pattern with Annotation-based configuration

What are Stereotype annotations?

Creating auto searchable beans using Stereotype annotations

Searching beans using component scanning

Annotating beans for autowiring

Using @Autowired with setter method

Using @Autowired with the fields

The Autowiring DI pattern and disambiguation

Resolving disambiguation in Autowiring DI pattern

Implementing the Abstract Factory Pattern in Spring (FactoryBean interface)

Implementation of FactoryBean interface in Spring

Sample implementation of FactoryBean interface

Best practices for configuring the DI pattern

Summary

Understanding the Bean Life Cycle and Used Patterns

The Spring bean life cycle and its phases

The initialization phase

Creating the application context from configuration

Load bean definitions

Initializing bean instances

Customizing beans using a BeanPostProcessor

The Initializer extension point

The Use phase of beans

Implementing the Decorator and Proxy patterns in Spring using Proxies

The destruction phase of the beans

Understanding bean scopes

The singleton bean scope

The prototype bean scope

The session bean scope

The request bean scope

Other scopes in Spring

Custom scopes

Creating custom scopes

Summary

Spring Aspect Oriented Programming with Proxy and Decorator pattern

Proxy pattern in Spring

Proxying classes using Decorator pattern in Spring

What are cross-cutting concerns?

What is Aspect-Oriented Programming?

Problems resolved by AOP

Code tangling

Code scattering

How AOP Works to solve problems

Core AOP terminology and concepts

Advice

Join Point

Pointcut

Aspect

Weaving

Defining pointcuts

Writing pointcuts

Creating aspects

Define aspects using Annotation

Implementing Advice

Advice type - Before

Before Advice example

Advice Types: After Returning

After Returning Advice example

Advice Types: After Throwing

After Throwing Advice example

Advice Types: After

After Advice example

Advice Types - Around

Around Advice example

Define aspects using XML configuration

Understanding AOP proxies

Summary

Accessing a Database with Spring and JDBC Template Patterns

The best approach to designing your data-access

The resource management problem

Implementing the template design pattern

Problems with the traditional JDBC

Solving problems with Spring's JdbcTemplate

Configuring the data source and object pool pattern

Configuring a data source using a JDBC driver

Configuring the data source using pool connections

Implementing the Builder pattern to create an embedded data source

Abstracting database access using the DAO pattern

The DAO pattern with the Spring Framework

Working with JdbcTemplate

When to use JdbcTemplate

Creating a JdbcTemplate in an application

Implementing a JDBC-based repository

Jdbc callback interfaces

Creating a RowMapper class

Implementing RowCallbackHandler

Implementing ResultSetExtractor

Best practices for Jdbc and configuring JdbcTemplate

Summary

Accessing Database with Spring ORM and Transactions Implementing Patterns

ORM Framework and the patterns used

Resource and transaction management

Consistent exception handling and translation

The data access object pattern

Creating DAOs using the Factory design pattern in Spring

The Data Mapper pattern

The domain model pattern

Proxy for the lazy loading pattern

Spring's Hibernate template pattern

Integrating Hibernate with Spring

Configuring Hibernate's SessionFactory in a Spring container

Implementing DAOs based on the plain Hibernate API

Transaction management strategies in Spring

Declarative transaction demarcation and implementation

Deploying the transaction manager

Step 1 - Implementing the transaction manager

Step 2 - Declaring the transaction demarcation

Programmatic transaction demarcation and implementation

Best practices for Spring ORM and transaction module in an application

Summary

Improving Application Performance Using Caching Patterns

What is cache?

Where do we use caching?

Understanding cache abstraction

Enabling caching via the Proxy pattern

Enabling the caching proxy using Annotation

Enabling the Caching Proxy using the XML namespace

Declarative Annotation-based caching

The @Cacheable annotation

The @CachePut annotation

Customizing the cache key

Conditional caching

The @CacheEvict annotation

The @Caching annotation

The @CacheConfig annotation

Declarative XML-based caching

Configuring the cache storage

Setting up the CacheManager

Third-party cache implementations

Ehcache-based cache

XML-based configuration

Creating custom caching annotations

Top caching best practices to be used in a web application

Summary

Implementing the MVC Pattern in a Web Application using Spring

Implementing the MVC pattern in a web application

Model 2 architecture MVC pattern with Spring

The Front Controller design pattern

Processing the life of a request

Configuring DispatcherServlet as the Front Controller

Defined by XML configuration

Defined by Java configuration

Enabling the Spring MVC

Implementing controllers

Defining a controller with @Controller

Mapping requests with @RequestMapping

@RequestMapping at method level

@RequestMapping at the class level

Defining @RequestMapping handler methods

Passing model data to the view

Accepting request parameters

Taking query parameters

Taking request parameters via path variables

Processing forms of a web page

Implementing a form handling controller

Data binding with Command Design pattern

Using @ModelAttributes for customizing data binding

Validating forms input parameters

Implementing View in the MVC pattern

Defining ViewResolver in the Spring MVC

Implement the View

Register ViewResolver with Spring MVC

The View Helper pattern

Composite View pattern using Apache tile view resolver

Configuring a Tiles ViewResolver

Best practices for web application design

Summary

Implementing Reactive Design Patterns

Understanding application requirement over the years

Understanding the reactive pattern

The reactive pattern traits

Responsiveness

Resilience

Scalable

Message-driven architecture

Blocking calls

Non-blocking calls

Back-pressure

Implementing reactive with the Spring 5 Framework

Reactive Streams

Spring Web reactive module

Implementing a reactive web application at the server side

The Annotation-based programming model

The functional programming model

Implementing a Reactive Client-Side application

Request and response body conversion

Summary

Implementing Concurrency Patterns

Active object pattern

Monitor object pattern

Half-Sync/Half-Async patterns

Leader/follower pattern

Reactor pattern

Thread-specific storage pattern

Best practices for concurrency module