手写Rxjava 装饰器模式

1.抽象观察者

/**
 * 抽象观察者
 * @param <T>
 */
public interface Observer<T> {
    //用于订阅成功的回调
    void onSubscribe();
    //收到消息
    void onNext(T t);
    //出错的回调
    void onError(Throwable e);
    //从订阅到消息全部发送成功
    void onComplete();
}

2.抽象被观察者

public interface ObservableSource<T> {
    void subscribe(Observer<T> observer);
}

3.定义消息发送功能

public interface ObservableOnSubscribe<T> {
    //为每个订阅的观察者提供一个能进行消息发送的功能
    void subscribe(Emitter<T> emitter);
}

/**
 * 定义发送消息的接口
 */
public interface Emitter<T> {
    //发送消息
    void onNext(T t);
    //发送异常
    void onError(Throwable e);
    //发送完成的信号
    void onComplete();
}

4.具体的被观察者

/**
 * 具体的被观察者
 */
public abstract class Observable<T> implements ObservableSource {

    @SuppressWarnings("unchecked")
    @Override
    public void subscribe(Observer observer) {
        subscribeActual(observer);
    }

    protected abstract void subscribeActual(Observer<T> observer);


    //创造被观察者的实例
    public static<T> Observable create(ObservableOnSubscribe<T> source){
        return new ObservableCreate<>(source);
    }

    //创建被观察者
    @SuppressWarnings("unchecked")
    public<U> Observable<U> map(Function<T,U> function){
        return new ObservableMap<>(this,function);
    }

    //被观察者的线程切换
    @SuppressWarnings("unchecked")
    public final Observable<T> subscribeOn(){
        return new ObservableSubscribeOn<>(this);
    }

    //观察者的线程切换
    @SuppressWarnings("unchecked")
    public final Observable<T> observeOn(){
        return new ObservableObserveOn<>(this);
    }
}

5.创建被观察者对象的类

/**
 * 用来创建被观察者对象
 */
public class ObservableCreate<T> extends Observable<T> {
    private ObservableOnSubscribe<T> source;
    public ObservableCreate(ObservableOnSubscribe<T> source){
        this.source = source;
    }

    @Override
    public void subscribe(Observer observer) {
        super.subscribe(observer);
    }
    @SuppressWarnings("unchecked")
    //如果订阅功能实现了，在这里就要通知observer消息更新了
    @Override
    protected void subscribeActual(Observer observer) {

        CreateEmitter<T> parent = new CreateEmitter<T>(observer);
        observer.onSubscribe();
        //把发射器和被观察者绑定在一起（完成订阅）
        source.subscribe(parent);
    }



    static final class CreateEmitter<T> implements Emitter<T>{

        Observer<T> observer;

        public CreateEmitter(Observer<T> observer) {
            this.observer = observer;
        }

        @Override
        public void onNext(T t) {
            observer.onNext(t);
        }

        @Override
        public void onError(Throwable e) {
            observer.onError(e);
        }

        @Override
        public void onComplete() {
            observer.onComplete();
        }
    }
}

6.模拟Rxjava的map类，这里用到了装饰器模式
（1）装饰器中间类

//装饰器模式中间类
public abstract class AbstractObservableWithUpstream<T,R> extends Observable<R> {
    protected final ObservableSource<T> source;
    public AbstractObservableWithUpstream(ObservableSource<T> source){
        this.source = source;
    }
}

（2）Function类实现转换与传递功能

//实现转换与传递功能
public interface Function<T,R>{
    //对输入值运用一些计算，得到一个结果，再传到下游
    R apply(T t);
}

（3）中间观察者BaseicFuseableObserver

public abstract class BaseicFuseableObserver<T,R> implements Observer<T> {

    protected final Observer<R> actual;

    public BaseicFuseableObserver(Observer<R> actual) {
        this.actual = actual;
    }

    @Override
    public void onSubscribe() {
        actual.onSubscribe();
    }


    @Override
    public void onError(Throwable e) {
        actual.onError(e);
    }

    @Override
    public void onComplete() {
        actual.onComplete();
    }
}

（4）具体map的实现类

public class ObservableMap<T,U> extends AbstractObservableWithUpstream<T,U> {

    final Function<T,U> function;

    public ObservableMap(ObservableSource<T> source, Function<T, U> function) {
        super(source);
        this.function = function;
    }

    @Override
    protected void subscribeActual(Observer<U> observer) {
        source.subscribe(new MapObserver<>(observer,function));
    }

    static final class MapObserver<T,U> extends BaseicFuseableObserver<T,U>{
        final Function<T,U> mapper;

        public MapObserver(Observer<U> actual, Function<T, U> mapper) {
            super(actual);
            this.mapper = mapper;
        }

        @Override
        public void onNext(T t) {
            U apply = mapper.apply(t);
            actual.onNext(apply);
        }
    }
}

7.让被观察者运行在io线程中的类

public class ObservableSubscribeOn<T> extends AbstractObservableWithUpstream<T,T>{

    private static ExecutorService executorService = Executors.newCachedThreadPool();

    public ObservableSubscribeOn(ObservableSource<T> source) {
        super(source);
    }

    @Override
    protected void subscribeActual(Observer<T> observer) {
        final SubscribeOnObserver<T> parent = new SubscribeOnObserver<>(observer);
//        observer.onSubscribe();
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                source.subscribe(parent);
            }
        });
    }

    static final class SubscribeOnObserver<T> implements Observer<T>{
        final Observer<? super T> actual;

        public SubscribeOnObserver(Observer<? super T> actual) {
            this.actual = actual;
        }

        @Override
        public void onSubscribe() {
            actual.onSubscribe();
        }

        @Override
        public void onNext(T t) {
            actual.onNext(t);
        }

        @Override
        public void onError(Throwable e) {
            actual.onError(e);
        }

        @Override
        public void onComplete() {
            actual.onComplete();
        }
    }
}

8.让观察者运行在主线程中

public class ObservableObserveOn<T> extends AbstractObservableWithUpstream<T,T>{
    
    public ObservableObserveOn(ObservableSource<T> source) {
        super(source);
    }

    @Override
    protected void subscribeActual(Observer<T> observer) {
        final ObserverOnObserver<T> parent = new ObserverOnObserver<>(observer);
        source.subscribe(parent);
    }

    static final class ObserverOnObserver<T> implements Observer<T>{
        final Observer<? super T> actual;
        private final Handler handler;

        public ObserverOnObserver(Observer<? super T> actual) {
            this.actual = actual;
            handler = new Handler(Looper.getMainLooper());
        }

        @Override
        public void onSubscribe() {
            actual.onSubscribe();
        }

        @Override
        public void onNext(final T t) {
            handler.post(new Runnable() {
                @Override
                public void run() {
                    Log.i("TAG","切回主线程");
                    actual.onNext(t);
                }
            });
        }

        @Override
        public void onError(Throwable e) {
            actual.onError(e);
        }

        @Override
        public void onComplete() {
            actual.onComplete();
        }
    }
}

9.实例

Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(Emitter<String> emitter) {
                emitter.onNext("大家好");
            }
        }).map(new Function<String,String>() {
            @Override
            public String apply(String o) {
                return o + "，哈哈哈";
            }
        }).subscribeOn()
                .observeOn()
                .subscribe(new Observer() {
            @Override
            public void onSubscribe() {
                Log.i("TAG","订阅成功" + Thread.currentThread().getName());
            }

            @Override
            public void onNext(Object o) {
                Log.i("TAG","调用onNext：" + Thread.currentThread().getName() + (String)o);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });

10.传递关系：
Observable.create().map().subscribeOn().observeOn().subscribe(observer)调用关系如下：
ObservableCreate -> ObservableMap -> ObservableSubscribeOn -> ObservableObserveOn
调用Observable的subscribe()方法时，依次反向调用了ObservableObserveOn、ObservableSubscribeOn、ObservableMap、ObservableCreate的subscribeActual()方法，然后正向依次调用ObservableCreate、ObservableMap、ObservableSubscribeOn、ObservableObserveOn里面的CreateEmitter、MapObserver、SubscribeOnObserver、ObserverOnObserver中的方法来向observer发送消息。