从《大话设计模式》看JDK及框架中常用的设计模式（四）

怼烎@ 2024-04-18 19:46 59阅读 0赞

### 观察者模式 ###

#### 1.介绍 ####

**模式动机**  
建立一种对象与对象之间的依赖关系，一个对象发生改变时将自动通知其他对象，其他对象将相应做出反应。在此，发生改变的对象称为观察目标，而被通知的对象称为观察者，一个观察目标可以对应多个观察者，而且这些观察者之间没有相互联系，可以根据需要增加和删除观察者，使得系统更易于扩展，这就是观察者模式的模式动机。

**模式定义**  
**观察者模式**(Observer Pattern)：定义对象间的一种一对多依赖关系，使得每当一个对象状态发生改变时，其相关依赖对象皆得到通知并被自动更新。**观察者模式**又叫做发布-订阅（Publish/Subscribe）模式、模型-视图（Model/View）模式、源-监听器（Source/Listener）模式或从属者（Dependents）模式。

观察者模式是一种对象行为型模式。  
**模式分析**  
**观察者模式描述了如何建立对象与对象之间的依赖关系**，如何构造满足这种需求的系统。  
这一模式中的关键对象是观察目标和观察者，一个目标可以有任意数目的与之相依赖的观察者，一旦目标的状态发生改变，所有的观察者都将得到通知。  
作为对这个通知的响应，每个观察者都将即时更新自己的状态，以与目标状态同步，这种\*\*交互也称为发布-订阅(\*\*publishsubscribe)。目标是通知的发布者，它发出通知时并不需要知道谁是它的观察者，可以有任意数目的观察者订阅它并接收通知。

#### 2.模式结构 ####

观察者模式包含如下角色：

Subject: 目标  
ConcreteSubject: 具体目标  
Observer: 观察者  
ConcreteObserver: 具体观察者  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTcwMjMx_size_16_color_FFFFFF_t_70]

#### 3.实例 ####

**经典**

public class News { 
        private String title;
        private String content;
    
        public String getTitle() { 
            return title;
        }
    
        public void setTitle(String title) { 
            this.title = title;
        }
    
        public String getContent() { 
            return content;
        }
    
        public void setContent(String content) { 
            this.content = content;
        }
    }

此类不属于观察者模式必须的类，用来存放事件的信息。

public interface Subject { 
        List<People> peopleList = new ArrayList<>();
    
        default void add(People people) { 
            peopleList.add(people);
        }
    
        default void remove(People people) { 
            peopleList.remove(people);
        }
    
        void update();
    }

抽象主题角色，在这个角色中，有一个字段peopleList，用来保存【观察者】的引用，同时定义了两个接口，这是Java8默认接口实现的写法。这两个接口是给客户端调用的，用来【删除观察者】【增加观察者】，还提供一个方法，此方法需要被【具体主题角色】重写，用来通知各个【观察者】。

public class NewsSubject implements Subject{ 
        public void update() { 
            for (People people : peopleList) { 
                News news = new News();
                news.setContent("今日在大街上，有人躲在草丛中袭击路人，还大喊“德玛西亚万岁”");
                news.setTitle("德玛西亚出现了");
                people.update(news);
            }
        }
    }

复制代码具体主题角色，重写了【抽象主题角色】的方法，循环列表，通知各个【观察者】。

public interface People { 
        void update(News news);
    }

抽象观察者角色，定义了一个接口，【具体观察者角色】需要重写这个方法。  
下面就是【具体观察者角色】了：

public class PeopleA implements People { 
        @Override
        public void update(News news) { 
            System.out.println("这个新闻真好看");
        }
    }

public class PeopleB implements People { 
        @Override
        public void update(News news) { 
            System.out.println("这个新闻真无语");
        }
    }

public class PeopleC implements People { 
        @Override
        public void update(News news) { 
            System.out.println("这个新闻真逗");
        }
    }

客户端：

public class Main { 
        public static void main(String[] args) { 
            Subject subject = new NewsSubject();
            subject.add(new PeopleA());
            subject.add(new PeopleB());
            subject.add(new PeopleC());
            subject.update();
        }
    }

代码运行：  
![在这里插入图片描述][20190911113259117.png]  
**JDK**

在Java中，本身就提供了一个接口：Observer，一个子类：Observable，其中Observer表示【观察者】，Observable表示【主题】，可以利用这两个子类和接口来实现观察者模式：

public class NewsObservable extends Observable { 
        public void update() { 
           setChanged();
           notifyObservers();
        }
    }

public class People1 implements Observer { 
        @Override
        public void update(Observable o, Object arg) { 
            System.out.println("小编真无聊");
        }
    }

public class People2 implements Observer { 
        @Override
        public void update(Observable o, Object arg) { 
            System.out.println("开局一张图，内容全靠编");
        }
    }

客户端：

public static void main(String[] args) { 
            NewsObservable newsObservable = new NewsObservable();
            newsObservable.addObserver(new People1());
            newsObservable.addObserver(new People2());
            newsObservable.update();
        }

复制代码运行结果：  
![在这里插入图片描述][20190911113657615.png]  
在这里，我不打算详细介绍这种实现方式，因为从Java9开始，Java已经不推荐这种写法了，而推荐用消息队列来实现。是不是很开心，找到一个借口不去研究Observable，Observer 这两个东西了。

#### 4.优缺点 ####

*  观察者模式的优点

1.  观察者模式可以实现表示层和数据逻辑层的分离，并定义了稳定的消息更新传递机制，抽象了更新接口，使得可以有各种各样不同的表示层作为具体观察者角色。
2.  观察者模式在观察目标和观察者之间建立一个抽象的耦合。
3.  观察者模式支持广播通信。
4.  观察者模式符合“开闭原则”的要求。

*  观察者模式的缺点

1.  如果一个观察目标对象有很多直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。
2.  如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。
3.  观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。

#### 适用环境 ####

在以下情况下可以使用观察者模式：

*  一个抽象模型有两个方面，其中一个方面依赖于另一个方面。将这些方面封装在独立的对象中使它们可以各自独立地改变和复用。
 *  一个对象的改变将导致其他一个或多个对象也发生改变，而不知道具体有多少对象将发生改变，可以降低对象之间的耦合度。
 *  一个对象必须通知其他对象，而并不知道这些对象是谁。  
    需要在系统中创建一个触发链，A对象的行为将影响B对象，B对象的行为将影响C对象……，可以使用观察者模式创建一种链式触发机制。

#### 模式应用 ####

观察者模式在软件开发中应用非常广泛，如某电子商务网站可以在执行发送操作后给用户多个发送商品打折信息，某团队战斗游戏中某队友牺牲将给所有成员提示等等，凡是涉及到一对一或者一对多的对象交互场景都可以使用观察者模式。

#### 模式扩展 ####

**MVC模式**

MVC模式是一种架构模式，它包含三个角色：模型(Model)，视图(View)和控制器(Controller)。观察者模式可以用来实现MVC模式，观察者模式中的观察目标就是MVC模式中的模型(Model)，而观察者就是MVC中的视图(View)，控制器(Controller)充当两者之间的中介者(Mediator)。当模型层的数据发生改变时，视图层将自动改变其显示内容。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTcwMjMx_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/a607e896c4184a5db9b9047156f65e30.png
[20190911113259117.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/efe37216af904734883370c20131663b.png
[20190911113657615.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/6a0b15c2375446c1b37d4c498976512c.png