RxJava编程：解决回调地狱与大数据云应用

需积分: 24 8 浏览量更新于2024-07-20 收藏 3.68MB PDF 举报

"《Reactive Java Programming》是一本专注于使用Java进行反应式编程的书籍，主要介绍了如何通过RxJava解决回调地狱问题，并教你如何编写无状态变量的线程安全代码，这对于处理大数据流处理和云计算软件服务问题尤其有用。书中还涵盖了反应式Android编程，适合对Java有经验但对反应式编程不熟悉的开发者。内容包括Observables、Observers、Subjects、Schedulers、Backpressure等关键概念，以及如何在网络编程和Android开发中应用RxJava。" 在这本书中，作者Andrea Maglie深入探讨了反应式编程的概念和实践，特别强调了RxJava在Java生态系统中的应用。以下是你可以从这本书中学到的一些核心知识点： 1. **ReactiveX和RxJava**: ReactiveX是一个反应式编程库，而RxJava是其在Java平台上的实现。它提供了一种声明式的编程方式，允许开发者处理异步数据流。 2. **Observables和Observers**: Observables是数据流的生产者，而Observers是消费者。学习如何创建和订阅Observables，以及如何使用Observers处理这些数据流是理解RxJava的基础。 3. **Subscription生命周期**: 了解订阅的开始、执行和结束过程至关重要，因为这直接影响到资源管理，防止内存泄漏和不必要的计算。 4. **Subjects**: Subjects是特殊的Observables，它们既是观察者也是可观察的对象，可以在不同线程间共享数据，是数据源和观察者之间的桥梁。 5. **网络编程与RxJava和Retrofit**: 使用RxJava与Retrofit结合，可以优雅地处理HTTP请求和响应，简化异步网络调用。 6. **RxJava和Android**: 反应式编程在Android开发中的应用，包括如何在Android事件驱动环境中使用RxJava，提高代码的可测试性和可维护性。 7. **过滤和组合事件**: 学习如何使用filter、map、concatMap、switchMap等操作符来过滤和转换事件，以满足特定业务需求。 8. **使用Schedulers**: Schedulers允许你在不同的线程上调度任务，有效地进行并行处理和线程管理。 9. **背压（Backpressure）**: 在高并发或大数据流场景下，背压策略是必需的，它可以避免数据过载，确保系统稳定运行。 10. **测试RxJava代码**: 学习如何编写单元测试和集成测试，确保反应式代码的正确性和可靠性。 11. **自定义操作符**: 当内置的操作符无法满足需求时，你可以编写自己的操作符来扩展RxJava的功能。这本书适合那些有一定Java基础，希望通过反应式编程提升效率和代码质量的开发者。通过学习，你将能够将反应式编程应用到自己的大数据云应用中，构建更高效、更易于维护的系统。

CHAPTER 1 ■ REACTIVEX AND RXJAVA

• Concurrency : Concurrency is supported and is safer to

implement, thanks also to the immutability by default.

• Referential transparency : This term defines the fact that

computations can be performed at any time, always producing

the same result (similar to static methods in Java).

• Lazy evaluation : Values can be computed only when needed

(lazily) because functions can be evaluated at any time, always

giving the same result (these functions do not depend on the

program’s internal state).

There are programming languages that are defined as purely functional

programming languages, like Haskell, Hope, and Mercury. Java is not one of these

languages, but we can get the advantages of functional programming also in Java.

With the release of Java 8, some constructs of functional programming have been

added, like lambda functions and streams. But with the RxJava library we can use

concepts of functional programming with Java 1.7 and Java 1.6.

Lambda Expressions

Lambda expressions are anonymous functions; the lambda operator is indicated using an

arrow symbol pointing to the right (->). Inputs are placed at the left of the operator, and

the function body is placed at the right.

In Java, lambda expressions can be used to replace anonymous inner classes that

implement an interface with just one method. For example, consider the following

Button object:

class Button {

...

setOnClickListener(OnButtonClickListener listener) {

...

}

interface OnButtonClickListener {

void onButtonClicked();

}

To attach a click listener to the Button , you can use an anonymous function:

Button button = ...

button.setOnClickListener(

new OnButtonClickListener() {

void onButtonClicked() {

// do something on button clicked

}

)

CHAPTER 1 ■ REACTIVEX AND RXJAVA

Using lambda expressions, the code above becomes the following:

Button button = ...

button.setOnClickListener( () -> // do something on button clicked )

On the right side of the lambda operator you include all of the code to be executed

when the button is clicked; this code has no input, as indicated by the two brackets on the

left side of the lambda operator.

If the method onButtonClicked accepts some parameters, the example above

becomes

interface OnButtonClickListener {

void onButtonClicked(Object param);

}

Button button = ...

button.setOnClickListener( param ->

// do something on button clicked

// param can be used in this code block

)

Java support for lambda expressions was introduced in Java 8, but you can use them

in previous Java versions using the retrolambda library (

https://github.com/evant/

gradle-retrolambda

Imperative or Functional?

So, why should you choose functional programming over imperative programming?

Functional code is often shorter and easier to understand than the corresponding

imperative code. You can do the same work by writing less code, and every programmer

knows that less code leads to less bugs.

In imperative programming, implementing abstraction requires you to define

interfaces and split code into components that implement those interfaces; functional

languages make it easier to create abstractions (just think about how lambda expressions

avoid the necessity of creating interfaces with implementations).

Reactive Programming

Reactive programming takes functional programming a little bit further, by adding the

concept of data flows (see the next section) and propagation of data changes.

In imperative programming, a value can be assigned to a variable in the following way:

x = y + z

Here, the sum of y and z will be assigned to variable x at the same time that

the function is called; later, variables y and z can change, but these changes will not

automatically influence the value of x .

CHAPTER 1 ■ REACTIVEX AND RXJAVA

In reactive programming, the value of x should updated whenever the values of y or z

change.

So, if the initial values are y = 1 and z = 1 , you’ll have

x = y + z = 2 .

If y (or z ) changes its value, this does not mean that x changes automatically, but you

must implement a mechanism to update the values of x when values of y and z are changed.

Functional reactive programming is a new programming paradigm; it was made

popular by Erik Meijer (who created the Rx library for .NET when working at Microsoft)

and it’s based on two concepts:

• Code “reacts” to events.

• Code handles values as they vary in time, propagating changes to

every part of the code that uses those values.

Streams of Data

The key to understand reactive programming is to think about it as operating on a stream

of data.

But what do I mean by “stream of data?” I mean a sequence of events, where an

event could be user input (like a tap on a button), a response from an API request (like a

Facebook feed), data contained in a collection, or even a single variable.

In reactive programming, there's often a component that acts as the source, emitting

a sequence of items (or a stream of data), and some other components that observe this

flow of items and react to each emitted item (they “react” to item emission).

The Observer Pattern

The Observer pattern is a design pattern in which there are two kinds of objects:

observers and subjects. An observer is an object that observes the changes of one or more

subjects; a subject is an object that keeps a list of its observers and automatically notifies

them when it changes its state.

The definition of the Observer pattern from the “Gang of Four” book ( Design

Patterns: Elements of Reusable Object-Oriented Software by Erich Gamma, Richard Helm,

Ralph Johnson, and John Vlissides, ISBN 0-201-63361-2) is to

“Define a one-to-many dependency between objects so that when

one object changes state, all its dependents are notified and updated

automatically.”

This pattern is the core of reactive programming. It fits perfectly the concept of

reactive programming by providing the structures to implement the produce/react

mechanism.

剩余114页未读，继续阅读

ramissue

粉丝: 354
资源: 1487

RxJava编程：解决回调地狱与大数据云应用

React小书（完整版）1

React中文入门教程 pdf 下载

Reactive Streams in Java.pdf

近3年的Java参考文献

Spring Security 5.0

推荐学习 project-reactor的博客

project reactor教程

SpringBoot相关的外文文献有哪些

Spring Security 5.x

java spring boot 外文文献

最新资源