观察者模式

观察者模式定义了对象间的一对多依赖关系，让一个或者多个观察者对象观察一个主题对象。当主题对象的状态发生变化时，系统能通知所有的依赖于此对象的观察者对象，从而使得观察者对象能自动更新。

在观察者模式中，被观察的对象通常被称为主题(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();

    }

}