6.从架构设计角度分析AAC源码-Rxjava2源码解析第1篇：Rxjava2观察者模式去理解源码

本文链接：https://blog.csdn.net/foshengtang/article/details/125971391

demo

Observable observable = Observable.create(new ObservableOnSubscribe<String>() {
        @Override
        public void subscribe(ObservableEmitter<String> emitter) throws Exception {
            emitter.onNext("1");
            emitter.onNext("2");
            emitter.onNext("3");
            emitter.onNext("4");
            emitter.onComplete();
        }
    });
    
    Observer observer = new Observer<String>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.d(TAG, "onSubscribe");
        }

        @Override
        public void onNext(String s) {
            Log.d(TAG, "s = " + s);
        }

        @Override
        public void onError(Throwable e) {

        }

        @Override
        public void onComplete() {
            Log.d(TAG, "完成 "  );
        }
    };

    observable.subscribe(observer);

打印结果：

onSubscribe
1
2
3
4
完成

观察者模式

定义

观察者模式（Observer Design Pattern）：在对象之间定义一个一对多的依赖，当一个对象状态改变的时候，所有依赖的对象都会得到通知并自动更新。

也叫发布订阅模式，能够很好的解耦一个对象改变，自动改变另一个对象这种情况。

Rxjava2观察者模式理解

被观察者：

 Observable observable = Observable.create(new ObservableOnSubscribe<String>() {
         @Override
         public void subscribe(ObservableEmitter<String> emitter) throws Exception {
             emitter.onNext("1");
             emitter.onNext("2");
             emitter.onNext("3");
             emitter.onNext("4");
             emitter.onComplete();
         }
     });

观察者：

 Observer observer = new Observer<String>() {
         @Override
         public void onSubscribe(Disposable d) {
             Log.d(TAG, "onSubscribe");
         }

         @Override
         public void onNext(String s) {
             Log.d(TAG, "s = " + s);
         }

         @Override
         public void onError(Throwable e) {

         }

         @Override
         public void onComplete() {
             Log.d(TAG, "完成 "  );
         }
     };

<被观察者>被<观察者>订阅：观察者依赖（或者叫订阅）于被观察者。
```
 observable.subscribe(observer);
```
如何体现一对多的依赖（订阅）关系：可以再次创建一个观察者订阅当前被观察者。

在被观察者subscribe方法中有一个参数ObservableEmitter表示发射器，调用onNext、onComplete方法表示发射数据、数据完成发射。

 Observable observable = Observable.create(new ObservableOnSubscribe<String>() {
         @Override
         public void subscribe(ObservableEmitter<String> emitter) throws Exception {
             emitter.onNext("1");
             emitter.onNext("2");
             emitter.onNext("3");
             emitter.onNext("4");
             emitter.onComplete();
         }
     });

所以总结如下：

定义一个被观察者；
定义一个或多个观察者；
被观察者.被订阅在.观察者上；
被观察者订阅方法传递一个发射器，调用其方法发射数据。

架构设计思路

初步设计思路

定义一个发射器：用于发射数据、发射完成处理、发射异常处理；

 public interface Emitter<T> {

 	//发射数据
 	public void onNext(T t);

 	//发射完成
 	public void complete();

 	//发射异常
 	public void onError(Throwable t);

 }

定义一个观察者：对发射的数据处理、发射完成处理、发射异常处理；

 public interface Observer<T>{
 	
 	public void onNext(T t);
 	
 	public void complete();

 	public void onError(Throwable t);
 }

定义一个被观察者：被观察者执行被(观察者)订阅的方法，该订阅方法（将观察者作为参数传递）调用时创建发射器；

 public interface ObservableOnSubscribe<T>{

 	//传递一个发射器，用于发射数据...
 	public void subscribe(Emitter emitter);
 }

 
 public final class ObservableCreate<T> {
 	  public ObservableCreate(ObservableOnSubscribe<T> source) {
     	this.source = source;
 	}

 	//将观察者作为参数传递
 	public void subscribe(final Observer<? super T> observer){
 		Emmitter emmitter = new Emmitter(){
 			public void onNext(T t){
 				observer.onNext();
 			}

 			public void complete(){
 				observer.complete();
 			}

 			public void onError(){
 				onbserver.onError();
 			}

 		};

 		try {
             source.subscribe(emmitter);
         } catch (Throwable ex) {
             Exceptions.throwIfFatal(ex);
             emmitter.onError(ex);
         }	
 	}
 }

执行案例如下：

//1. 被观察者：被观察者中创建发射器
ObservableCreate observableCreate = new ObservableCreate(new ObservableOnSubscribe<String>() {
        @Override
        public void subscribe(Emitter<String> emitter) throws Exception {
			//发射器发射数据
            emitter.onNext("1");
            emitter.onNext("2");
            emitter.onNext("3");
            emitter.onNext("4");
			//发射完成
            emitter.onComplete();
        }
    });

//2.观察者
Observer observer = new Observer<String>() {
       
        @Override
        public void onNext(String s) {
            Log.d(TAG, "s = " + s);
        }

        @Override
        public void onError(Throwable e) {

        }

        @Override
        public void onComplete() {
            Log.d(TAG, "完成 "  );
        }
    };

//3. 被观察者 被(观察者)订阅
observableCreate.subscribe(observer);

以上手敲版代码，就是当前观察者模式下Rxjava2源码的主体结构。

和Rxjava2源码源码比较

Observable作为基类，ObservableCreate类用于创建被观察者继承Observable；
观察者Observer接口，多了一个onSubscribe方法，该方法可用于手动切断当前观察者和被观察者之间的联系 - **该方法的调用一定是在执行观察者其他方法之前，或者说在执行被观察者发射器发射数据前。**我们看ObservableCreate的subscribeActual方法

在这里插入图片描述

代码细节

我们再去仔细看看源码细节，同样有不小的收获。

上下游（很重要）：通过构造函数传递过来的参数我们理解为上游对象；通过subscribeActual方法传递的参数我们理解为下游对象；
事务传递：在ObservableCreate订阅方法subscribeActual中创建发射器 -> 被观察者操作发射器（发射数据以及发射完毕处理）方法 -> 发射器方法调用观察者方法。**发射器方法是否能调用观察者对象的方法体现了事务的传递。**因为在发射器方法调用观察者对象方法时，会先判断!isDisposed()才会执行观察者对象方法，案例如下ObservableCreate类中的CreateEmitter类发射方法：
```
 @Override
 public void onNext(T t) {
     if (t == null) {
         onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
         return;
     }
     if (!isDisposed()) {
         observer.onNext(t);
     }
 }
```

hook钩子函数

看一段案例：

RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));

什么是hook技术

Hook 技术又叫做钩子函数，在系统没有调用该函数之前，钩子程序就先捕获该消息，钩子函数先得到控制权，这时钩子函数既可以加工处理（改变）该函数的执行行为，还可以强制结束消息的传递。简单来说，就是把系统的程序拉出来变成我们自己执行代码片段。

理解一下即可，这里其实并没有使用到hook技术，但是还是做了这一步处理，为了方便后期扩展或者说程序猿得到钩子函数的控制权去处理额外的代码逻辑。

总结

这里只是简单的使用观察者模式去理解一下Rxjava2源码，当然了，装饰器模式也可以去理解。

但是Rxjava2的核心是异步和数据流（操作符）。我们继续往下讲。