RxJava

Rx作为响应式编程的框架，其中还可以进行异步流操作，所以在Android中一定要配合RxAndroid使用。
RxJava内部实际上采用了观察者设计模式，那么简单举一个例子来说明什么是观察者模式。

观察者模式.png

在这里我们自己是被观察者，爸爸妈妈还有亲戚是观察者，当我们考试成绩下来之后需要通知观察者。

//观察者
public interface Observer {
    void receive(String s);
}
//被观察者
public interface Observable {
    void addObserver(Observer o);

    void removeObserver(Observer o);

    void notifyObservers(String s);

}
//家人
public class Human implements Observer {
    private String name;

    public Human(String name) {
        this.name=name;
    }

    @Override
    public void receive(String s) {
        System.out.println("name="+name+",info="+s);
    }
}
//我自己
public class Me implements Observable{

    List<Observer> list=new ArrayList<>();

    @Override
    public void addObserver(Observer o) {
        list.add(o);
    }

    @Override
    public void removeObserver(Observer o) {
        list.remove(o);
    }

    @Override
    public void notifyObservers(String s) {

        for (int i = 0; i <list.size() ; i++) {
            Observer observer = list.get(i);
            observer.receive(s);
        }
    }


    public void getGrade(){
        String s="me getGrade 60";

        System.out.println(s);

        notifyObservers(s);
    }
}
//test
public class Test {
    public static void main(String[] args) {
        Human baba = new Human("baba");
        Human mama = new Human("mama");
        Human nainai = new Human("nainai");

        Me me = new Me();

        me.addObserver(baba);
        me.addObserver(mama);
        me.addObserver(nainai);

        me.getGrade();
    }
}

简单用法

调用just操作符

disposable = Observable.just("A")
                .map(new Function<String, Bitmap>() {
                    @Override
                    public Bitmap apply(String s) throws Throwable {
                        return null;
                    }
                })
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<Bitmap>() {
                    @Override
                    public void accept(Bitmap o) throws Throwable {

                    }
                });
 @Override
    protected void onDestroy() {
        super.onDestroy();
        //必须要在这里中断，否则会内存泄漏
        if (disposable!=null)
            if (!disposable.isDisposed())
                disposable.dispose();
    }

Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> emitter) throws Throwable {
                emitter.onNext("A");
            }
        }).map(new Function<String, Bitmap>() {
            @Override
            public Bitmap apply(String s) throws Throwable {
                return null;
            }
        }).subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<Bitmap>() {
                    @Override
                    public void onSubscribe(@NonNull Disposable d) {
                        disposable=d;
                    }

                    @Override
                    public void onNext(@NonNull Bitmap bitmap) {

                    }

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

                    }

                    @Override
                    public void onComplete() {

                    }
                });

使用flatmap操作符可以多次触发改变
如果我们存在嵌套请求的时候，当请求完第一个接口的时候，使用doOnNext就可以去主线程刷新数据，然后再去请求下一个接口，再去刷新数据。

List<String> s=new ArrayList<>();
        s.add("a");
        s.add("b");
        disposable=Observable.just(s)
                .flatMap(new Function<List<String>, Observable<String>>() {
                    @Override
                    public Observable<String> apply(List<String> list) throws Throwable {
                        return Observable.fromIterable(list);
                    }
                }).doOnNext(new Consumer<String>() {
            @Override
            public void accept(String s) throws Throwable {
                
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Throwable {

            }
        });

简单概念

Observable 是被观察者
Observer是观察者
subscribe 是订阅
当我们需要观察某一个被观察者的行为的时候可以在过程中添加自己的卡片，对中间的数据进行处理。

Rx添加中间处理层.png