设计模式之禅【观察者模式】

心已赠人 2022-06-02 10:51 180阅读 0赞

# 真刀实枪之观察者模式 #

*  韩非子身边的卧底到底是谁派来的
    
     *  “知己知彼，百战不殆；不知彼知己，一胜一负；不知己不知彼，每战必殆”
     *  那么怎样才能做到知彼呢，这个在世界都比较常见，就是安插间谍
     *  李斯和韩非子都是荀子的弟子，李斯是师兄，韩非子是师弟，若干年后，李斯成为最强诸侯秦国的上尉，致力于统一全国，于是安插间谍到各个国家，韩非子这么重量级人物，当然身边少不了间谍，韩非子做的李斯都了如指掌。
     *  用今天的技术重现当年的风云吧
     *  类图--两个重要人物
        
         *  ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70][]
     *  仅有这两个对象是不能说明怎么监控的，现在创建一个线程来将其开启监听吧！
        
         *  ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 1][]
     *  这是真实世界的翻版，安排了一个间谍，观察韩非子的生活起居，并上报给李斯，然后李斯在触发update事件，其中Spy是间谍角色，专门用户监听韩非子，然后报告给李斯
     *  接下来实现一下
        
         *  代码
            
             *  IHanFeiZi
                
                    package com.peng.gc;
                    
                    /**
                     * @author kungfu~peng
                     * @data 2017年11月25日
                     * @description
                     */
                    public interface IHanFeiZi {
                        // 吃早饭
                        public void havaBreakfast();
                    
                        // 娱乐
                        public void haveFun();
                    }
             *  HanFeiZI
                
                    package com.peng.gc;
                    
                    /**
                     * @author kungfu~peng
                     * @data 2017年11月25日
                     * @description
                     */
                    public class HanFeiZi implements IHanFeiZi {
                        // 是否在吃早饭
                        private boolean isHavingBreakfast = false;
                        // 是否在娱乐
                        private boolean isHavingFun = false;
                    
                        @Override
                        public void havaBreakfast() {
                            System.out.println("韩非子在吃早饭！");
                            this.isHavingBreakfast = true;
                        }
                    
                        @Override
                        public void haveFun() {
                            System.out.println("韩非子在娱乐！");
                            this.isHavingFun = true;
                        }
                    
                        // getter/setter
                        public boolean isHavingBreakfast() {
                            return isHavingBreakfast;
                        }
                    
                        public void setHavingBreakfast(boolean isHavingBreakfast) {
                            this.isHavingBreakfast = isHavingBreakfast;
                        }
                    
                        public boolean isHavingFun() {
                            return isHavingFun;
                        }
                    
                        public void setHavingFun(boolean isHavingFun) {
                            this.isHavingFun = isHavingFun;
                        }
                    
                    
                    }
             *  ILiSi
                
                    package com.peng.gc;
                    
                    /**
                     * @author kungfu~peng
                     * @data 2017年11月25日
                     * @description
                     */
                    public interface ILiSi {
                        // 一旦发现别人有动静，自己也要行动起来
                        public void update(String context);
                    }
             *  LiSi
                
                    package com.peng.gc;
                    
                    /**
                     * @author kungfu~peng
                     * @data 2017年11月25日
                     * @description
                     */
                    public class LiSi implements ILiSi {
                    
                        @Override
                        public void update(String context) {
                            System.out.println("李斯：观察到韩非子活动，开始向老板汇报~~");
                            this.reportToQinShiHuang(context);
                            System.out.println("李斯汇报完毕！");
                        }
                    
                        // 给秦始皇汇报监听结果
                        private void reportToQinShiHuang(String context) {
                            System.out.println("李斯：报告，秦老板！韩非子有活动了--》" + context);
                        }
                    }
             *  Spy
                
                    package com.peng.gc;
                    
                    /**
                     * @author kungfu~peng
                     * @data 2017年11月25日
                     * @description
                     */
                    public class Spy extends Thread {
                        private HanFeiZi hanFeiZi;
                        private LiSi liSi;
                        private String type;
                    
                        // 构造函数，传递被监控者和监控者
                        public Spy(HanFeiZi hanFeiZi, LiSi liSi, String type) {
                            super();
                            this.hanFeiZi = hanFeiZi;
                            this.liSi = liSi;
                            this.type = type;
                        }
                    
                        @Override
                        public void run() {
                            while (true) {
                                try {
                                    Thread.sleep(200);
                                } catch (InterruptedException e) {
                                    e.printStackTrace();
                                }
                                if (this.type.equals("breakfast")) {// 监控是否在吃早餐
                                    if (this.hanFeiZi.isHavingBreakfast()) {
                                        this.liSi.update("韩非子在吃早饭！");
                                        this.hanFeiZi.setHavingBreakfast(false);
                                    }
                                } else if (this.type.equals("fun")) {// 监控是否在娱乐
                                    if (this.hanFeiZi.isHavingFun()) {
                                        this.liSi.update("韩非子在娱乐！");
                                        this.hanFeiZi.setHavingFun(false);
                                    }
                                }
                            }
                        }
                    }
             *  Client
                
                    package com.peng.gc;
                    
                    /**
                     * @author kungfu~peng
                     * @data 2017年11月25日
                     * @description
                     */
                    public class Client {
                        public static void main(String[] args) throws InterruptedException {
                            // 定义出韩非子和李斯
                            HanFeiZi hanFeiZi = new HanFeiZi();
                            LiSi liSi = new LiSi();
                            // 观察早餐
                            Spy spy1 = new Spy(hanFeiZi, liSi, "breakfast");
                            // 开启线程监控
                            spy1.start();
                            // 观察娱乐情况
                            Spy spy2 = new Spy(hanFeiZi, liSi, "fun");
                            // 开启线程监控
                            spy2.start();
                    
                            // 韩非子活动
                            while (true) {
                                // 主线程休眠一秒
                                Thread.sleep(1000);
                                // 韩非子吃早饭
                                hanFeiZi.havaBreakfast();
                                // 主线程休眠一秒
                                Thread.sleep(1000);
                                // 韩非子吃早饭
                                hanFeiZi.haveFun();
                            }
                    
                        }
                    }
             *  执行结果
                
                    韩非子在吃早饭！
                    李斯：观察到韩非子活动，开始向老板汇报~~
                    李斯：报告，秦老板！韩非子有活动了--》韩非子在吃早饭！
                    李斯汇报完毕！
                    韩非子在娱乐！
                    李斯：观察到韩非子活动，开始向老板汇报~~
                    李斯：报告，秦老板！韩非子有活动了--》韩非子在娱乐！
                    李斯汇报完毕！
                    韩非子在吃早饭！
                    李斯：观察到韩非子活动，开始向老板汇报~~
                    李斯：报告，秦老板！韩非子有活动了--》韩非子在吃早饭！
                    李斯汇报完毕！
                    韩非子在娱乐！
                    李斯：观察到韩非子活动，开始向老板汇报~~
                    李斯：报告，秦老板！韩非子有活动了--》韩非子在娱乐！
                    李斯汇报完毕！
                    。。。
     *  当执行这段代码的时候，有没有看到cpu在飙升，Eclipse不响应【还好其中有sleep】，为什么呢，因为其中写了死循环。这样的程序不可以用到程序中，那怎么办？可以试一试聚合【把李斯聚集在韩非子身上，这在现实生活中比较难以接受，但在程序里无所不能~~】，立马动手
        
         *  类图
            
             *  ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 2][]
         *  看一下需要动的代码吧
            
             *  HanFeiZi
                
                    package com.peng.gc;
                    
                    /**
                     * @author kungfu~peng
                     * @data 2017年11月25日
                     * @description
                     */
                    public class HanFeiZi implements IHanFeiZi {
                        // LiSI
                        private LiSi liSi = new LiSi();
                        // 是否在吃早饭
                        private boolean isHavingBreakfast = false;
                        // 是否在娱乐
                        private boolean isHavingFun = false;
                    
                        @Override
                        public void havaBreakfast() {
                            System.out.println("韩非子在吃早饭！");
                            liSi.update("韩非子在吃早饭！");
                            this.isHavingBreakfast = true;
                        }
                    
                        @Override
                        public void haveFun() {
                            System.out.println("韩非子在吃娱乐！");
                            liSi.update("韩非子在娱乐！");
                            this.isHavingFun = true;
                        }
                    
                        // getter/setter
                        public boolean isHavingBreakfast() {
                            return isHavingBreakfast;
                        }
                    
                        public void setHavingBreakfast(boolean isHavingBreakfast) {
                            this.isHavingBreakfast = isHavingBreakfast;
                        }
                    
                        public boolean isHavingFun() {
                            return isHavingFun;
                        }
                    
                        public void setHavingFun(boolean isHavingFun) {
                            this.isHavingFun = isHavingFun;
                        }
                    
                    }
             *  Client
                
                    package com.peng.gc;
                    
                    /**
                     * @author kungfu~peng
                     * @data 2017年11月25日
                     * @description
                     */
                    public class Client {
                        public static void main(String[] args) throws InterruptedException {
                            // 定义出韩非子和李斯
                            HanFeiZi hanFeiZi = new HanFeiZi();
                            hanFeiZi.havaBreakfast();
                            hanFeiZi.haveFun();
                    
                        }
                    }
             *  执行结果
                
                    韩非子在吃早饭！
                    李斯：观察到韩非子活动，开始向老板汇报~~
                    李斯：报告，秦老板！韩非子有活动了--》韩非子在吃早饭！
                    李斯汇报完毕！
                    韩非子在吃娱乐！
                    李斯：观察到韩非子活动，开始向老板汇报~~
                    李斯：报告，秦老板！韩非子有活动了--》韩非子在娱乐！
                    李斯汇报完毕！
 *  在战国争雄的时候，韩非子这么有名望，有实力的人，就只有秦国关心他吗？想想也不能啊，肯定有好多的间谍在监视着，继续修改类图吧~
    
     *  类图
        
         *  ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 3][]
     *  解释：
        
        1.  Observable:实现该接口的是被观察者
        2.  Observer:观察者的接口
     *  代码
        
         *  Observable
            
                package gc2;
                
                /**
                 * @author kungfu~peng
                 * @data 2017年11月25日
                 * @description
                 */
                public interface Observable {
                    // 增加一个观察者
                    public void addObserver(Observer observer);
                
                    // 删除一个观察者
                    public void deleteObserver(Observer observer);
                
                    // 通知观察者
                    public void notifyObserver(String context);
                }
         *  IHanFeiZi
            
                package gc2;
                
                /**
                 * @author kungfu~peng
                 * @data 2017年11月25日
                 * @description
                 */
                public interface IHanFeiZi {
                    // 吃早饭
                    public void havaBreakfast();
                
                    // 娱乐
                    public void haveFun();
                }
         *  HanFeiZi
            
                package gc2;
                
                import java.util.ArrayList;
                
                /**
                 * @author kungfu~peng
                 * @data 2017年11月25日
                 * @description
                 */
                public class HanFeiZi implements IHanFeiZi, Observable {
                    // 存放间谍
                    private ArrayList<Observer> spys = new ArrayList<Observer>();
                
                    // 增加间谍
                    @Override
                    public void addObserver(Observer observer) {
                        this.spys.add(observer);
                    }
                
                    // 删除间谍
                    @Override
                    public void deleteObserver(Observer observer) {
                        this.spys.remove(observer);
                    }
                
                    // 通知间谍
                    @Override
                    public void notifyObserver(String context) {
                        for (Observer observer : spys) {
                            observer.update(context);
                        }
                    }
                
                    @Override
                    public void havaBreakfast() {
                        System.out.println("韩非子在吃早饭！");
                        // 通知所有观察者
                        this.notifyObserver("韩非子在吃早饭！");
                    }
                
                    @Override
                    public void haveFun() {
                        System.out.println("韩非子在娱乐！");
                        // 通知所有观察者
                        this.notifyObserver("韩非子在娱乐！");
                    }
                }
         *  Observer
            
                package gc2;
                
                /**
                 * @author kungfu~peng
                 * @data 2017年11月25日
                 * @description
                 */
                public interface Observer {
                    // 一有动静，自己也行动起来
                    void update(String context);
                
                }
         *  LiSi1
            
                package gc2;
                
                /**
                 * @author kungfu~peng
                 * @data 2017年11月25日
                 * @description
                 */
                public class LiSi1 implements Observer {
                
                    @Override
                    public void update(String context) {
                        System.out.println("李斯1：观察到韩非子，向老板1汇报~~");
                        this.reportToBoss(context);
                        System.out.println("李斯1汇报完毕1");
                    }
                
                    private void reportToBoss(String context) {
                        System.out.println("李斯1：报告，老板1！韩非子有活动了-》" + context);
                    }
                
                }
         *  LiSi2
            
                package gc2;
                
                /**
                 * @author kungfu~peng
                 * @data 2027年22月25日
                 * @description
                 */
                public class LiSi2 implements Observer {
                
                    @Override
                    public void update(String context) {
                        System.out.println("李斯2：观察到韩非子，向老板2汇报~~");
                        this.reportToBoss(context);
                        System.out.println("李斯2汇报完毕2");
                    }
                
                    private void reportToBoss(String context) {
                        System.out.println("李斯2：报告，老板2！韩非子有活动了-》" + context);
                    }
                
                }
         *  LiSi3
            
                package gc2;
                
                /**
                 * @author kungfu~peng
                 * @data 2037年33月25日
                 * @description
                 */
                public class LiSi3 implements Observer {
                
                    @Override
                    public void update(String context) {
                        System.out.println("李斯3：观察到韩非子，向老板3汇报~~");
                        this.reportToBoss(context);
                        System.out.println("李斯3汇报完毕3");
                    }
                
                    private void reportToBoss(String context) {
                        System.out.println("李斯3：报告，老板3！韩非子有活动了-》" + context);
                    }
                
                }
         *  Client
            
                package gc2;
                
                /**
                 * @author kungfu~peng
                 * @data 2017年11月25日
                 * @description
                 */
                public class Client {
                    public static void main(String[] args) {
                        // 生产三个观察者
                        Observer lisi1 = new LiSi1();
                        Observer lisi2 = new LiSi2();
                        Observer lisi3 = new LiSi3();
                        // 定义韩非子
                        HanFeiZi hanfeizi = new HanFeiZi();
                        // 添加间谍
                        hanfeizi.addObserver(lisi1);
                        hanfeizi.addObserver(lisi2);
                        hanfeizi.addObserver(lisi3);
                        // 吃早饭
                        hanfeizi.havaBreakfast();
                        // 娱乐
                        hanfeizi.haveFun();
                    }
                }
         *  执行结果
            
                韩非子在吃早饭！
                李斯1：观察到韩非子，向老板1汇报~~
                李斯1：报告，老板1！韩非子有活动了-》韩非子在吃早饭！
                李斯1汇报完毕1
                李斯2：观察到韩非子，向老板2汇报~~
                李斯2：报告，老板2！韩非子有活动了-》韩非子在吃早饭！
                李斯2汇报完毕2
                李斯3：观察到韩非子，向老板3汇报~~
                李斯3：报告，老板3！韩非子有活动了-》韩非子在吃早饭！
                李斯3汇报完毕3
                韩非子在娱乐！
                李斯1：观察到韩非子，向老板1汇报~~
                李斯1：报告，老板1！韩非子有活动了-》韩非子在娱乐！
                李斯1汇报完毕1
                李斯2：观察到韩非子，向老板2汇报~~
                李斯2：报告，老板2！韩非子有活动了-》韩非子在娱乐！
                李斯2汇报完毕2
                李斯3：观察到韩非子，向老板3汇报~~
                李斯3：报告，老板3！韩非子有活动了-》韩非子在娱乐！
                李斯3汇报完毕3

### 观察者模式的定义 ###

*  Observer Pattern
 *  也叫做发布订阅模式（Pulish/subscribe）
 *  Define a one-to-many dependency between objects so that when one object changes state,all its dependents are notified and updated automatically.(定义对象间的一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并被自动更新)

### 观察者的通用类图 ###

*  ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 4][]
 *  解释下这个类图：
    
    1.  Subject：被观察者，可以增加观察者、删除观察者、通知观察者
    2.  Observer：观察者。当接收到被观察者的动作后，自己做出相应的反应
    3.  ConcreteSubject：具体被观察者--定义自己的业务逻辑
    4.  ConcreteObserver：具体观察者--定义接收消息后自己的处理逻辑
 *  通用代码就不必在啰嗦了吧!只是注意几点
    
    1.  ArrayList是线程异步--不安全；Vector是线程同步--安全
    2.  根据实际的需求来写出自己的逻辑

### 观察者模式的应用 ###

*  观察者模式的优点
    
    1.  观察者和被观察者之间是抽象耦合【容易扩展】
    2.  建立一套触发机制【有事件的触发--有响应者做出相应的响应动作】
 *  观察者模式的缺点
    
    1.  开发效率
    2.  运行效率--一个卡，后面的卡，建议异步
    3.  多级触发

### 使用场景 ###

*  关联行为的场景--注意行为是可拆分的
 *  事件多级触发场景
 *  跨系统的消息交换场景--消息队列

### 观察者模式的注意事项 ###

*  广播链问题：如果一个对象既是观察者，又是被观察者，则逻辑就比较复杂了，注意滥用
 *  它和责任链的最大区别就是：传递的消息是随时可以更改的
 *  异步问题：EJB是个很好的例子--可以看看Message Queue

### 观察者模式的扩展 ###

*  java世界中的观察者模式：java.util.Observable类和java.util.Observer接口
    
    1.  "暴露狂"，这个类为那些喜欢讲自己状态暴露出去的人准备的
    2.  可以自行替换
    3.  替换后类图
        
        1.  ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 5][]
 *  项目中的真实观察者模式
    
     *  观察者与被观察者之间的沟通（数据的交流）：【被观察者，DTO（传输对象Data Transfer Object）】【xml格式的数据】
     *  观察者的相应方式：性能的考虑【多线程-异步架构】【缓存技术--提前把资源准备好--同步架构】
     *  被观察者尽量自己做主：被观察者的动作改变一定要通知观察者吗？有需要在进行通知【钩子方法】
 *  订阅发布模型--EJB3是个非常优秀的框架

### 最佳实践 ###

*  文件系统
    
    1.  新建文件
    2.  通知目录管理器来增加一个文件
    3.  通知磁盘减少1kb的空间
 *  猫鼠游戏
    
    1.  猫叫
    2.  老鼠跑
    3.  主人被吵醒
 *  ATM取钱
    
     *  插卡并输密码
     *  密码三次错误，第四次被吞卡：
        
        1.  摄像头连续快拍
        2.  通知监控系统
        3.  吞卡
        4.  初始化ATM屏幕
 *  广播收音机
    
     *  一个或几个收音机来听广播

### 声明 ###

*  摘自秦小波《设计模式之禅》第2版；
 *  仅供学习，严禁商业用途；
 *  代码手写，没有经编译器编译，有个别错误，自行根据上下文改正；

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70]: /images/20220602/613c8626689446deb4e45659326c2c12.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 1]: /images/20220602/46f9ea7905c447f8a525d0113de08d6f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 2]: /images/20220602/4075a8f0496946cd8e29433e074fefe2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 3]: /images/20220602/68812acd66294bf3b83219148d051cb7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 4]: /images/20220602/69545c680e0a4a85a98a3ecb64a99302.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 5]: /images/20220602/4faf049678984ae2a4d525311d5dad8a.png