Reactive Programming with RxJava. Creating Asynchronous, Event-Based Applications (ebook)(audiobook)(audiobook)

Spis treści

• Foreword
• Introduction
  • Who Should Read This Book
  • Note from Ben Christensen
  • Note from Tomasz Nurkiewicz
  • Navigating This Book
  • Online Resources
  • Conventions Used in This Book
  • Safari Books Online
  • How to Contact Us
  • Acknowledgments
    • From Ben
    • From Tomasz
• 1. Reactive Programming with RxJava
  • Reactive Programming and RxJava
  • When You Need Reactive Programming
  • How RxJava Works
    • Push versus Pull
    • Async versus Sync
      • In-memory data
      • Synchronous computation (such as operators)
    • Concurrency and Parallelism
    • Lazy versus Eager
    • Duality
    • Cardinality
      • Event stream
      • Multiple values
      • Composition
      • Single
      • Completable
      • Zero to infinity
  • Mechanical Sympathy: Blocking versus Nonblocking I/O
  • Reactive Abstraction
• 2. Reactive Extensions
  • Anatomy of rx.Observable
  • Subscribing to Notifications from Observable
    • Capturing All Notifications by Using Observer<T>
  • Controlling Listeners by Using Subscription and Subscriber<T>
  • Creating Observables
    • Mastering Observable.create()
      • Managing multiple subscribers
    • Infinite Streams
    • Timing: timer() and interval()
    • Hot and Cold Observables
  • Use Case: From Callback API to Observable Stream
    • Manually Managing Subscribers
  • rx.subjects.Subject
  • ConnectableObservable
    • Single Subscription with publish().refCount()
    • ConnectableObservable Lifecycle
  • Summary
• 3. Operators and Transformations
  • Core Operators: Mapping and Filtering
    • 1-to-1 Transformations Using map()
    • Wrapping Up Using flatMap()
    • Postponing Events Using the delay() Operator
    • Order of Events After flatMap()
    • Preserving Order Using concatMap()
      • Controlling the concurrency of flatMap()
  • More Than One Observable
    • Treating Several Observables as One Using merge()
    • Pairwise Composing Using zip() and zipWith()
    • When Streams Are Not Synchronized with One Another: combineLatest(), withLatestFrom(), and amb()
      • withLatestFrom() operator
      • amb() operator
  • Advanced Operators: collect(), reduce(), scan(), distinct(), and groupBy()
    • Scanning Through the Sequence with Scan and Reduce
    • Reduction with Mutable Accumulator: collect()
    • Asserting Observable Has Exactly One Item Using single()
    • Dropping Duplicates Using distinct() and distinctUntilChanged()
  • Slicing and Dicing Using skip(), takeWhile(), and Others
    • Ways of Combining Streams: concat(), merge(), and switchOnNext()
    • Criteria-Based Splitting of Stream Using groupBy()
    • Where to Go from Here?
  • Writing Customer Operators
    • Reusing Operators Using compose()
    • Implementing Advanced Operators Using lift()
      • Looking under the hood of the map() operator
      • Our first operator
  • Summary
• 4. Applying Reactive Programming to Existing Applications
  • From Collections to Observables
  • BlockingObservable: Exiting the Reactive World
  • Embracing Laziness
  • Composing Observables
    • Lazy paging and concatenation
  • Imperative Concurrency
  • flatMap() as Asynchronous Chaining Operator
  • Replacing Callbacks with Streams
  • Polling Periodically for Changes
  • Multithreading in RxJava
    • What Is a Scheduler?
      • Scheduler implementation details overview
    • Declarative Subscription with subscribeOn()
    • subscribeOn() Concurrency and Behavior
    • Batching Requests Using groupBy()
    • Declarative Concurrency with observeOn()
    • Other Uses for Schedulers
  • Summary
• 5. Reactive from Top to Bottom
  • Beating the C10k Problem
    • Traditional Thread-Based HTTP Servers
      • Single threaded server
    • Nonblocking HTTP Server with Netty and RxNetty
      • Observable server with RxNetty
    • Benchmarking Blocking versus Reactive Server
      • Plain server returning 200 OKs
      • Simulating server-side work
    • Reactive HTTP Servers Tour
  • HTTP Client Code
    • Nonblocking HTTP Client with RxNetty
  • Relational Database Access
    • NOTIFY AND LISTEN on PostgreSQL Case Study
  • CompletableFuture and Streams
    • A Short Introduction to CompletableFuture
    • Interoperability with CompletableFuture
      • Turning CompletableFuture into Observable with single item
      • From Observable to CompletableFuture
  • Observable versus Single
    • Creating and Consuming Single
    • Combining Responses Using zip, merge, and concat
    • Interoperability with Observable and CompletableFuture
    • When to Use Single?
  • Summary
• 6. Flow Control and Backpressure
  • Flow Control
    • Taking Periodic Samples and Throttling
    • Buffering Events to a List
      • Buffering by time periods
    • Moving window
    • Skipping Stale Events by Using debounce()
      • Avoid starvation in debounce()
  • Backpressure
    • Backpressure in RxJava
    • Built-in Backpressure
    • Producers and Missing Backpressure
    • Honoring the Requested Amount of Data
  • Summary
• 7. Testing and Troubleshooting
  • Error Handling
    • Where Are My Exceptions?
    • Declarative try-catch Replacement
      • Replacing errors with a fixed result using onErrorReturn()
      • Lazily computing fallback value using onErrorResumeNext()
    • Timing Out When Events Do Not Occur
    • Retrying After Failures
      • Retrying by using delay and limited attempts
  • Testing and Debugging
    • Virtual Time
    • Schedulers in Unit Testing
  • Unit Testing
    • Verifying emitted events
  • Monitoring and Debugging
    • doOn() Callbacks
    • Measuring and Monitoring
  • Summary
• 8. Case Studies
  • Android Development with RxJava
    • Avoiding Memory Leaks in Activities
    • Retrofit with Native RxJava Support
    • Schedulers in Android
    • UI Events as Streams
  • Managing Failures with Hystrix
    • The First Steps with Hystrix
    • Nonblocking Commands with HystrixObservableCommand
    • Bulkhead Pattern and Fail-Fast
    • Batching and Collapsing Commands
    • Monitoring and Dashboards
  • Querying NoSQL Databases
    • Couchbase Client API
    • MongoDB Client API
  • Camel Integration
    • Consuming Files with Camel
    • Receiving Messages from Kafka
  • Java 8 Streams and CompletableFuture
    • Usefulness of Parallel Streams
    • Choosing the Appropriate Concurrency Abstraction
    • When to Choose Observable?
  • Memory Consumption and Leaks
    • Operators Consuming Uncontrolled Amounts of Memory
      • distinct() caching all seen events
      • Buffering events with toList() and buffer()
      • Caching with cache() and ReplaySubject
      • Backpressure keeps memory usage low
  • Summary
• 9. Future Directions
  • Reactive Streams
  • Observable and Flowable
  • Performance
  • Migration
• A. More HTTP Server Examples
  • fork() Procedure in C Language
  • Thread per Connection
  • Thread Pool of Connections
• B. A Decision Tree of Observable Operators
• Index

pokaż cały spis treści

ukryj recenzje