RxJava1.x的诞生_2_优化

上一篇我们根据大佬jeasonlzy的资料学习了RxJava1.x的诞生，然后后面还有优化~~这里我也跟一遍~学习一下~

先贴下之前的Observable:

package com.love.flower.rxjavame.rx;

public abstract class Observable<T> {
    /**
     * 这个接口的目的是什么？就是为了用户调用start方法并传入对应的带不同泛型类的callback
     * 得到对应的结果。
     * @param observer
     */
    public abstract void subscribe(Observer<T> observer);

    public <R> Observable<R> map(final Fun1<T,R> fun1){
        final Observable<T> source =this;
        return new Observable<R>() {
            @Override
            public void subscribe(final Observer<R> observer) {
                source.subscribe(new Observer<T>() {
                    @Override
                    public void onNext(T t) {
                        R r = fun1.call(t);
                        observer.onNext(r);
                    }

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


    public <R> Observable<R> flatMap(final Fun1<T, Observable<R>> fun1) {
        final Observable<T> source=this;
        return  new Observable<R>() {
            @Override
            public void subscribe(final Observer<R> observer) {
                source.subscribe(new Observer<T>() {
                    @Override
                    public void onNext(T t) {
                        Observable<R> call = fun1.call(t);
                        call.subscribe(new Observer<R>() {
                            @Override
                            public void onNext(R r) {
                                observer.onNext(r);
                            }

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

                    @Override
                    public void onError(Exception e) {

                    }
                });
            }
        };
    }
}

上一次的Observable里有个抽象类subscribe，也就是之前的start。现在我们直接把它替换为接口。我们新建两个接口：

public interface Action1<T> {
    public void call(T t);
}

public interface OnSubscribe<T> extends Action1<Observer<T>>{

    }

用这两个替换

 public abstract void subscribe(Observer<T> observer);

然后具体Observable就变成了这样:

public class Observable<T> {
    /**
     * 这个接口的目的是什么？就是为了用户调用start方法并传入对应的带不同泛型类的callback
     * 得到对应的结果。
     *
     */
//    public abstract void subscribe(Observer<T> observer);

    public interface OnSubscribe<T> extends Action1<Observer<T>> {

    }

    private OnSubscribe<T> onSubscribe;

    public Observable(OnSubscribe<T> onSubscribe) {
        this.onSubscribe = onSubscribe;
    }

    private void subscribe(Observer<T> observer) {
        onSubscribe.call(observer);
    }

    public <R> Observable<R> map(final Fun1<T, R> fun1) {
        final Observable<T> source = this;
        return new Observable<R>(new OnSubscribe<R>() {
            @Override
            public void call(final Observer<R> rObserver) {
                source.subscribe(new Observer<T>() {
                    @Override
                    public void onNext(T t) {
                        R r = fun1.call(t);
                        rObserver.onNext(r);
                    }

                    @Override
                    public void onError(Exception e) {
                        rObserver.onError(e);
                    }
                });
            }
        });
    }


    public <R> Observable<R> flatMap(final Fun1<T, Observable<R>> fun1) {
        final Observable<T> source = this;
        return new Observable<R>(new OnSubscribe<R>() {
            @Override
            public void call(final Observer<R> rObserver) {
                source.subscribe(new Observer<T>() {
                    @Override
                    public void onNext(T t) {
                        Observable<R> call = fun1.call(t);
                        call.subscribe(new Observer<R>() {
                            @Override
                            public void onNext(R r) {
                                rObserver.onNext(r);
                            }

                            @Override
                            public void onError(Exception e) {
                                rObserver.onError(e);
                            }
                        });
                    }

                    @Override
                    public void onError(Exception e) {

                    }
                });
            }
        });
    }
}

这一顿操作。。我觉得基本就是把抽象类变成接口，同时我们让该接口在外部类中继承，并把接口方法放到外部接口中。。但是我并看不出好处(希望高人指点)所以我继续往下看。。

然后我们将map里改为create方法：

这样我们就可以把new Observable<R> 替换为 create

添加下面这个方法:

 private static <T> Observable<T> create(OnSubscribe<T> onSubscribe) {
        return new Observable<>(onSubscribe);
    }

然后Observable就变为下面的样子：

public class Observable<T> {
    /**
     * 这个接口的目的是什么？就是为了用户调用start方法并传入对应的带不同泛型类的callback
     * 得到对应的结果。
     *
     */
//    public abstract void subscribe(Observer<T> observer);

    public interface OnSubscribe<T> extends Action1<Observer<T>> {

    }

    private OnSubscribe<T> onSubscribe;

    public Observable(OnSubscribe<T> onSubscribe) {
        this.onSubscribe = onSubscribe;
    }

    private void subscribe(Observer<T> observer) {
        onSubscribe.call(observer);
    }

    private static <T> Observable<T> create(OnSubscribe<T> onSubscribe) {
        return new Observable<>(onSubscribe);
    }

    public <R> Observable<R> map(final Fun1<T, R> fun1) {
        final Observable<T> source = this;
        return create(new OnSubscribe<R>() {
            @Override
            public void call(final Observer<R> rObserver) {
                source.subscribe(new Observer<T>() {
                    @Override
                    public void onNext(T t) {
                        R r = fun1.call(t);
                        rObserver.onNext(r);
                    }

                    @Override
                    public void onError(Exception e) {
                        rObserver.onError(e);
                    }
                });
            }
        });
    }


    public <R> Observable<R> flatMap(final Fun1<T, Observable<R>> fun1) {
        final Observable<T> source = this;
        return create(new OnSubscribe<R>() {
            @Override
            public void call(final Observer<R> rObserver) {
                source.subscribe(new Observer<T>() {
                    @Override
                    public void onNext(T t) {
                        Observable<R> call = fun1.call(t);
                        call.subscribe(new Observer<R>() {
                            @Override
                            public void onNext(R r) {
                                rObserver.onNext(r);
                            }

                            @Override
                            public void onError(Exception e) {
                                rObserver.onError(e);
                            }
                        });
                    }

                    @Override
                    public void onError(Exception e) {

                    }
                });
            }
        });
    }
}

然后我们发现这个类里的map 和 flatmap 这种方法的方法体代码比较多，所以我们希望抽出去，毕竟以后要是操作符更多了这个类会很冗长。。

既然要抽，我们就找一下map的特点，需要一个source也就是当前的this对象，create需要一个还有一个Onsubscribe的接口实现对象，map还需要一个fun1，返回一个Observable。所以我们新建一个类进行提取：

public class OnSubscribeMap<T,R> implements Observable.OnSubscribe<R>{
    private  Observable<T> source;
    private  Fun1<T, R> fun1;

    public OnSubscribeMap(Observable<T> observable, Fun1<T,R>fun1) {
        source = observable;
        this.fun1 = fun1;
    }


    @Override
    public void call(final Observer<R> rObserver) {
        source.subscribe(new Observer<T>() {
            @Override
            public void onNext(T t) {
                R r = fun1.call(t);
                rObserver.onNext(r);
            }

            @Override
            public void onError(Exception e) {
                rObserver.onError(e);
            }
        });
    }
}

原理的map就变为:

public <R> Observable<R> map(final Fun1<T, R> fun1) {
        return create(new OnSubscribeMap<>(this,fun1));
    }

我觉得这一步提取很开心~

同理，我们提取一下flatmap：

public class OnSubscribeMap<T,R> implements Observable.OnSubscribe<R>{
    private  Observable<T> source;
    private  Fun1<T, R> fun1;

    public OnSubscribeMap(Observable<T> observable, Fun1<T,R>fun1) {
        source = observable;
        this.fun1 = fun1;
    }


    @Override
    public void call(final Observer<R> rObserver) {
        source.subscribe(new Observer<T>() {
            @Override
            public void onNext(T t) {
                R r = fun1.call(t);
                rObserver.onNext(r);
            }

            @Override
            public void onError(Exception e) {
                rObserver.onError(e);
            }
        });
    }
}

public <R> Observable<R> flatMap(final Fun1<T, Observable<R>> fun1) {
        return create(new OnSubscribeFlatMap<>(this,fun1));
    }

这样就提出来了。

然后基本上Rxjava1.2左右代码就是这样的了。。。

这里再给大佬打下广告吧。。 489873144 大佬带我们使用okgo框架 

大佬GitHub: https://github.com/jeasonlzy

并且我已将我的学习代码上传至https://github.com/zcbcba123/RxjavaMe，以供大家学习分享