java设计模式--观察者模式

基本概念

观察者模式是对象的行为模式，又叫发布-订阅(Publish/Subscribe)模式或者从属者(Dependents)模式；

观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象；当这个主题对象在状态上发生变化时，会通知所有观察者对象，使它们能够自动更新自己；

通俗的理解，微信公众号，订阅号等等；

基本结构图：

 基本组成：

• 抽象主题(Subject)：抽象主题把所有观察者对象的引用保存在一个集合里，每个主题都可以有任何数量的观察者；提供一个接口，可以增加和删除观察者对象；
• 具体主题(ConcreteSubject)：将有关状态存入具体观察者对象；在具体主题的内部状态改变时，给所有登记过的观察者发出通知；
• 抽象观察者(Observer)：为所有的具体观察者定义一个接口，在得到主题的通知时更新自己；
• 具体观察者(ConcreteObserver)：存储与主题状态自恰的状态；具体观察者实现抽象观察者所要求的更新接口，以便使本身的状态与主题的状态相协调；如果需要，具体观察者角色可以保持一个指向具体主题对象的引用；

基本代码演示

抽象主题类

public abstract class Subject {
   //用来保存注册的观察者对象
   private    List<Observer> list = new ArrayList<Observer>();
    //注册观察者对象
    public void attach(Observer observer){
        list.add(observer);
        System.out.println("Attached an observer");
    }
     //删除观察者对象
    public void detach(Observer observer){
        list.remove(observer);
    }
    //通知所有注册的观察者对象
    public void nodifyObservers(String newState){
        for(Observer observer : list){
            observer.update(newState);
        }
    }
}

具体主题类

public class ConcreteSubject extends Subject{
    private String state;
    public String getState() {
        return state;
    }
    public void change(String newState){
        state = newState;
        System.out.println("主题状态为：" + state);
        //状态发生改变，通知各个观察者
        this.nodifyObservers(state);
    }
}

抽象观察者:

public interface Observer {
     //更新接口
    public void update(String state);
}

具体观察者

public class ConcreteObserver implements Observer {
    //观察者的状态
    private String observerState;
    @Override
    public void update(String state) {
        //更新观察者的状态，使其与目标的状态保持一致
        observerState = state;
        System.out.println("状态为："+observerState);
    }
}

客户端测试：

public class Client {
    public static void main(String[] args) {
        //创建主题对象
        ConcreteSubject subject = new ConcreteSubject();
        //创建观察者对象
        Observer observer = new ConcreteObserver();
        //将观察者对象登记到主题对象上
        subject.attach(observer);
        //改变主题对象的状态
        subject.change("new state");
    }
}

推模型和拉模型

• 推模型

主题对象向观察者推送主题的详细信息，不管观察者是否需要，推送的信息通常是主题对象的全部或部分数据

• 拉模型

主题对象在通知观察者的时候，只传递少量信息；
如果观察者需要更具体的信息，由观察者主动到主题对象中获取，相当于是观察者从主题对象中拉数据；
一般这种模型的实现中，会把主题对象自身通过update()方法传递给观察者，
这样在观察者需要获取数据的时候，就可以通过这个引用来获取了；

具体代码实现

拉模型的抽象主题类：

拉模型的抽象主题类主要的改变是nodifyObservers()方法；
在循环通知观察者的时候，也就是循环调用观察者的update()方法的时候，传入的参数不同了;

public abstract class Subject {
    //用来保存注册的观察者对象
    private    List<Observer> list = new ArrayList<Observer>();
    //注册观察者对象
    public void attach(Observer observer){
        list.add(observer);
        System.out.println("Attached an observer");
    }
    // 删除观察者对象
    public void detach(Observer observer){
        list.remove(observer);
    }
    // 通知所有注册的观察者对象
    public void nodifyObservers(){
        for(Observer observer : list){
            observer.update(this);
        }
    }
}

拉模型的具体主题类

public class ConcreteSubject extends Subject{
    private String state;
    public String getState() {
        return state;
    }
    public void change(String newState){
        state = newState;
        System.out.println("主题状态为：" + state);
        //状态发生改变，通知各个观察者
        this.nodifyObservers();
    }
}

拉模型的抽象观察者类：

public interface Observer {
  // 更新接口,传入主题对象，方面获取相应的主题对象的状态
  public void update(Subject subject);
}

拉模型的具体观察者类

public class ConcreteObserver implements Observer {
    //观察者的状态
    private String observerState;
    @Override
    public void update(Subject subject) {
        // 更新观察者的状态，使其与目标的状态保持一致
        observerState = ((ConcreteSubject)subject).getState();
        System.out.println("观察者状态为："+observerState);
    }
}

推拉两种模式的对比：

• 推模式

1 推模型是假定主题对象知道观察者需要的数据；
推模型会使得观察者对象难以复用，因为观察者的update()方法是按需要定义的参数，
2 可能无法兼顾没有考虑到的使用情况；
这就意味着出现新情况的时候，就可能提供新的update()方法，或者是干脆重新实现观察者

•  拉模式

1 拉模型是主题对象不知道观察者具体需要什么数据，没有办法的情况下，
干脆把自身传递给观察者，让观察者自己去按需要取值；
2 拉模型下，update()方法的参数是主题对象本身，
这基本上是主题对象能传递的最大数据集合了，基本上可以适应各种情况的需要；