Op werkdagen voor 23:00 besteld, morgen in huis Gratis verzending vanaf €20
,

Reactive Systems in Java

Resilient, Event-Driven Architecture with Quarkus

Paperback Engels 2021 9781492091721
Verkooppositie 3314Hoogste positie: 3314
Verwachte levertijd ongeveer 8 werkdagen

Samenvatting

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

Specificaties

ISBN13:9781492091721
Taal:Engels
Bindwijze:paperback
Aantal pagina's:250
Uitgever:O'Reilly
Druk:1
Verschijningsdatum:23-11-2021
Hoofdrubriek:IT-management / ICT

Lezersrecensies

Wees de eerste die een lezersrecensie schrijft!

Geef uw waardering

Zeer goed Goed Voldoende Matig Slecht

Over Ken Finnigan

Ken Finnigan has worked as an engineer and consultant for nearly 20 years. He currently co-leads the development of WildFly Swarm for Red Hat.

Andere boeken door Ken Finnigan

Inhoudsopgave

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

Part 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

Part 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

Part 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

Part 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

Managementboek Top 100

Rubrieken

Populaire producten

    Personen

      Trefwoorden

        Reactive Systems in Java