设计模式-观察者模式

Author Avatar
晓晓Sama 3月 24, 2018

前言

观察者模式定义了对象间的一对多依赖关系,让一个或者多个观察者对象观察一个主题对象。当主题对象的状态发生变化时,系统能通知所有的依赖于此对象的观察者对象,从而使得观察者对象能自动更新。
在观察者模式中,被观察的对象通常被称为主题(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();
    }
}