深入自定义观察者模式的实现和应用

兰森环游世界

于 2024-08-27 14:25:37 发布

阅读量650

点赞数 22

本文链接：https://blog.csdn.net/weixin_31486261/article/details/141642832

版权

本文还有配套的精品资源，点击获取

简介：观察者模式是一种行为设计模式，允许一个对象状态改变时，通知多个关注它的对象。在Java中，通过自定义Subject和Observer接口，我们可以灵活实现需求。本文章将介绍如何自定义观察者模式，并通过代码示例展示其结构和工作原理。自定义观察者模式可以提供更灵活的通知策略，并在事件驱动编程、用户界面更新、状态管理等场景中发挥重要作用，有助于系统解耦和维护。

1. 观察者模式定义及应用

观察者模式是软件设计领域中一种非常重要的行为型模式，它的核心是对象间的一对多依赖关系。当一个对象改变状态时，其依赖的所有对象将得到通知并被自动更新。在复杂的系统设计中，观察者模式能够帮助我们实现松耦合的组件间通信，提升系统内部的协作效率和可维护性。

具体而言，观察者模式包含两个主要的元素：Subject（主题）和Observer（观察者）。Subject负责维护一系列的Observer对象，并在状态变化时通知这些Observer。而每个Observer对象则维护自身的状态，并响应来自Subject的通知。

在许多现代软件应用中，观察者模式都被用来实现事件处理系统、响应式编程以及消息传递系统等。例如，在前端开发中，我们可以使用观察者模式来创建一个响应式的用户界面，其中用户界面的各个部分作为观察者，它们能够响应模型层的数据变化。此外，观察者模式在事件驱动的架构中也扮演着关键角色，它可以帮助系统组件在运行时动态地订阅和响应各种事件，从而使得系统的行为更加灵活。

通过本章的学习，读者将掌握观察者模式的基础知识，并理解它在实际开发中的多种应用。接下来的章节将详细介绍Subject与Observer角色的具体职责以及如何在代码中实现它们的交互机制。

2. Subject和Observer角色介绍

2.1 Subject角色详解

2.1.1 Subject接口的定义

在观察者模式中， Subject 角色是一个核心组件，负责维护观察者的列表，并提供注册、注销、通知观察者的功能。通常， Subject 会定义以下几个关键的方法：

public interface Subject {
    void registerObserver(Observer o);
    void removeObserver(Observer o);
    void notifyObservers();
}

这里， registerObserver 方法用于将一个观察者对象添加到主题的观察者列表中，而 removeObserver 方法则用于从列表中移除一个观察者对象。 notifyObservers 方法则是用来通知所有注册的观察者，即当主题的状态发生变化时，它会被调用。

2.1.2 Subject在观察者模式中的职责

Subject 角色的职责在于维护观察者列表，并且在状态发生变化时通知所有注册的观察者。这种职责的分离使得主题与观察者之间保持了解耦的状态。主题不需要知道观察者具体是如何工作的，它只需知道如何管理它们。而观察者也不需要直接与主题交互，它们仅通过 Subject 接口与其通信。

2.2 Observer角色详解

2.2.1 Observer接口的定义

与 Subject 类似， Observer 也是一个接口，定义了观察者需要实现的方法：

public interface Observer {
    void update();
}

update 方法是观察者的核心，当 Subject 状态发生变化时，这个方法会被调用。观察者需要在这个方法内部实现更新自身的逻辑，以响应主题的变化。

2.2.2 Observer在观察者模式中的职责

观察者的职责是响应主题状态的变化。当主题的状态发生变化时， Subject 会通知所有的观察者。每个观察者接收到通知后，会在其 update 方法中实现具体的响应逻辑。观察者的实现可以多样，可以是显示数据更新，执行计算任务，或者是触发其他业务逻辑。

2.3 角色间的交互机制

2.3.1 注册与注销观察者

主题和观察者之间的注册与注销机制是观察者模式中的基础操作。主题需要提供方法供观察者注册和注销自身，通常情况下，当观察者不再需要接收通知时，它们会调用 removeObserver 方法从主题的观察者列表中移除自己。这个机制保证了主题不会发送通知给那些不再关注其变化的观察者，有助于减少无谓的计算和资源浪费。

2.3.2 通知机制的实现

通知机制是观察者模式的核心，当主题的状态发生变化时，它会调用 notifyObservers 方法。这个方法会依次调用每一个注册观察者的 update 方法。在实际的实现中， Subject 可能需要考虑线程安全问题，特别是在多线程环境中，避免因为状态更新的通知导致的数据不一致问题。

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

在上面的代码示例中，我们假设有 observers 这个 List<Observer> 集合存储了所有注册的观察者。当主题状态改变时，遍历这个列表，并且依次调用每个观察者的 update 方法。

代码逻辑分析完成后，我们对 Subject 和 Observer 角色进行了深入的介绍和职责分析。这为之后的实际实现步骤和业务适用性分析打下了坚实的基础。在下一章中，我们将详细探讨如何自定义实现观察者模式，以及如何通过编码实践这些理论。

3. 自定义观察者模式的实现步骤

3.1 设计自定义观察者模式的架构

设计自定义的观察者模式架构是实现该模式的第一步。架构的设计决定了模式的灵活性、可扩展性和可维护性。以下是设计自定义观察者模式架构的关键步骤和考虑因素。

3.1.1 确定Subject和Observer的接口设计

在实现自定义观察者模式时，首先需要定义两个核心接口：Subject和Observer。它们是观察者模式中两个主要的参与者。

Subject接口的定义

public interface Subject {
    void registerObserver(Observer o);
    void removeObserver(Observer o);
    void notifyObservers();
}

registerObserver 方法用于注册一个新的观察者， removeObserver 方法用于移除一个已注册的观察者，而 notifyObservers 方法则用于通知所有已注册的观察者。

Observer接口的定义

public interface Observer {
    void update(Object arg);
}

update 方法是所有观察者必须实现的，该方法定义了观察者在接收到通知时的响应方式。

3.1.2 实现Subject和Observer的基本功能

在定义了接口之后，下一步就是实现这些接口。Subject需要维护一个观察者列表，并在适当的时候通知这些观察者。

实现Subject类

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

public class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<>();
    @Override
    public void registerObserver(Observer o) {
        observers.add(o);
    }

    @Override
    public void removeObserver(Observer o) {
        observers.remove(o);
    }

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

实现Observer类

public class ConcreteObserver implements Observer {
    @Override
    public void update(Object arg) {
        // Update logic here
        System.out.println("Observer received update: " + arg);
    }
}

3.2 编码实现自定义观察者模式

编码实现自定义观察者模式是一个将架构设计转化为实际代码的过程。此过程涉及编写Subject和Observer类的具体实现，并进行测试以确保它们能够正确交互。

3.2.1 编写Subject类的代码实现

在自定义实现中，Subject类通常维护一个观察者列表，当状态发生变化时，它会遍历这个列表并通知所有观察者。

public class SubjectImpl implements Subject {
    private List<Observer> observers = new ArrayList<>();

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

    @Override
    public void removeObserver(Observer o) {
        int i = observers.indexOf(o);
        if (i >= 0) {
            observers.remove(i);
        }
    }

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

3.2.2 编写Observer类的代码实现

观察者类需要实现 update 方法，该方法将由Subject在适当的时候调用。

public class ObserverImpl implements Observer {
    private String name;

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

    @Override
    public void update(Object arg) {
        // Observer specific update logic here.
        // For demonstration, print the event.
        System.out.println(name + " has been updated!");
    }
}

3.2.3 测试Subject与Observer的交互

创建Subject和Observer的实例，并进行测试以确保它们能够正确地交互。

public class ObserverPatternDemo {
    public static void main(String[] args) {
        Subject subject = new SubjectImpl();
        Observer observer1 = new ObserverImpl("Observer1");
        Observer observer2 = new ObserverImpl("Observer2");
        subject.registerObserver(observer1);
        subject.registerObserver(observer2);

        System.out.println("First notification:");
        subject.notifyObservers();

        subject.removeObserver(observer1);

        System.out.println("\nSecond notification:");
        subject.notifyObservers();
    }
}

测试结果分析

在以上代码执行后，观察者 Observer1 和 Observer2 应该接收到两次通知。第一次通知时，它们都接收到更新事件。第二次通知时，只有 Observer2 接收到更新，因为 Observer1 已被移除。

First notification:
Observer1 has been updated!
Observer2 has been updated!

Second notification:
Observer2 has been updated!

通过以上步骤，我们已经成功实现了自定义的观察者模式，并通过测试验证了其功能。这个实现展示了Subject和Observer之间如何通过注册、通知和更新机制进行交互。在实际应用中，可以根据具体需求调整和扩展这些类的功能。

4. Java标准库观察者模式实现概述

在本章节中，将重点介绍Java标准库中实现观察者模式的方法。Java通过内置的Observable类和Observer接口提供了一种简便的方式来实现观察者模式。这一实现方式对于快速开发和实现事件驱动的系统架构具有重要意义。

4.1 Java中观察者模式的标准实现

4.1.1 Java内置的Observable类和Observer接口

Java的Observable类和Observer接口是观察者模式的标准实现，位于java.util包中。Observable类代表了可被观察的对象，它内部维护了一个Observer列表，用于在状态改变时通知这些观察者。而Observer接口则定义了update方法，该方法在被观察的对象发生变化时被调用。

下面是一个使用Observable类和Observer接口的基本示例：

import java.util.Observable;
import java.util.Observer;

public class WeatherData extends Observable {
    private float temperature;
    private float humidity;

    public void measurementsChanged() {
        setChanged(); // 标记状态已改变
        notifyObservers(); // 通知所有注册的观察者
    }

    public void setMeasurements(float temperature, float humidity) {
        this.temperature = temperature;
        this.humidity = humidity;
        measurementsChanged(); // 更新数据后通知观察者
    }

    public float getTemperature() {
        return temperature;
    }

    public float getHumidity() {
        return humidity;
    }
}

public class CurrentConditionsDisplay implements Observer {
    private float temperature;
    private float humidity;
    private Observable observable;

    public CurrentConditionsDisplay(Observable observable) {
        this.observable = observable;
        observable.addObserver(this); // 注册自己为观察者
    }

    public void update(Observable obs, Object arg) {
        if (obs instanceof WeatherData) {
            WeatherData weatherData = (WeatherData) obs;
            this.temperature = weatherData.getTemperature();
            this.humidity = weatherData.getHumidity();
            display();
        }
    }

    public void display() {
        System.out.println("Current conditions: " + temperature + "F degrees and " + humidity + "% humidity");
    }
}

4.1.2 Java标准观察者模式的使用方法

使用Java标准观察者模式非常直接。首先，创建一个继承自Observable的类，实现其内部状态改变时的逻辑，并在状态改变时调用notifyObservers()方法。然后创建实现了Observer接口的类，并在update方法中处理来自Observable对象的数据。

例如，使用上面的WeatherData和CurrentConditionsDisplay类，可以这样创建对象并进行交互：

public class WeatherStation {
    public static void main(String[] args) {
        WeatherData weatherData = new WeatherData();
        CurrentConditionsDisplay currentDisplay = new CurrentConditionsDisplay(weatherData);
        weatherData.setMeasurements(80, 65);
        weatherData.setMeasurements(82, 70);
    }
}

当WeatherData的setMeasurements方法被调用时，它会自动通知CurrentConditionsDisplay对象，后者随后调用update方法并显示新的天气条件。

4.2 标准实现的局限性分析

4.2.1 性能瓶颈与适用场景

尽管Java的Observable类和Observer接口提供了快速实现观察者模式的途径，但它们也存在一些性能上的局限。Observable是一个类而不是一个接口，这意味着它不能被继承或者扩展，这限制了它的灵活性。此外，Java的Observable类设计在现代多线程环境中并不是线程安全的，因此在并发环境中使用需要额外的同步控制。

4.2.2 线程安全与并发控制问题

由于Observable类和Observer接口设计年代较早，它们并不是为现代多线程环境而设计的。在处理多个线程同时更新Observable对象或者执行观察者的update方法时，可能会出现线程安全问题。因此，开发者在使用这些标准实现时需要特别注意线程安全和并发控制，尤其是在高并发和复杂场景下。

为了在实际项目中使用标准实现，开发者可能需要考虑使用外部同步机制，如使用synchronized关键字或显式锁。此外，对于某些场景，可能更适合使用基于发布-订阅模式的现代库，如RxJava，来提供更加健壮、线程安全且易于使用的观察者模式实现。

注意：在本文中，我们详细地探讨了Java标准库中观察者模式的实现方法，并对其性能和适用性进行了分析。此外，我们还指出了在并发环境下使用标准Observable类和Observer接口时需要注意的线程安全问题，为使用Java实现观察者模式的开发者提供了深入的见解。下一章节将深入探讨自定义Subject和Observer接口的设计与实现，以及如何与Java标准库进行对比。

5. 自定义Subject和Observer接口及其实现

5.1 自定义Subject接口的设计与实现

5.1.1 接口设计原则与方法定义

在设计自定义的Subject接口时，我们遵循了一些面向对象编程的基本原则，如单一职责、开闭原则和依赖倒置原则。我们希望Subject接口能够满足以下几点：

能够注册和注销观察者。
能够在状态改变时通知所有已注册的观察者。
能够管理好观察者的集合，保证观察者列表的线程安全。

基于这些原则和要求，我们可以定义Subject接口如下：

public interface Subject {
    void registerObserver(Observer o);
    void removeObserver(Observer o);
    void notifyObservers();
    void setState(Object newState);
    Object getState();
}

接口中的方法说明：

registerObserver(Observer o) : 注册一个新的观察者。
removeObserver(Observer o) : 注销一个已注册的观察者。
notifyObservers() : 通知所有注册的观察者状态变更。
setState(Object newState) : 设置Subject的新状态。
getState() : 返回Subject的当前状态。

5.1.2 Subject类的继承与扩展

实现这个接口，我们需要创建一个抽象类，这个类实现了Subject接口，并提供了状态管理及观察者列表维护的基础功能。这里的实现需要注意线程安全问题，特别是在多线程环境下对观察者列表的修改。

public abstract class AbstractSubject implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private Object state;

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

    @Override
    public void removeObserver(Observer o) {
        synchronized (observers) {
            observers.remove(o);
        }
    }

    @Override
    public void notifyObservers() {
        List<Observer> localObservers;

        synchronized (observers) {
            localObservers = new ArrayList<>(observers);
        }

        for (Observer observer : localObservers) {
            observer.update(this);
        }
    }

    protected void setState(Object newState) {
        this.state = newState;
        notifyObservers();
    }

    protected Object getState() {
        return state;
    }
}

在上面的代码中，我们使用了 synchronized 关键字来保证线程安全。这是一个简单且有效的方法，但它可能会引入一些性能问题，因为每次对观察者列表的操作都需要获取锁。

5.2 自定义Observer接口的设计与实现

5.2.1 接口设计原则与方法定义

对于Observer接口，我们同样遵循了面向对象编程的基本原则。我们希望Observer接口能够做到以下几点：

当Subject状态变更时，能够得到通知。
能够根据Subject传递的状态更新自己的状态。

基于这些原则和要求，我们可以定义Observer接口如下：

public interface Observer {
    void update(Subject subject);
}

update(Subject subject) 方法说明：

这个方法会在Subject的状态变更时被调用，参数 subject 是一个引用到Subject对象的实例，通过它可以获取最新的状态信息，并据此更新自己的状态。

5.2.2 Observer类的实现与特性分析

现在，我们可以创建一个具体的Observer类来实现这个接口。这个类将具体定义如何响应Subject状态的变更。

public class ConcreteObserver implements Observer {
    private Object observerState;

    @Override
    public void update(Subject subject) {
        observerState = subject.getState();
        // 在这里，ConcreteObserver将基于subject的状态更新自己的状态
        // 更新逻辑依赖于具体的业务场景
        doSomethingToUpdateObserverState(observerState);
    }

    private void doSomethingToUpdateObserverState(Object newState) {
        // 实现具体的更新逻辑
    }
}

在 ConcreteObserver 类中，我们实现了一个私有辅助方法 doSomethingToUpdateObserverState 来完成具体的状态更新逻辑。这部分代码会根据实际业务需求来填写，可能包括数据处理、UI更新等。

5.3 接口实现与Java标准库的对比

5.3.1 功能完整性对比

与Java标准库中的实现相比，我们的自定义实现提供了更大的灵活性。我们可以根据具体需求对Subject和Observer接口进行扩展，添加新的方法和属性。而Java标准库中的Observable类和Observer接口设计相对固定，可能无法满足一些特殊需求。

5.3.2 性能及灵活性的对比

从性能角度来看，我们通过代码示例已经看到了，在自定义实现中，我们可以通过同步块或使用更高级的并发工具（如java.util.concurrent包下的类）来提高性能和线程安全。

从灵活性角度来看，自定义实现允许开发者更好地控制Subject和Observer之间的交互细节，同时也可以为Subject和Observer添加更多的业务相关方法和属性，而不必受限于Java标准库的约束。

在实际项目中，根据具体的性能要求和业务需求选择合适的实现方式是非常重要的。自定义实现提供了更多的控制权，但也意味着开发者需要投入更多的时间来确保其健壮性和性能。

本文还有配套的精品资源，点击获取

兰森环游世界

关注

22
点赞
踩
14

收藏

觉得还不错? 一键收藏
0
评论
深入自定义观察者模式的实现和应用

本文还有配套的精品资源，点击获取简介：观察者模式是一种行为设计模式，允许一个对象状态改变时，通知多个关注它的对象。在Java中，通过自定义Subject和Observer接口，我们可以灵活实现需求。本文章将介绍如何自定义观察者模式，并通过代码示例展示其结构和工作原理。自定义观察者模式可以提供更灵活的通知策略，并在事件驱动编程、用户界面更新、状态管理等场景中发挥重要作用，有...
复制链接

扫一扫