Java设计模式之一：观察者模式

目录

一、什么是观察者模式

二、如何使用观察者模式

三、观察者模式的优势和使用场景

---

 

一、什么是观察者模式

观察者模式是一种常见的设计模式，用于在对象之间建立一对多的依赖关系。在该模式中，一个主题（被观察者）维护了一个观察者列表，并在自身状态发生变化时通知所有观察者进行相应的更新。

观察者模式的核心概念包括以下几个角色：

1. 主题（Subject）：也称为被观察者或发布者，它维护了一个观察者列表，并提供方法用于注册、注销和通知观察者。

2. 观察者（Observer）：也称为订阅者或监听器，它定义了一个接口或抽象类，包含了观察者所需实现的方法，通常包括更新方法，在主题状态改变时被调用。

3. 具体主题（Concrete Subject）：实现主题接口或抽象类，具体主题维护自身状态，并在状态变化时通知观察者。

4. 具体观察者（Concrete Observer）：实现观察者接口或抽象类的具体类，它负责接收主题的通知并执行相应的操作。

观察者模式的优点在于解耦了主题和观察者之间的依赖关系，使得主题和观察者可以独立变化。当主题的状态发生改变时，所有观察者将被通知，从而实现了一种松耦合的方式来实现对象间的交互。

观察者模式广泛应用于许多场景，如事件处理、GUI开发、消息传递系统等。它提供了一种灵活的机制，使得对象之间能够及时响应和相互协作，同时也提高了代码的可维护性和可扩展性。

 

二、如何使用观察者模式

观察者模式是一种行为型设计模式，用于构建对象之间的一对多依赖关系。当一个对象（称为主题）的状态发生变化时，它会自动通知其所有依赖对象（称为观察者），以便它们可以做出相应的更新。

以下是一个使用Java实现观察者模式的简单示例代码：

首先，我们定义主题接口 Subject，其中包含了注册、注销和通知观察者的方法：

public interface Subject {
    void registerObserver(Observer observer);
    void unregisterObserver(Observer observer);
    void notifyObservers();
}

然后，我们定义观察者接口 Observer，其中包含了接收主题通知并进行相应操作的方法：

public interface Observer {
    void update();
}

接下来，我们实现具体的主题类 ConcreteSubject：

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

public class ConcreteSubject implements Subject {
    private List observers = new ArrayList<>();
    private int state;

    public int getState() {
        return state;
    }

    public void setState(int state) {
        this.state = state;
        notifyObservers();
    }

    @Override
    public void registerObserver(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void unregisterObserver(Observer observer) {
        observers.remove(observer);
    }

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

最后，我们实现具体的观察者类 ConcreteObserver：

public class ConcreteObserver implements Observer {
    private int observerState;
    private ConcreteSubject subject;

    public ConcreteObserver(ConcreteSubject subject) {
        this.subject = subject;
        this.subject.registerObserver(this);
    }

    @Override
    public void update() {
        observerState = subject.getState();
        System.out.println("Observer state updated: " + observerState);
    }
}

现在，我们可以使用这些类来演示观察者模式的工作方式：

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

        ConcreteObserver observer1 = new ConcreteObserver(subject);
        ConcreteObserver observer2 = new ConcreteObserver(subject);

        subject.setState(10);
        // 输出：
        // Observer state updated: 10
        // Observer state updated: 10

        subject.setState(20);
        // 输出：
        // Observer state updated: 20
        // Observer state updated: 20

        subject.unregisterObserver(observer2);

        subject.setState(30);
        // 输出：
        // Observer state updated: 30
    }
}

在上述示例中，我们创建了一个具体主题对象 subject 和两个具体观察者对象 observer1 和 observer2。当主题的状态发生变化时，它会通知所有注册的观察者，并调用其 update() 方法进行更新。

观察者模式使得主题与观察者之间松散耦合，使系统更灵活和可扩展。当我们需要在对象之间建立一对多的依赖关系，并实现对象状态的同步更新时，观察者模式是一个常用且强大的设计模式。

 

三、观察者模式的优势和使用场景

观察者模式是一种行为型设计模式，用于在对象之间建立一对多的依赖关系，当一个对象的状态发生变化时，其所有依赖对象都会自动收到通知并进行相应的更新。观察者模式具有以下优势和适用场景：

优势：

1. 解耦：观察者模式将被观察者和观察者解耦，使它们可以独立地进行扩展和修改，而不会影响到彼此。
2. 松散耦合：被观察者只需要知道观察者接口而不需要了解具体观察者的实现，从而降低了彼此之间的依赖程度，实现了松散耦合。
3. 可重用性：观察者模式可增加新的观察者或被观察者，无需修改原有代码，提高了代码的可重用性。

使用场景：

1. 当一个对象的改变需要同时通知其他多个对象，并且这些对象的更新操作可能不同步时，可以使用观察者模式。
2. 当一个对象的状态变化需要引起其他相关对象的状态变化时，可以使用观察者模式来保持对象之间的一致性。
3. 当系统中存在一个主体对象和多个观察者对象之间的动态关系，并且希望避免对象之间的紧耦合关系时，可以使用观察者模式。
4. 当一个对象需要将自己的状态变化通知给一组观察者，同时这些观察者对象具有不同的行为和角色时，可以使用观察者模式。

总结来说，观察者模式适用于多个对象之间存在一对多的依赖关系，当一个对象的状态变化需要通知其他对象并进行相应处理时，观察者模式能够提供一种松散耦合的解决方案，增加系统的灵活性和可扩展性。