案例分析：设计模式与代码的结构特性

Posted 2020-11-24 weihong775

案例分析：设计模式与代码的结构特性

本文选择的是基于观察者模式的案例分析，观察者模式属于23模式下的一种，在Java编程中有较广泛的应用。
github源码：https://github.com/colinNaive/DesignPatternAndroid.git

 

一、观察者模式介绍

 

1、概念

• 当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知它的依赖对象。观察者模式属于行为型模式。
• 观察者模式（又被称为发布-订阅（Publish/Subscribe）模式，属于行为型模式的一种，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态变化时，会通知所有的观察者对象，使他们能够自动更新自己。

 

2、介绍

• 意图：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
• 主要解决：一个对象状态改变给其他对象通知的问题，而且要考虑到易用和低耦合，保证高度的协作。
• 何时使用：一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）都将得到通知，进行广播通知。
• 如何解决：使用面向对象技术，可以将这种依赖关系弱化。
• 关键代码：在抽象类里有一个 ArrayList 存放观察者们。
• 应用实例：
  1、拍卖的时候，拍卖师观察最高标价，然后通知给其他竞价者竞价。
  2、西游记里面悟空请求菩萨降服红孩儿，菩萨洒了一地水招来一个老乌龟，这个乌龟就是观察者，他观察菩萨洒水这个动作。
• 优点：
  1、观察者和被观察者是抽象耦合的。
  2、建立一套触发机制。
• 缺点：
  1、如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。
  2、如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。
  3、观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。

 

二、观察者模式实例

现在我们从类图的角度来看一下：

从上面我们可以看到，这里面包含了两大类（主题和观察者）一共四个角色：

• Subject：抽象主题，他把所有观察者对象保存在一个集合里，可以有任意数量的观察者，抽象主题提供一个接口，可以增加和删除观察者对象。
• ConcreteSubject：具体主题，该角色将有关状态存入具体观察者对象，在具体主题的内部状态发生改变时，给所有注册过的观察者发送通知。
• Observer：抽象观察者，是观察者者的抽象类，它定义了一个更新接口，使得在得到主题更改通知时更新自己。
• ConcrereObserver：具体观察者，实现抽象观察者定义的更新接口，以便在得到主题更改通知时更新自身的状态。

观察者模式还是比较简单的，就是一个粉丝关注明星的实例。现在代码来实现一下。

 

1、被观察者Subject对象

首先是一个Subject类的父类，它实现了维护装有观察者引用集合的功能。

    public class Subject {
        //保存注册的观察者对象
        private List<Observer> mObervers = new ArrayList<>();

        //注册观察者对象
        public void attach(Observer observer) {
            mObervers.add(observer);
            Log.e("SZH", "attach an observer");
        }

        //注销观察者对象
        public void detach(Observer observer) {
            mObervers.remove(observer);
            Log.e("SZH", "detach an observer");
        }

        //通知所有注册的观察者对象
        public void notifyEveryOne(String newState) {
            for (Observer observer : mObervers) {
                observer.update(newState);
            }
        }
    }

接着是一个具体的被观察者对象

    public class ConcreteSubject extends Subject {
        private String state;

        public String getState() {
            return state;
        }

        public void change(String newState) {
            state = newState;
            Log.e("SZH", "concreteSubject state:" + newState);

            //状态发生改变，通知观察者
            notifyEveryOne(newState);
        }
    }

 

2、观察者Observer对象

首先是一个接口，抽象出了一个及时更新的方法

    public interface Observer {
        void update(String newState);
    }

接着是几个观察者对象。

    public class ObserverA implements Observer {

        //观察者状态
        private String observerState;

        @Override
        public void update(String newState) {
            //更新观察者状态，让它与目标状态一致
            observerState = newState;
            Log.e("SZH", "接收到消息：" + newState + "；我是A模块，快来抢吧！！");
        }
    }

    public class ObserverB implements Observer {
        //观察者状态
        private String observerState;

        @Override
        public void update(String newState) {
            //更新观察者状态，让它与目标状态一致
            observerState = newState;
            Log.e("SZH", "接收到消息：" + newState + "；我是B模块，快来抢吧！！");
        }
    }

    public class ObserverC implements Observer {
        //观察者状态
        private String observerState;

        @Override
        public void update(String newState) {
            //更新观察者状态，让它与目标状态一致
            observerState = newState;
            Log.e("SZH", "接收到消息：" + newState + "；我是C模块，快来抢吧！！");
        }
    }

 

三、观察者模式分析

 

1、模式优缺点分析

• 优点：观察者模式解除了主题和具体观察者的耦合，让耦合的双方都依赖于抽象，而不是依赖具体。从而使得各自的变化都不会影响另一边的变化。
• 缺点：依赖关系并未完全解除，抽象通知者依旧依赖抽象的观察者。

 

2、简述其中多态机制

观察者模式由抽象主题(Subject)角色、具体主题(Concrete Subject)角色组成。通过抽象主题和具体主题可实现多态，当主题未标注时使用默认主题通知，在具体主题时通过多态来进行动态添加通知。

 

3、模式内的抽象封装方法

• 抽象主题(Subject)角色：
  把所有对观察者对象的引用保存在一个集合中，每个抽象主题角色都可以有任意数量的观察者。抽象主题提供一个接口，可以增加和删除观察者。一般用接口或抽象类来实现抽象主题角色。

• 抽象观察者(Observer)角色
  为具体的观察者定义一个更新接口，在得到主题的通知时更新自己。

• 具体主题(Concrete Subject)角色
  在具体主题内部状态改变时，给所有登记过的观察者发出通知。是抽象主题的子类（或实现）。

• 具体观察者(Concrete Observer)角色
  该角色实现抽象观察者角色所要求的更新接口，以便本身的状态与主题的状态相协调。如果需要，具体观察者角色可以保存一个指向具体主题角色的引用。

 

四、总结

观察者模式的让我们知道了在设计开发的时候一定要“多用组合，少用继承”。
我们设计开发是应该是针对接口变成，而不针对实现编程。
这是一种创建松散耦合代码的技术。它定义对象间 一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都将得到通知。由主体和观察者组成，主体负责发布事件，同时观察者通过订阅这些事件来观察该主体。主体并不知道观察者的任何事情，观察者知道主体并能注册事件的回调函数。