【设计模式】观察者模式 ( 简介 | 适用场景 | 优缺点 | 代码示例 )

package observer;
import java.util.Observable;
/**
 * 被观察的主题对象
 *      JDK 提供了对观察者模式的支持 , 被观察者可以继承 Observable 类
 *
 * 被观察对象 继承 Observable 类
 */
public class Game extends Observable {
    private String name;
    public Game(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    /**
     * 用户提交问题
     * @param game
     * @param question
     */
    public void produceQuestion(Game game, Question question) {
        System.out.println(question.getUserName() +
                " 在 " + game.name + " 游戏中提交问题 : " + question.getContent());
        // 该方法是 Observable 提供的方法
        // 将 private boolean changed = false 成员变量设置为 true
        // 代表 被观察者 的状态发生了改变
        setChanged();
        // 通知 观察者
        notifyObservers(question);
    }
}

package observer;
import java.util.Observable;
import java.util.Observer;
/**
 * 管理员类
 *      管理员类观察的是游戏
 *      用户反馈的问题 属于 游戏 , 管理员关注的是游戏
 *      无法关注 问题
 *
 * 如 : 在电商平台 , 关注的是某个商品 , 在降价时发送通知
 *      商品是存在的 , 降价消息 在关注的时候还没有被创建 , 是无法获取依赖的
 */
public class Manager implements Observer {
    /**
     * 管理员名称
     */
    private String name;
    public Manager(String name) {
        this.name = name;
    }
    @Override
    public void update(Observable o, Object arg) {
        // 获取 被观察者 对象
        Game game = (Game) o;
        // 获取 被观察者 对象 调用 notifyObservers 方法的参数
        Question question = (Question) arg;
        System.out.println(name + " 观察者 接收到 被观察者 " + game.getName() +
                " 的通知 , 用户 " + question.getUserName() +
                " 提出问题 " + question.getContent());
    }
}

package observer;
public class Question {
    /**
     * 用户名
     */
    private String userName;
    /**
     * 问题内容
     */
    private String content;
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getContent() {
        return content;
    }
    public void setContent(String content) {
        this.content = content;
    }
}

package observer;
public class Main {
    public static void main(String[] args) {
        // 创建被观察者
        Game game = new Game("Cat And Mouse");
        // 创建观察者
        Manager manager = new Manager("Tom");
        // 关联 观察者 与 被观察者
        game.addObserver(manager);
        // 业务逻辑 : 用户提出问题到游戏中 , 管理员接收到通知消息
        Question question = new Question();
        question.setUserName("Jerry");
        question.setContent("游戏崩溃");
        // 在游戏中提交问题
        game.produceQuestion(game, question);
    }
}

Jerry 在 Cat And Mouse 游戏中提交问题 : 游戏崩溃
Tom 观察者 接收到 被观察者 Cat And Mouse 的通知 , 用户 Jerry 提出问题 游戏崩溃

public class Observable {
    private boolean changed = false;
    /** 使用 Vector 是线程安全的集合 , 存放观察者对象 , 在构造器中初始化该类 */
    private Vector<Observer> obs;
    /** Construct an Observable with zero Observers. */
    public Observable() {
        obs = new Vector<>();
    }
    /**
     * 添加观察者对象 , 采用了 synchronized 修饰 , 是同步方法 , 保证了线程安全 
     *
     * @param   o   an observer to be added.
     * @throws NullPointerException   if the parameter o is null.
     */
    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);
    }
    /**
     * 通知观察者 , 无参
     *
     * @see     java.util.Observable#clearChanged()
     * @see     java.util.Observable#hasChanged()
     * @see     java.util.Observer#update(java.util.Observable, java.lang.Object)
     */
    public void notifyObservers() {
        notifyObservers(null);
    }
    /**
     * 通知观察者 , 有参
     *
     * @param   arg   any object.
     * @see     java.util.Observable#clearChanged()
     * @see     java.util.Observable#hasChanged()
     * @see     java.util.Observer#update(java.util.Observable, java.lang.Object)
     */
    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;
    }
    /**
     * 查看观察者数量 
     *
     * @return  the number of observers of this object.
     */
    public synchronized int countObservers() {
        return obs.size();
    }
}

package java.util;
/**
 * A class can implement the <code>Observer</code> interface when it
 * wants to be informed of changes in observable objects.
 *
 * @author  Chris Warth
 * @see     java.util.Observable
 * @since   JDK1.0
 */
public interface Observer {
    /**
     * 当 被观察者 对象发生改变时 , 即被观察者对象调用 notifyObservers 方法时 , 自动调用该方法
     *
     * @param   o     被观察的对象.
     * @param   arg   被观察对象调用 notifyObservers 方法时传入的参数 
     */
    void update(Observable o, Object arg);
}