设计模式之Observer

最新推荐文章于 2022-08-15 09:30:00 发布
最新推荐文章于 2022-08-15 09:30:00 发布
阅读量417 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式 观察者模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/eckotan/article/details/44393301
版权

Observer

tags: design pattern，Observer

要求：

模拟以下情景：

小孩在睡觉
醒了之后要吃东西

第一种设计方法

（说实话这是我第一反应想到的方法，我果然还是图样图森破。。。）

有一个Dad类， 有一个Child类， Dad类持有Child类的引用， Dad监测着Child， 如果Child醒了， Dad就调用feed方法去喂小孩。

package simulation;

class Child implements Runnable {

    private boolean wakeUp = false;

    public void wakeUp() {
        this.wakeUp = true;
    }

    public boolean isWakeUp() {
        return this.wakeUp;
    }

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

        this.wakeUp();
    }

}

class Dad implements Runnable {

    private Child child;

    public Dad(Child c) {
        this.child = c;
    }

    @Override
    public void run() {
        while (!child.isWakeUp()) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        this.feed(this.child);
    }

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

}

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

分析：
程序可行是可行， 但是有极其不合理的地方：Dad每隔一秒钟看一下Child， 完全干不了别的事。–> CPU的资源被无端消耗， 上面的代码在效率和资源消耗上都有很大问题！！！

那么应该如何改进呢？

第二种设计方法：

化主动为被动！

把Dad主动监测Child变为被动监测， 就是说， 反过来， 让Child监测Dad。换句话说， 在Child睡觉的时候Dad可以干别的事， 但Child一醒过来，Dad马上过来喂他吃东西。

这时候把上面的代码修改成下面的： 

package simulation;

class Child implements Runnable {

    private Dad dad;
    // private boolean wakeUp = false;

    public Child(Dad d) {
        this.dad = d;
    }

    public void wakeUp() {
        // this.wakeUp = true;
        this.dad.feed(this);
    }

    // public boolean isWakeUp() {
    // return this.wakeUp;
    // }

    @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();
    }
}

这时候Dad完全可以不用作为一个线程类， Dad这个类里也可以只保留feed这个方法， Child中持有Dad的引用， Child一醒过来， Dad就调用feed方法。

这样修改之后， 明显比第一种方法更具有效率。

但是作为设计来讲， 在一个程序当中， 如果只考虑当前而没有预料到将来一定时间内将会发生的变化， 那么程序不具有可扩展性，弹性很差。

比如上面这个情景， Child醒过来这件事，包含了许多信息：几点醒过来？是在早上还是在晚上？
睡了多久？在哪里醒过来？等等。 针对不同的事件信息，作为监测者的Dad应该有不同的处理方式， 不能说一醒过来就喂， 如果是晚上Child刚吃完饭睡了一下， 醒过来， Dad又喂他吃东西， 那么Child就撑死了。

所以第二种方法仅仅是把程序写通，可扩展性很差。

对于事件的处理

Child醒过来这件事的发生包含了许多具体情况（具体信息），应该把这些情况告诉监测者， 也就是Dad， Dad根据这件事情的具体情况， 来做出具体的处理方式。

因此把事件抽象出来，封装成另外一个类。

package simulation;

class WakeUpEvent {

    private long time;
    private String location;
    private Object source;

    public WakeUpEvent(long time, String location, Object source) {
        this.time = time;
        this.location = location;
        this.source = source;
    }

    public long getTime() {
        return time;
    }

    public void setTime(long time) {
        this.time = time;
    }

    public String getLocation() {
        return location;
    }

    public void setLocation(String location) {
        this.location = location;
    }

    public Object getSource() {
        return source;
    }

    public void setSource(Object source) {
        this.source = source;
    }

}

class Child implements Runnable {

    private Dad dad;

    // private boolean wakeUp = false;

    public Child(Dad d) {
        this.dad = d;
    }

    public void wakeUp() {
        // this.wakeUp = true;
        this.dad.actionToWakeUp(new WakeUpEvent(System.currentTimeMillis(),
                "bed", this));
    }

    // public boolean isWakeUp() {
    // return this.wakeUp;
    // }

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

        this.wakeUp();
    }
}

class Dad {

    public void actionToWakeUp(WakeUpEvent event) {
        // do something according to the event
    }

}

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

注意上面WakeUpEvent这个类里面， 属性除了有time和location之外还有一个source， 而且类型是Object（其实也可以写成Child类型， 但为了更像AWT， 所以写成Object），这里表示一个事件源对象，就是发生这件事的对象。比如说Child醒了这个事件， Child就是事件源。

然后再思考：Child一醒过来Dad就要喂他， 那么喂这个动作就已经被固定下来了。假如Child醒来之后不想让Dad喂他， 而是想让Dad抱他出去玩，那么明显feed这个方法已经不合适了。更灵活的方法是：Child一醒过来， 发生了这么一件事， Dad便对这件事做出反应，至于是喂他还是抱他出去玩都可以。

所以把Dad这个类中原来的feed方法修改了，方法名改成了actionToWakeUp,参数改成了WakeUpEvent event。 在方法体内， 便可以增加判断，根据事件的不同具体信息做出不同的反应。这样写明显比使用feed方法灵活得多。

继续思考：如果现在不只有Dad， Child醒过来之后，他的Grandpa也要做出反应，那么应该怎么办呢？按照之前的思路， 增加一个Grandpa类， 里面也有一个actionToWakeUp(WakeUpEvent event)方法，另外在Child这个类里增加一个Grandpa的引用。那么如果现在不仅是爸爸、爷爷对小孩醒过来做出反应，小孩的妈妈、奶奶、外公、外婆甚至是家里的狗都要做出反应呢？那岂不是要不断的修改Child这个类的源代码？！在OO里面有一个极其重要的核心原则————OCP， open close principle， 开闭原则， 对扩展开放， 对修改关闭。上面的方法要不断修改Child的源代码，显然是不符合这个原则的， 说明了设计还不到位！

第三种设计方法 Observer

现在有好多好多监测小孩醒过来这件事的人，而且每个人对这件事的响应各不相同，但是有一个共同点，可以把响应的方法都叫actionToWakeUp(WakeUpEvent event)，参数都是小孩醒过来这件事。这时候可以考虑使用接口把变化的这部分给抽象出来，因为接口抽象出来的是一系列的类所具有的共同特点。
因此增加一个WakeUpListener的接口，里面有actionToWakeUp(WakeUpEvent event)这个方法。 然后让Dad和Grandpa这两个类实现这个接口。

这时候再思考一下，为什么这个方法里传的参数是WakeUpEvent而不是Child？ 假如写成Child， 那么这个方法就只能用在小孩身上了，但是如果是WakeUpEvent，那么小狗醒了也可以用这个方法，小猫醒了也可以用这个方法，也就是说， 事件本身也是和事件源是脱离的。这个时候灵活性最高！

把上面的代码修改：

package simulation;

import java.util.*;

class WakeUpEvent {

    private long time;
    private String location;
    private Object source;

    public WakeUpEvent(long time, String location, Object source) {
        this.time = time;
        this.location = location;
        this.source = source;
    }

    public long getTime() {
        return time;
    }

    public void setTime(long time) {
        this.time = time;
    }

    public String getLocation() {
        return location;
    }

    public void setLocation(String location) {
        this.location = location;
    }

    public Object getSource() {
        return source;
    }

    public void setSource(Object source) {
        this.source = source;
    }

}

class Child implements Runnable {

    private List<WakeUpListener> listeners = new ArrayList<WakeUpListener>();

    public void addWakeUpListener(WakeUpListener listener) {
        this.listeners.add(listener);
    }

    public void wakeUp() {

        for (Iterator<WakeUpListener> it = this.listeners.iterator(); it
                .hasNext();) {
            WakeUpListener l = it.next();
            l.actionToWakeUp(new WakeUpEvent(System.currentTimeMillis(), "bed",
                    this));
        }
    }

    // public boolean isWakeUp() {
    // return this.wakeUp;
    // }

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

        this.wakeUp();
    }

}

interface WakeUpListener {
    public void actionToWakeUp(WakeUpEvent event);
}

class Dad implements WakeUpListener {

    public void actionToWakeUp(WakeUpEvent event) {
        System.out.println("feed child");
    }
}

class Grandpa implements WakeUpListener {
    public void actionToWakeUp(WakeUpEvent event) {
        System.out.println("hug child");
    }
}

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

注意：这时候Child这个类里没有Dad或者Grandpa的引用， 而是改成了一个List<WakeUpListener>， 并且多了一个addWakeUpListener(WakeUpListener listener)的方法，当需要添加监听器的时候，添加一个实现了WakeUpListener这个接口的类， 在main方法里new一个新的监听器对象，然后直接调用这个方法添加便可以，完全无需修改Child的代码。扩展程序而无需修改Child的源代码， 这才符合OCP原则！

比如我还想添加一个小狗， 他也在监听着小孩醒来这件事：

package simulation;

import java.util.*;

class WakeUpEvent {

    private long time;
    private String location;
    private Object source;

    public WakeUpEvent(long time, String location, Child source) {
        this.time = time;
        this.location = location;
        this.source = source;
    }

    public long getTime() {
        return time;
    }

    public void setTime(long time) {
        this.time = time;
    }

    public String getLocation() {
        return location;
    }

    public void setLocation(String location) {
        this.location = location;
    }

    public Object getSource() {
        return source;
    }

    public void setSource(Object source) {
        this.source = source;
    }

}

class Child implements Runnable {

    private List<WakeUpListener> listeners = new ArrayList<WakeUpListener>();

    public void addWakeUpListener(WakeUpListener listener) {
        this.listeners.add(listener);
    }

    public void wakeUp() {

        for (Iterator<WakeUpListener> it = this.listeners.iterator(); it
                .hasNext();) {
            WakeUpListener l = it.next();
            l.actionToWakeUp(new WakeUpEvent(System.currentTimeMillis(), "bed",
                    this));
        }
    }

    // public boolean isWakeUp() {
    // return this.wakeUp;
    // }

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

        this.wakeUp();
    }

}

interface WakeUpListener {
    public void actionToWakeUp(WakeUpEvent event);
}

class Dad implements WakeUpListener {

    public void actionToWakeUp(WakeUpEvent event) {
        System.out.println("feed child");
    }
}

class Grandpa implements WakeUpListener {
    public void actionToWakeUp(WakeUpEvent event) {
        System.out.println("hug child");
    }
}


class Dog implements WakeUpListener {
    public void actionToWakeUp(WakeUpEvent event) {
        System.out.println("Wang!!!!");
    }
}


public class Test {
    public static void main(String[] args) {
        Dad d = new Dad();
        Grandpa g = new Grandpa();
        Child c = new Child();
        c.addWakeUpListener(d);
        c.addWakeUpListener(g);

        Dog dog = new Dog();
        c.addWakeUpListener(dog);

        new Thread(c).start();
    }
}

由上面的代码可以看见， 只是新建了一个Dog的类， 然后再在main方法里添加了

        Dog dog = new Dog();
        c.addWakeUpListener(dog);

这两句话，其他的完全没有修改。主要的逻辑类Child完全没有变，可扩展性很高！

再进一步思考！假如我现在有一个Student类，他也可以发出WakeUpEvent这件事，那么我只需要复制Child里的代码到Student这个类里面就可以了，WakeUpEvent这个类也得到了复用，灵活性更高！！！想想AWT里面，除了Button这个类会发出ActionEvent这件事， TextField也会， 因此ActionEvent也被重用了。在这里，Button相当于Child， Textfield相当于Student， ActionEvent相当于WakeUpEvent。

另外还可以封装一个CryEvent类，HappyEvent类等等各种各样的event，然后再封装一个abstract class Event，让各种event从这个抽象类继承，方法传参数的时候形参定义为Event类型，这样灵活性更强。

反思与总结

从一开始第一种设计方法的一两个类实现了基本功能，到最后的多个类、接口，可以看到：使用设计模式是一把双刃剑。

  • 优点：

    1. 可扩展性强
    2. 维护成本降低

  • 缺点：

    1. 复杂度增加
    2. 开发成本增加

但是切忌为了使用设计模式而使用设计模式，要具体问题具体分析。

EckoTan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式之Observer Pattern
Bright
05-20 865
观察者模式是我们经常会用到的设计模式，比如说你设计了一个系统，当系统到来某个消息的时候，你希望通知该系统的其他模块，那么就相当于其他模块监听了这个事件，我们可以认为这些模块就是观察者，这就是典型的观察者模式的应用。
设计模式-Observer模式
最新发布
weixin_44438755的博客
02-22 1360
观察者模式定义了对象间一对多的依赖关系，当一个对象（本文称其为目标对象）的状态发生改变时，所有依赖它的对象（本文称其为观察者对象）都会得到通知并被自动更新。可能描述有些抽象，请看下图：Observer模式描述了如何建立这种关系。这一模式中的关键对象就是目标（subject）和观察者（observer）。一个目标可以有任意数目的观察者，一但该目标状态发生变化，所有的观察者都会得到通知。而作为对这个通知的相应，每个观察者都会查询目标以使其状态与目标状态同步。这种交互又称为。
设计模式——Observer(观察者)模式
qq_36566262的博客
04-21 2056
目录前言1 定义2 适用性3 结构3.1 结构图3.2 参与者4 应用举例4.1 Subject——Observable4.2 ConcreteSubject——ClockSubject4.3 Observer——Observer4.4 ConcreteObserver——ObserverOne、ObserverTwo4.5 测试程序——Client5 总结参考文献 前言 当一个对象与其它对象紧密关联，如果直接引用的话可能导致紧密耦合，如何描述这种一对多的关联关系？本文的观察者模式是一种思路。 1 定义 O
设计模式-Observer模式（观察者模式）
weixin_44030848的博客
08-15 338
图解设计模式中的观察者模式
Java设计模式—Observer模式
github_36601823的博客
03-16 669
简单地说，观察者模式定义了一个一对多的依赖关系，让一个或多个观察者对象监察一个主题对象。这样一个主题对象在状态上的变化能够通知所有的依赖于此对象的 那些观察者对象，使这些观察者对象能够自动更新。 　　一、观察者模式的结构 　　本模式的类图结构如下： 图1、观察者模式的静态结构可从类图中看清楚。 　　在观察者模式里有如下的角色：
C#设计模式之Observer设计模式(观察者设计模式)
wl58796351的专栏
11-20 1031
C#设计模式之Observer设计模式(观察者设计模式) 一、观察者（Observer）模式 观察者模式又叫做发布-订阅（Publish/Subscribe）模式、模型-视图（Model/View）模式、源-监听器（Source/Listener）模式或从属者（Dependents）模式。 观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个
Java23种设计模式之观察者模式（Observer）
Jieur的博客
01-06 775
观察者模式 (一)概述：定义对象间的一种一对多的依赖关系,以便当一个对象的状态发生改变时,所有依赖于他的对象都能得到通知并自动刷新 (二)帮助理解： 报社的业务就是出版报纸。 向某家报社订阅报纸，只要他们有新报纸出版，就会给你送来。只要你是他们的订户、你就会一直收到新报纸。 当你不想再看报纸的时候，取消订阅，他们就不会再送新报纸来。 只要报社还在运营，就会一直有人（或单位)向他们订阅报纸或取消订阅报纸。 报社：被观察者 订户：观察者 一个报社对应多个订户 (三)角色 Subject:抽象主题：(报社
javascript设计模式之Observer（观察者）模式
vuturn的专栏
09-02 8059
Observer(观察者)是一种设计模式，一个对象（subject）维持一系列依赖于它（观察者）的对象，将任何状态的任何变更自动通知给它们。 Suject(目标) 维护一系列的观察者，方便添加或者删除观察者。 Observer（观察者） 为那些在目标状态发生改变时需获得通知的对象提供更新接口   首先，建立Observer所需要的代码 function ObserverList
C#设计模式之Observer观察者模式解决牛顿童鞋成绩问题示例
08-29
主要介绍了C#设计模式之Observer观察者模式解决牛顿童鞋成绩问题,简单讲述了观察者模式的原理并结合具体实例形式分析了使用观察者模式解决牛顿童鞋成绩问题的具体步骤相关操作技巧,并附带demo源码供读者下载参考,...
java设计模式之Observer参考.pdf
11-04
java设计模式之Observer参考.pdf
java设计模式之Observer[整理].pdf
10-19
java设计模式之Observer[整理].pdf
设计模式之复合模式
EckoTan的专栏
07-16 864
DesignPattern之复合模式1. Definition组合模式允许将对象组合成树形结构来表现“整体 / 部分”层次结构，能让客户以==一致==的方式处理个别对象及对象组合（一视同仁） 2. 分析（Head First Design Pattern p358）根据 Head First Design Pattern 第358页的uml图来分析： 类图当中有三个类，一个是Component（节点
设计模式之工厂
EckoTan的专栏
07-05 721
设计模式之工厂
设计模式之适配器、外观模式
EckoTan的专栏
06-21 620
适配器 Adapter 外观 Facade 迪米特原则
设计模式之模板方法
EckoTan的专栏
07-02 586
Template（模板方式方法）在一个方法中定义了一个算法的骨架，而将一些步骤延迟到了子类中，由子类去实现具体的某几个步骤。Template模式使得子类可以在不改变算法结构的情况下，重新定义了算法的某些步骤。
设计模式之状态模式
EckoTan的专栏
07-17 483
DesignPattern之State1. Definition==状态模式允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它的类==。 这个模式将封装成为独立的类，并将动作委托到代表当前状态的对象，从而使行为会随着内部状态的改变而改变。
observer 设计模式 code c++
07-10
下是一个使用观察者（Observer）设计模式的示例代码（C++）： ```cpp #include #include // 观察者接口 class Observer { public: virtual void update(const std::string& message) = 0; }; // 具体观察者A ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值