手写rxjava事件变换

首先还是看怎么使用

 Observable.just("http://d.paper.i4.cn/max/2016/10/10/15/1476085552237_716159.jpg")
                .map(new Function<String, Bitmap>() {
                    @Override
                    public Bitmap apply(@NonNull String s) throws Exception {
                        URL url = new URL("http://d.paper.i4.cn/max/2016/10/10/15/1476085552237_716159.jpg");
                        HttpURLConnection httpsURLConnection = (HttpURLConnection) url.openConnection();
                        httpsURLConnection.connect();
                        InputStream inputStream = httpsURLConnection.getInputStream();
                        Bitmap bitmap = BitmapFactory.decodeStream(inputStream);
                        return bitmap;
                    }
                }).map(new Function<Bitmap, Bitmap>() {
            @Override
            public Bitmap apply(@NonNull Bitmap bitmap) throws Exception {
                bitmap = createWatermark(bitmap, "rxjava");
                return bitmap;
            }
        }).subscribeOn(Schedulers.io()).
                observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<Bitmap>() {
                    @Override
                    public void accept(Bitmap bitmap) throws Exception {
                        mImage.setImageBitmap(bitmap);
                    }
                });

看源码分析

just源码分析

    public static <T> Observable<T> just(T item) {
        ObjectHelper.requireNonNull(item, "The item is null");
        //将String转换成ObservableJust对象
        return RxJavaPlugins.onAssembly(new ObservableJust<T>(item));
    }

接下来看这个源码subscribe(new Consumer() ）

Consumer源码分析

public interface Consumer<T> {
     //泛型接口,T肯定是我们转换后的类型
    void accept(T t) throws Exception;
}

subscribe源码分析

 public final Disposable subscribe(Consumer<? super T> onNext) {
 return subscribe(onNext, Functions.ON_ERROR_MISSING, Functions.EMPTY_ACTION, Functions.emptyConsumer());
    }

public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
            Action onComplete, Consumer<? super Disposable> onSubscribe) {
        ObjectHelper.requireNonNull(onNext, "onNext is null");
        ObjectHelper.requireNonNull(onError, "onError is null");
        ObjectHelper.requireNonNull(onComplete, "onComplete is null");
        ObjectHelper.requireNonNull(onSubscribe, "onSubscribe is null");
         //将传入的参数进行封装，实际上这时候简单点可以看成我们自己复写的是observer的onNext方法
        LambdaObserver<T> ls = new LambdaObserver<T>(onNext, onError, onComplete, onSubscribe);
         //又调用订阅方法，这个上篇文章解析过
        subscribe(ls);

        return ls;
    }

自己手写subscribe方法

首先还是写观察者接口

public interface Observer<T>  {
    void onSubscribe();
    void onNext(@NonNull T s);
    void onError(@NonNull Throwable e);
    void onComplete();
}

然后写订阅接口ObservableSource

public interface ObservableSource<T> {
    void subscribe(@NonNull Observer<? super T> observer);
}

ObservableJust对象封装

public class ObservableJust<T> extends Observable<T> {
    private T item;
    public ObservableJust(T item) {
     this.item=item;
    }


    @Override
    protected void subscribeActual(Observer<? super T> observer) {
        //对observer和value进行封装
        ScalarDisposable sd=new ScalarDisposable(observer,item);
        observer.onSubscribe();
        sd.run();
    }
    //执行在这个类
    private class ScalarDisposable<T>{
        private Observer observer;
        private T item;

        public ScalarDisposable(Observer<T> observer, T item) {
            this.observer = observer;
            this.item = item;
        }

        public void run() {
            try {
                observer.onNext(item);
                observer.onComplete();
            } catch (Exception e) {
                observer.onError(e);
            }

        }
    }
}

然后先写MainActivity的使用

 Observable.just("http://d.paper.i4.cn/max/2016/10/10/15/1476085552237_716159.jpg")
               .subscribe(new Consumer<String>() {
                   @Override
                   public void onNext(String item) {
                        Log.e("TAG",item);
                   }
               });

Consumer接口

public interface Consumer<T>  {
    void onNext(T item);
}

Observable

public abstract class Observable<T> implements ObservableSource<T> {
    public static <T> Observable<T> just(T item) {
        return onAssembly(new ObservableJust<T>(item));
    }
    //实际就是返回ObservableJust对象
    private static <T> Observable<T> onAssembly(ObservableJust<T> source) {
        return source;
    }

    @Override
    public void subscribe(@NonNull Observer<? super T> observer) {
          subscribeActual(observer);
    }
     //订阅
    protected abstract void subscribeActual(Observer<? super T> observer);

    public void subscribe(Consumer<T> consumer){//实际调用的还是consumer封装成Observer
          subscribe(new LambdaObserver(consumer));
    }
}

LambdaObserver

public class LambdaObserver<T> implements Observer<T> {
    private Consumer<T> mConsumer;
    public  LambdaObserver(Consumer<T> consumer) {
        this.mConsumer=consumer;
    }

    @Override
    public void onSubscribe() {

    }

    @Override
    public void onNext(@NonNull T s) {
      mConsumer.onNext(s);
    }

    @Override
    public void onError(@NonNull Throwable e) {

    }

    @Override
    public void onComplete() {

    }
}

Map操作符源码分析

map(new Function

public interface Function<T, R> {
    //T是我们传的，这里是String,R使我们的目标，这里是Bitmap 
    R apply(@NonNull T t) throws Exception;
}

map源码分析

  public final <R> Observable<R> map(Function<? super T, ? extends R> mapper) {
        ObjectHelper.requireNonNull(mapper, "mapper is null");
        //实际是将我们的传入的参数和目标转换成ObservableMap   this是ObservableSource
        return RxJavaPlugins.onAssembly(new ObservableMap<T, R>(this, mapper));
    }

ObservableMap看这个类,它会复写subscribeActual

   public void subscribeActual(Observer<? super U> t) {
         //代理对象的订阅方法  MapObserver再次封装
        source.subscribe(new MapObserver<T, U>(t, function));
    }

手写map操作符

首先看MainActivity的使用

  new Thread(new Runnable() {
            @Override
            public void run() {
                Observable.just("http://img.taopic.com/uploads/allimg/130331/240460-13033106243430.jpg")
                        .map(new Function<String, Bitmap>() {
                            @Override
                            public Bitmap apply(String urlPath) throws Exception {
                                // 第五步
                                URL url = new URL(urlPath);
                                HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
                                InputStream inputStream = urlConnection.getInputStream();
                                Bitmap bitmap = BitmapFactory.decodeStream(inputStream);
                                return bitmap;
                            }
                        })
                        .map(new Function<Bitmap, Bitmap>() {
                            @Override
                            public Bitmap apply(@NonNull Bitmap bitmap) throws Exception {
                                bitmap = createWatermark(bitmap, "RxJava2.0");
                                return bitmap;
                            }
                        })
                        .map(new Function<Bitmap, Bitmap>() {
                            @Override
                            public Bitmap apply(Bitmap bitmap) throws Exception {
                                return bitmap;
                            }
                        })
                        .subscribe(new Consumer<Bitmap>() {
                            @Override
                            public void onNext(final Bitmap bitmap) {
                                // 第七步
                                Log.e("TAG", "item = " + bitmap);
                                runOnUiThread(new Runnable() {
                                    @Override
                                    public void run() {
                                        mImage.setImageBitmap(bitmap);
                                    }
                                });
                            }
                        });
            }
        }).start();

Function接口

//R是目标
public interface Function<T,R> {
    R apply(T t) throws Exception;
}

Obserable添加代码

public <R> Observable<R> map(Function<T, R> function){
        //String,Bitmap封装到ObservableJust
        return onAssembly(new ObservableMap<>(this,function));
    }

ObservableMap类

public class ObservableMap<T, R> extends Observable<R> {
    final Observable<T> source;// 前面的 Observable
    final Function<T, R> function;// 当前转换

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

    //重新复写了订阅
    @Override
    protected void subscribeActual(Observer<? super R> observer) {
        source.subscribe(new MapObserver(observer, function));
    }

    private class MapObserver<T> implements Observer<T> {

        final Observer<R> observer;
        final Function<T, R> function;

        public MapObserver(Observer<R> source, Function<T, R> function) {
            this.observer = source;
            this.function = function;
        }

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

        @Override
        public void onNext(@NonNull T s) {
            try {
                R applyR = function.apply(s);
                observer.onNext(applyR);
            } catch (Exception e) {
                e.printStackTrace();
                observer.onError(e);
            }
        }

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

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