设计模式-观察者模式

观察者模式：对象一对多的依赖关系，使得每当一个对象状态改变时，其相关依赖对象皆得到通知并被自动更新。

第一种方法(自己实现)：
UML结构分析图：

6CBBE987-DF43-40C4-81DD-B3D4DD01DBD6.png

Subject抽象类：

//被观察者抽象类
public abstract class Subject {
    //保存注册的观察者对象
    private List<Observer> mObservers = new ArrayList<>();

    //注册观察者对象
    public void attach(Observer observer) {
        mObservers.add(observer);
        Log.v("TAG", "Attached an observer");
    }

    //注销观察者对象
    public void detach(Observer observer) {
        mObservers.remove(observer);
        Log.v("TAG", "Detach an observer");
    }

    //通知所有注册的观察者对象
    public void notifyObservers(String newState) {
        for (Observer observer : mObservers) {
            observer.update(newState);
        }
    }
}

//观察者抽象接口
Observice接口：

public interface Observer {
    void update(String state);
}

ConcreteSubject类：

//被观察者实体类
public class ConcreteSubject extends Subject{
    private String subjectState;
    public String getState(){
        return subjectState;
    }
    public void setState(String state){
        this.subjectState=state;
    }
}

ConcreteObserver类：

//观察者实体类
public class ConcreteObserver implements Observer {
    //观察者状态
    private String observerState;
    @Override
    public void update(String state) {
        observerState=state;
        Log.v("TAG","ConcreteObserver state:"+observerState);
    }
}

测试类重要代码：

        //创建目标对象
        ConcreteSubject concreteSubject = new ConcreteSubject();
        //创建观察者对象
        Observer observer1 = new ConcreteObserver();
        Observer observer2 = new ConcreteObserver();
        //将观察者对象注册到目标对象上
        concreteSubject.attach(observer1);
        concreteSubject.attach(observer2);
        //改变目标对象到状态
        concreteSubject.setState("I change");
        //通知并更新观察者对象
        concreteSubject.notifyObservers(concreteSubject.getState());

第二种方法(使用Java API)：
TargetObservable类：

//Observable是被观察者对象接口，实现该接口就是：目标（被观察者）的具体实现
public class TargetObservable extends Observable {
    //要观察的数据：消息发生改变时，所有被添加的观察者都能收到通知
    private String message;

    public String getContent(){
        return message;
    }

    public void setMessage(String message){
        this.message=message;
        //被观察者数据发生改变时，通过一下两行代码通知所有的观察者
        this.setChanged();
        this.notifyObservers(message);
    }
}

TargetObserver类：

//Observer对象是观察者，实现Observer的对象就是具体的观察者对象
public class TargetObserver implements Observer {
    //定义观察者名字
    private String name;

    public String getObserverName(){
        return this.name;
    }

    public void setObserverName(String observerName){
        this.name=observerName;
    }

    @Override
    public void update(Observable o, Object arg) {
        this.name=((TargetObservable)o).getContent();
        //更新消息数据
        Log.v("TAG"," 收到了发生变化的数据内容是："+ this.name);
    }
}

测试类重要代码：

        //创建被观察者对象
        TargetObservable targetObservable = new TargetObservable();
        //创建观察者对象1
        TargetObserver observer1 = new TargetObserver();
        //创建观察者对象2
        TargetObserver observer2 = new TargetObserver();
        //将观察者对象1和被观察者进行关联
        targetObservable.addObserver(observer1);
        //将观察者对象2和被观察者进行关联
        targetObservable.addObserver(observer2);
        //改变被观察者的数据，并通知观察者数据改变
        targetObservable.setMessage("数据改变");

两者方式比较：
1.Observable使用Vector存储，相比List线程安全。
2.Vector可以用CopyOnWriteArrayList替代。

第三种方法(使用回调)：
Employe类：

//观察者
public class Employee {
    //定义回调接口的成员变量
    private Callback mCallback;

    //声明回调接口
    public interface Callback {
        public abstract void work();
    }

    //设置回调接口对象成员变量
    public void setCallback(Callback callback) {
        this.mCallback = callback;
    }

    //调用回调接口对象中的方法
    public void doWork() {
        mCallback.work();
    }

}

测试类重要代码：

 //为Employee设置回调函数，并定义具体的回调方法
 Employee employee=new Employee();  
 employee.setCallback(new Employee.Callback() {
            @Override
            public void work() {
                Log.v("TAG","setCallback");
            }
        });

        employee.doWork();