Java设计模式－－观察者模式

什么是观察者模式

观察者模式定义了对象之间的一对多关系，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。

模拟现实中的一种需求

• 报社出版了人民日报，
  1. A和B都在报社订阅了人民日报
  2. 这个时候C也想订一份人民日报，报社说那好，你交钱我就给你订上，以后我每期人民日报你都可以收到，C交了钱，订了报纸。
  3. 以后每天A、B、C都会在门口拿到一份人民日报。
  4. 后来B觉得看报纸没什么意思，就跟报社说不想订了，你把钱退给我吧，报社说行，钱退给你，订阅名单里边就没有你了，以后就不给你报纸了。
  5. 只要报社正常经营，会有越来越多的ABC。

实现方法

• 开始时A、B订阅了报纸，代码大概是这样

public class 报社 {
    String  报纸;
    
    //报社本身属性。。。。
    
    //假设每次新出报纸会调用这个方法
    public void onPublic(){
        a.门口拿包装纸(报纸);
        b.门口拿包装纸(报纸);
    }
}

public class A {
    public void 门口拿报纸(String 报纸){
        System.out.println("看国家大事");
    }
}

public class B {
    public void 门口拿报纸(String 报纸){
        System.out.println("看娱乐新闻！！！");
    }
}

• C也想看报纸，所以接着写

public class 报社 {
    String  报纸;
    
    //报社本身属性。。。。
    
    //假设每次新出报纸会调用这个方法
    public void onPublic(){
        a.门口拿包装纸(报纸);
        b.门口拿包装纸(报纸);
        c.门口拿包装纸(报纸);
    }
}

public class C {
    public void 门口拿报纸(String 报纸){
        System.out.println("看新发地菜价！！");
    }
}

• B又不想订报纸了，那就把B注释掉

public class 报社 {
    String  报纸;
    
    //报社本身属性。。。。
    
    //假设每次新出报纸会调用这个方法
    public void onPublic(){
        a.门口拿包装纸(报纸);
        //b.门口拿包装纸(报纸);
        c.门口拿包装纸(报纸);
    }
}

• 当ABC越来越多的时候代码就会成了这样

public class 报社 {
    String  报纸;
    
    //报社本身属性。。。。
    
    //每次新出报纸会调用这个方法
    public void onPublic(){
        a.门口拿包装纸(报纸);
//      b.门口拿包装纸(报纸);
        c.门口拿包装纸(报纸);
        d.门口拿包装纸(报纸);
        e.门口拿包装纸(报纸);
//      f.门口拿包装纸(报纸);
        g.门口拿包装纸(报纸);
        h.门口拿包装纸(报纸);
//      i.门口拿包装纸(报纸);
        j.门口拿包装纸(报纸);
        k.门口拿包装纸(报纸);
        ...
    }
}

• 所以，正如你看到的
  1. 对于每一个想订阅报纸的人，我们都要修改代码
  2. 无法在运行的时候动态的增加或者删除观察者（订阅报纸的人）
  3. 针对的是具体实现编程，并不是针对接口编程
  4. 没有封装改变的部分

OK，报社改个名称叫Observable，ABC改个名称叫Observer，知道怎么订报纸就知道什么是观察者模式了。

明确三个关键词，Observable（被观察者）、subscribe（订阅）、Observer（观察者）。Observable（报社）是一个有各种状态的对象，Observer（A、B、C）subscribe（订阅）了Observable（报社）

那就用观察者模式来实现一下上面的需求，实现观察者模式的方法不止一种，最常见的就是实现Observabe和Observer接口，下面具体实现，对比看一下优点。

观察者模式接口实现

• Observable

public interface Observable {
    void registerObserver(Observer o);
    void removeObserver(Observer  o);
    //更新状态的时候会掉用这个方法
    void notifyObserver();
}

• Observer

public interface Observer {
    void 门口看报纸(String 报纸);
}

• 接下来让报社这个类实现Observable接口，ABC实现Observer接口

public class 报社 implements Observable {
    private List observers;
    String  报纸;
    
    public 报社() {
        observers = new ArrayList<>();
    }
    
    @Override
    public void notifyObserver() {
        for(Observer o:observers){
            o.门口看报纸(报纸);
        }
        
    }
    
    @Override
    public void registerObserver(Observer o) {
        observers.add(o);
        
    }
    
    @Override
    public void removeObserver(Observer o) {
        int index = observers.indexOf(o);
        if(index>0){
            observers.remove(index);
        }
    }
}

public class A implements Observer{
    
    @Override
    public void 门口看报纸(String 报纸) {
        System.out.println("看国家大事");
        
    }
}

• 接下来就是订报纸

public class Test {

    public static void main(String[] args) {
        报社 test = new 报社();
        A a =new A();
        B b = new B();
        //a 添加订阅
        test.registerObserver(a);
        //b 添加订阅
        test.registerObserver(b);
        //c 添加订阅
        test.registerObserver(c);
        //b 移除订阅
        test.removeObserver(b);
    }
}

• 所以，正如你看到的
  1. 对于每一个想订阅报纸的人，我们不需要修改代码，只要实现了Observer接口后registerObserver就好了。
  2. 无法随意在运行的时候动态的增加或者删除观察者（订阅报纸的人）
  3. 针对的是具体实现接口编程，并不是针对接口具体实现编程
  4. 没有封装改变的部分

结束语

观察者模式在JDK就有实现，只不过是用类实现的，需要继承，众所周知，java是单继承的，所以有一定的黑暗面。另外，Java swing 中的JButton、Android中给Button设置OnClickListenner以及现在非常火的RxJava都是观察者模式的实现，有兴趣的可以看看源码，OK就到这里了，欢迎指正。