android架构师之路——RXJava实现方式解析

简介

一个可观测的序列来组成异步的、基于事件的程序的库。（简单来说：它就是一个实现异步操作的库）

GitHub地址：https://github.com/ReactiveX/Rxjava 

本文得目的

简单解析RXJava原理，RXJava的被观察者，观察者，发射器简单实现，最终完成以下代码

1. 操作符create创建被观察者
2. 转换符map实现字符串转换
3. subscribeOn 线程池转换
4. observeOn主线程转换

    private void test() {
        //创建
        Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) {
                emitter.onNext("125");
                emitter.onComplete();
            }
        });
        //map方法
        observable.map(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                Log.d(TAG, "--apply--" + s+ "---" + Thread.currentThread().getName());
                return Integer.parseInt(s);
            }
        }).subscribeOn()//map方法在线程池中调用
                .observeOn()//主线程中调用
                .subscribe(new Observer<Integer>() { //处理结果
            @Override
            public void onSubscribe(Disposeble d) {
                Log.d(TAG, "onSubscribe   " + d + "---" + Thread.currentThread().getName());
            }

            @Override
            public void onNext(Integer s) {
                Log.d(TAG, "onNext   " + s+ "---" + Thread.currentThread().getName());
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError   " + e+ "---" + Thread.currentThread().getName());
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete   "+ "---" + Thread.currentThread().getName());
            }
        });

    }

具体实现

• 创建被观察者

//创建
Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
        @Override
        public void subscribe(ObservableEmitter<String> emitter) {
             emitter.onNext("125");
             emitter.onComplete();
        }
});

create是在Observable中一个静态方法

    //创建被观察者
    public static<T> Observable<T> create(ObservableOnSubscribe<T> observable) {
        return new ObservableCreate(observable);
    }

create方法中，传递了一个ObservableOnSubscribe接口，这个接口包含了subscribe方法

public interface ObservableOnSubscribe<T> {
    void subscribe(ObservableEmitter<T> emitter);
}

ObservableOnSubscribe这接口中，传递了一个ObservableEmitter接口

public interface ObservableEmitter<T> {
    //发出正常值信号
    void onNext(T value);
    //发出一个Throwable异常信号
    void onError(Throwable throwable);
    //发出完成的信号
    void onComplete();
}

• 创建观察者

public interface Observer<T> {
    void onSubscribe(Disposeble d);

    void onNext(T t);

    void onError(Throwable e);

    void onComplete();
}

• 发射器（链接被观察者与观察者） 这里就是联动观察者与被观察者的主要方法

    //发射器绑定
    public void subscribe(Observer observer) {
        subscribeActual(observer);
    }

联动的具体实现

public class ObservableCreate<T> extends Observable<T> {
    final ObservableOnSubscribe<T> source;

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

    @Override
    protected void subscribeActual(Observer<? super T> observer) {
        CreateEmitter<T> parent = new CreateEmitter<>(observer);
        observer.onSubscribe(parent);   //通知观察者订阅成功

        try {
            source.subscribe(parent);
        } catch (Exception e) {
            e.printStackTrace();
            parent.onError(e);
        }
    }

    static final class CreateEmitter<T> implements ObservableEmitter<T>, Disposeble {
        final Observer<? super T> observer;
        private boolean bool;

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

        @Override
        public void onNext(T value) {
            if(!bool){
                observer.onNext(value); //observer === MapObserver
            }
        }

        @Override
        public void onError(Throwable throwable) {
            if(!bool) {
                observer.onError(throwable);
            }
        }

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

        @Override
        public void dispose(boolean bool) {
            this.bool = bool;
        }

        @Override
        public boolean isDisposed() {
            return bool;
        }
    }
}

map联动具体实现

public class ObservableMap<T, R> extends Observable<R> {
    protected final Observable<T> source;
    final Function<? super T, ? extends R> function;

    public ObservableMap(Observable<T> source, Function<? super T, ? extends R> function) {
        this.function = function;
        this.source = source;
    }

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


    //观察者
    static final  class MapObserver<T, U> extends BasicFuseableObserver<T, U>{
        final Function<? super T, ? extends U> mapper;

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

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

            actual.onNext(apply);
        }
    }
}

线程池方法具体实现

public class ObservableSubscribeOn<T, R> extends Observable<R> {

    protected final Observable<T> source;
    private static ExecutorService executorService = Executors.newCachedThreadPool();
    public ObservableSubscribeOn(Observable<T> source) {
        this.source = source;
    }

    @Override
    protected void subscribeActual(Observer<? super R> observer) {
        //从新包装observer
        final SubscribeOnObserver parent = new SubscribeOnObserver(observer);
        //告诉下游观察者订阅成功
        observer.onSubscribe(parent);
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                source.subscribe(parent);
            }
        });
    }


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

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

        @Override
        public void dispose(boolean bool) {
            this.disposeble.dispose(bool);
        }

        @Override
        public boolean isDisposed() {
            return this.disposeble.isDisposed();
        }

        @Override
        public void onSubscribe(Disposeble d) {
            this.disposeble = d;
        }

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

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

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

主线程联动具体实现

public class ObservableObserveOn<T> extends Observable<T> {

    protected final Observable<T> source;

    public ObservableObserveOn(Observable<T> source) {
        this.source = source;
    }

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


    //包装下游观察者，并关联onNext,.....  放入主线程中执行
    static final class ObserverOnObserver<T> implements Observer<T>, Disposeble {
        final Observer<? super T> actual;
        Disposeble disposeble;
        private Handler handler;
        ObserverOnObserver(Observer<? super T> actual) {
            this.actual = actual;
            handler = new Handler(Looper.getMainLooper());
        }

        @Override
        public void dispose(boolean bool) {
            this.disposeble.dispose(bool);
        }

        @Override
        public boolean isDisposed() {
            return this.disposeble.isDisposed();
        }

        @Override
        public void onSubscribe(Disposeble d) {
            this.disposeble = d;
            actual.onSubscribe(d);
        }

        @Override
        public void onNext(final T t) {
            handler.post(new Runnable() {
                @Override
                public void run() {
                    actual.onNext(t);
                }
            });
        }

        @Override
        public void onError(final Throwable e) {
            handler.post(new Runnable() {
                @Override
                public void run() {
                    actual.onError(e);
                }
            });
        }

        @Override
        public void onComplete() {
            handler.post(new Runnable() {
                @Override
                public void run() {
                    actual.onComplete();
                }
            });
        }
    }
}

一个简单的rxjava就具体实现了，详细请参考demo demo下载地址