Hands-On High Performance with Spring 5电子书

Title Page

Copyright and Credits

Hands-On High Performance with Spring 5

Packt Upsell

Why subscribe?

PacktPub.com

Contributors

About the authors

About the reviewer

Packt is searching for authors like you

Preface

Who this book is for

What this book covers

To get the most out of this book

Download the example code files

Download the color images

Conventions used

Get in touch

Reviews

Exploring Spring Concepts

Introducing the Spring Framework

Problems with EJB

Simplifying implementation using POJO

Benefits of the Spring Framework

No need to reinvent the wheel

Ease of unit testing

Reduction in implementing code

Inversion of control and API

Consistency in transaction management

Modular architecture

Up to date with time

Understanding Spring modules

Core Container

Crosscutting concerns

Data Access/Integration

Web

Spring projects

Spring Boot

Spring Data

Spring Batch

Spring Cloud

Spring Security

Spring HATEOAS

Spring's IoC container

What are Spring beans?

Instantiating a Spring container

BeanFactory

ApplicationContext

Spring bean life cycle

New features in the Spring Framework 5.0

Baseline upgrades

Reactive programming support

Core features upgrades

Spring Web MVC upgrades

Spring's new functional web framework – WebFlux

Modularity support

Kotlin language support

Improved testing support

Dropped or deprecated features

Summary

Spring Best Practices and Bean Wiring Configurations

Dependency injection configurations

Types of DI patterns

Constructor-based DI

Advantages of the constructor-based DI

Disadvantages of the constructor-based DI

Setter-based DI

Advantages of the setter-based DI

Disadvantages of the setter-based DI

Field-based DI

Constructor versus setter injection

Configuring the DI with Spring

XML-based configuration

Java-based configuration

Annotation-based configuration

The @Autowired annotation

@Autowired with required = false

The @Primary annotation

The @Qualifier annotation

Automatic bean detection with stereotype annotations

The @ComponentScan annotation

The @Lazy annotation

Spring bean scopes

Performance assessment with different configurations

Lazy loading versus preloading

Singleton versus prototype bean

Spring bean configuration best practices

DI pitfalls

First pitfall

Second pitfall (with AOP)

Summary

Tuning Aspect-Oriented Programming

AOP concepts

Limitations of OOP

Code tangling

Code scattering

AOP – problem solver

Spring AOP terminology and concepts

Defining pointcuts

Types of advice

Aspect instantiation models

AOP proxies

JDK dynamic proxies and CGLIB proxies

ProxyFactoryBean

ProxyFactoryBean in action

Performance JDK dynamic proxy versus CGLIB proxy

Caching

AOP method profiling

PerformanceMonitorInterceptor

Custom monitoring interceptor

Spring AOP versus AspectJ

What is AspectJ?

Differences between Spring AOP and AspectJ

Capabilities and goals

Weaving

Join points

Simplicity

Performance

AspectJ with Spring

AOP best programming practices

Pointcut expressions

Advice ordering

Best practices of AOP proxies

Caching

Summary

Spring MVC Optimization

Spring MVC configuration

Spring MVC architecture

XML-based configuration

Configuring front controller

Creating a Spring application context

Configuring ViewResolver

Java-based configuration

Configuring front controller

Creating a Spring application context and configuring a ViewResolver

Creating a controller

Creating a view

Spring asynchronous processing, @Async annotation

@Async annotation modes

Fire and forget mode

Result retrieval mode

Limitations of @Async annotation

Thread pool executor

CompletableFuture with Spring Async

runAsync() – running a task asynchronously

supplyAsync() – running a task asynchronously, with a return value

Attaching a callback to the CompletableFuture

Spring Security configuration

Configuring Spring Security dependencies

Configuring a security filter for incoming requests

Configuring Spring Security

Adding a controller

Authentication cache

Implementing the caching configuration class

Providing UserCache to AuthenticationProvider

Providing AuthenticationProvider to AuthenticationManagerBuilder

Fast and stateless API authentication with Spring Security

API authentication with the JSESSIONID cookie

API authentication without the JSESSIONID cookie

Monitoring and managing Tomcat with JMX

Connecting JMX to monitor Tomcat

Creating an MBean

Exporting an MBean in a Spring context

Spring MVC performance improvements

High performance using connection pooling

Hibernate improvements

Testing improvements

Proper server maintenance

Using the authentication cache with Spring Security

Implementing Executor service framework

Summary

Understanding Spring Database Interactions

Spring JDBC configuration

Problems with core JDBC

Solving problems with Spring JDBC

Spring JDBC dependencies

Spring JDBC example

Database design for optimal performance

Table design

Vertical partitioning of a table

Use indexing

Using the correct data type

Defining column constraints

Using stored procedures

Transaction management

Choosing a transaction manager in Spring

Declarative ACID using @Transactional

Optimal isolation levels

Read uncommitted

Read committed

Repeatable read

Serializable

Optimal fetch size

Optimal connection pooling configuration

Sizing the connection pool

Validate connections

Connection leaks

Tomcat JDBC connection pool versus HikariCP

Reliability

Performance

Features

Ease of use

Database interaction best practices

Using Statement versus PreparedStatement versus CallableStatement

Using Batch instead of PreparedStatement

Minimizing the use of database metadata methods

Using get methods effectively

When to avoid connection pooling

Choose commit mode carefully

Summary

Hibernate Performance Tuning and Caching

Introduction to Spring Hibernate and Spring Data

Spring Hibernate

Spring Data

Spring Hibernate configuration

Spring with JPA using Hibernate

Spring Data configuration

Common Hibernate traps

Hibernate n + 1 problem

The open session in view anti-pattern

Unknown Id.generator exception

Hibernate performance tuning

Approaches to avoid the n + 1 problem

Fetch join using JPQL

Join fetch in Criteria API

Named entity graph

Dynamic entity graph

Finding performance issues with Hibernate statistics

Using query-specific fetching

Caching and its best practices

First level cache

Second level cache

Query cache

Performing updates and deletes in bulk

Hibernate programming practices

Caching

Miscellaneous

Summary

Optimizing Spring Messaging

What is messaging?

What is AMQP?

Problems with the JMS API

Why do we need AMQP?

Differences between AMQP and the JMS API

Platform compatibility

Messaging models

Message data type

Message structure

Message routing

Workflow strategy

What are exchanges, queues, and bindings?

Exchange

Queue

Binding

Introducing RabbitMQ

Setting up the RabbitMQ server

Spring messaging configuration

Configuring a Maven dependency for RabbitMQ

Configuring RabbitMQ

Configuring ConnectionFactory

Configuring a queue

Configuring an exchange

Configuring a binding

Configuring RabbitAdmin

Configuring a message converter

Creating a RabbitTemplate

Configuring a listener container

Creating a message receiver

Creating a message producer

Maximizing throughput with RabbitMQ

Performance and scalability with RabbitMQ

Summary

Multithreading and Concurrent Programming

Java classical threads

Creating threads

Thread life cycle and states

More advanced thread tasks

Synchronizing threads

Issues with multithreading

The java.util.concurrent package

Executors

ThreadFactory

Synchronizers

Concurrent collection classes

Lock

Callable and Future

Atomic variables

Using thread pools for asynchronous processing

Spring task execution and scheduling

TaskExecutor

TaskScheduler

Spring Async

The @EnableAsync annotation

The @Async annotation

@Async with CompletableFuture

Spring and threads – transactions

Java threads best programming practices

Summary

Profiling and Logging

Performance profiling

Application performance

Application logging and monitoring

Application logging

Logging best practices

Logging tools

Java standard logging

Apache Log4j 2

Application monitoring

Stagemonitor

Pinpoint

MoSKito

Glowroot

New Relic

Profiling tools

VisualVM

JConsole

Summary

Application Performance Optimization

Performance issue symptoms

Timeouts

Running out of worker threads

Threads waiting on class loaders

Time spent on class-loading activities

Class loader trying to load non-existent classes

Performance tuning life cycle

Connection pooling

Hibernate

Transaction

Periodical clearing of Hibernate sessions

Lazy initialization

Constructor-based HQLs

Entity and query caching

Native queries

Primary key generation

Database

Indexing

Views

Spring Security

Authentication cache

LDAP custom authorities

Native LDAP

Multithreading

Performance tuning patterns and anti-patterns

Anti-patterns

Architectural anti-patterns

Implementing anti-patterns

The iterative performance-tuning process

Spring support of JMX

Managed beans

Summary

Inside JVM

Understanding JVM internals

Class loader subsystem

Memory areas

Execution engine

Understanding memory leak

Memory leak in Java

Common reasons for memory leaks

Common pitfalls

Number of garbage collectors

Wrong garbage collector

Parallel / Concurrent keywords

G1 is a problem solver

Average transaction time

Reducing new object allocation rates improves GC behavior

GC logs cause overhead

GC

How GC works

GC roots

GC methods and policies

Serial collector

Parallel/Throughput collector

CMS garbage collector

G1 collector

Heap memory

JVM flags

-Xms and -Xmx

-XX:NewSize and -XX:MaxNewSize

-XX:NewRatio

-XX:SurvivorRatio

-XX:InitialTenuringThreshold, -XX:MaxTenuringThreshold, and -XX:TargetSurvivorRatio

-XX:CMSInitiatingOccupancyFraction

-XX:+PrintGCDetails, -XX:+PrintGCDateStamps, and -XX:+PrintTenuringDistribution

Tools to analyze GC logs

GCeasy

Tips on JVM tuning

JVM Heap Size

Key Performance Indicators

GC Statistics

GC Causes

Summary

Spring Boot Microservice Performance Tuning

Spring Boot configuration

What is Spring Boot?

Spring Initializr

Starters with Maven

Creating your first Spring Boot application

Metrics with Spring Boot Actuator

What is Spring Actuator?

Enabling Spring Boot Actuator

Enabling endpoints

Health checks

Microservices using Spring Boot

First microservice with Spring Boot

Loading sample data into the database

The JPA way of initial data loading

The ApplicationRunner way of initial data loading

Microservice client

Microservices with Spring Cloud

Spring microservice configuration example

Monitoring microservices with Spring Boot admin

Spring Boot performance tuning

Undertow as an embedded server

Overhead with the @SpringBootApplication annotation

Summary

Other Books You May Enjoy

Leave a review - let other readers know what you think