Reactive Programming

Reactive programming is useful in Java when data arrives asynchronously, work must stay non-blocking, and consumers need explicit demand control. It is not a default upgrade over executors or futures. The design question is whether streams, backpressure, and operator composition actually make the system easier to reason about.

This chapter covers the model itself, the Reactor and RxJava toolkits, backpressure strategy choices, error handling, testing, and the practical trade-offs that determine when reactive code is worth its cost.

In this section

• Reactive Programming Fundamentals in Java
  Learn the core ideas behind reactive Java systems, including asynchronous streams, backpressure, and when reactive models outperform simpler concurrency tools.
• Reactive Streams in Java
  Learn the Reactive Streams contract in Java so publishers, subscribers, and processors interact with explicit demand and non-blocking flow control.
• Project Reactor and RxJava
  Compare Project Reactor and RxJava, then decide which Java reactive toolkit fits your API style, ecosystem, and operational needs.
  • Getting Started with Project Reactor in Java
    Start using Project Reactor in Java by creating `Flux` and `Mono` pipelines and understanding the lifecycle rules they impose.
  • Understanding Flux and Mono in Java
    Understand when Java reactive flows should emit one value, many values, or no value so `Mono` and `Flux` stay semantically clear.
  • RxJava Overview for Java Developers
    Review RxJava's core abstractions and where observable-based composition still fits modern Java reactive systems.
  • Comparing Project Reactor and RxJava in Java
    Compare Project Reactor and RxJava by ecosystem fit, API shape, and operational trade-offs so Java teams choose a toolkit deliberately.
• Backpressure Strategies
  Choose buffering, dropping, throttling, and demand-based request strategies when reactive Java producers can outrun consumers.
  • Buffering in Reactive Java
    Use buffering in reactive Java pipelines when short bursts are acceptable and queue growth remains bounded and observable.
  • Dropping and Throttling in Reactive Java
    Apply dropping and throttling in reactive Java when preserving responsiveness matters more than processing every emitted item.
  • Requesting Strategies in Reactive Java
    Control demand explicitly in reactive Java streams so subscribers request work at a rate they can actually process.
• Error Handling and Retries in Reactive Java
  Use retries, fallbacks, and recovery operators in reactive Java flows without turning transient failures into amplified outages.
• Testing Reactive Applications in Java
  Test reactive Java flows with deterministic timing, explicit assertions, and tools such as StepVerifier so concurrency does not hide failures.
• Advanced Reactive Techniques
  Combine streams, integrate reactive Java code with external systems, and tune performance without hiding blocking or overload problems.
  • Combining Reactive Streams in Java
    Compare `merge`, `concat`, `zip`, and `combineLatest` in Java reactive pipelines so multiple sources can be coordinated without losing timing or ordering guarantees.
  • Performance Optimization in Reactive Java
    Optimize reactive Java throughput by choosing schedulers, operators, and buffering rules that reduce contention without hiding latency problems.
  • Integrating Reactive Java Applications with Databases and Messaging Systems
    Integrate reactive Java services with databases and messaging systems while keeping blocking boundaries, acknowledgements, and delivery semantics explicit.
• Reactive Programming Use Cases and Examples in Java
  Review Java reactive programming use cases and examples to decide where event streams, backpressure, and non-blocking composition provide real value.