观察者模式（Observer Pattern）

观察者模式（Observer Pattern）

定义

• 观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。
• 别名：模型-视图模式、源-收听者模式、从属者模式、发布-订阅模式。
• 观察者模式通过解耦观察者和被观察者，使得它们可以独立地变化和复用。
• 是行为型设计模式。

适用场景

1. 当一个抽象模型包含两个方面内容，其中一个方面依赖于另一个方面；
2. 其他一个或多个对象的变化依赖于另一个对象的变化；
3. 实现类似于广播机制的功能，无需知道具体收听者，只需分发广播，系统中感兴趣的对象会自动接收该广播；
4. 多层级嵌套使用，形成一种链式触发机制，使得事件具备跨域（跨越两种观察者类型）通知。

标准示例

观察者模式通常包含以下几个角色：
Subject（主题/被观察者）：维护一个观察者列表，并提供注册、移除和通知观察者的方法。
Observer（观察者）：定义一个更新接口，以便在得到主题通知时更新自己。
ConcreteSubject（具体主题）：具体的被观察者，在内部状态改变时，通知所有注册的观察者。
ConcreteObserver（具体观察者）：实现抽象观察者的定义，以便在得到主题状态更改通知时更新自身。

示例代码：
ISubject 抽象主题

/**
 * 抽象主题
 */
public interface ISubject<E> {
    boolean attach(IObserver<E> observer);
    boolean detach(IObserver<E> observer);
    void notify(E event);
}

IObserver 抽象观察者

/**
 * 抽象观察者
 */
public interface IObserver<E> {
    /**
     * 更新
     * @param event
     */
    void update(E event);
}

ConcreteSubject 具体主题

/**
 * 具体主题
 */
public class ConcreteSubject<E> implements ISubject<E>{
    private List<IObserver<E>> observers = new ArrayList<IObserver<E>>();
    public boolean attach(IObserver<E> observer) {
        return !this.observers.contains(observer) && this.observers.add(observer);
    }

    public boolean detach(IObserver<E> observer) {
        return this.observers.remove(observer);
    }

    public void notify(E event) {
        for(IObserver<E> observer:observers){
            observer.update(event);
        }
    }
}

ConcreteObserver 具体观察者

public class ConcreteObserver<E> implements IObserver<E>{
    public void update(E event) {
        System.out.println(this.getClass().getSimpleName() + " receive event : " + event);
    }
}

客户端调用代码：

public class ClientTest {
    public static void main(String[] args) {
        //被观察者
        ISubject<String> subject = new ConcreteSubject<String>();
        //观察者
        IObserver<String> observer = new ConcreteObserver<String>();
        //被观察者注册
        subject.attach(observer);
        //通知
        subject.notify("hello");
    }
}

输出执行结果：

ConcreteObserver receive event : hello

接下来，我们使用jdk中提供的观察者模式接口来实现一个如下场景：
明星发声，粉丝关注并收听。

Idol 明星主题抽象类

/**
 * 抽象主题者——偶像
 */
public interface Idol {
    void posting(String message);
}

ConcreteIdol 明星主题具体类

/**
 * 具体偶像类
 */
@Data
public class ConcreateIdol extends Observable implements Idol{

    private String name;
    public ConcreateIdol(String name){
        this.name = name;
    }
    public void posting(String message) {
        System.out.println("【明星发布】 "+message);
        setChanged();
        notifyObservers(message);
    }
}

Fans粉丝具体类

/**
 * 观察者
 */
public class Fans implements Observer {
    private String idol;
    private String selfName;

    public Fans(String idol,String selfName){
        this.idol = idol;
        this.selfName = selfName;
    }

    public void update(Observable o, Object arg) {
        System.out.println("【粉丝"+this.selfName+"收到通知】 " +  "收到偶像消息："+ arg);
    }
}

JDK中，java.util.Observable 类，相当于IObserver的存在，所以，我们的Fans类，只要继承Observable即可。在发布的被监听方法中，只要调用如下两个方法，可以实现发布。

setChanged();
notifyObservers();

而监听者实现类 Fans，只需要实现jdk中的 java.util.Observer 接口。其中的 update 方法，即为订阅到发布消息后的回调方法。
ClientTest 客户端调用类：

public class ClientTest {
    public static void main(String[] args) {
        ConcreateIdol zhazhahui = new ConcreateIdol("渣渣辉");
        zhazhahui.addObserver(new Fans(zhazhahui.getName(),"小明明"));
        zhazhahui.addObserver(new Fans(zhazhahui.getName(),"小甜甜"));
        String message = "大家好，我是"+zhazhahui.getName()+"，欢迎体验我代言的新版砍怪看到手抽筋大型即使PK古装仙侠网游！";
        zhazhahui.posting(message);
    }
}

执行后的结果输出为：

【明星发布】 大家好，我是渣渣辉，欢迎体验我代言的新版砍怪看到手抽筋大型即使PK古装仙侠网游！
【粉丝小甜甜收到通知】 收到偶像消息：大家好，我是渣渣辉，欢迎体验我代言的新版砍怪看到手抽筋大型即使PK古装仙侠网游！
【粉丝小明明收到通知】 收到偶像消息：大家好，我是渣渣辉，欢迎体验我代言的新版砍怪看到手抽筋大型即使PK古装仙侠网游！