首先还是看怎么使用
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();
}
}
}