观察者模式
观察者模式定义了对象间的一对多依赖关系，让一个或者多个观察者对象观察一个主题对象。当主题对象的状态发生变化时，系统能通知所有的依赖于此对象的观察者对象，从而使得观察者对象能自动更新。
在观察者模式中，被观察的对象通常被称为主题(Subject),依赖的对象被称为观察者(Observer)。在java中其实就有经典的AWT，比如按钮单击监听等等。
请模拟下面的情形：
- 小孩在睡觉
- 醒来后要吃东西
版本1：
主要思想：设计两个类Child和Dad，都是线程类，其中Dad类主动监测小孩是否还在睡觉，如果小孩一旦醒来，就喂它吃东西。
Child类:设置小孩的状态为睡着的，过了5秒，就醒来。
public class Child implements Runnable { private boolean wakenUp = false; void wakeUp(){ wakenUp = true; } @Override public void run() { try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } wakeUp(); } public boolean isWakenUp() { return wakenUp; } public void setWakenUp(boolean wakenUp) { this.wakenUp = wakenUp; } }
Dad类：将Child的引用传给Dad，监听小孩一旦醒来，就喂他吃的。
public class Dad implements Runnable{ Child c; public Dad(Child c) { this.c = c; } void feed(Child c) { System.out.println("Child is feeded!"); } @Override public void run() { while(!c.isWakenUp()){ try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } } c.wakeUp(); feed(c); } }
监听测试：
public class DadOberverChild { public static void main(String[] args) { Child c = new Child(); new Thread(c).start(); new Thread(new Dad(c)).start(); } }
该设计有些不合理，主动地监测，爸爸要不停地看着小孩，内存消耗严重，浪费时间。
版本2：
修正版本1中cpu浪费的情形，现在不拿Dad来监控Child，反过来被动监测，让Child来监控Dad，比如你可以一边看欧洲杯，当儿子一醒来后，他就会用绳子拉着你去喂他。
Child类
public class Child implements Runnable { private boolean wakenUp = false; private Dad d; public Child(Dad d){ this.d = d; } void wakeUp(){ wakenUp = true; } @Override public void run() { try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } wakeUp(); d.feed(this); } public boolean isWakenUp() { return wakenUp; } public void setWakenUp(boolean wakenUp) { this.wakenUp = wakenUp; } }
Dad类
public class Dad{ void feed(Child c) { System.out.println("Child is feeded!"); } }
监听测试类：
public class DadOberverChild { public static void main(String[] args) { Dad d = new Dad(); new Thread(new Child(d)).start(); } }
版本3：
小孩一醒过来，触发一件事，就让爸爸对这件事做出反应，不管是喂他吃东西，还是抱他出去玩，都会使程序更灵活。
Child类
public class Child implements Runnable { private Dad d; public Child(Dad d){ this.d = d; } void wakeUp(){
//处理小孩从床上醒来的情况 d.ActionToWakenUp(new WakenUpEvent(System.currentTimeMillis(),"bed",this)); } public void run() { try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } this.wakeUp(); } }
Dad类
public class Dad{ void feed(Child c) { System.out.println("Child is feeded!"); }
//处理可能发生的事件 public void ActionToWakenUp(WakenUpEvent wakenUpEvent) { System.out.println("OK!"); } }
事件类：封装发生的事件对象
public class WakenUpEvent { private long wakenTime; //醒来时间 private String location; //醒来地点 private Child source; //事件源对象 public WakenUpEvent(long wakenTime, String location, Child source) ...... public Setter()/Getter() ...... }
版本4：
对于小孩来说，一旦某件事发生，监听着这件事的人可能不只有一个，比如爸爸喂他吃东西，爷爷带他出去玩，奶奶给他开电视机...
Child类
public class Child implements Runnable { //存放监听者对象 private List<WakenUpListener> wakenUpListeners = new ArrayList<WakenUpListener>(); //为监听者对象添加监听器 public void addWakenUpListener(WakenUpListener l){ wakenUpListeners.add(l); } void wakeUp(){ for(int i=0;i<wakenUpListeners.size();i++){ WakenUpListener l = wakenUpListeners.get(i); l.ActionToWakenUp(new WakenUpEvent(System.currentTimeMillis(),"bed",this)); } } public void run() { .... } }
Dad类
public class Dad implements WakenUpListener{ public void ActionToWakenUp(WakenUpEvent wakenUpEvent) { System.out.println("Feed Child!"); } }
GrendFather类
public class GrendFather implements WakenUpListener { public void ActionToWakenUp(WakenUpEvent wakenUpEvent) { System.out.println("Hug Child!"); } }
监听者接口
public interface WakenUpListener { public void ActionToWakenUp(WakenUpEvent wakenUpEvent); }
事件类之前就已经封转好了，不用改变。
监听测试类
public class DadOberverChild { public static void main(String[] args) { Child c = new Child(); Dad d = new Dad(); GrendFather gf = new GrendFather(); c.addWakenUpListener(d); c.addWakenUpListener(gf); new Thread(c).start(); } }
测试结果：
Feed Child!
Hug Child!
程序改装到现在，灵活性非常高了，此时如果还有什么人要对小孩做什么事的话，只要再创建一个类就好，而且我们可以将要调用的类的信息放到配置文件中，在测试时，只需要读取配置文件中的信息就好，程序的可维护性变高了。
如：在程序中建立Observer.properties文件，随意添加对象名称。如：
observers = Dad,GrendFather
监听测试类：解析资源文件Observer.properties
public class DadOberverChild {
//只加载一次 static Properties props = new Properties(); static{ try {
//加载资源文件 props.load(DadOberverChild.class.getClassLoader().getResourceAsStream("Observer.properties")); } catch (IOException e) { e.printStackTrace(); } } private DadOberverChild(){} public static void main(String[] args) { Child c = new Child(); //取得文件中的内容并分解 String[] observers = props.getProperty("observers").split(","); for(String s : observers){ try {
//创建对象，并添加监听者 c.addWakenUpListener((WakenUpListener)(Class.forName(s).newInstance())); } catch (InstantiationException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); } } new Thread(c).start(); } }
