2017年Android开发必备：RxJava入门与实战指南

需积分: 9 115 浏览量更新于2024-07-17 收藏 2.56MB PDF 举报

《Reactive Programming on Android with RxJava (2017)》是由Christopher Arriola和Angus Huang合作编写的一本专业书籍，于2017年6月27日通过Leanpub平台发布。这本书旨在帮助Android开发者理解和掌握RxJava库，使其能够在其应用程序中实现响应式编程。书中的主要内容分为两个部分：基础篇和进阶篇。基础篇包括： 1. **第一章：什么是响应式编程？** 这章回顾了响应式编程的历史背景，并通过实例解释其核心概念，让读者理解这一编程范式的原理。 2. **第二章：RxJava核心组件** 介绍RxJava的三个主要组件：Observable（可观察者）、Observer（观察者）以及Operator（操作符）。作者还使用Marble Diagrams（ Marble图）来直观展示这些组件的工作方式。 3. **第三章：操作符** 在本章，作者深入讲解如何使用操作符进行数据转换和过滤，以及组合多个操作符的技巧。还介绍了聚合和实用操作符，以及如何重用操作符链。 4. **第四章：多线程与并发** 探讨在Android应用中处理异步编程和调度器的重要性，帮助读者理解如何在不同的线程上下文中控制和管理工作流。进阶篇则涵盖了： 5. **第五章：应用到Android** 将前面章节学到的知识应用于实际的Android开发场景，将理论知识转化为实际操作。 6. **第六章：回压控制** 讨论如何通过回压机制管理数据流，防止过载和内存溢出问题。 7. **第七章：错误处理** 比较RxJava的错误处理机制与Java传统异常处理的区别，强调在响应式编程中的正确处理策略。这本书对于经验丰富的Android开发者来说是一个很好的入门指南，通过实例和实践，让读者逐步掌握RxJava库，将其融入到自己的项目中，提升应用的性能和用户体验。同时，作为Leanpub出版的作品，作者还利用了轻量级工具和迭代过程收集读者反馈，确保内容的实用性和与时俱进。

Meijer essentially did in creating Rx was flip the Iterator Pattern on its head,

turning it into a push-based pattern.

The Observable was designed to be the dual of the Iterable. Instead of

pulling data out of an Iterable with .next(), the Observable pushes data to

an Observer using .onNext(). So, where the Iterator Pattern uses

synchronous pulling of data, RxJava allows for asynchronous pushing of

data, allowing code to be truly reactive.

Functional Programming

One of the most important aspects of RxJava is that it uses functional

programming, in particular, with its Operators. Functional programming is

programming with pure functions. A pure function is one that satisfies the

following two conditions:

1. The function always returns the same value given the same input (i.e.

it’s deterministic). This implies that the function cannot depend on any

global state (e.g. a Java class’s member variable) nor any external

resource (e.g. a web service).

2. The function does not cause any side effects. This means that the

function cannot mutate any input parameter, update any global state, or

interact with any external resource.

Functional programming leads to code that is…

Declarative: Instead of dictating how something is done, as is done with

imperative programming, RxJava uses a declarative approach by

describing what should be done (through our use of Operators). This

declarative style maps much more closely to how we as humans think

(as opposed to how a computer executes), and allows us to much more

easily reason about what the program is doing.

Thread-Safe: Because functional programming avoids state mutation, it

is inherently thread-safe. We have none of the problems that we

normally see when introducing concurrency (e.g. synchronization issues,

race conditions, resource contention). Concurrency can be supported

safely and easily with RxJava.

Testable: Functional code becomes much easier to test because the

functions are completely self-contained and deterministic. We don’t

Thirdly, RxJava Operators are designed to be chained together, which also

contributes to the conciseness of the resulting code. Each Operator method

itself returns a modified Observable allowing for a subsequent Operator to

be chained.

Fluent Interface

Although the above code snippet probably requires an initial somewhat-

lengthy explanation, once you have a baseline understanding, you can see the

code is very idiomatic and self-explanatory. RxJava uses a fluent interface

with Operator names that read like English prose, especially when chained

together. This allows for not only faster coding, but also for someone reading

the code to parse what’s going on much more quickly.

Lazy Evaluation

RxJava, in general, uses lazy evaluation. Remember from above that the

network call is not performed until the very last step when we make the

.subscribe() call. The Observable lays idle until an Observer subscribes to

it. Because subscription initiates the action, the Observable can be reused;

every Observer that subscribes will cause the Observable to be invoked.

Lazy evaluation has its pros and cons. In many cases, lazy evaluation is

beneficial. For example, if the Observable queries a web service, we likely

want the most up-to-date data, which means that execution should happen

when the Observer subscribes (and not when the Observable is created). The

same should apply for any Observer that subscribes to the Observable; no

matter what time the Observer subscribes, it should get the latest data.

However, if our Observable is retrieving data that will not change, then we

do not want it to make a network round-trip for every subscriber. We’d prefer

eager evaluation in this case and have the Observable get the data once and

hold on to it. RxJava, and its plentiful toolbox of APIs, actually allows for

this with the .cache() operator. In fact, we’ll see how to dictate the laziness

vs. eagerness of an Observable more when we talk about Observable

creation and cold vs. hot Observables in Chapter 2.

Easy Concurrency

In our example, we were able to have the network request executed on a

background thread and then switch back to having the UI be updated on the

main UI thread. This was accomplished with literally two lines of code (using

our .subscribeOn() and .observeOn() Operators). We didn’t have to

manually create a new Thread; we didn’t have to implement an AsyncTask

class and all its methods; we didn’t have to lock or synchronize anything.

This is concurrency made easy. We will take a deeper dive into concurrency

in Chapter 4: Multithreading.

Async Error Handling

Java’s regular error-handling mechanism of throwing/catching exceptions is

ill-equipped at handling concurrency. What happens when the work is

performed on a separate thread? Where would the exception be propagated

to? The Observer does not have a chance to catch and handle this exception

(unless it occurs before the .subscribe() returns, which is unlikely in a non-

blocking function where all the interesting work is performed on a separate

thread after the function returns).

RxJava provides a solution by letting the Observer provide an error callback.

In RxJava, errors are passed down the stream just like any other event. This

allows the Observer to be reactive in the face of failure in the same way it is

reactive with normal events. Also, it does away with the verbose try/catch

construct, which most Java developers would love not having to deal with.

We will discuss more about error handling in Chapter 7.

Functional Reactive Programming (FRP)

There has been a lot of confusion over terminology around the industry. While

reactive programming includes elements of functional programming, it is

debatable whether we can call it “functional reactive programming”.

Functional Reactive Programming (FRP) is a precise, mathematically defined

programming technique defined in 1997 by Conal Elliott and Paul Hudak. And

Rx does not conform to FRP’s precise definition or “continuous time”

requirement where values change continuously over time.

Still, a lot of different resources will still refer to Rx as “functional reactive

programming”, much to the discontent of Conal Elliott. The FRP creator has

been everywhere from StackOverflow to Twitter to call out misappropriations

of his term, but “misuse” of the term has only spread along with Rx’s

popularity. Most of these Rx articles do so without knowledge of the original

FRP specification, although some do so in outright disregard of it because it is

such a convenient term to use when describing Rx.

This book will refrain from describing Rx as “functional reactive

programming” or “FRP”. But we did want to clarify the backstory and let you

make your own decision on how to use the term and how to interpret it as you

come across it in other literature.

As you proceed through this book, keep in mind that there is a significant

learning curve to reactive programming. It requires a different way of

thinking as compared to the regular imperative way of doing things that most

Java programmers are used to. But as with most changes in thinking,

hopefully there’s that a-ha moment where things start to click.

RxJava was designed to handle asynchronicity and event-driven conditions in

a concise, functional, resilient, and reactive way. The more complex your

data streams are and the more inter-dependent they are, the more value you’ll

get out of using RxJava. When data streams (such as network responses) need

to be combined or nested, the old imperative way gets messy quickly; you’ll

quickly find yourself in “callback hell” trying to manage concurrency-related

complexities. RxJava is the way out of this hell.

If you’re lucky enough, however, to have a simple program with completely

independent data streams, then you may find RxJava to be overkill. Being

direct and going imperative might be the way to go in this case rather than

dealing with the RxJava abstraction layer.

Regardless, it is worthwhile to learn reactive programming. RxJava is now

pervasive across platforms–from backend servers to mobile clients–and it has

definitely cemented its place in the Android ecosystem. RxJava is supported

in many open-source Android libraries (Retrofit, to name one very important

one). It’s being embraced by some of the top Android apps in the Play Store.

And Google even designed the new Android Architecture Components with

RxJava in mind, embracing many of its push-based, reactive concepts (the

LiveData class was no doubt based on RxJava’s Observable–there is an API

to convert between the two–and the Room persistence library has an option to

剩余116页未读，继续阅读

OneCrazyStone

粉丝: 5
资源: 45

2017年Android开发必备：RxJava入门与实战指南

Reactive Programming on Android with RxJava

RxSwift.Reactive.Programming.with.Swift.3rd.pdf

RxSwift.Reactive.Programming.with.Swift.v2.0.pdf

RayWenderlich RxSwift : Reactive Programming with Swift 英文高清完整.pdf版下载

Reactive Programming with RxJava.7z

Leanpub.Functional Reactive Programming on iOS.2014.pdf

Apress.Reactive.Programming.with.Angular.and.ngrx

Reactive.Programming.with.Scala.and.Akka.1783984341.epub

Learning.Reactive.Programming.With.Java.8

RxSwift.Reactive.Programming.with.Swift.v2.0

最新资源