观察者设计模式(Observer Design Pattern)[论点:概念、组成角色、相关图示、示例代码、框架中的运用、适用场景]

概念

        观察者设计模式(Observer Design Pattern)是一种行为型设计模式,它定义了一种对象间的一对多的依赖关系,让多个观察者对象同时监听某一个主题对象,当主题对象状态发生改变时,通知所有观察者对象,使它们能够自动更新。

组成角色

  1. 主题(Subject):主题是一个抽象类或接口,它定义了添加、删除和通知观察者的方法。
  2. 具体主题(ConcreteSubject):具体主题是主题接口的实现,它包含观察者列表和业务逻辑。当状态发生改变时,具体主题负责通知所有观察者。
  3. 观察者(Observer):观察者是一个抽象类或接口,它定义了一个更新方法,用于接收主题的通知。
  4. 具体观察者(ConcreteObserver):具体观察者是观察者接口的实现,它根据主题的通知来更新自己的状态。

相关图示

在这里插入图片描述

示例代码

        这个代码示例展示了观察者设计模式的基本实现。具体主题ConcreteSubject存储了观察者列表和当前状态,当状态发生改变时,它会通知所有注册的观察者。观察者ConcreteObserverAConcreteObserverB实现了观察者接口Observer,并在更新状态时输出相应的消息。在main方法中,我们创建了一个具体主题和两个具体观察者,将观察者添加到主题中,然后改变主题的状态并观察输出结果。当从主题中移除一个观察者后,再次改变主题状态,可以看到只有剩下的观察者接收到了通知。

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

// 主题接口
interface Subject {
    // 添加观察者
    void addObserver(Observer observer);
    // 移除观察者
    void removeObserver(Observer observer);
    // 通知所有观察者
    void notifyObservers();
}

// 具体主题
class ConcreteSubject implements Subject {
    // 存储观察者的列表
    private List<Observer> observers = new ArrayList<>();
    // 主题的状态
    private String state;

    // 设置状态并通知所有观察者
    public void setState(String state) {
        this.state = state;
        notifyObservers();
    }

    // 添加观察者到列表
    @Override
    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    // 从列表中移除观察者
    @Override
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    // 通知所有观察者状态已改变
    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(state);
        }
    }
}

// 观察者接口
interface Observer {
    // 更新观察者状态
    void update(String state);
}

// 具体观察者A
class ConcreteObserverA implements Observer {
    // 当收到主题通知时,更新状态
    @Override
    public void update(String state) {
        System.out.println("ConcreteObserverA received new state: " + state);
    }
}

// 具体观察者B
class ConcreteObserverB implements Observer {
    // 当收到主题通知时,更新状态
    @Override
    public void update(String state) {
        System.out.println("ConcreteObserverB received new state: " + state);
    }
}

public class ObserverDemo {
    public static void main(String[] args) {
        // 创建具体主题
        ConcreteSubject subject = new ConcreteSubject();
        // 创建具体观察者A和B
        ConcreteObserverA observerA = new ConcreteObserverA();
        ConcreteObserverB observerB = new ConcreteObserverB();

        // 向主题添加观察者A和B
        subject.addObserver(observerA);
        subject.addObserver(observerB);

        // 改变主题状态并通知观察者
        subject.setState("New state 1");
        subject.setState("New state 2");

        // 从主题中移除观察者A
        subject.removeObserver(observerA);

        // 再次改变主题状态并通知观察者
        subject.setState("New state 3");
    }
}

运行结果
在这里插入图片描述

框架中的运用

在Spring框架中,观察者模式主要应用在事件处理机制中。Spring监听器主要涉及到以下几个构成部分:

  1. ApplicationEvent(事件):
    ApplicationEvent是Spring中所有事件的基类,它继承自java.util.EventObject。自定义事件需要继承ApplicationEvent。当某个特定操作发生时,可以创建一个自定义的ApplicationEvent实例,并将其发布到整个应用程序。
  2. ApplicationListener(监听器):
    ApplicationListener是一个泛型接口,泛型参数为继承自ApplicationEvent的类。监听器负责监听特定类型的事件。实现ApplicationListener接口的类需要实现onApplicationEvent()方法以处理对应的事件。当一个事件被发布时,关注该事件的监听器会收到通知,并执行onApplicationEvent()方法来处理事件。
  3. ApplicationEventPublisher(事件发布器):
    ApplicationEventPublisher是一个接口,负责发布事件。它提供了publishEvent()方法,用于发布事件到整个应用程序。在Spring中,ApplicationContext实现了ApplicationEventPublisher接口,因此事件发布主要由ApplicationContext管理。
  4. ApplicationEventMulticaster(事件多播器):
    ApplicationEventMulticaster是一个接口,负责将事件分发给关联的监听器。SimpleApplicationEventMulticasterApplicationEventMulticaster的一个默认实现。在Spring中,ApplicationEventMulticaster负责管理所有注册的ApplicationListener。当ApplicationEventPublisher发布事件时,ApplicationEventMulticaster会将事件分发给所有关注该事件的监听器。
  • org.springframework.context.ApplicationEvent:

ApplicationEvent是Spring事件模型的基类,它继承了java.util.EventObject。所有自定义事件需要继承ApplicationEvent类。

package org.springframework.context;

import java.util.EventObject;

public abstract class ApplicationEvent extends EventObject {
    private static final long serialVersionUID = 7099057708183571937L;
    private final long timestamp;

    public ApplicationEvent(Object source) {
        super(source);
        this.timestamp = System.currentTimeMillis();
    }

    public final long getTimestamp() {
        return this.timestamp;
    }
}

  • org.springframework.context.ApplicationListener:

ApplicationListener是一个泛型接口,它的泛型参数是一个继承自ApplicationEvent的类。它类似于观察者模式中的观察者。实现ApplicationListener接口的类需要实现onApplicationEvent()方法以处理事件。

package org.springframework.context;

import java.util.EventListener;

public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {
    void onApplicationEvent(E event);
}

  • org.springframework.context.ApplicationEventPublisher:

ApplicationEventPublisher接口负责发布事件。它类似于观察者模式中的主题。实现该接口的类需要实现publishEvent()方法来发布事件。

package org.springframework.context;

public interface ApplicationEventPublisher {
    void publishEvent(ApplicationEvent event);
    void publishEvent(Object event);
}

  • org.springframework.context.event.SimpleApplicationEventMulticaster

SimpleApplicationEventMulticasterApplicationEventMulticaster接口的一个实现。它负责将事件分发给关联的监听器。其主要方法是multicastEvent(ApplicationEvent),该方法会遍历注册的监听器,并将事件分发给匹配的监听器。

package org.springframework.context.event;

public class SimpleApplicationEventMulticaster extends AbstractApplicationEventMulticaster {
    // ...

    @Override
    public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
        ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
        for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {
            Executor executor = getTaskExecutor();
            if (executor != null) {
                executor.execute(() -> invokeListener(listener, event));
            } else {
                invokeListener(listener, event);
            }
        }
    }

    // ...
}
  • org.springframework.context.support.AbstractApplicationContext

AbstractApplicationContext实现了ApplicationEventPublisher接口,因此在Spring中,事件发布主要由ApplicationContext管理。AbstractApplicationContext中的publishEvent(ApplicationEvent)方法会委托给ApplicationEventMulticaster进行事件的发布。

public abstract class AbstractApplicationContext extends DefaultResourceLoader
        implements ConfigurableApplicationContext {

    // ...

    @Override
    public void publishEvent(ApplicationEvent event) {
        publishEvent(event, null);
    }

    @Override
    public void publishEvent(Object event) {
        publishEvent(event, null);
    }

    protected void publishEvent(Object event, @Nullable ResolvableType eventType) {
        Assert.notNull(event, "Event must not be null");
        if (logger.isTraceEnabled()) {
            logger.trace("Publishing event in " + getDisplayName() + ": " + event);
        }

        // Decorate event as an ApplicationEvent if necessary
        ApplicationEvent applicationEvent;
        if (event instanceof ApplicationEvent) {
            applicationEvent = (ApplicationEvent) event;
        } else {
            applicationEvent = new PayloadApplicationEvent<>(this, event);
            if (eventType == null) {
                eventType = ((PayloadApplicationEvent) applicationEvent).getResolvableType();
            }
        }

        // Multicast right now if possible - or lazily once the multicaster is initialized
        if (this.earlyApplicationEvents != null) {
            this.earlyApplicationEvents.add(applicationEvent);
        } else {
            getApplicationEventMulticaster().multicastEvent(applicationEvent,
        eventType);
        }
          // 发布事件给父级 ApplicationContext
      	if (this.parent != null) {
            if (this.parent instanceof AbstractApplicationContext) {
                ((AbstractApplicationContext) this.parent).publishEvent(event, eventType);
            } else {
                this.parent.publishEvent(event);
            }
        }
		}
}
// ...

总之大概的逻辑是这样

  1. 创建自定义事件CustomEvent,该事件需要继承ApplicationEvent

  2. 创建自定义事件监听器CustomEventListener,该监听器需要实现ApplicationListener<CustomEvent>接口。

  3. 在需要的地方使用ApplicationEventPublisher(通常是ApplicationContext)发布事件。在AbstractApplicationContext中,publishEvent方法会将事件委托给ApplicationEventMulticaster进行发布。

  4. SimpleApplicationEventMulticaster(默认的ApplicationEventMulticaster实现)会将事件分发给关联的监听器。在multicastEvent方法中,它会遍历所有注册的监听器,并将事件分发给匹配的监听器。

  5. 监听器收到事件后,将执行onApplicationEvent()方法处理事件。

        通过上述流程,我们可以看到Spring监听器执行原理是基于观察者设计模式的。当事件发布后,所有关注该事件的监听器都会收到通知并执行相应的操作。这种机制实现了松耦合的事件处理,可以在不同组件之间实现动态交互。

适用场景

  1. 事件处理系统:观察者模式可以用于实现事件驱动的架构,当一个事件发生时,所有关心这个事件的观察者都会收到通知。这在GUI开发、游戏开发等场景中非常常见。
  2. 数据绑定和同步:当多个组件需要共享或同步相同的数据时,可以使用观察者模式。当数据发生变化时,所有依赖于该数据的观察者都会收到通知并自动更新。这在前端开发、实时协同编辑等场景中非常有用。
  3. 消息发布和订阅:观察者模式可以用于实现发布/订阅系统。在这种系统中,发布者负责发布消息,订阅者负责订阅消息。当发布者发布新消息时,所有订阅了该消息的订阅者都会收到通知。这在分布式系统、消息队列、事件总线等场景中非常常见。
  4. 状态监控和报警:在系统监控和报警场景中,观察者模式可以用于实时监控被观察对象的状态。当被观察对象的状态发生异常时,观察者可以根据预定义的规则执行相应的操作,如发送报警邮件、记录日志等。
本图文内容来源于网友网络收集整理提供,作为学习参考使用,版权属于原作者。
THE END
分享
二维码

)">
< <上一篇
下一篇>>