book

Reactive Systems in Java

by Clement Escoffier, Ken Finnigan

November 2021

Intermediate to advanced

296 pages

7h 17m

English

O'Reilly Media, Inc.

Book available

Read now

Unlock full access

Who Should Read This Book?What About Quarkus?Navigating This BookGetting You ReadyConventions Used in This BookO’Reilly Online LearningHow to Contact UsAcknowledgments
What Do We Mean by Reactive?Reactive Software Is Not NewThe Reactive LandscapeWhy Are Reactive Architectures So Well-Suited for Cloud Native Applications?Reactive Is Not a Silver Bullet
Java on the CloudThorntail ExampleQuarkus ExampleThe Quarkus WayCreate Your First Quarkus ApplicationKubernetes with Quarkus in 10 MinutesGoing NativeSummary
What’s a Distributed System?The New Kids on the Block: Cloud Native and Kubernetes Native ApplicationsThe Dark Side of Distributed SystemsFallacies of Distributed Computing in a Kubernetes WorldA Question of Timing: The Synchronous Communication DrawbackSummary
Reactive Systems 101Commands and EventsCommandsEventsMessagesCommands Versus Events: An ExampleDestinations and Space DecouplingTime DecouplingThe Role of Nonblocking Input/OutputBlocking Network I/O, Threads, and ConcurrencyHow Does Nonblocking I/O Work?Reactor Pattern and Event LoopAnatomy of Reactive ApplicationsSummary
Asynchronous Code and PatternsUsing FuturesProject Loom: Virtual Threads and Carrier ThreadsReactive ProgrammingStreamsOperatorsReactive Programming LibrariesReactive Streams and the Need for Flow ControlBuffering ItemsDropping ItemsWhat Is Backpressure?Introducing Reactive StreamsBe Warned: It’s a Trap!Backpressure in Distributed SystemsSummary
The Imperative ModelThe Reactive ModelUnification of Reactive and ImperativeA Reactive EngineA Reactive Programming ModelEvent-Driven Architecture with QuarkusSummary

Why Another Reactive Programming Library?What Makes Mutiny Unique?Mutiny Usage in QuarkusUni and MultiMutiny and Flow ControlObserving EventsTransforming EventsChaining Asynchronous ActionsRecovering from FailureCombining and Joining ItemsSelecting ItemsCollecting ItemsSummary
The Journey of an HTTP RequestSay Hello to RESTEasy Reactive!What’s the Benefit?Asynchronous Endpoints Returning UniDealing with Failure and Customizing the ResponseStreaming DataRaw StreamingStreaming JSON ArrayUsing Server-Sent-EventsReactive ScoreSummary
The Problem with Data AccessNonblocking Interactions with Relational DatabasesUsing a Reactive ORM: Hibernate ReactiveWhat About NoSQL?Interacting with RedisData-Related Events and Change Data CaptureUsing Debezium to Capture ChangeSummary
From Reactive Applications to Reactive SystemsChannels and MessagesProducing MessagesConsuming MessagesProcessing MessagesAcknowledgmentsConnectorsBuilding Message-Based ApplicationsMessage and AcknowledgmentFailures and Negative AcknowledgmentStream ManipulationBlocking ProcessingRetrying ProcessingPutting Everything TogetherSummary
Kafka or AMQP: Picking the Right ToolBuilding Reactive Systems with KafkaApache KafkaPoint-to-Point CommunicationPublish/SubscribeElasticity PatternsDealing with FailuresBackpressure and Performance ConsiderationsKafka on KubernetesBuilding Reactive Systems with AMQPAMQP 1.0Point-to-Point CommunicationPublish/SubscribeElasticity PatternsAcknowledgment and RedeliveryCredit-Flow Backpressure ProtocolAMQP on KubernetesSummary
Interacting with an HTTP EndpointThe REST Client ReactiveMapping HTTP APIs to Java InterfacesInvoking the ServiceBlocking and NonblockingHandling FailuresFallbackRetriesTime-outBulkheads and Circuit BreakerBuilding API Gateways with the RESTEasy Reactive ClientUsing the REST Client in Messaging ApplicationsSummary
Why Is Observability Important?Health with MessagingMetrics with MessagingDistributed Tracing with MessagingSummary
A Brief SummaryIs That All?The Future of Reactive SystemsThe End of the Beginning

Overview

Reactive systems and event-driven architecture are becoming indispensable to application design, and companies are taking note. Reactive systems ensure that applications are responsive, resilient, and elastic no matter what failures or errors may be occurring, while event-driven architecture offers a flexible and composable option for distributed systems. This practical book helps Java developers bring these approaches together using Quarkus 2.x, the Kubernetes-native Java framework.

Clement Escoffier and Ken Finnigan show you how to take advantage of event-driven and reactive principles to build robust distributed systems, reducing latency and increasing throughput, particularly in microservices and serverless applications. You'll also get a foundation in Quarkus to help you create true Kubernetes-native applications for the cloud.

Understand the fundamentals of reactive systems and event-driven architecture
Learn how to use Quarkus to build reactive applications
Combine Quarkus with Apache Kafka or AMQP to build reactive systems
Develop microservices that utilize messages with Quarkus for use in event-driven architectures
Learn how to integrate external messaging systems, such as Apache Kafka, with Quarkus
Build applications with Quarkus using reactive systems and reactive programming concepts