• 我的Java设计模式-观察者模式


    相信大家都有看过《喜洋洋与灰太狼》,说的是灰太狼和羊族的“斗争”,而每次的结果都是灰太狼一飞冲天,伴随着一句“我还会回来的......”。为灰太狼感到悲哀,抓不到羊,在家也被老婆平底锅虐待。灰太狼为什么会这么背?

    很简单,灰太狼本身就有“暴露行踪”的属性,羊咩咩就能知晓灰太狼要干嘛,不背才怪呢。

    为了帮助灰太狼摆脱被老婆平底锅抽的悲剧,发起了“解救灰太狼”的行动,必须要知道观察者模式

    一、观察者模式##

    定义###

      观察者模式又叫做发布-订阅模式,定义了对象间一对多的依赖关系,使得当对象状态发生变化时,所有依赖它的对象都会收到通知并且自动更新自己。

    特点###

      1)被观察者需要持有一个或者多个观察者对象。

      2)系统中一个模块的变化,某些模块也会跟随着变化。

    UML###

    观察者模式UML图

    从上面的UML可以看出来,观察者模式设计到的角色有如下四个:

      - 抽象被观察者角色:定义了动态增加、删除以及通知观察者对象的方法,职责就是管理和通知观察者。持有观察者对象的集合。

      - 具体被观察者角色:一般继承抽象被观察者,实现自己本身的业务逻辑,当状态发生改变时发起通知。

      - 抽象观察者角色:提供一个接口,定义了观察者收到通知时更新自己的方法。

      - 具体观察者角色:实现抽象观察者接口,处理不同具体观察者的不同业务逻辑。

    二、实战##

    灰太狼具有被观察者属性,喜洋洋这些羊咩咩一直都在观察者灰太狼,所以羊咩咩们是观察者。OK,角色确定了,看看具体是怎么实现的...

    抽象被观察者代码如下:

    public abstract class Subject {
    
        /**
         * 观察者对象的集合
         */
        private List<Observer> observerList = new ArrayList<>();
    
        /**
         * 登记观察者
         *
         * @param observer
         */
        public void attach(Observer observer) {
            observerList.add(observer);
            System.out.println("增加了观察者:" + observer.getName());
        }
    
        /**
         * 删除观察者
         *
         * @param observer
         */
        public void dettach(Observer observer) {
            observerList.remove(observer);
            System.out.println("删除了观察者:" + observer.getName());
        }
    
        /**
         * 通知所有观察者
         */
        public void notifyObserver() {
            for (Observer observer : observerList) {
                observer.update("灰太狼要搞事情了");
            }
        }
    
    }
    

    灰太狼是具体被观察者,继承抽象被观察者,代码如下:

    public class Wolf extends Subject {
    
        public void invade(){
    
            System.out.println("灰太狼:我要搞事情了");
            // 通知所有观察者
            notifyObserver();
        }
    
    }
    

    抽象观察者代码如下:

    public interface Observer {
    
        String getName();
    
        /**
         * 通知更新方法
         *
         * @param msg
         */
        public void update(String msg);
    
    }
    

    喜羊羊是具体观察者,实现抽象观察者,代码如下:

    public class PleasantSheep implements Observer{
    
        @Override
        public String getName() {
            return "喜羊羊";
        }
    
        /**
         * 具体业务逻辑
         */
        @Override
        public void update(String msg) {
            System.out.println("喜羊羊收到通知:" + msg);
        }
    
    }
    

    接下来看客户端如何把观察者模式跑起来,代码如下:

    public class Client {
    
        public static void main(String[] args) {
            // 灰太狼--被观察者
            Wolf wolf = new Wolf();
            // 喜羊羊--观察者
            Observer pleasantSheep = new PleasantSheep();
            // 登记观察者
            wolf.attach(pleasantSheep);
            // 灰太狼入侵
            wolf.invade();
        }
    
    }
    

    运行客户端代码,结果如下:

    增加了观察者:喜羊羊

    灰太狼:我要搞事情了

    喜羊羊收到通知:灰太狼要搞事情了

    看到了吧,灰太狼这不是自找虐吗!搞事情还要发通知,活该被平底锅拍飞。灰太狼不止通知了喜羊羊,还通知了懒羊羊。

    懒羊羊也是具体观察者,代码如下:

    public class LazySheep implements Observer {
    
        @Override
        public String getName() {
            return "懒羊羊";
        }
    
        @Override
        public void update(String msg) {
            System.out.println("懒羊羊收到通知:" + msg);
        }
        
    }
    

    客户端代码如下:

    public class Client {
    
        public static void main(String[] args) {
            // 灰太狼--被观察者
            Wolf wolf = new Wolf();
    
            // 喜羊羊--观察者
            Observer pleasantSheep = new PleasantSheep();
            // 登记观察者
            wolf.attach(pleasantSheep);
    
            // 懒羊羊--观察者
            Observer lazySheep = new LazySheep();
            // 登记观察者
            wolf.attach(lazySheep);
            
            // 灰太狼入侵
            wolf.invade();
        }
    
    }
    

    上面客户端代码创建了一个懒羊羊观察者,添加了观察者集合中,这样懒羊羊也会受到通知,运行结果如下:

    增加了观察者:喜羊羊

    增加了观察者:懒羊羊

    灰太狼:我要搞事情了

    喜羊羊收到通知:灰太狼要搞事情了

    懒羊羊收到通知:灰太狼要搞事情了

    那如何帮助灰太狼摆脱这个命运呢,把观察者从集合中移除就OK了,代码如下:

    public class Client {
    
        public static void main(String[] args) {
            // 灰太狼--被观察者
            Wolf wolf = new Wolf();
    
            // 喜羊羊--观察者
            Observer pleasantSheep = new PleasantSheep();
            // 登记观察者
            wolf.attach(pleasantSheep);
    
            // 懒羊羊--观察者
            Observer lazySheep = new LazySheep();
            // 登记观察者
            wolf.attach(lazySheep);
    
            // 灰太狼入侵
            wolf.invade();
            
            // 删除观察者
            wolf.dettach(pleasantSheep);
            
            wolf.invade();
        }
    
    }
    

    再次运行客户端,结果如下:

    增加了观察者:喜羊羊

    增加了观察者:懒羊羊

    灰太狼:我要搞事情了

    喜羊羊收到通知:灰太狼要搞事情了

    懒羊羊收到通知:灰太狼要搞事情了

    删除了观察者:喜羊羊

    灰太狼:我要搞事情了

    懒羊羊收到通知:灰太狼要搞事情了

    可以看到,把喜羊羊从观察者集合中移除了,它就不会再收到通知。

    三、观察者模式的优缺点##

    优点###

    1)观察者和被观察者之间抽象耦合。观察者模式容易扩展,被观察者只持有观察者集合,并不需要知道具体观察者内部的实现。

    2)对象之间的保持高度的协作。当被观察者发生变化时,所有被观察者都会通知到,然后做出相应的动作。

    缺点

    1)如果观察者太多,被观察者通知观察者消耗的时间很多,影响系统的性能。

    2)当观察者集合中的某一观察者错误时就会导致系统卡壳,因此一般会采用异步方式。

    四、比较##

    跟代理模式对比:观察者模式和代理模式主要区别在它们功能不一样,观察者模式强调的是被观察者反馈结果,而代理模式是同根负责做同样的事情。

    总结##

    在Java中已经提供了Observable类以及一个Observer接口,也就是说Java已经实现了观察者模式的定义,可看出观察者模式在程序系统中的使用率是很高的,不单是Java,Android中也经常看到观察者模式的运用,比如OnClickListener,Rxjava等。下一篇会补上属于创建型模式的原型模式,下回分解,再见。

    设计模式Java源码GitHub下载https://github.com/jetLee92/DesignPattern

  • 相关阅读:
    spring(2)
    Android之滑动按钮实现Demo
    spring(1)
    spring(4)
    Android之ImageSwitch控件
    使用非阻塞ServerSocketChannel、SocketChannel代替ServerSocket和Socket
    Android之界面刷新(invalidate和postInvalidate使用)
    Android之改变控件的背景及形态
    Android之获得内存剩余大小与总大小
    OpenCV中矩阵的归一化
  • 原文地址:https://www.cnblogs.com/AndroidJet/p/7737644.html
Copyright © 2020-2023  润新知