Sign In Start Free Trial

Hands-On High Performance with Spring 5

By : Mehta, Subhash Shah, Shah, Prashant Goswami, Dinesh Radadiya

5 (1)

Hands-On High Performance with Spring 5

5 (1)

By: Mehta, Subhash Shah, Shah, Prashant Goswami, Dinesh Radadiya

Overview of this book

While writing an application, performance is paramount. Performance tuning for real-world applications often involves activities geared toward detecting bottlenecks. The recent release of Spring 5.0 brings major advancements in the rich API provided by the Spring framework, which means developers need to master its tools and techniques to achieve high performance applications. Hands-On High Performance with Spring 5 begins with the Spring framework's core features, exploring the integration of different Spring projects. It proceeds to evaluate various Spring specifications to identify those adversely affecting performance. You will learn about bean wiring configurations, aspect-oriented programming, database interaction, and Hibernate to focus on the metrics that help identify performance bottlenecks. You will also look at application monitoring, performance optimization, JVM internals, and garbage collection optimization. Lastly, the book will show you how to leverage the microservice architecture to build a high performance and resilient application. By the end of the book, you will have gained an insight into various techniques and solutions to build and troubleshoot high performance Spring-based applications.

Preface

Preface

Who this book is for

What this book covers

To get the most out of this book

Get in touch

Free Chapter

Exploring Spring Concepts

Exploring Spring Concepts

Introducing the Spring Framework

Understanding Spring modules

Spring projects

Spring's IoC container

New features in the Spring Framework 5.0

Summary

Spring Best Practices and Bean Wiring Configurations

Spring Best Practices and Bean Wiring Configurations

Dependency injection configurations

Performance assessment with different configurations

DI pitfalls

Summary

Tuning Aspect-Oriented Programming

Tuning Aspect-Oriented Programming

AOP concepts

AOP proxies

AOP method profiling

Spring AOP versus AspectJ

AOP best programming practices

Summary

Spring MVC Optimization

Spring MVC Optimization

Spring MVC configuration

Spring asynchronous processing, @Async annotation

CompletableFuture with Spring Async

Spring Security configuration

Authentication cache

Fast and stateless API authentication with Spring Security

Monitoring and managing Tomcat with JMX

Spring MVC performance improvements

Summary

Understanding Spring Database Interactions

Understanding Spring Database Interactions

Spring JDBC configuration

Database design for optimal performance

Transaction management

Optimal isolation levels

Optimal fetch size

Optimal connection pooling configuration

Database interaction best practices

Summary

Hibernate Performance Tuning and Caching

Hibernate Performance Tuning and Caching

Introduction to Spring Hibernate and Spring Data

Spring Hibernate configuration

Common Hibernate traps

Hibernate performance tuning

Hibernate programming practices

Summary

Optimizing Spring Messaging

Optimizing Spring Messaging

What is messaging?

What is AMQP?

Introducing RabbitMQ

Spring messaging configuration

Maximizing throughput with RabbitMQ

Summary

Multithreading and Concurrent Programming

Multithreading and Concurrent Programming

Java classical threads

The java.util.concurrent package

Using thread pools for asynchronous processing

Spring task execution and scheduling

Spring Async

Spring and threads – transactions

Java threads best programming practices

Summary

Profiling and Logging

Profiling and Logging

Performance profiling

Application logging and monitoring

Profiling tools

Summary

Application Performance Optimization

Application Performance Optimization

Performance issue symptoms

Performance tuning life cycle

Performance tuning patterns and anti-patterns

The iterative performance-tuning process

Spring support of JMX

Summary

Inside JVM

Inside JVM

Understanding JVM internals

Understanding memory leak

Common pitfalls

GC

GC methods and policies

Heap memory

JVM flags

Tools to analyze GC logs

Summary

Spring Boot Microservice Performance Tuning

Spring Boot Microservice Performance Tuning

Spring Boot configuration

Metrics with Spring Boot Actuator

Health checks

Microservices using Spring Boot

Microservices with Spring Cloud

Spring microservice configuration example

Monitoring microservices with Spring Boot admin

Spring Boot performance tuning

Summary

Other Books You May Enjoy

Other Books You May Enjoy

Leave a review - let other readers know what you think

Customer Reviews

5 (1)

5 star

100%

4 star

0

3 star

0

2 star

0

1 star

0

Java threads best programming practices

The purpose of using multithreading and concurrent programming is to improve performance, but we need to always remember that speed comes after correctness. The Java programming language provides lots of synchronization and concurrency support from the language to API level, but it depends on an individual's expertise in writing bug-free Java concurrency code. The following are Java concurrency and multithreading best practices, which help us write better concurrency code in Java:

Use immutable classes: We should always prefer the immutable class in multithreading programming because immutable classes make sure that values are not changed in the middle of an operation without using synchronized blocks. For example, in an immutable class, such as java.lang.String, any modification on String, such as adding something or converting into...

Search

Your notes and bookmarks