观察者模式是对象的行为模式。又叫做发布-订阅模式、模型-视图模式、源-监听器模式。
抽象主题角色：主题角色将所有对观察者对象的引用到保存在一个集合里，每个主题都可以拥有任意数量的观察者。抽象主题提供一个接口，可以增加或者删除观察者对象。主题角色又叫被观察者。
具体主题角色：将有关状态存入具体观察者对象，在具体主题的内部状态改变时，给所有登记过的观察者发出通知。具体主题角色是抽象主题的一个具体子类实现。
抽象观察者角色：为所有的具体观察者定义一个接口，在得到主题通知的时候更新自己。
具体观察者角色：抽象观察者的具体子类实现。
代码
抽象主题
package com.demo.exercise.observer;
/**
* 抽象主题
*/
public interface Subject {
void add(Observer observer);
void del(Observer observer);
void notifyObservers();
}
抽象观察者
package com.demo.exercise.observer;
/**
* 抽象观察者
*/
public interface Observer {
void update();
}
具体观察者
package com.demo.exercise.observer;
/**
* 具体观察者
*/
public class ConcreteObserver implements Observer {
@Override
public void update() {
System.out.println(this + "：接收到通知了...");
}
}
具体主题
package com.demo.exercise.observer;
import java.util.Iterator;
import java.util.Vector;
/**
* 具体主题
*/
public class ConcreteSubject implements Subject {
private Vector<Observer> observers = new Vector<>();
@Override
public void add(Observer observer) {
observers.add(observer);
}
@Override
public void del(Observer observer) {
observers.remove(observer);
}
@Override
public void notifyObservers() {
System.out.println("通知所有观察者...");
Iterator<Observer> iterator = observers.iterator();
while (iterator.hasNext()){
iterator.next().update();
}
}
}
运行
public static void main(String[] args) {
Observer a = new ConcreteObserver();
Observer b = new ConcreteObserver();
Subject subject = new ConcreteSubject();
subject.add(a);
subject.add(b);
subject.notifyObservers();
}
输出
优化方案
上面的【抽象主题角色】，其中管理集合的方法，都是由子类来实现的，而实际情况则是这些管理集合的方法是所有实现子类共用的，所以可以把这些转移到抽象主题中去。
抽象主题（这里还是用的interface，你也可以用abstract class）
package com.demo.exercise.observer;
import java.util.Iterator;
import java.util.Vector;
/**
* 抽象主题
*/
public interface Subject {
Vector<Observer> observers = new Vector<>();
default void add(Observer observer){
observers.add(observer);
}
default void del(Observer observer){
observers.remove(observer);
}
default void notifyObservers(){
System.out.println("通知所有观察者...");
Iterator<Observer> iterator = observers.iterator();
while (iterator.hasNext()){
iterator.next().update();
}
}
/**
* 子类需要自定义的方法
* @param status
*/
void change(String status);
}
具体子类
package com.demo.exercise.observer;
/**
* 具体主题
*/
public class ConcreteSubject implements Subject {
private String status;
/**
* 主题状态改变，调用通知方法
* @param status
*/
public void change(String status){
System.out.println(status);
this.status = status;
this.notifyObservers();
}
}
运行
public static void main(String[] args) {
Observer a = new ConcreteObserver();
Observer b = new ConcreteObserver();
Subject subject = new ConcreteSubject();
subject.add(a);
subject.add(b);
subject.change("主题状态改变");
}
输出
引申
那么这种设计模式用来解决什么问题呢？类似于下面这种代码，大家初学Java的时候肯定用过，点击按钮事件，只要点击按钮，就会自动执行相关方法。
JButton button = new JButton();
button.addActionListener((event) -> {
// TODO
});
其中的原理也是观察者模式。下面我就来简单模拟一下
抽象主题
package com.demo.exercise.observer;
import java.util.Iterator;
import java.util.Vector;
/**
* 抽象主题
*/
public abstract class Button {
private Vector<ActionListener> observers = new Vector<>();
void addActionListener(ActionListener observer){
observers.add(observer);
}
void removeActionListener(ActionListener observer){
observers.remove(observer);
}
void notifyObservers(){
Iterator<ActionListener> iterator = observers.iterator();
while (iterator.hasNext()){
iterator.next().actionPerformed();
}
}
}
抽象观察者
package com.demo.exercise.observer;
/**
* 抽象观察者
*/
public interface ActionListener {
void actionPerformed();
}
具体主题
package com.demo.exercise.observer;
/**
* 具体主题
*/
public class JButton extends Button {
/**
* 点击事件
*/
public void click(){
System.out.println("【假装产生了点击事件】");
this.notifyObservers();
}
}
运行
public static void main(String[] args) {
JButton button = new JButton();
button.addActionListener(() -> {
System.out.println("点击事件处理...");
});
button.addActionListener(() -> {
System.out.println("另外一个点击事件处理...");
});
button.click();
}
输出
Java对观察者模式的支持
一个是被观察者：java.util.Observable
一个是观察者：java.util.Observer
Observer里面只有一个update方法。
public interface Observer {
/**
* This method is called whenever the observed object is changed. An
* application calls an <tt>Observable</tt> object's
* <code>notifyObservers</code> method to have all the object's
* observers notified of the change.
*
* @param o the observable object.
* @param arg an argument passed to the <code>notifyObservers</code>
* method.
*/
void update(Observable o, Object arg);
}
当被观察者的状态发生改变，就会调用这一方法。
public void notifyObservers(Object arg) {
/*
* a temporary array buffer, used as a snapshot of the state of
* current Observers.
*/
Object[] arrLocal;
synchronized (this) {
/* We don't want the Observer doing callbacks into
* arbitrary code while holding its own Monitor.
* The code where we extract each Observable from
* the Vector and store the state of the Observer
* needs synchronization, but notifying observers
* does not (should not). The worst result of any
* potential race-condition here is that:
* 1) a newly-added Observer will miss a
* notification in progress
* 2) a recently unregistered Observer will be
* wrongly notified when it doesn't care
*/
if (!changed)
return;
arrLocal = obs.toArray();
clearChanged();
}
for (int i = arrLocal.length-1; i>=0; i--)
((Observer)arrLocal[i]).update(this, arg);
}
用法呢，我再给你示范一下。
最简单的，仅仅需要自己实现一个观察者
package com.demo.exercise.observer;
import java.util.Observable;
import java.util.Observer;
/**
* 具体被观察者
*/
public class JJButton extends Observable {
public void change(){
// changed 置为true，表示状态改变，才会通知所有观察者，与之对应的是clearChanged
this.setChanged();
// 通知所有观察者
this.notifyObservers();
}
public void addListener(Observer o){
this.addObserver(o);
}
}
运行
public static void main(String[] args) {
JJButton button = new JJButton();
button.addListener((o, arg) -> {
System.out.println("点点点！！！");
});
button.change();
}
输出
为了好理解，对于事件监听一类的：事件发起者是被观察者，事件处理则是观察者，肯定是被观察者去通知观察者。