Spring 观察者模式详解以及自定义监听器扩展实现

在这里插入图片描述

嗨,您好 我是 vnjohn,在互联网企业担任 Java 开发,CSDN 优质创作者
推荐专栏:Spring、MySQL、Nacos、Java,后续其他专栏会持续优化更新迭代
文章所在专栏:Spring
我当前正在学习微服务领域、云原生领域、消息中间件等架构、原理知识
向我询问任何您想要的东西,ID:vnjohn
觉得博主文章写的还 OK,能够帮助到您的,感谢三连支持博客
代词: vnjohn
⚡ 有趣的事实:音乐、跑步、电影、游戏

目录

    • 前言
    • 观察者模式/监听机制
      • 观察者模式(传统)
      • 观察者模式(Spring)
        • 基本概念
        • 事件驱动准备工作及执行过程
    • SpringBoot 监听器加载过程
    • 自定义监听器扩展实现
      • 监听所有事件
      • 监听特定事件
      • 自定义事件
    • 总结

前言

在 Spring 运用中,观察者模式运用的场景很多,只不过在 Spring 内部为观察者模式定义为了抽象,使用多路广播器方式将观察者、被观察者、行为抽象了事件、监听器、事件源等名,下面对该内容进行详细分析

观察者模式/监听机制

监听器:模式中的观察者角色
多路广播器:被观察者触发事件调用,多个观察者监听到事件处理对应方法的逻辑
在 Spring 里面其实就是运用观察者模式进行设计的,它对比传统的观察者模式基础上进行了加工,概念上已经改为了基于事件驱动触发行为动作,下面对传统观察者模式、Spring 加工后的观察者模式进行介绍

观察者模式(传统)

Spring 观察者模式详解以及自定义监听器扩展实现_第1张图片

观察者模式又称为发布/订阅(Publish/Subscribe)模式,在对象之间定义了一对多的依赖,这样一来,当一个对象改变状态,依赖它的对象会收到通知并自动更新触发行为

观察者、被观察者共有行为

/**
 * 被观察者
 */
public interface Observable {
     public void addObserver(Observer observer);
     public void deleteObserver(Observer observer);
     public void notifyObserver(String str);
}

/**
 * 观察者
 */
public interface Observer {
    public void make(String str);
}

被观察者实现类

public class BadMan implements Observable {

    private ArrayList<Observer> observers = new ArrayList<Observer>();

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

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

    @Override
    public void notifyObserver(String str) {
        for (Observer observer1 : observers) {
            observer1.make(str);
        }
    }

    public void run(){
        System.out.println("罪犯要逃跑了");
        this.notifyObserver("追击罪犯");
    }

    public void play(){
        System.out.println("罪犯在玩");
        this.notifyObserver("不动做任何事情,静观其变");
    }
}

观察者

public class Police implements Observer {
    @Override
    public void make(String str) {
        System.out.println("police(警察)开始行动");
        System.out.println("--------"+str);
    }
}

public class Soldier implements Observer {
    @Override
    public void make(String str) {
        System.out.println("军官(soldier)开始行动");
        System.out.println("====="+str);
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        // 创建被观察者
        BadMan bm = new BadMan();
        // 创建观察者
        Police gm = new Police();
        Soldier gm2 = new Soldier();
        // 向被观察者中添加观察者
        bm.addObserver(gm);
        bm.addObserver(gm2);
        // 等待罪犯触发某些行为
        bm.run();
    }
}

java.util 包下有提供 Observer 接口、Observable

  • 被观察者:存储一个观察者的集合,执行不同动作时,要调用观察者的方法进行处理
  • 观察者:看到被观察者不同行为的时候触发的反应

观察者模式(Spring)

在 Spring 中,观察者模式被理解为 “事件驱动”,通过对传统模式的理解进行细化拆分

基本概念
  • 事件:被观察者具体要执行的动作「代码中的 run、play 方法」被拆分成事件,所有事件都实现于 ApplicationEvent 接口,交给子类在不同的事件情况时去执行自己内部的逻辑
  • 监听器:作为观察者,可能存在多个,接受不同的事件去做不同的处理工作,所有监听器都实现于 ApplicationListener 接口,重写 onApplicationEvent 方法,方法内部通过不同的事件【ApplicationEvent】类型进行调用
  • 多播器:把被观察者遍历观察者列表通知的消息操作拿出来,委托给一个多播器来进行消息通知,或者说通过观察者进行不同的操作,一般是 ApplicationEventMulticaster 子类 SimpleApplicationEventMulticaster 进行事件广播操作
  • 事件源:谁来调用或者执行发布具体的事件,如在 AbstractApplicationContext 中调用 publishEvent(new ContextRefreshedEvent(this))发布事件,比如 AbstractApplicationContext 就是指的事件源,它实现了 ApplicationEventPublisher 接口,可以调用 publishEvent 方法,类图如下

Spring 观察者模式详解以及自定义监听器扩展实现_第2张图片

事件驱动准备工作及执行过程

事件驱动的准备工作如下:

  • 提前准备好 N 多个事件
  • 初始化多播器(创建多播器对象,此多播器对象中应该包含一个监听器的集合)
  • 准备好一系列的监听器,向多播器中注册进去需要执行的监听器
  • 准备事件发布,通知多播器循环调用监听器 onApplicationEvent 方法进行相关的逻辑处理工作

Spring 相关的源码

初始化事件监听多路广播器

protected void initApplicationEventMulticaster() {
    // 获取当前bean工厂,一般是DefaultListableBeanFactory
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    // 判断容器中是否存在bdName为applicationEventMulticaster的bd,也就是说自定义的事件监听多路广播器,必须实现ApplicationEventMulticaster接口
    if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
        // 如果有,则从bean工厂得到这个bean对象
        this.applicationEventMulticaster =
            beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
        if (logger.isTraceEnabled()) {
            logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
        }
    }
    else {
        // 如果没有,则默认采用 SimpleApplicationEventMulticaster
        this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
        beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
        if (logger.isTraceEnabled()) {
            logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +
                         "[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
        }
    }
}

默认采用的是 SimpleApplicationEventMulticaster 多路广播器,它的父类 AbstractApplicationEventMulticaster 内部类专门使用了一个集合来存储所有加载的监听器

// 创建监听器助手类,用于存放应用程序的监听器集合,参数是否是预过滤监听器为false
private final ListenerRetriever defaultRetriever = new ListenerRetriever(false);
private class ListenerRetriever {
    // ApplicationListener 对象集合
    public final Set<ApplicationListener<?>> applicationListeners = new LinkedHashSet<>();
    // BeanFactory 中的 applicationListener 类型 Bean 名集合
    // 在设置监听器时会通过 beanName 去获取监听器,再放入 applicationListeners 集合中
    public final Set<String> applicationListenerBeans = new LinkedHashSet<>();
.......
}

注册监听器的源码:在所有注册的 bean 中查找监听器,将监听器注册到消息广播器中

protected void registerListeners() {
    // 遍历应用程序中存在的监听器集合,并将对应的监听器添加到监听器的多路广播器中
    for (ApplicationListener<?> listener : getApplicationListeners()) {
        getApplicationEventMulticaster().addApplicationListener(listener);
    }

    // 从容器中获取所有实现了ApplicationListener接口的bd的bdName
    // 放入 ApplicationListenerBeans 集合中
    String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
    for (String listenerBeanName : listenerBeanNames) {
        getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
        // 可以直接获取监听器实例进去,无须在取用的时候再次 getBean	getApplicationEventMulticaster().addApplicationListener(this.getBean(listenerBeanName,ApplicationListener.class));
    }

    // 此处先发布早期的监听器集合
    Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
    this.earlyApplicationEvents = null;
    if (!CollectionUtils.isEmpty(earlyEventsToProcess)) {
        for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
            getApplicationEventMulticaster().multicastEvent(earlyEvent);
        }
    }
}

事件驱动的逻辑执行过程如下:

  • 事件源来发布不同的事件
  • 当发布事件之后会调用多播器的方法来进行事件广播操作,由多播器去触发具体的监听器去执行操作
  • 监听器接收到具体的事件之后,可以验证是否能处理当前事件的类型,如果可以,进行处理;如果不行,不做任何操作

SpringBoot 监听器加载过程

Spring 观察者模式详解以及自定义监听器扩展实现_第3张图片
首先加载 META-INF/spring.factories 文件中的 key:ApplicationListener,value:全限定类名,然后获取到所有的实例存入 ApplicationContext 中,方便后续创建多播器对象时可以获取到这些监听器实例,注入:ApplicationContext 实例以后,就可以调用它来进行事件发布动作
Spring 观察者模式详解以及自定义监听器扩展实现_第4张图片
通过观察以上内置监听器的源码,可以发现在这些监听器里都实现了 ApplicationListener 同时会使用到抽象类 ApplicationEvent,但这些内置监听器中的事件都是基于它抽象的实现,定义自己的事件类

事件驱动机制是基于观察者设计模式的实现,通过 ApplicationEvent 类、ApplicationListener 接口,可以通过 ApplicationContext 实现事件的发布

如下图整理了 SpringBoot 内置的监听器和事件:

Spring 观察者模式详解以及自定义监听器扩展实现_第5张图片

# Run Listeners
org.springframework.boot.SpringApplicationRunListener=\
org.springframework.boot.context.event.EventPublishingRunListener

前戏: 在事件准备发布时,首先会通过 getRunListeners 方法来获取我们在 META-INF/spring.factories 文件中的定义 SpringApplicationRunListener 接口实现类 EventPublishingRunListener,同时会完成该类的实例化操作,调用构造方法时,会初始化多路广播器对象:SimpleApplicationEventMulticaster,同时从上下文获取到前面加载好的 11 个监听器,进行绑定操作.

前戏工作做完以后,就到了发布事件的时候了
SimpleApplicationEventMulticaster#multicastEvent:在容器启动时会调用 listener#starting 方法(事件名:ApplicationStartingEvent)、环境对象准备前会调用 listener#environmentPrepared(事件名:ApplicationEnvironmentPreparedEvent)

以 ConfigFileApplicationListener 为例,会在其内部处理配置文件的解析工作,接受 ApplicationEnvironmentPreparedEvent 事件的处理,源码如下:

public void onApplicationEvent(ApplicationEvent event) {
      if (event instanceof ApplicationEnvironmentPreparedEvent) {
          this.onApplicationEnvironmentPreparedEvent((ApplicationEnvironmentPreparedEvent)event);
      }
      if (event instanceof ApplicationPreparedEvent) {
          this.onApplicationPreparedEvent(event);
      }
  }

自定义监听器扩展实现

通过几个不同类型自定义事件案例来加深对事件驱动机制的理解

监听所有事件

先创建一个自定义监听器,来监听所有的事件;创建一个 Java 类,实现 ApplicationListener 接口在泛型中指定要监听的事件类型即可,如果要监听所有的事件,那么泛型就写 ApplicationEvent

public class MySpringApplicationListener implements ApplicationListener<ApplicationEvent> {
	@Override
	public void onApplicationEvent(ApplicationEvent event) {
		System.out.println("自定义监听器--->" + event);
	}
}

之后为了在容器启动中能够发现我们的监听器并且添加到 SimpleApplicationEventMulticaster 中,我们需要在 spring.factories/META-INF 中注册自定义的监听器

org.springframework.context.ApplicationListener=\
com.vnjohn.demo.listener.MySpringApplicationListener

这样当我们启动服务的时候就可以看到相关事件发布,我们的监听器被触发了,会打印对应的信息

监听特定事件

如果是监听特定的事件,我们只需要在泛型出指定类型即可

public class MySpringApplicationStartingListener implements ApplicationListener<ApplicationStartingEvent> {
	@Override
	public void onApplicationEvent(ApplicationStartingEvent event) {
		// 该事件是启动启动时就会进行发布的,查询容器启动日志信息即可 
		System.out.println("MySpringApplicationStartingListener--------->" + event);
	}
}
org.springframework.context.ApplicationListener=\
com.vnjohn.demo.listener.MySpringApplicationListener,\
com.vnjohn.demo.listener.MySpringApplicationStartingListener

启动服务时可以看到相关的事件发布

自定义事件

若我们想要通过自定义的监听器来监听自定义的事件呢?首先创建自定义的事件类,非常简单,只需要继承 ApplicationEvent 即可

public class MyEvent extends ApplicationEvent {
	public MyEvent(Object source) {
		super(source);
	}
}

然后在自定义的监听器中监听自定义的事件

public class MyCustomerEventListener implements ApplicationListener<MyEvent> {
	@Override
	public void onApplicationEvent(MyEvent event) {
		System.out.println("MyCustomerEventListener ---》自定义事件触发" + event);
		// 触发对应的事件后 业务处理
		new Thread(()->{
			// 业务....
		}).start();
	}
}

事件的监听和发布是同步执行的,如果想让其异步的进行,可以抛给一个线程进行处理

org.springframework.context.ApplicationListener=\
com.vnjohn.demo.listener.MySpringApplicationListener,\
com.vnjohn.demo.listener.MySpringApplicationStartingListener,\
com.vnjohn.demo.listener.MyCustomerEventListener

之后我们就可以在我们特定的业务场景中类发布对应的事件了

@Component
public class MyApplicationContextAware implements ApplicationContextAware {
	private static ApplicationContext applicationContext;

	@Override
	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
		MyApplicationContextAware.applicationContext = applicationContext;
	}

	public static void publishEvent(ApplicationEvent applicationEvent) {
		applicationContext.publishEvent(applicationEvent);
	}
}
@RestController
public class HelloController {
	
	@GetMapping("/hello")
	public String hello(){
		MyApplicationContextAware.publishEvent(new MyEvent(new Object()));
		return "hello---";
	}
}

当提交请求后,对应的监听器就触发了,这样一来不光搞清楚了 SpringBoot 中的监听机制,而且也可以扩展使用到我们业务开发中了

总结

希望对你有所帮助,您的支持是对我最大的鼓励,关注+赞+收藏三连,感谢!

如果觉得博文不错,关注我 vnjohn,后续会有更多实战、源码、架构干货分享!
大家的「关注❤️ + 点赞 + 收藏⭐」就是我创作的最大动力!谢谢大家的支持,我们下文见!

你可能感兴趣的:(Spring,spring,java)