观察者模式Observer -- 深入理解

灰太狼 2023-07-17 15:42 65阅读 0赞

# 一、what is 观察者模式？ #

观察者模式又称为发布订阅模式，它定义了一种一对多的依赖关系，一个被观察者对象会被多个观察者同时监视，当被观察者的状态发生改变，会通知所有观察者，并让其作出相应动作。

这种关系和数学里面的函数类似：比如y=2x，当x=1，y=2；x=2，y=4.....；x是自变量，y是因变量。x就对应被观察者，y就对应观察者（这时只有一个观察者，实际生活中或者开发中是多个）。

简单情形：有A、B、C、D等四个独立的对象，其中B、C、D这三个对象想在A对象发生改变的第一时间知道这种改变，以便做出相应的响应或者对策。

当然可以**有多个观察者**，**多个被观察者**。**观察者与被观察者也不是对立的，一个对象可以观察其他对象，同是也可以被其他对象观察，即一个对象既是观察者又是被观察者。**

# 二、观察者模式实例 #

先看个简单的实例：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTIzMTkyOA_size_16_color_FFFFFF_t_70][]

public interface Observer {
        public void update();
    }

public class Subject {
    
        //观察者数组
        private Vector<Observer> observerVector = new Vector<>();
    
        //增加一个观察者
        public void addObserver(Observer observer) {
            this.observerVector.add(observer);
        }
    
        //删除一个观察者
        public void deleteObserver(Observer observer) {
            this.observerVector.remove(observer);
        }
    
        //通知所有观察者
        public void notifyObserver() {
            for(Observer observer : this.observerVector) {
                observer.update();
            }
        }
    }

public class ConcreteSubject extends Subject {
    
        //具体业务
        public void doSomething() {
            //...
            super.notifyObserver();
        }
    }

public class ConcreteObserver implements Observer {
    
        @Override
        public void update() {
            System.out.println("收到消息，进行处理");
        }
    }

public class Client {
        public static void main(String[] args) {
            //创建一个主题
            ConcreteSubject subject = new ConcreteSubject();
            //定义一个观察者
            Observer observer = new ConcreteObserver();
            //观察
            subject.addObserver(observer);
            //开始活动
            subject.doSomething();
        }
    }

> # 三、使用jdk实现观察者模式 #

上面的例子是自己写的Observer类，自己实现的添加观察者、删除观察者方法，实际写的时候不需要自己去写，JDK已经为我们提供了观察者模式相关的类及方法。

分别是：

1.  java.util.Observable ——被观察者，程序中的被观察者类，需要继承这个类。
2.  java.util.Observer——观察者，是接口。程序中的观察者类，需要实现这个接口中的update()方法。

具体的实例如下：

被观察者，继承Observable ：

import java.util.Observable;
    
    public class NumObservable extends Observable {
        int data = 0;
    
        public void setData(int i) {
            data = i;
            setChanged();    //标记此 Observable对象为已改变的对象
            notifyObservers();    //通知所有观察者
        }
    }

观察者1，实现Observer接口：

import java.util.Observable;
    import java.util.Observer;
    
    public class NumObserver implements Observer {
    
        @Override
        public void update(Observable o, Object arg) {    //有被观察者发生变化，自动调用对应观察者的update方法
            NumObservable observable = (NumObservable) o;     //获取被观察者对象
            System.out.println("Data has changed to " + observable.data);
        }
    }

观察者2：

public class NumObserver_01 implements Observer {
        @Override
        public void update(Observable o, Object arg) {
            NumObservable observable = (NumObservable) o;
            Console.log("观察者2——Data has changed to " + observable.data);
        }
    }

Client客户端：

public class Client {
        public static void main(String[] args) {
            NumObservable number = new NumObservable();    //被观察者对象
            number.addObserver(new NumObserver());    //给number这个被观察者添加观察者(当然可以有多个观察者)
            number.addObserver(new NumObserver_01());
            number.setData(1);
            number.setData(2);
            number.setData(3);
        }
    }

观察者2——Data has changed to 1
    Data has changed to 1
    观察者2——Data has changed to 2
    Data has changed to 2
    观察者2——Data has changed to 3
    Data has changed to 3

> # 四、**既是观察者又是被观察者** #

前面说过，**一个对象可以既是观察者又是被观察者。**

import java.util.Observable;
    import java.util.Observer;
    
    public class NotOnlyObservableButAlsoObserver_A extends Observable implements Observer {
    
        @Override
        public void update(Observable o, Object arg) {
            NotOnlyObservableButAlsoObserver_B b = (NotOnlyObservableButAlsoObserver_B) o;     //获取被观察者对象
            System.out.println("A监听到B数据变化：" + b.data);
    
            setChanged();
            notifyObservers();    //自己观察到数据变化，通知自己的观察者
        }
    }

public class NotOnlyObservableButAlsoObserver_B extends Observable implements Observer {
    
        int data = 0;
    
        public void setData (int i) {
            data = i;
            setChanged();         //标记此 Observable对象为已改变的对象
            notifyObservers();    //通知所有观察者
        }
    
        @Override
        public void update(Observable arg0, Object arg1) {
            System.out.println("同时，A反过来通知B自己的变化");
        }
    }

public class Client {
        public static void main(String[] args) {
            NotOnlyObservableButAlsoObserver_A ooa = new NotOnlyObservableButAlsoObserver_A();
            NotOnlyObservableButAlsoObserver_B oob = new NotOnlyObservableButAlsoObserver_B();
            oob.addObserver(ooa);
            ooa.addObserver(oob);
            oob.setData(1);
        }
    }

> # 五、**观察者模式的应用场景** #

介绍完了观察者模式，回过头来再看看它的优缺点，再总结下它的使用场景。

> 优点：
> 
> 观察者模式可以让主题对象和观察者对象之间松耦合，主题只知道观察者实现了某个接口，而无需知道观察者的具体类，以及具体如何实现。这样，即使之后要添加新的观察者类型，仍然只需实现该接口然后注册到主题对象中即可，无需修改已有代码，这也符合了对修改关闭，对扩展开发。
> 
> 缺点：
> 
> 1.首先观察者模式限定了类必须继承自Observer基类，单继承不友好。
> 
> 2.观察者模式限定了成员函数的名字，参数，返回值等。

当一个对象改变需要改变其他对象，并且不知道有多少对象有待改变时，考虑使用观察者模式。

> **使用场景：**
> 
>  *  1.当一个抽象模型有两个方面,其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。
>  *  2.当对一个对象的改变需要同时改变其它对象,而不知道具体有多少对象有待改变。
>  *  3.当一个对象必须通知其它对象， 而它又不能假定其它对象是谁。
> 
> 总之，当一个对象的改变需要同时改变其它对象，并且它不知道具体有多少对象有待改变的时候，应该考虑使用观察者模式。而使用观察者模式的动机在于：将一个系统分割成一系列相互协作的类有一个很不好的副作用，就是需要维护相关对象间的一致性，我们不希望为了维持一致性而使各类紧密耦合，这样会给维护、扩展和重用都带来不便，而**观察者模式所做的工作就是在解除耦合**。

**　　**为了更好的理解什么是观察者模式，下面举一些可能用到该模式的情形或例子：

*  (1)**周期性任务**。比如linux中的周期性任务命令crontab命令，win7下的定时关机命令shutdown -s -t 1200(1200s后关机)。这些命令当预期系统时间到后，就可以通知相应的观察者激活相应的命令。
 *  (2)**重新加载配置文件**。现在做大型系统基本都会有配置文件，例如在SSH项目中每次修改配置文件后，都需要重新启动服务器才能使得新的配置文件生效(当然SSH中貌似已经提供了参数设置，当配置文件修改时，可以自动重新加载)。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTIzMTkyOA_size_16_color_FFFFFF_t_70]: /images/20230528/90fe211ac41c4138940581b3bc054c39.png