《设计模式》之观察者模式

一、什么是观察者模式

观察者模式又称为 发布-订阅模式，定义了对象之间一对多依赖关系，当目标对象(被观察者)的状态发生改变时，它的所有依赖者(观察者)都会收到通知。一个观察目标可以对应多个观察者，而这些观察者之间没有相互联系，所以能够根据需要增加和删除观察者，使得系统更易于扩展，符合开闭原则；并且观察者模式让目标对象和观察者松耦合，虽然彼此不清楚对方的细节，但依然可以交互，目标对象只知道一个具体的观察者列表，但并不认识任何一个具体的观察者，它只知道他们都有一个共同的接口。

但观察者模式的缺点在于如果存在很多个被观察者的话，那么将需要花费一定时间通知所有的观察者，如果观察者与被观察者之间存在循环依赖的话，那么可能导致系统崩溃，并且观察者模式没有相应的机制让观察者知道被观察对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。

二、UML 结构图

 Subject：抽象主题（被观察者），每一个主题可以有多个观察者，并将所有观察者对象的引用保存在一个集合里，被观察者提供一个接口，可以增加和删除观察者角色

ConcreteSubject：具体主题，将有关状态存入具体观察者对象，在主题发生改变时，给所有的观察者发出通知

Observer：抽象观察者，为所有的具体观察者定义一个更新接口，该接口的作用是在收到主题的通知时能够及时的更新自己

ConcreteObserver：具体观察者，实现抽象观察者角色定义的更新接口，以便使本身的状态与主题状态相协调。如果需要，具体观察者角色可以保存一个指向具体主题角色的引用。

三、代码实现

练习案例：猫，狗与老鼠

假设猫是老鼠和狗的观察目标,老鼠和狗是观察者,猫叫老鼠跑,狗也跟着叫,使用观察者模式描述该过程。

抽象目标类 MySubject

MySubject是抽象目标类,在其中定义了一个ArrayList类型的集合observers,用于存储观察者对象,并定义了注册方法attach()和注销方法detach() ,同时声明了抽象的通知方法 cry()。需要注意的是attach()方法和detach()方法都必须针对抽象观察者进行编程,任何抽象观察者的子类对象都可以注册或注销。

package observer.test1;
 
import java.util.ArrayList;
 
/**
 * @author mengzhichao
 * @create 2021-12-04-12:17
 */
public abstract class MySubject {
 
    protected ArrayList observers =new ArrayList();
 
    //注册方法
    public void attach(MyObserver observer){
        observers.add(observer);
    }
 
    //注销方法
    public void detach(MyObserver observer){
        observers.remove(observer);
    }
 
    public abstract void cry(); //抽象通知方法
 
}

抽象观察者类 MyObserver

抽象观察者MyObserver定义为一个接口,在其中声明了抽象响应方法response()。

package observer.test1;
 
/**
 * @author mengzhichao
 * @create 2021-12-04-12:20
 */
public interface MyObserver {
    void response(); //抽象响应方法
}

具体目标类 Cat（猫类）

Cat是目标类MySubject 的子类,它实现了抽象方法 cry() ,在cry()中遍历了观察者集合,调用每一个观察者对象的response()响应方法。

package observer.test1;
 
/**
 * @author mengzhichao
 * @create 2021-12-04-12:19
 */
public class Cat extends MySubject {
    @Override
    public void cry() {
        System.out.println("猫叫!");
        System.out.println("-----------------------------------------");
 
        for (Object obs:observers){
            ((MyObserver)obs).response();
        }
    }
}

具体观察者类 Mouse（老鼠类）

Mouse是具体观察者类,它实现了在抽象观察者中定义的响应方法response()。

package observer.test1;
 
/**
 * @author mengzhichao
 * @create 2021-12-04-13:04
 */
public class Mouse implements MyObserver {
    @Override
    public void response() {
        System.out.println("老鼠努力逃跑!");
    }
}

具体观察者类 Dog（狗类）

Dog也是具体观察者类,它实现了在抽象观察者中定义的响应方法response()。

package observer.test1;
 
/**
 * @author mengzhichao
 * @create 2021-12-04-13:05
 */
public class Dog implements MyObserver {
    @Override
    public void response() {
        System.out.println("狗跟着叫!");
    }
}

编写客户端类并测试

在客户端代码中需要实例化具体目标类和具体观察者类,先调用目标对象的attach()方法来注册观察者,再调用目标对象的cry()方法,在cry()方法的内部将调用观察者对象的响应方法。

package observer.test1;
 
/**
 * @author mengzhichao
 * @create 2021-12-04-13:05
 */
public class Client {
    public static void main(String[] args) {
        MySubject subject=new Cat();
 
        MyObserver obs1,obs2,obs3;
        obs1=new Mouse();
        obs2=new Mouse();
        obs3=new Dog();
 
        subject.attach(obs1);
        subject.attach(obs2);
        subject.attach(obs3);
 
        subject.cry();
    }
}

观察者模式很好地体现了面向对象设计原则中的开闭原则。

如果需要增加一个观察者,如猪也作为猫的观察者,但是猫叫猪无须有任何反应,只需要增加一个新的具体观察者类Pig,而对原有的类库无须做任何改动,这对于系统的扩展性和灵活性有很大提高。

新增的具体观察者类Pig的代码如下:

package observer.test1;
 
/**
 * @author mengzhichao
 * @create 2021-12-04-13:13
 */
public class Pig implements MyObserver {
    @Override
    public void response() {
        System.out.println("猪没有反应!");
    }
}

在客户端代码中可以定义一个Pig实例,再将它注册到目标对象的观察者集合中,则需要增加如下代码:

package observer.test1;
 
/**
 * @author mengzhichao
 * @create 2021-12-04-13:05
 */
public class Client {
    public static void main(String[] args) {
        MySubject subject=new Cat();
 
        MyObserver obs1,obs2,obs3,obs4;
        obs1=new Mouse();
        obs2=new Mouse();
        obs3=new Dog();
        obs4=new Pig();
 
        subject.attach(obs1);
        subject.attach(obs2);
        subject.attach(obs3);
        subject.attach(obs4);
 
        subject.cry();
    }
}

从本实例可以看出增加新的具体观察者很容易，原有类库代码无须进行任何修改。 在实际使用时,还需要注意以下几个问题 

• 在客户端尽量针对抽象目标和抽象观察者编程，可以将具体观察者类的类名存储在配置文件中,如果需要更换或增加具体观察者对象只需要修改配置文件即可。如果目标对象和观察者对象之间是一对一关系,则实现过程比较简单,但是如果目标和观察者是一对多关系,则实现过程相对较为复杂。
• 在本实例中,由于具体观察者与具体目标类之间没有关联关系,因此增加新的具体目标类也非常方便,只需要扩展抽象目标类即可,而且也可以通过配置文件来存储具体目标类的类名,提高系统的灵活性和可扩展性。
• 如果具体观察者与具体目标类之间存在关联关系,则增加新的具体目标类会比较复杂,如果原有观察者类需要访问新增加的具体目标类中的状态,需要修改原有观察者类的源代码,系统的扩展性受到一定影响,不符合“开闭原则”的要求。

四、总结 

观察者模式定义对象间的一种一对多依赖关系,使得每当一个对象状态发生改变时,其相关依赖对象皆得到通知并被自动更新。

观察者模式适用情况包括：

• 一个抽象模型有两个方面,其中一个方面依赖于另一个方面;一个对象的改变将导致其他一个或多个对象也发生改变,而不知道具体有多少对象将发生改变;一个对象必须通知其他对象,而并不知道这些对象是谁;需要在系统中创建一个触发链。

观察者模式包含四个角色: 

• 目标又称为主题,它是指被观察的对象﹔具体目标是目标类的子类,通常它包含有经常发生改变的数据,当它的状态发生改变时,向它的各个观察者发出通知﹔观察者将对观察目标的改变做出反应﹔在具体观察者中维护一个指向具体目标对象的引用,它存储具体观察者的有关状态,这些状态需要和具体目标的状态保持一致。

观察者模式的主要优点在于可以实现表示层和数据逻辑层的分离,并在观察目标和观察者之间建立一个抽象的耦合,支持广播通信;其主要缺点在于如果一个观察目标对象有很多直接和间接的观察者的话,将所有的观察者都通知到会花费很多时间,而且如果在观察者和观察目标之间有循环依赖的话,观察目标会触发它们之间进行循环调用,可能导致系统崩溃。

五、模式扩展（Java语言提供的对观察者模式的支持）

• 观察者模式在Java语言中的地位非常重要。在JDK的 java.util包中,提供Observable类以及Observer接口,它们构成了Java语言对观察者模式的支持。

Observer接口

java.util. Observer接口只定义一个方法,它充当抽象观察者,其方法定义代码如下

void update(Observable o,object arg);

当观察目标的状态发生变化时,该方法将会被调用,在Observer的实现子类中实现该update()方法，即具体观察者可以根据需要具有不同的更新行为。当调用观察目标类Observable 的 notifyObservers()方法时,将调用观察者类中的update()方法。 

Observable类

java.util. Observable类充当观察目标类,在Observable中定义了一个向量Vector来存储观察者对象。它的方法包括：

我们可以直接使用Observer接口和Observable类来作为观察者模式的抽象层,自定义具体的观察者类和观察目标类,通过使用Java API中的Observer接口和Observable类，可以更加方便地在Java语言中使用观察者模式。 

参考文章: 详解Java设计模式之观察者模式（Observer Pattern）_虫链Java Library的博客-CSDN博客_java设计模式观察者模式

Java设计模式之行为型：观察者模式_张维鹏的博客-CSDN博客