观察者模式：对象间的一种一对多的依赖关系
点击上方「蓝字」关注我们
0x01：观察者模式入门
观察者模式[ 又称发布(publish)-订阅(Subscribe)模式 ]，它定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。其实就是一种通知机制，让发送通知的一方（被观察方）和接收通知的一方（观察者）能彼此分离，互不影响。UML类图如下：
从类图上看主要包含如下角色：
Subject（抽象主题）: 被观察者, 抽象主题角色把所有观察者对象保存在一个集合里，每个主题都可以有任意数量的观察者，抽象主题提供一个接口，可以增加和删除观察者对象。
ConcreteSubject（具体主题）：被观察者，该角色将有关状态存入具体观察者对象，在具体主题的内部状态发生改变时，给所有注册过的观察者发送通知。
Observer（抽象观察者）：是观察者者的抽象类，它定义了一个更新接口，使得在得到主题更改通知时更新自己。
ConcrereObserver（具体观察者）：实现抽象观察者定义的更新接口，以便在得到主题更改通知时更新自身的状态。
Subject（抽象主题）：
public interface ISubject{
public void addObserver(Observer observer);
public void deleteObserver(Observer observer) ;
public void notifyObserver() ;
}
ConcreteSubject（具体主题）：
public class Subject implements ISubject{
//观察者数组
private Vector observers = new Vector<>();
//增加一个观察者
@Override
public void addObserver(Observer observer) {
this.observers.add(observer);
}
//删除一个观察者
@Override
public void deleteObserver(Observer observer) {
this.observers.remove(observer);
}
//通知所有观察者
@Override
public void notifyObserver() {
for(Observer observer : this.observers ) {
observer.update();
}
}
}
Observer（抽象观察者）
public interface Observer {
//更新
public void update();
}
}
ConcrereObserver（具体观察者)
public class ConcrereObserver implements Observer {
private String name;
public ConcrereObserver(String name) {
this.name = name;
}
@Override
public void update() {
System.out.println(name);
}
}客户端Client：
public class Client {
public static void main(String[] args) {
ISubject subject=new Subject();
//创建观察者
Observer observer1=new ConcrereObserver("subject1");
Observer observer2=new ConcrereObserver("subject2");
Observer observer3=new ConcrereObserver("subject3");
//添加观察者
subject.addObserver(observer1);
subject.addObserver(observer2);
subject.addObserver(observer3);
//被观察者发生变更，通知所有观察者
subject.notify();
}
}
0x02：JDK提供的观察者模式接口
以上是观察者模式的最简单介绍，其实如果大家留意的话，发现JDK已经内置了观察者模式的抽象实现，对应的类是：
java.util.Observer
java.util.Observable
java.util.Observer（观察者抽象）
package java.util;
public interface Observer {
void update(Observable o, Object arg);
}
java.util.Observable（被观察者抽象）
package java.util;
public class Observable {
private boolean changed = false;
private Vector 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 synchronized void deleteObservers() {
obs.removeAllElements();
}
synchronized void setChanged() {
changed = true;
}
protected synchronized void clearChanged() {
changed = false;
}
public synchronized boolean hasChanged() {
return changed;
}
public synchronized int countObservers() {
return obs.size();
}
}
可以看出来与自己的设计大体一致。不过也不能不感叹JDK的设计者考虑的问题还是不自己考虑的多。JDK多设计了一个标识位，同时考虑了线程安全问题。
0x03：观察者模式的思考
从抽象被观察者代码看，里面定义了一个容器存放观察者。当被观察者发生变更时，需要循环通知观察者。如果使用观察者模式处理这样一个业务场景：观察者非常多，而且观察者的update()方法调用时间可能非常长。那一定出现业务延时的问题，这样的话就不在适合使用观察者模式了。那这样的业务场景需要采用什么解决方案呢？我觉得采用消息队列MQ非常适合
扫码二维码
获取更多精彩
Java乐园
有用！分享+在看☟