观察者模式

1.定义

指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。这种模式有时又称作发布-订阅模式、模型-视图模式，它是对象行为型模式。

2.场景

2.1 常见场景

火车站实时显示到站信息，微信公众号和该公众号订阅者等

2.2 实现

以微信公众号为例，说明

2.2.1 自定义推模式实现

（1）设计一个主题接口，包含添加，删除，通知的功能

/**
 * 主题
 */
public interface Subject {
    /**
     * 添加观察者
     */
    public void addObserver(Observer observer);

    /**
     * 删除观察者
     */
    public void deleteObserver(Observer observer);

    /**
     * 通知所有观察者
     */
    public void notifyObservers();

}

（2）观察者接口

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

（3）微信公众号

public class WeChatOfficialAccount implements Subject {
    private List<Observer> observerList; // 观察者列表
    private String message;

    WeChatOfficialAccount() {
        this.observerList = new ArrayList<>();
    }

    @Override
    public void addObserver(Observer observer) {
       this.observerList.add(observer);
    }

    @Override
    public void deleteObserver(Observer observer) {
        this.observerList.remove(observer);
    }

    @Override
    public void notifyObservers() {
     for(Observer observer : observerList){
         observer.update(message);
     }
    }

    public void setMessage(String message) {
        this.message = message;
        // 关键：设置信息时，通知所有的观察者
        notifyObservers();
    }
}

（4）订阅者

public class WeChatUser implements Observer {
    private String name;

    WeChatUser(String name) {
        this.name = name;
    }

    @Override
    public void update(String message) {
        System.out.println(String.format("%s 收到公众号推送信息: %s", name, message));
    }
}

（5）测试

public class TestObserver {

    public static void main(String[] args) {
        WeChatOfficialAccount weChatOfficialAccount = new WeChatOfficialAccount();
        WeChatUser weChatUser1 = new WeChatUser("张三");
        WeChatUser weChatUser2 = new WeChatUser("李四");
        weChatOfficialAccount.addObserver(weChatUser1);
        weChatOfficialAccount.addObserver(weChatUser2);
        weChatOfficialAccount.setMessage("你们好");
    }
}

----------------------------console
张三 收到公众号推送信息: 你们好
李四 收到公众号推送信息: 你们好

可以看到在推模式中，观察者观察到的数据完全取决于主题，只能"被动"的接收。其实还有一种方式可以"主动"操作想到的数据。这就是下面要介绍的拉模式：

2.2.2 自定义拉模式实现

（1） 观察者

public interface Observer {
    /**
     * 收到通知时不再是只处理指定内容，而是直接操作主题对象
     * @param subject
     */
    void update(Subject subject);
}

（2）主题

public interface Subject {
    /**
     * 添加观察者
     */
    public void addObserver(Observer observer);

    /**
     * 删除观察者
     */
    public void deleteObserver(Observer observer);

    /**
     * 通知所有观察者
     */
    public void notifyObservers();

}

（3）具体主题

public class WeChatOfficialAccount implements Subject {
    private List<Observer> observerList; // 观察者列表
    private String message;

    public String getMessage(){
        return message;
    }

    WeChatOfficialAccount() {
        this.observerList = new ArrayList<>();
    }

    @Override
    public void addObserver(Observer observer) {
       this.observerList.add(observer);
    }

    @Override
    public void deleteObserver(Observer observer) {
        this.observerList.remove(observer);
    }

    @Override
    public void notifyObservers() {
     for(Observer observer : observerList){
         // 直接操作主题对象
         observer.update(this);
     }
    }

    public void setMessage(String message) {
        this.message = message;
        notifyObservers();
    }
}

（4）具体观察者

public class WeChatUser implements Observer {
    private String name;

    WeChatUser(String name) {
        this.name = name;
    }

    @Override
    public void update(Subject subject) {
        // 获取具体的主题，可以操作相应的属性和方法
        if (subject instanceof WeChatOfficialAccount) {
            WeChatOfficialAccount weChatOfficialAccount = (WeChatOfficialAccount) subject;
            System.out.println(String.format("%s 收到公众号推送信息: %s", name, weChatOfficialAccount.getMessage()));
        }

    }
}

（5）测试

public class TestObserver {

    public static void main(String[] args) {
        WeChatOfficialAccount weChatOfficialAccount = new WeChatOfficialAccount();
        WeChatUser weChatUser1 = new WeChatUser("张三");
        WeChatUser weChatUser2 = new WeChatUser("李四");
        weChatOfficialAccount.addObserver(weChatUser1);
        weChatOfficialAccount.addObserver(weChatUser2);
        weChatOfficialAccount.setMessage("你们好");
    }
}
----------------------------console
张三 收到公众号推送信息: 你们好
李四 收到公众号推送信息: 你们好

2.2.3 java内置观察者模式

（1） 介绍
从上面可以看出，观察者和主题的格式一般比较固定，就是提供增删和通知等基本功能。所以jdk已经帮我们好了两个类：java.util.Observable（对应主题），java.util.Observer（对应观察者）

public class WeChatOfficialAccount extends Observable {
    private String message;

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
    // 需要调用setChanged方法
        setChanged();
        notifyObservers();
    }
}

public class WeChatUser implements Observer {
    private String name;

    WeChatUser(String name) {
        this.name = name;
    }
    @Override
    public void update(Observable o, Object arg) {
        if (o instanceof WeChatOfficialAccount) {
            WeChatOfficialAccount weChatOfficialAccount = (WeChatOfficialAccount) o;
            System.out.println(String.format("%s 收到公众号推送信息: %s", name, weChatOfficialAccount.getMessage()));
        }
    }
}

利用上面的方式，可以借助原生的jdk可以快速的使用观察者模式。

（2）原理分析

（2.1）观察者
这是增加一个额外的参数，可以在通知时添加附加内容

public interface Observer {
    void update(Observable o, Object arg);
}

（2.2）主题

public class Observable {
    private boolean changed = false; // 增加变量控制是否被改变
    private Vector<Observer> obs; // 可以线程安全地增删观察者

    public Observable() {
        obs = new Vector<>();
    }

    /**
     * 添加观察者（同步）
     */
    public synchronized void addObserver(Observer o) {
        if (o == null)
            throw new NullPointerException();
        if (!obs.contains(o)) {
            obs.addElement(o);
        }
    }

    /**
     * 同步删除
     */
    public synchronized void deleteObserver(Observer o) {
        obs.removeElement(o);
    }

    /**
     * 通知，空参表示不传额外的参数
     */
    public void notifyObservers() {
        notifyObservers(null);
    }

    /**
     * 通知支持额外的参数
     */
    public void notifyObservers(Object arg) {
        /*
         * 临时的数组，保存当前的观察者集合
         */
        Object[] arrLocal;

        synchronized (this) {
            if (!changed) // 如果没有发生改变直接返回
                return;
            arrLocal = obs.toArray(); // 保存一份快照，防止遍历时观察者集合有改变
            clearChanged();
        }

        for (int i = arrLocal.length-1; i>=0; i--)
            ((Observer)arrLocal[i]).update(this, arg);
    }

    /**
     * 清空观察者
     */
    public synchronized void deleteObservers() {
        obs.removeAllElements();
    }

    protected synchronized void setChanged() {
        changed = true;
    }

    /**
     * 清除改变
     */
    protected synchronized void clearChanged() {
        changed = false;
    }

    public synchronized boolean hasChanged() {
        return changed;
    }

    public synchronized int countObservers() {
        return obs.size();
    }
}

Observable 已经帮我们处理了多线程的问题，就算在多线程的环境下也可以直接使用，极大地简化了我们的操作。