第五篇：观察者模式的事件驱动

Damon_0411

已于 2023-09-27 16:46:46 修改

阅读量165

点赞数 1

分类专栏： spring设计模式文章标签：观察者模式设计模式 spring

于 2023-09-27 16:45:49 首次发布

本文链接：https://blog.csdn.net/weixin_43172297/article/details/133356255

版权

spring设计模式专栏收录该内容

7 篇文章 0 订阅

订阅专栏

本文详细解读了观察者模式在Spring框架中的应用，介绍了事件发布与订阅机制，展示了如何通过事件驱动实现松耦合的组件间通信，并通过实例演示了如何在Spring中使用ApplicationEventPublisher进行观察者模式实践。

摘要由CSDN通过智能技术生成

引言

观察者模式是一种经典的行为型设计模式，用于实现对象之间的一对多依赖关系。当一个对象的状态发生变化时，其相关的对象会自动收到通知并进行相应的操作。在软件开发中，观察者模式有着广泛的应用，尤其在Spring框架中，观察者模式被用于事件驱动的编程模型，实现解耦和可扩展性。本篇博客将深入探讨Spring框架中观察者模式的实现方式、事件驱动的开发模式，并讨论如何在应用程序中使用观察者模式实现松耦合的组件通信。

1 观察者模式概述

观察者模式，又称为发布-订阅模式，是一种设计模式，用于定义一种对象之间的依赖关系，使得一个对象的状态改变时，其所有依赖对象都会得到通知并自动更新。这种模式提供了一种松耦合的方式，使得主题对象（被观察者）和观察者对象之间能够独立演化，互不影响。
在观察者模式中，通常包含以下角色：

主题（Subject）：也称为被观察者，它维护一组观察者对象，并通知它们状态的变化。
观察者（Observer）：观察主题的对象，当主题状态发生改变时，观察者会得到通知并执行相应的操作。

2 Spring框架中的观察者模式

Spring框架是一个开源的应用程序框架，它提供了广泛的功能来支持企业级Java应用程序的开发。其中一个关键特性是事件驱动编程模型，它是基于观察者模式实现的，用于解耦组件之间的通信，以及实现可扩展性。

2.1 事件发布和订阅机制

在Spring框架中，事件发布和订阅是通过以下核心组件来实现的：

应用程序事件（Application Event）：应用程序事件是一个普通的Java对象，它封装了事件的信息。通常，你可以创建自定义的应用程序事件来表示你的业务需求。
应用程序事件监听器（Application Event Listener）：事件监听器是观察者模式中的观察者，它负责监听特定类型的事件，并在事件发生时执行相应的操作。

2.2 Spring框架中的主题和观察者

在Spring框架中，并没有显式的主题和观察者角色，而是通过事件机制来实现观察者模式。Spring的事件发布者充当了主题的角色，而事件监听器则充当了观察者的角色。

当一个事件发布者发布一个事件时，所有注册的事件监听器都会收到通知并执行相应的操作。这种方式允许各个组件之间松耦合地通信，因为事件发布者不需要知道事件监听器的具体实现，只需要发布事件，而事件监听器也不需要关心事件的来源，只需要监听感兴趣的事件类型。

2.3 示例：使用Spring事件驱动实现松耦合通信

在Spring框架中，实现观察者模式是通过 ApplicationEventPublisher 来完成的。这个接口是Spring框架提供的关键组件，用于发布应用程序事件（Application Event）和管理事件监听器（Event Listeners）。

2.3.1 ApplicationEventPublisher 简介

ApplicationEventPublisher 是一个接口，通常由Spring容器提供的ApplicationContext实现。它允许你在应用程序中发布自定义事件，并将事件传递给已注册的事件监听器。

该接口定义了一个主要方法：

publishEvent(ApplicationEvent event): 用于发布应用程序事件。你可以创建自定义的事件类，继承自 ApplicationEvent，并通过 publishEvent 方法将事件发布到Spring容器中。

2.3.2 示例：使用 ApplicationEventPublisher

让我们通过一个示例来说明如何使用 ApplicationEventPublisher 在Spring应用程序中实现观察者模式。

假设我们有一个在线商店的订单系统，需要在订单创建时通知多个观察者，如库存管理系统、发货系统等。首先，我们定义一个自定义的应用程序事件 OrderCreatedEvent：

import org.springframework.context.ApplicationEvent;

public class OrderCreatedEvent extends ApplicationEvent {
    private final Order order;

    public OrderCreatedEvent(Object source, Order order) {
        super(source);
        this.order = order;
    }

    public Order getOrder() {
        return order;
    }
}

接下来，我们创建一个订单服务 OrderService，该服务负责创建订单并发布 OrderCreatedEvent 事件：

import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Service;

@Service
public class OrderService {
    private final ApplicationEventPublisher eventPublisher;

    public OrderService(ApplicationEventPublisher eventPublisher) {
        this.eventPublisher = eventPublisher;
    }

    public void createOrder(Order order) {
        // 创建订单逻辑
        // ...

        // 发布订单创建事件
        eventPublisher.publishEvent(new OrderCreatedEvent(this, order));
    }
}

在上述示例中，OrderService 类通过构造函数注入了 ApplicationEventPublisher，然后在订单创建时使用 publishEvent 方法发布 OrderCreatedEvent 事件。

现在，我们创建两个观察者类，分别用于库存管理和发货处理：

import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;

@Component
public class InventoryManager {
    @EventListener
    public void handleOrderCreatedEvent(OrderCreatedEvent event) {
        // 处理库存管理逻辑
        // ...
    }
}

import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;

@Component
public class ShippingService {
    @EventListener
    public void handleOrderCreatedEvent(OrderCreatedEvent event) {
        // 处理发货处理逻辑
        // ...
    }
}

在上述示例中，InventoryManager 和 ShippingService 类都使用 @EventListener 注解标记了一个方法，该方法监听 OrderCreatedEvent 事件，并在事件发生时执行相应的操作。

现在，当订单服务的 createOrder 方法被调用时，它会发布 OrderCreatedEvent 事件，然后 InventoryManager 和 ShippingService 会收到通知并执行各自的处理逻辑。这样，我们实现了一个松耦合的组件通信机制，不需要硬编码的调用关系。

总之，ApplicationEventPublisher 是Spring框架中实现观察者模式的关键组件之一。它允许我们创建自定义事件并通知已注册的事件监听器，实现了松耦合的组件通信。这种事件驱动的编程模型在Spring应用程序中非常常见，并提供了更好的可维护性和扩展性。
让我们通过一个示例来说明如何在Spring框架中使用观察者模式来实现松耦合的组件通信。

3. 优势与适用场景

观察者模式在软件设计中具有多个优势，并适用于各种情况。在本节中，我们将深入探讨这些优势，并通过示例代码进一步解释。

3.1 解耦和可扩展性

观察者模式通过将主题对象与观察者对象解耦，使得它们可以独立演化，互不影响。这种解耦性使系统更容易维护和扩展。如果你需要添加新的观察者对象或改变现有观察者对象的行为，不需要修改主题对象的代码。

示例代码：

假设我们有一个天气应用程序，其中主题对象是气象站，观察者对象包括显示当前天气的界面和提供天气预报的服务。首先，我们定义主题和观察者的接口：

// 主题接口
public interface Subject {
    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}

// 观察者接口
public interface Observer {
    void update(String weatherData);
}

接下来，实现主题对象和观察者对象：

// 气象站实现主题接口
public class WeatherStation implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private String weatherData;

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

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

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

    // 模拟气象数据更新
    public void setWeatherData(String weatherData) {
        this.weatherData = weatherData;
        notifyObservers();
    }
}

// 显示当前天气的界面实现观察者接口
public class CurrentWeatherDisplay implements Observer {
    @Override
    public void update(String weatherData) {
        System.out.println("当前天气：" + weatherData);
    }
}

// 提供天气预报的服务实现观察者接口
public class WeatherForecastService implements Observer {
    @Override
    public void update(String weatherData) {
        System.out.println("天气预报：" + weatherData);
    }
}

在上述示例中，主题对象是WeatherStation，观察者对象包括CurrentWeatherDisplay和WeatherForecastService。它们之间通过观察者模式实现了解耦和可扩展性。

3.2 高度灵活性

观察者模式使系统更加灵活，因为它允许你在运行时动态添加或删除观察者对象，而不会影响其他部分的代码。这种灵活性使你可以根据需要定制系统的行为。

示例代码：

假设我们的气象应用程序需要支持多种天气数据源，每种数据源对应一个观察者对象。我们可以在运行时根据用户的选择动态添加或删除观察者对象，而不需要修改主题对象的代码。

public class WeatherApp {
    public static void main(String[] args) {
        WeatherStation weatherStation = new WeatherStation();
        CurrentWeatherDisplay currentDisplay = new CurrentWeatherDisplay();
        WeatherForecastService forecastService = new WeatherForecastService();

        // 用户选择使用当前天气显示
        weatherStation.registerObserver(currentDisplay);

        // 模拟气象数据更新
        weatherStation.setWeatherData("晴天");

        // 用户选择同时使用天气预报服务
        weatherStation.registerObserver(forecastService);

        // 模拟气象数据更新
        weatherStation.setWeatherData("多云");

        // 用户取消使用当前天气显示
        weatherStation.removeObserver(currentDisplay);

        // 模拟气象数据更新
        weatherStation.setWeatherData("阵雨");
    }
}

在上述示例中，我们演示了如何在运行时动态添加和删除观察者对象，以满足用户的选择，而不需要修改主题对象的代码。

3.3 可测试性

观察者模式有助于提高代码的可测试性。由于各个观察者对象的行为是相对独立的，你可以轻松地编写针对单个观察者对象的单元测试，以验证其正确性。

示例代码：

假设我们要测试CurrentWeatherDisplay观察者的行为，我们可以创建一个测试类并模拟主题对象的通知：

public class CurrentWeatherDisplayTest {
    @Test
    public void testUpdate() {
        WeatherStation weatherStation = new WeatherStation();
        CurrentWeatherDisplay currentDisplay = new CurrentWeatherDisplay();
        weatherStation.registerObserver(currentDisplay);

        // 模拟气象数据更新
        weatherStation.setWeatherData("晴天");

        // 编写断言来验证观察者的行为
        // ...
    }
}