定义
它定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。在观察者模式中，主体是通知的发布者，它发出通知时并不需要知道谁是它的观察者，可以有任意数目的观察者订阅并接收通知。
角色
- 抽象主题（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);
}
}
使用场景
当更改一个对象的状态可能需要更改其他对象，并且实际的对象集事先
未知或动态更改时，请使用观察者模式。
