二十三种设计模式全面解析-当你的对象需要知道其他对象的状态变化时，观察者模式是你的救星！

news2024/11/22 1:38:11

在软件设计的世界中，有一种设计模式以其简洁而强大的特性闪耀着光芒，它就是——观察者模式（Observer Pattern）。这个模式它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，为我们创造了一种优雅的编程体验。本文将带你深入探讨，观察者模式的神秘面纱，揭示其强大之处，让你在面对复杂系统时能游刃有余。

1、什么是观察者模式

观察者模式是一种行为型设计模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。当主题对象发生变化时，它会通知所有的观察者对象，使它们能够自动更新自己。在观察者模式中，主题对象和观察者对象之间是松耦合的，它们之间并不直接依赖，而是通过抽象的接口或抽象类进行交互。

2、适用场景

观察者模式适用于以下场景：

当一个对象的改变需要同时改变其他对象的时候。
当一个对象需要将自己的改变通知其他对象，而又不希望知道具体有多少个对象需要通知时。
当一个对象需要通知其他对象，但是又希望这些对象是动态的，即不需要在编译时就确定下来。

例如，一个新闻发布机构可以作为主题对象，而订阅该机构新闻的用户可以作为观察者对象。当新闻发布机构发布新闻时，所有订阅该机构新闻的用户都会收到通知。

3、技术要点

观察者模式包含以下几个核心角色：

主题（Subject）：维护一组观察者对象，提供注册和删除观察者对象的方法，并通知观察者对象状态变化。
观察者（Observer）：定义了一个更新接口，用于在主题状态变化时接收通知。
具体主题（Concrete Subject）：继承或实现主题接口，实现注册、删除和通知观察者对象的方法。
具体观察者（Concrete Observer）：继承或实现观察者接口，实现更新接口，以便在主题状态变化时更新自己的状态。

4、观察者模式案例

import java.util.ArrayList;
import java.util.List;

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

interface Subject {
    public void attach(Observer observer);
    public void detach(Observer observer);
    public void notifyObservers();
}

class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<Observer>();
    private String message;

    public void attach(Observer observer) {
        observers.add(observer);
    }

    public void detach(Observer observer) {
        observers.remove(observer);
    }

    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(message);
        }
    }

    public void setMessage(String message) {
        this.message = message;
        notifyObservers();
    }
}

class ConcreteObserver implements Observer {
    private String name;

    public ConcreteObserver(String name) {
        this.name = name;
    }

    public void update(String message) {
        System.out.println(name + " received message: " + message);
    }
}

public class ObserverPatternDemo {
    public static void main(String[] args) {
        ConcreteSubject subject = new ConcreteSubject();

        ConcreteObserver observer1 = new ConcreteObserver("Observer 1");
        ConcreteObserver observer2 = new ConcreteObserver("Observer 2");
        ConcreteObserver observer3 = new ConcreteObserver("Observer 3");

        subject.attach(observer1);
        subject.attach(observer2);

        subject.setMessage("Hello World!");

        subject.detach(observer2);
        subject.attach(observer3);

        subject.setMessage("Goodbye World!");
    }
}

在这里插入图片描述

在上面的代码中，我们定义了一个 Subject 接口和一个 Observer 接口。

Subject 接口定义了注册、删除和通知观察者的方法，而 Observer 接口定义了更新方法。

然后我们定义了一个具体的主题类 ConcreteSubject，它维护了一个观察者列表，并实现了 Subject 接口中的方法。

我们还定义了一个具体的观察者类 ConcreteObserver，它实现了 Observer 接口中的更新方法。在 ObserverPatternDemo 类中，我们创建了一个具体的主题对象 subject 和三个具体的观察者对象 observer1、observer2 和 observer3。

我们首先将 observer1 和 observer2 注册到 subject 中，然后改变 subject 的状态，这会导致 observer1 和 observer2 的更新方法被调用。

接着我们将 observer2 从 subject 中删除，并将 observer3 注册到 subject 中，然后再次改变 subject 的状态，这会导致 observer1 和 observer3 的更新方法被调用。

这个案例代码展示了如何使用观察者模式来实现对象之间的松耦合，并且可以在运行时动态地选择不同的观察者，而不需要修改客户端代码。