设计模式（三）--观察者模式
最近一直没有什么状态，无心学习，业余时间不能再宅在家里了，宅男都有神经病，整天对着手机说话，不出门，没朋友，我说的对吗？siri？博客不定期更新，爱看不看，反正也没几个人看。还有，男人都要像灭霸一样，即使是反派，也要光明磊落，说不害谁就不害谁，更何况是队友呢？
记录一下观察者模式，这个模式应该是项目中最可能用到的模式之一了，话不多说，进入正题。
什么是观察者模式，我自己理解，就是一个类管理着所有依赖于它的观察者类，并且它状态变化时会主动给这些依赖它的类发出通知。
下面给出观察者模式的类图。
我们根据UML图翻译成java代码，首先是观察者接口。
/** * 观察者接口 * @author xiaodongdong * @create 2018-05-16 17:02 **/ public interface Observer { void update(Observable o); }
接下来是具体的观察者。
/** * 具体观察者1 * @author xiaodongdong * @create 2018-05-16 17:04 **/ public class ConcreteObserver1 implements Observer { @Override public void update(Observable o) { System.out.println("观察者1观察到" + o.getClass().getSimpleName() + "发生变化"); System.out.println("观察者1做出相应"); } }
/** * 具体观察者2 * @author xiaodongdong * @create 2018-05-16 17:05 **/ public class ConcreteObserver2 implements Observer { @Override public void update(Observable o) { System.out.println("观察者2观察到" + o.getClass().getSimpleName() + "发生变化"); System.out.println("观察者2做出相应"); } }
接下来是被观察者，被观察者持有一个观察者的集合，一旦被观察者发生变化，会主动调用观察者的接口方法通知相关观察者。
import java.util.ArrayList; import java.util.List; /** * 被观察者 * @author xiaodongdong * @create 2018-05-16 17:06 **/ public class Observable { List<Observer> observers = new ArrayList<Observer>(); public void addObserver(Observer o){ observers.add(o); } public void changed(){ System.out.println("我是被观察者，我已经发生变化了"); //通知观察自己的所有观察者 notifyObservers(); } public void notifyObservers(){ for (Observer observer : observers) { observer.update(this); } } }
测试一下。
/** * 测试 * @author xiaodongdong * @create 2018-05-16 17:09 **/ public class Client { public static void main(String[] args) throws Exception { Observable observable = new Observable(); observable.addObserver(new ConcreteObserver1()); observable.addObserver(new ConcreteObserver2()); //被观察者状态改变 observable.changed(); } }
打印结果如下。
其实观察者是被动接收通知的，是不是能作为观察者，能不能接收通知，完全是被观察者决定。
在网上看到一个不错的例子，写在这里。我们经常看的小说网站，都有这样的功能，就是读者可以订阅作者，作者一旦有什么新书发表，就要通知已经订阅他的读者，这是一个典型的观察者模式的应用场景。
JDK已经帮我们写好了观察者接口和被观察者类，LZ列举一下JDK的关键实现，熟悉一下JDK的源码。
首先是观察者接口。
/** * 观察者接口，每一个观察者都必须实现这个接口 */ public interface Observer { //除了依赖被观察者，还提供了一个预留参数 void update(Observable o, Object arg); }
再是被观察者类。
package java.util.Observable; import java.util.Observer; import java.util.Vector; //被观察者类 public class Observable { //用来表示被观察者有没有改变 private boolean changed = false; //观察者列表 private Vector<java.util.Observer> obs; public Observable() { obs = new Vector<>(); } //添加观察者，添加时会去重 public synchronized void addObserver(java.util.Observer o) { if (o == null) throw new NullPointerException(); if (!obs.contains(o)) { obs.addElement(o); } } //删除观察者 public synchronized void deleteObserver(java.util.Observer o) { obs.removeElement(o); } public void notifyObservers() { notifyObservers(null); } //通知所有观察者 也就是调用观察者的update方法 public void notifyObservers(Object arg) { //一个临时的数组，用于并发访问被观察者时，留住观察者列表的当前状态，这种处理方式其实也算是一种设计模式，即备忘录模式。 Object[] arrLocal; //注意这个同步块，它表示在获取观察者列表时，该对象是被锁定的 //也就是说，在我获取到观察者列表之后，不允许其他线程改变观察者列表 synchronized (this) { //如果没变化直接返回 if (!changed) return; //这里将当前的观察者列表放入临时数组 arrLocal = obs.toArray(); //将改变标识重新置回未改变 clearChanged(); } //注意这个for循环没有在同步块，此时已经释放了被观察者的锁，其他线程可以改变观察者列表 //但是这并不影响我们当前进行的操作，因为我们已经将观察者列表复制到临时数组 //在通知时我们只通知数组中的观察者，当前删除和添加观察者，都不会影响我们通知的对象 for (int i = arrLocal.length-1; i>=0; i--) ((Observer)arrLocal[i]).update(this, arg); } //删除所有观察者 public synchronized void deleteObservers() { obs.removeAllElements(); } //标识被观察者被改变过了 protected synchronized void setChanged() { changed = true; } //标识被观察者没改变 protected synchronized void clearChanged() { changed = false; } //返回被观察者是否改变 public synchronized boolean hasChanged() { return changed; } //返回观察者数量 public synchronized int countObservers() { return obs.size(); } }
看注释应该能理解的差不多，但是这块有不足的地方，就是通知所有观察的地方，
for (int i = arrLocal.length-1; i>=0; i--) ((Observer)arrLocal[i]).update(this, arg);
在循环遍历观察者时，JDK没有处理update可能抛出的异常，假设有一个update方法抛出异常，那么剩下的观察者就都得不到通知了。所以我觉得这块代码可以优化成这样。
for (int i = arrLocal.length-1; i>=0; i--){ try { ((Observer)arrLocal[i]).update(this, arg); } catch (Throwable e) { e.printStackTrace(); } }
我们自己做的时候，需要保证读者类中的update方法不会抛异常。JDK的观察者模式源码差不多就长这样，我们用JDK的实现把上面那个读者订阅作者的例子完成。首先要搞明白这个例子里面谁是观察者，谁是被观察者，很明显，读者是观察者，作者是被观察者，除此之外，我们还需要一个管理器来帮我们管理作者的列表，我们逐一实现，首先是读者类。
import java.util.Observable; import java.util.Observer; /** * 读者 * @author xiaodongdong * @create 2018-05-17 15:55 **/ public class Reader implements Observer { private String name; public Reader(String name) { super(); this.name = name; } public String getName() { return name; } //关注作者 public void subscribe(String writerName){ WriterManager.getInstance().getWriter(writerName).addObserver(this); } //取关作者 public void unsubscribe(String writerName){ WriterManager.getInstance().getWriter(writerName).deleteObserver(this); } //作者发表新书时调用 @Override public void update(Observable o, Object obj) { if (o instanceof Writer) { Writer writer = (Writer) o; System.out.println(name+"得到通知====" + writer.getName() + "发布了新书《" + writer.getLastNovel() + "》"); } } }
下面是作者类。
//作者类，要继承自被观察者类 public class Writer extends Observable{ private String name;//作者的名称 private String lastNovel;//记录作者最新发布的小说 public Writer(String name) { super(); this.name = name; WriterManager.getInstance().add(this); } //作者发布新小说了，要通知所有关注自己的读者 public void addNovel(String novel) { System.out.println(name + "发布了新书《" + novel + "》！"); lastNovel = novel; setChanged(); notifyObservers(); } public String getLastNovel() { return lastNovel; } public String getName() { return name; } }
作者管理器，关键作用无非是快速查找作者，组合Map实现。
import java.util.HashMap; import java.util.Map; /** * 作者管理器 * @author xiaodongdong * @create 2018-05-17 15:56 **/ public class WriterManager{ private Map<String, Writer> writerMap = new HashMap<String, Writer>(); //添加作者 public void add(Writer writer){ writerMap.put(writer.getName(), writer); } //根据作者姓名获取作者 可优化 作者名字可能重复 public Writer getWriter(String name){ return writerMap.get(name); } //单例 private WriterManager(){} public static WriterManager getInstance(){ return WriterManagerInstance.instance; } private static class WriterManagerInstance{ private static WriterManager instance = new WriterManager(); } }
测试一下。
/** * 测试 * @author xiaodongdong * @create 2018-05-17 16:05 **/ public class Client { public static void main(String[] args) { //假设四个读者，两个作者 Reader r1 = new Reader("读者1"); Reader r2 = new Reader("读者2"); Reader r3 = new Reader("读者3"); Reader r4 = new Reader("读者4"); Writer w1 = new Writer("作者1"); Writer w2 = new Writer("作者2"); //四人关注了作者1 r1.subscribe("作者1"); r2.subscribe("作者1"); r3.subscribe("作者1"); r4.subscribe("作者1"); //读者3和读者4还关注了作者2 r3.subscribe("作者2"); r4.subscribe("作者2"); //作者发布新书就会通知关注的读者 //作者1写了设计模式 w1.addNovel("设计模式"); //作者2写了JAVA编程思想 w2.addNovel("JAVA编程思想"); //读者1取关作者1 r1.unsubscribe("作者1"); //作者1再写书将不会通知读者1 w1.addNovel("观察者模式"); } }
结果如下。
观察者模式差不多就这样，后续项目中遇到实际的例子，可以补充在后面。
