Reactive Systems in Java: Resilient, Event-Driven Architecture with Quarkus

Preface
    Who Should Read This Book?
    What About Quarkus?
    Navigating This Book
    Getting You Ready
    Conventions Used in This Book
    O’Reilly Online Learning
    How to Contact Us
    Acknowledgments
I. Reactive and Quarkus Introduction
1. Reactive in a Nutshell
    What Do We Mean by Reactive?
    Reactive Software Is Not New
    The Reactive Landscape
    Why Are Reactive Architectures So Well-Suited for Cloud Native Applications?
    Reactive Is Not a Silver Bullet
2. Introduction to Quarkus
    Java on the Cloud
        Thorntail Example
        Quarkus Example
    The Quarkus Way
    Create Your First Quarkus Application
    Kubernetes with Quarkus in 10 Minutes
    Going Native
    Summary
II. Reactive and Event-Driven Applications
3. The Dark Side of Distributed Systems
    What’s a Distributed System?
    The New Kids on the Block: Cloud Native and Kubernetes Native Applications
    The Dark Side of Distributed Systems
    Fallacies of Distributed Computing in a Kubernetes World
    A Question of Timing: The Synchronous Communication Drawback
    Summary
4. Design Principles of Reactive Systems
    Reactive Systems 101
    Commands and Events
        Commands
        Events
        Messages
        Commands Versus Events: An Example
    Destinations and Space Decoupling
    Time Decoupling
    The Role of Nonblocking Input/Output
        Blocking Network I/O, Threads, and Concurrency
        How Does Nonblocking I/O Work?
        Reactor Pattern and Event Loop
    Anatomy of Reactive Applications
    Summary
5. Reactive Programming:  Taming the Asynchronicity
    Asynchronous Code and Patterns
    Using Futures
    Project Loom: Virtual Threads and Carrier Threads
    Reactive Programming
        Streams
        Operators
        Reactive Programming Libraries
    Reactive Streams and the Need for Flow Control
        Buffering Items
        Dropping Items
        What Is Backpressure?
        Introducing Reactive Streams
        Be Warned: It’s a Trap!
        Backpressure in Distributed Systems
    Summary
III. Building Reactive Applications  and Systems with Quarkus
6. Quarkus: Reactive Engine
    The Imperative Model
    The Reactive Model
    Unification of Reactive and Imperative
    A Reactive Engine
    A Reactive Programming Model
    Event-Driven Architecture with Quarkus
    Summary
7. Mutiny: An Event-Driven  Reactive Programming API
    Why Another Reactive Programming Library?
    What Makes Mutiny Unique?
    Mutiny Usage in Quarkus
    Uni and Multi
    Mutiny and Flow Control
    Observing Events
    Transforming Events
    Chaining Asynchronous Actions
    Recovering from Failure
    Combining and Joining Items
    Selecting Items
    Collecting Items
    Summary
8. HTTP with Reactive in Mind
    The Journey of an HTTP Request
    Say Hello to RESTEasy Reactive!
    What’s the Benefit?
    Asynchronous Endpoints Returning Uni
    Dealing with Failure and Customizing the Response
    Streaming Data
        Raw Streaming
        Streaming JSON Array
        Using Server-Sent-Events
    Reactive Score
    Summary
9. Accessing Data Reactively
    The Problem with Data Access
    Nonblocking Interactions with Relational Databases
    Using a Reactive ORM: Hibernate Reactive
    What About NoSQL?
    Interacting with Redis
    Data-Related Events and Change Data Capture
    Using Debezium to Capture Change
    Summary
IV. Connecting the Dots
10. Reactive Messaging: The Connective Tissue
    From Reactive Applications to Reactive Systems
        Channels and Messages
        Producing Messages
        Consuming Messages
        Processing Messages
        Acknowledgments
        Connectors
    Building Message-Based Applications
        Message and Acknowledgment
        Failures and Negative Acknowledgment
        Stream Manipulation
        Blocking Processing
        Retrying Processing
    Putting Everything Together
    Summary
11. The Event Bus: The Backbone
    Kafka or AMQP: Picking the Right Tool
    Building Reactive Systems with Kafka
        Apache Kafka
        Point-to-Point Communication
        Publish/Subscribe
        Elasticity Patterns
        Dealing with Failures
        Backpressure and Performance Considerations
        Kafka on Kubernetes
    Building Reactive Systems with AMQP
        AMQP 1.0
        Point-to-Point Communication
        Publish/Subscribe
        Elasticity Patterns
        Acknowledgment and Redelivery
        Credit-Flow Backpressure Protocol
        AMQP on Kubernetes
    Summary
12. Reactive REST Client: Connecting  with HTTP Endpoints
    Interacting with an HTTP Endpoint
    The REST Client Reactive
        Mapping HTTP APIs to Java Interfaces
        Invoking the Service
    Blocking and Nonblocking
    Handling Failures
        Fallback
        Retries
        Time-out
        Bulkheads and Circuit Breaker
    Building API Gateways with the RESTEasy Reactive Client
    Using the REST Client in Messaging Applications
    Summary
13. Observing Reactive and  Event-Driven Architectures
    Why Is Observability Important?
    Health with Messaging
    Metrics with Messaging
    Distributed Tracing with Messaging
    Summary
Conclusion
    A Brief Summary
    Is That All?
    The Future of Reactive Systems
    The End of the Beginning
Index