Reactive Systems in Java

Introduction

The book "Reactive Systems in Java" (authors: Clement Escoffier and Ken Finnigan, 2021, 330 pages) is a practical guide to designing and developing modern reactive systems. Despite its title, the book actively uses the Kotlin language (alongside Java), making it especially valuable for developers working in the JVM ecosystem. The authors are recognized experts in the field of reactive programming: Clement Escoffier is known for his contributions to the Vert.x project, and Ken Finnigan is the author of books on WildFly and JBoss.

The book was published in 2021, but its ideas and approaches remain relevant today, as the reactive paradigm continues to gain popularity in microservice architecture and cloud applications.

What the book is about

The book is dedicated to building reactive systems — distributed applications that respond to requests quickly, are resilient to failures, scale, and remain responsive even under high load. The authors consistently cover all aspects of the reactive approach, based on the Reactive Manifesto (responsiveness, resilience, elasticity, message-driven).

The main focus is on the practical application of libraries and frameworks: Eclipse Vert.x (for building reactive microservices), Mutiny (a reactive library for Java/Kotlin), as well as integration with databases, message queues, and external services. Examples are written in Kotlin, which demonstrates the conciseness and expressiveness of reactive code.

Who this book is for

The book is intended for Java and Kotlin developers who already have basic experience in building web applications and want to move on to building high-load, fault-tolerant systems. It will be useful for:

• microservice developers wanting to master the reactive approach;
• architects designing distributed systems;
• team leads implementing reactive practices in their teams;
• anyone interested in modern approaches to real-time data processing.

It is assumed that the reader is familiar with the basics of multithreading, asynchrony, and at least one JVM language.

What the reader will learn

After reading the book, the reader will be able to:

• understand the principles of the Reactive Manifesto and their practical implementation;
• design reactive microservices using Vert.x and Mutiny;
• work with asynchronous data streams (Reactive Streams);
• implement fault tolerance through supervisors and circuit breakers;
• integrate reactive services with databases (including reactive drivers);
• test reactive applications using specialized tools;
• deploy reactive systems in containers and the cloud.

Strengths

The main advantage of the book is its practical focus. Each chapter contains ready-made code examples that can be immediately run and modified. The authors not only explain the theory but also show how to solve real problems: from request processing to monitoring and debugging.

Another plus is the use of Kotlin. This allows for cleaner and more expressive code, and also demonstrates how reactive concepts fit naturally into modern languages. For Java developers unfamiliar with Kotlin, the book will serve as an excellent introduction to the language.

The book is well-structured: from the basics of reactive programming to specific frameworks, and then to integration and deployment. Special mention should be made of the chapters on testing and monitoring — topics that often remain outside the scope of similar guides.

Who it is recommended for

The book will be useful for anyone who wants to build modern, scalable, and fault-tolerant systems on the JVM. It is especially recommended for:

• teams transitioning from a monolith to microservices;
• developers working