android 观察者(observer)模式

android 观察者(observer)模式

观察者模式
被观察者调用观察者的回调方法，实现被观察者向观察者的事件传递
接口回调
是观察者模式的一种实现方式，属于观察者模式（接口回调在实际运用中只有一个观察者）

RxJava观察者模式：
Observable (被观察者)
Observer (观察者)
subscribe (订阅)
event (事件)
Observable和Observer通过subscribe()方法实现订阅关系，从而Observable可以在需要的时候发出事件来通知Observer

1、创建观察者Observer: 事件触发时—真正的功能实现部分

Observer<String> observer = new Observer<String>() {
    @Override
    public void onNext(String s) { }  // test0 test1
    @Override
    public void onCompleted() { } 
    @Override
    public void onError(Throwable e) { }
};

Subscriber 实现了Observer接口的抽象类，对Observer接口进行了扩展, 实际上RxJava在subscibe过程中，会先将Observer转换为一个Subscriber, 所以首先使用Subscriber。

public abstract class Subscriber<T> implements Observer<T>, Subscription {}

Observer与Subscriber的主要区别在于onCompleted()方法执行完毕后是否取消了订阅, 且Subscriber增加onStart()方法

2、创建被观察者Observable
它决定什么时候触发事件以及触发怎样的事件。Observable.create方法来创建Observable，定义事件触发规则

Observable observable = Observable.create(new Observable.OnSubscribe<String>() {
    @Override
    public void call(Subscriber<? super String> subscriber) {
        subscriber.onNext("test0");
        subscriber.onNext("test1");
        subscriber.onCompleted();
    }
});

3、Subscribe (订阅)
subscribe()方法将Observable和Observer联结起来：

observable.subscribe(observer); //observable.subscribe(subscriber);

public final Subscription subscribe(Subscriber<? super T> subscriber) {
    return Observable.subscribe(subscriber, this);
}

private static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> observable) {
    ...
    // new Subscriber, so onStart it
    subscriber.onStart();

    // if not already wrapped
    if (!(subscriber instanceof SafeSubscriber)) {
        // assign to `observer` so we return the protected version
        subscriber = new SafeSubscriber<T>(subscriber);
    }

    try {
        // allow the hook to intercept and/or decorate
        hook.onSubscribeStart(observable, observable.onSubscribe).call(subscriber);
        return hook.onSubscribeReturn(subscriber);
    } catch (Throwable e) {
        ...
        return Subscriptions.unsubscribed();
    }
}

RxJava观察者模式大致执行步骤：
1、订阅者(观察者)创建
2、被观察者创建，变换、线程控制设置
3、订阅
4、被观察者的事件序列发送
5、订阅者事件响应
flatMap：
1. 使用传入的事件对象创建一个Observable对象；
2. 激活该Observable对象, 并让它开始发送事件；
3. 每一个传入的事件对象，最终都被汇入该Observable，由它将这些事件统一交给Subscriber的回调方法

示例:

public Student {
    private String name;
    private int  age;
    private String gender;

    public Student(String name){
        this.name=name;
    } 
}
Student[] students;
Subscriber<String> subscriber = new Subscriber<String>() { //1、 订阅者/观察者
    @Override
    public void onNext(String name) { // 5、事件触发、响应
        System.out.println("student: "+name);
    }
    ...
};
Observable.from(students) //2、 被观察者
    .flatMap(new Func1<Student, Observable<String>>() { 
        @Override
        public Observable<String> call(Student student) { // 4、事件序列发送
            return Observable.from(student.name);
        }
    })
    .subscribeOn(Schedulers.io()) // 指定 subscribe() 发生在IO线程
    .observeOn(AndroidSchedulers.mainThread()) // 指定Subscriber的回调发生在主线程
    .subscribe(subscriber); //3、 订阅

Android观察者模式的实现有三种方式：
广播、事件总线otto、EventBus、接口回调

android framework提供了对observer支持：
java.util.Observable Observable类
java.util.Observer Observer角色，一个类只需实现java.util.Observer接口。
java.util.Observable的实现类通过调用setChanged()方法以及notifyObservers(Object)方法便可简单地通知Observer。
诸如：ContentObserver（ContentProvider数据更新）、ChangeObserver（CursorAdapter中的内部类）

基于android系统的Observable、Observer类和接口实现观察/订阅功能：

//1、定义观察者--实现Observer接口的类
public class TestObserver implements Observer{
    public String name;
    public TestObserver(String name){
        this.name=name;
    } 
    @Override
    public void update(Observable obs, Object arg) { //重写update()方法
        System.out.println(name+"接收："+arg+",更新消息");
    }
}
//2、定义被观察者--Observable实现类
public class TestObservable extends Observable{
    public void postNewPublication(String content){   
        setChanged(); //标识内容、状态发生改变 
        notifyObservers(content); //通知观察者
    }
}
//3、测试使用
public class Test {
    public static void main(String[] args) {
        //1、 创建被观察者对象
        TestObservable testObservable=new TestObservable();
        //2、 创建观察者
        TestObserver testObserver0=new TestObserver("test Observer0");
        TestObserver testObserver1=new TestObserver("test Observer1");
        //3、 将观察者注册到被观察对象的观察者列表中(类似依赖注入、接口回调，被观察者持有观察者对象的引用，通过该引用调用观察者的更新方法)
        testObservable.addObserver(testObserver0);
        testObservable.addObserver(testObserver1);
        //4、 发布消息
        testObservable.postNewPublication("发布消息！");
    }
}

自定义方式实现观察/订阅功能（观察者模式，基本与android系统的Observable框架机制相同）：
1、观察者接口
public interface Observer {
    void update(String s);
}

2、被观察者接口
public interface Observable {
    void add(Observer observer); //注册、订阅---即把观察者的对象引用加入到被观察者类的成员变量（观察者列表）中
    void event(String s); //被观察行为
}

3、定义被观察者 -- 实现被观察者接口
public class TestObservable implements Observable {
    private List<Observer> mObservers = new ArrayList<>(); // 观察者列表
    @Override
    public void add(Observer observer) {
        mObservers.add(observer);
    }
    @Override
    public void event(String s) {
        for (Observer observer : mObservers) { // 被观察者持有观察者对象的引用，通过该引用调用观察者的更新方法，实现观察、订阅功能
            observer.update(s);
        }
    }
}

4、定义观察者 --- 实现观察者接口
public class TestObserver implements Observer {
    public String name;
    public TestObserver(String name){
        this.name=name;
    } 
    @Override
    public void update(String s) {
        System.out.println(name+"接收："+s);
    }
}

//5、测试使用
public class Test {
    public static void main(String[] args) {
        //1、 创建被观察者对象
        TestObservable testObservable=new TestObservable();
        //2、 创建观察者
        TestObserver testObserver0=new TestObserver("test Observer0");
        TestObserver testObserver1=new TestObserver("test Observer1");
        //3、 将观察者注册到被观察对象的观察者列表中(类似依赖注入、接口回调，被观察者持有观察者对象的引用，通过该引用调用观察者的更新方法)
        testObservable.addObserver(testObserver0);
        testObservable.addObserver(testObserver1);
        //4、 发布消息
        testObservable.event("消息0！");
    }
}