设计模式之观察者模式

定义

它定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。在观察者模式中，主体是通知的发布者，它发出通知时并不需要知道谁是它的观察者，可以有任意数目的观察者订阅并接收通知。

角色

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

示例

• 抽象主题（Subject）

public abstract class Subject {

    private List<Observer> observers = new ArrayList<>();

    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    public void notice() {
        notice(null);
    }

    public void notice(Object arg) {
        for (Observer observer : observers) {
            observer.update(this, arg);
        }
    }
}

• 具体主题1

public class Subject1 extends Subject {
}

• 具体主题2

public class Subject2 extends Subject {
}

• 抽象观察者（Observer），支持多个观察者

public interface Observer {

    void update(Subject subject, Object arg);
}

• 具体观察者1

public class Observer1 implements Observer {
    @Override
    public void update(Subject subject, Object arg) {
    	// 只处理发布者1（Subject1）发布的变更
        if (subject instanceof Subject1) {
            System.out.println("update Observer1: " + arg);
        }
    }
}

• 具体观察者2

public class Observer2 implements Observer {
    @Override
    public void update(Subject subject, Object arg) {
    	// 只处理发布者2（Subject2）发布的变更
        if (subject instanceof Subject2) {
            System.out.println("update Observer2: " + arg);
        }
    }
}

测试，观察者1和观察者2同时在观察发布者1和发布者2

public class Test {

    public static void main(String[] args) {
    	// 创建两个观察者
    	Observer1 observer1 = new Observer1();
    	Observer2 observer2 = new Observer2();
    	// 创建具体主题1，并设置观察者
        Subject subject = new Subject1();
        subject.addObserver(observer1);
        subject.addObserver(observer2);
        System.out.println("Subject1发布测试事件");
        subject.notice("发布测试事件1");  //发布变更
        System.out.println("========================");
		// 创建具体主题2，并设置观察者
        Subject subject2 = new Subject2();
        subject2.addObserver(observer1);
        subject2.addObserver(observer2);
        System.out.println("Subject2发布测试事件");
        subject2.notice("发布测试事件2"); //发布变更
    }
}

以上就是观察者模式基本架构，因为ArrayList不是线程安全的，所以这种实现并不是线程安全的。其实JDK已经帮我们定义了一套线程安全的架构，只需实现具体的主题和观察者即可

JDK源码实现

• 抽象主题

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 interface Observer {
    void update(Observable o, Object arg);
}

使用Veactor支持多线程同时添加观察者，并且在发布变更时必须调用Observable的setChanged方法才能通知观察者。

Spring容器监听器实现

• 自定义事件发布器

public class MyApplicationEvent extends ApplicationEvent {
    public MyApplicationEvent(Object source) {
        super(source);
    }
}

• 定义事件监听器

public class MyApplicationListener implements ApplicationListener<MyApplicationEvent> {
    @Override
    public void onApplicationEvent(MyApplicationEvent event) {
        System.out.println("MyApplicationListener receive: " + event);
    }
}

• 测试

public class ListenerTest {

    public static void main(String[] args) {
        //创建Spring容器，并注册MyApplicationListener类型的bean对象
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.registerBean("myApplicationListener", MyApplicationListener.class, null);
        context.refresh();
        //利用Spring容器发布事件
        MyApplicationEvent event = new MyApplicationEvent("MyEvent");
        context.publishEvent(event);
    }
}

使用场景

当更改一个对象的状态可能需要更改其他对象，并且实际的对象集事先
未知或动态更改时，请使用观察者模式。