Android上使用RxJava实现响应式编程

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

"《Android上的响应式编程：RxJava实战》是一本由Christopher Arriola和Angus Huang合作编写的书籍，于2017年6月27日发布。该书在Leanpub平台上发行，利用了Lean Publishing的理念，即通过轻量级工具进行持续迭代，收集读者反馈，不断优化内容，直到找到最佳的出版形态并积累读者基础。这本书专为Android开发者设计，深入讲解了RxJava在Android应用中的应用。第一部分：RxJava基础知识 1. **什么是响应式编程**：这部分介绍了响应式编程的概念，包括其历史发展，以及如何通过观察和处理数据流的方式提高代码的简洁性和可维护性。 2. **RxJava核心组件**：主要涵盖了三个核心概念：Observable（可观察的序列）、Observer（观察者）和Operator（操作符）。通过 Marble Diagrams（可视化数据流的工具），作者展示了如何创建和理解这些组件的工作原理。此外，区分了冷Observable（首次订阅时才会计算）和热Observable（任何时候订阅都会计算），以及懒加载（Lazy Emissions）的概念。 3. **操作符**：这部分详述了如何使用各种操作符进行数据变换和过滤，如map、filter、combine等，以及如何组合和重用操作符链，以实现灵活的数据处理。 4. **多线程处理**：探讨了异步编程的重要性，如何利用RxJava的调度器（Schedulers）来控制并发和线程间的交互，确保应用程序的性能和用户体验。这本书不仅适合希望学习RxJava的Android开发人员，也适合那些希望通过响应式编程思想优化现有项目的开发者。通过学习本书，读者可以掌握如何将这一强大的工具应用于实际的Android项目中，提升代码的可读性和可扩展性。最后，特别提到了作者Christopher Arriola对妻子Bianca的感激之情，她给予了他无尽的灵感和支持。"

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页未读，继续阅读

caofeng891102

粉丝: 171
资源: 1238

Android上使用RxJava实现响应式编程

Reactive Programming on Android with RxJava (2017).pdf

Reactive Programming with RxJava

ref和reactive

module "rxjava_reactive-streams-1.0.4" variant "android_common": module source path "vendor/qcom/proprietary/ais/test/Carlog/libs/rxjava/reactive-streams-1.0.4.jar" does not exist 11:37:22 soong bootstrap failed with: exit status 1 报错含义

推荐学习 project-reactor的博客

推荐几篇 webflux的培训教程

hibernate reactive panache

vue.runtime.esm.js:620 [Vue warn]: Cannot set reactive property on undefined, null, or primitive value: undefined

java Flowable 学习教程

value cannot be made reactive

最新资源