Reactive Systems in Java

Spis treści książki

• Preface
  • Who Should Read This Book?
  • What About Quarkus?
  • Navigating This Book
  • Getting You Ready
  • Conventions Used in This Book
  • OReilly 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
  • Whats 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: Its 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!
  • Whats 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
      • Commit strategies
      • Acknowledgment strategies
      • Dead-letter queue
    • 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

pokaż cały spis treści

ukryj recenzje