java设计模式-Observe

一、背景　　　　　　　　　　　　　　　　　　　　

请模拟下面情形：

小孩在睡觉，醒来后要求吃东西

 

代码：

class Child{
    private boolean wakenUp = false;
    
    void wakeUp(){
        wakenUp = true;
    }

    public boolean isWakenUp() {
        return wakenUp;
    }
    public void setWakenUp(boolean wakenUp) {
        this.wakenUp = wakenUp;
    }
}

class Dad implements Runnable{
    Child c;
    
    public Dad(Child c){
        this.c = c;
    }
    
    @Override
    public void run() {
        while(!c.isWakenUp()){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        
        feed(c);
    }

    private void feed(Child c) {
        System.out.println("feed child");
    }
    
}


public class Test {

    public static void main(String[] args) {
        Child d = new Child();
        new Thread(new Dad(d)).start();
    }

}

上面代码运行起来是有问题的，永远等在那里，因为child永远不会醒过来；

那么，想让小孩5s之后醒过来怎么做？

二、让小孩5s之后醒　　　　　　　　　　

每一个小孩就是一个单独的线程；

 

代码：

class Child implements Runnable{
    private boolean wakenUp = false;
    
    void wakeUp(){
        wakenUp = true;
    }

    public boolean isWakenUp() {
        return wakenUp;
    }
    public void setWakenUp(boolean wakenUp) {
        this.wakenUp = wakenUp;
    }

    @Override
    public void run() {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.wakeUp();
    }
}

class Dad implements Runnable{
    Child c;
    
    public Dad(Child c){
        this.c = c;
    }
    
    @Override
    public void run() {
        while(!c.isWakenUp()){
            System.out.println("child is't wake up");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        
        feed(c);
    }

    private void feed(Child c) {
        System.out.println("feed child");
    }
    
}


public class Test {

    public static void main(String[] args) {
        Child d = new Child();
        new Thread(d).start();
        new Thread(new Dad(d)).start();
    }

}

console：

child is't wake up
child is't wake up
child is't wake up
child is't wake up
child is't wake up
feed child

这个小程序就模拟完了；也就是说要做完这个功能就已经做完了；

但是有什么不合理的地方？

小孩一直在睡着，如果采取现在这种编程模式，Dad就一直监视，无法干其他事情了，就只能在这里死死的盯着他；1s钟盯一眼，太累了；

这个累的意思就是，CPU的资源无端的被消耗了，CPU没事老是在这循环着；如果小孩3小时不醒就得循环3小时；这种编程的方式起码在效率上有问题；

 

那么，怎么修正这个问题呢？

 

 

 

三、第二版的设计　　　　　　　　　　　　　　

第二版的设计，不要让Dad在这浪费时间了；

Dad是主动的检测这个小孩有没有醒；主动的监听是非常消耗CPU资源的；

让小孩醒过来的时候自己调我这方法就完了；反过来让小孩监控他Dad；

 

代码:

class Child implements Runnable{
    private Dad d;
    
    public Child(Dad d){
        this.d = d;
    }
    
    void wakeUp(){
        d.feed(this);
    }

    @Override
    public void run() {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.wakeUp();
    }
}

class Dad{
    public void feed(Child c) {
        System.out.println("feed child");
    }
}


public class Test {

    public static void main(String[] args) {
        Dad d = new Dad();
        Child c = new Child(d);
        new Thread(c).start();
    }

}

过5s后，console打印：feed child

同样的功能，这种方式比上面的要效率高一些，消耗的CPU要少一些；

但是作为设计来讲，在一个软件项目之中的设计，如果只考虑到当前这种设计不具有弹性，也就是不具有可扩展性；

什么叫做没有弹性？

比方说设计一个新闻系统，发表一篇文章需要经过三级审查，编辑审了，副主编审，再主编审；如果不符合要求或者含有反动等信息就不能发表出去；

这时候你在程序里就写了三级，假如说将来级别增加了，需要四级审查、五级...怎么办？改源代码就很累；

考虑到可扩展性就可以用一个参数做配置，在配置文件里写3就是三级审查，写4就是四级审查....这样就有弹性一些；

 

上面代码，考虑一个问题：小孩可能会在不同的时间段醒来、不同的地点醒来，针对于不同醒来的事件，Dad的处理方式应该是不同的；这件事情的发生是包含着一些具体情况的，应该把不同的情况告诉他Dad，怎么样把事情的各种各样的信息告诉他Dad呢？

该用什么样的设计方法？

 

 

 

四、对于事件的处理　　　　　　　　　　　　

对于Dad来说，要根据事件的具体情况，才能做出具体的选择，也就是说作为Child来说，有责任把这件事情的具体情况通知你的监测人；

可以这么写，在Child里面增加什么时候醒来的时间time、醒来的地点loc，然后传给feed()里面的child c；

 

 可以这么写：

class Child implements Runnable{
    private Dad d;
    String time;
    String loc;
    
    public Child(Dad d){
        this.d = d;
    }
    
    void wakeUp(){
        time = "晚上";
        loc = "床上";
        d.feed(this);
    }

    @Override
    public void run() {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.wakeUp();
    }
}

class Dad{
    public void feed(Child c) {
        System.out.println("child wake up time :" + c.time);
        System.out.println("child wake up location :" + c.loc);
        System.out.println("feed child");
    }
}


public class Test {

    public static void main(String[] args) {
        Dad d = new Dad();
        Child c = new Child(d);
        new Thread(c).start();
    }
}

console：5s后打印：

child wake up time :晚上
child wake up location :床上
feed child

但是：仔细分析，作为time它应该是小孩的属性吗？loc应该是小孩的属性吗？

不是，它们应该是事件本身的属性；是事件发生时候的时间、地点。

所以，面向对象设计的一条最基础的原则：最合适的属性应该放在最合适的类里面；

 

所以：

1）再增加一个事件类：

2）并且，child的wakeUp()方法里面调用Dad的feed()方法，已经写死了，假如child醒过来不想让Dad喂他，而是让Dad带他出去玩呢？

那么feed方法就不合适了。更灵活的方法是：child一醒过来发出一件事，就让Dad对这件事做出反应，只要Dad做出正确的反应就ok了。

所以feed方法换为ActionToWakenUp;

代码：

/**
 * 醒过来的事件
 */
class WakenUpEvent{
    private long time;
    private String loc;
    private Child source;        //发生事件的源对象
    
    public WakenUpEvent(long time, String loc, Child source) {
        super();
        this.time = time;
        this.loc = loc;
        this.source = source;
    }
    public long getTime() {
        return time;
    }
    public void setTime(long time) {
        this.time = time;
    }
    public String getLoc() {
        return loc;
    }
    public void setLoc(String loc) {
        this.loc = loc;
    }
    public Child getSource() {
        return source;
    }
    public void setSource(Child source) {
        this.source = source;
    }
}

class Child implements Runnable{
    private Dad d;

    public Child(Dad d){
        this.d = d;
    }
    
    void wakeUp(){
        d.ActionToWakenUp(new WakenUpEvent(System.currentTimeMillis(), "bed", this));
    }

    @Override
    public void run() {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.wakeUp();
    }
}

class Dad{
    public void ActionToWakenUp(WakenUpEvent e) {
        System.out.println("child wake up time " + e.getTime());
        System.out.println("child wake up location " + e.getLoc());
        System.out.println("feed child");
    }
}

public class Test {

    public static void main(String[] args) {
        Dad d = new Dad();
        Child c = new Child(d);
        new Thread(c).start();
    }
}

console，5s后打印：

child wake up time 1529505152384
child wake up location bed
feed child

上面的设计其实还有问题：

假如说不止Dad，小孩醒过来爷爷也要做出一点反应，该怎么办呢？怎么样让更多的人对这件事做出反应？

 五、第三种设计方法　　　　　　　　　　

现在问题是怎么让监听事件的这些个人Dad、GrandFather、奶奶，以及对事件做出响应，怎么能做到比较好的扩展，不需要在Child类里面改来改去；

因为在Child里面改的话：

不但要增加private GrandFather gf;

还需要在wakeUp方法里面增加GrandFather的ActionToWakenUp方法；

还需要修改Child的构造方法，Child(Dad d, GrandFather gf)

...

 

修改为如下：

import java.util.ArrayList;
import java.util.List;



public class Test {
    public static void main(String[] args) {
        Child c = new Child();
        c.addWakenUpListener(new Dad());
        c.addWakenUpListener(new GrandFather());
        new Thread(c).start();
    }
}

/**
 * 发出事件的主体
 */
class Child implements Runnable{
    private List<WakenUpListener> WakenUplisteners = new ArrayList<WakenUpListener>();

    public void addWakenUpListener(WakenUpListener l){
        this.WakenUplisteners.add(l);
    }

    void wakeUp(){
        for(WakenUpListener listener : WakenUplisteners){
            listener.ActionToWakenUp(new WakenUpEvent(System.currentTimeMillis(), "bed", this));
        }
    }
    
    @Override
    public void run() {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.wakeUp();
    }
}

//对应醒事件的监听器接口
interface WakenUpListener {
    public void ActionToWakenUp(WakenUpEvent e);
}

//Dad监听器
class Dad implements WakenUpListener{
    public void ActionToWakenUp(WakenUpEvent e) {
        System.out.println("event time: "+e.getTime() +",event location: "+e.getLoc());
        System.out.println("feed child");
    }
}
//GrandFather监听器
class GrandFather implements WakenUpListener{
    public void ActionToWakenUp(WakenUpEvent e) {
        System.out.println("event time: "+e.getTime() +",event location: "+e.getLoc());
        System.out.println("hug child");
    }
}

/**
 * 醒事件
 */
class WakenUpEvent{
    private long time;
    private String loc;
    private Object source;        //发生事件的源对象
    
    public WakenUpEvent(long time, String loc, Object source) {
        super();
        this.time = time;
        this.loc = loc;
        this.source = source;
    }
    public long getTime() {
        return time;
    }
    public void setTime(long time) {
        this.time = time;
    }
    public String getLoc() {
        return loc;
    }
    public void setLoc(String loc) {
        this.loc = loc;
    }
    public Object getSource() {
        return source;
    }
    public void setSource(Object source) {
        this.source = source;
    }
}

console：

event time: 1529508249412,event location: bed
feed child
event time: 1529508249413,event location: bed
hug child