java响应式编程框架_还不会Rxjava响应式编程框架设计，先从这篇文章入手-CSDN博客

本文链接：https://blog.csdn.net/weixin_42116805/article/details/114791330

一.Rxjava是什么

Rxjava在GitHub 主页上的自我介绍是 "a library for composing asynchronous and event-based programs using observable sequences for the Java VM"(一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库)。

通俗来说，Rxjava是一个采用了观察者模式设计处理异步的框架。链式调用设计让代码优雅易读。

举个例子：

Observable observable = Observable.create(new ObservableOnSubscribe() {

@Override

public void subscribe(ObservableEmitter e) throws Exception {

e.onNext("a");

}

});

observable.subscribe(new Observer() {

@Override

public void onSubscribe(Disposable d) {

}

@Override

public void onNext(String s) {

}

@Override

public void onError(Throwable e) {

}

@Override

public void onComplete() {

}

});

这是Rxjava2最简单的用法：

1.创建一个Observable，重写subscribe方法，这里主要处理被观察的事件。

2.订阅这个Observable，事件会回调observer的方法，我们可以对事件做响应的处理

二.Rxjava源码解析

2.1. 创建Observable：

创建Observable用的是Observable.create(ObservableOnSubscribe source)方法。这个方法的参数是ObservableOnSubscribe：

public interface ObservableOnSubscribe {

/**

* Called for each Observer that subscribes.

* @param e the safe emitter instance, never null

* @throws Exception on error

void subscribe(@NonNull ObservableEmitter e) throws Exception;

}

ObservableOnSubscribe是一个接口，唯一的方法是subscribe，参数是ObservableEmitter e。ObservableEmitter是一个继承了Emitter的接口，接口Emitter里定义了onNext、onError、onComplete等方法，和Observer(观察者)的方法相对应。

public interface Emitter {

/**

* Signal a normal value.

* @param value the value to signal, not null

void onNext(@NonNull T value);

/**

* Signal a Throwable exception.

* @param error the Throwable to signal, not null

void onError(@NonNull Throwable error);

/**

* Signal a completion.

void onComplete();

}

ObservableEmitter对接口Emitter进行扩展，增加了setDisposable、setCancellable等方法

基本参数了解了，现在看看create方法里面做了什么，代码如下：

public static Observable create(ObservableOnSubscribe source) {

return RxJavaPlugins.onAssembly(new ObservableCreate(source));

}

调用了RxJavaPlugins的onAssembly方法。又有一个新参数ObservableCreate(source)，我们看看它是什么：

final class ObservableCreate extends Observable {

public ObservableCreate(ObservableOnSubscribe source) {

this.source = source;

}

继承了Observable，所以也是个被观察对象，在构造函数中我们看到我们new的ObservableOnSubscribe对象，被存在了ObservableCreate的source里面

那我们继续看看onAssembly方法做什么：

public static Observable onAssembly(@NonNull Observable source) {

Function super Observable, ? extends Observable> f = onObservableAssembly;

if (f != null) {

return apply(f, source);

}

return source;

}

一个Hook方法。onObservableAssembly是一个静态变量，我们没有设置，默认为空，所以直接返回source对象。也就是说，Observable的create方法其实就是把我们ObservableOnSubscribe对象，存储在ObservableCreate对象的source里面，然后返回ObservableCreate对象。

我们知道ObservableCreate是继承Observable的，所以创建了ObservableCreate对象，我们的Observable也就创建完了。

2.2 订阅事件(被观察者)

订阅被观察者的操作是observable.subscribe(new Observer())。这个操作符其实是个“被动”，就是事件被观察者观察。因为subscribe方法里的参数Observer才是观察者。我们也会在Observer里的各个会调方法里接收到事件相关的返回值。

我们看看subscribe方法的源码：

public final void subscribe(Observer super T> observer) {

try {

subscribeActual(observer);

} catch (NullPointerException e) { // NOPMD

throw e;

} catch (Throwable e) {

RxJavaPlugins.onError(e);

}

看代码我们知道最主要调用的方法是：subscribeActual(observer);，这个方法是Observable里的抽象方法，而此时我们的Observable是一个ObservableCreate对象(前面create方法返回的对象)。所以我们去看一下ObservableCreate里面是如何重写这个方法的。代码如下：

protected void subscribeActual(Observer super T> observer) {

CreateEmitter parent = new CreateEmitter(observer);

observer.onSubscribe(parent);

try {

source.subscribe(parent);

} catch (Throwable ex) {

Exceptions.throwIfFatal(ex);

parent.onError(ex);

}

我们一看到这个方法主要做了三件事：

①创建一个CreateEmitter对象parent。

②把parent传给source的subscribe方法。上面我们知道source就是刚才存的ObservableOnSubscribe对象，subscribe也就是我们重写的方法：