springboot监听器

最新推荐文章于 2024-03-27 15:49:23 发布

焦虑的二狗

最新推荐文章于 2024-03-27 15:49:23 发布

阅读量4.7k

点赞数 3

分类专栏： SpringBoot 文章标签： java spring boot

本文链接：https://blog.csdn.net/qq_36364521/article/details/120553076

版权

SpringBoot 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

监听器模式介绍

监听器模式

监听器模式的四要素

事件
监听器
广播器
触发机制

手动实现一个监听器（天气预报的模拟）

定义事件

//事件接口
public interface WeatherEvent {

    String getWeather();

}

//下雨事件
public class RainWeatherEvent implements WeatherEvent {
    @Override
    public String getWeather() {
        return "rain";
    }
}

//下雪事件
public class SnowWeatherEvent implements WeatherEvent {
    @Override
    public String getWeather() {
        return "snow";
    }
}

定义监听器

//监听器接口
public interface WeatherListener {

    void doWeatherListener(WeatherEvent event);

}

//下雨监听器
public class RainWeatherListener implements WeatherListener {
    @Override
    public void doWeatherListener(WeatherEvent event) {
        if (event instanceof RainWeatherEvent) {
            System.out.println(this + " --- the weather is " + event.getWeather());
        }
    }
}

//下雪监听器
public class SnowWeatherListener implements WeatherListener {
    @Override
    public void doWeatherListener(WeatherEvent event) {
        if (event instanceof SnowWeatherEvent) {
            System.out.println( this + " --- the weather is " + event.getWeather());
        }
    }
}

定义广播器

//事件广播器接口
public interface EventBroadcast {
   //事件广播
    void broadcast(WeatherEvent event);
    //注册监听器
    void addListener(WeatherListener listener);
    //溢出监听器
    void removeListener(WeatherListener listener);

}

//模板方法 定义抽象的事件广播器
public abstract class AbstractEventBroadcast implements EventBroadcast {
   //注册的所有的时间监听器
    public List<WeatherListener> weatherListenerList;

    @Override
    public void broadcast(WeatherEvent event){
        doStart(event);
        if (null != weatherListenerList && weatherListenerList.size() > 0) {
            weatherListenerList.stream().forEach(listener -> listener.doWeatherListener(event));
        }
        doEnd(event);
    }

    @Override
    public void addListener(WeatherListener listener) {
        if (null == weatherListenerList) {
            weatherListenerList = Lists.newArrayList();
        }
        weatherListenerList.add(listener);
    }

    @Override
    public void removeListener(WeatherListener listener) {
        if (null != weatherListenerList) {
            weatherListenerList.remove(listener);
        }
    }
    //广播前动作
    abstract void doStart(WeatherEvent event);
    //广播后动作
    abstract void doEnd(WeatherEvent event);
}

//实现抽象的广播器模板方法
public class WeatherEventBroadcast extends AbstractEventBroadcast {
    @Override
    void doStart(WeatherEvent event) {
        System.out.println("开始向所有监听器广播天气事件--------------start");
    }

    @Override
    void doEnd(WeatherEvent event) {
        System.out.println("完成向所有监听器广播天气事件--------------end");
    }
}

SpringBoot系统监听器介绍

监听器ApplicationListener的类介绍

/**
  * 由应用程序事件侦听器实现的接口。
  *
  * <p>基于标准的{@code java.util.EventListener}接口
  * 用于观察者设计模式。
  *
  * <p>从 Spring 3.0 开始，一个 {@code ApplicationListener} 可以一般地声明
  * 它感兴趣的事件类型。当用 Spring 注册时
  * {@code ApplicationContext}，事件将被相应地过滤，使用仅为匹配事件对象调用侦听器。
 */
@FunctionalInterface
public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {
		/**
		* 处理应用程序事件。
		* @param event 要响应的事件
		*/ 
      void onApplicationEvent(E event);
}

系统广播器ApplicationEventMulticaster的类介绍

/**
 * 由可以管理多个对象的对象实现的接口
  * {@link ApplicationListener} 对象并向它们发布事件。
  *
  * <p>一个{@link org.springframework.context.ApplicationEventPublisher}，通常是
  * 一个 Spring {@link org.springframework.context.ApplicationContext}，可以使用一个
  * {@code ApplicationEventMulticaster} 作为实际发布事件的委托。
 */
public interface ApplicationEventMulticaster {

/**
* 添加一个监听器来接收所有事件的通知。
* @param listener 要添加的监听器
*/
	void addApplicationListener(ApplicationListener<?> listener);

/**
* 添加一个侦听器 bean 以接收所有事件的通知。
* @param listenerBeanName 要添加的监听器 bean 的名称
*/
	void addApplicationListenerBean(String listenerBeanName);

/**
* 从通知列表中删除一个监听器。
* @param listener 要删除的监听器
*/
	void removeApplicationListener(ApplicationListener<?> listener);

/**
* 从通知列表中删除侦听器 bean。
* @param listenerBeanName 要删除的侦听器 bean 的名称
*/
	void removeApplicationListenerBean(String listenerBeanName);

/**
* 从注册的集合中删除所有匹配的监听器
* {@code ApplicationListener} 实例（包括适配器类
* 如 {@link ApplicationListenerMethodAdapter}，例如 为注释
* {@link EventListener} 方法）。
* <p>注意：这仅适用于实例注册，不适用于侦听器
* 通过 bean 名称注册。
* @param predicate 谓词，用于识别要删除的侦听器实例，
*/
	void removeApplicationListeners(Predicate<ApplicationListener<?>> predicate);

/**
* 从注册的集合中删除所有匹配的侦听器 bean
* 侦听器 bean 名称（指的是 bean 类，它们依次
* 直接实现 {@link ApplicationListener} 接口）。
* <p>注意：这仅适用于 bean 名称注册，不适用于
* 以编程方式注册的 {@code ApplicationListener} 实例。
* @param predicate 谓词，用于识别要删除的侦听器 bean 名称
*/
	void removeApplicationListenerBeans(Predicate<String> predicate);

/**
* 删除所有注册到此多播器的侦听器。
* <p>remove 调用后，多播器将不执行任何操作
* 在事件通知上，直到注册新的侦听器。
*/
	void removeAllListeners();

/**
* 将给定的应用程序事件多播给适当的侦听器。
* <p>考虑使用 {@link #multicastEvent(ApplicationEvent, ResolvableType)}
* 如果可能，因为它为基于泛型的事件提供了更好的支持。
* @param event 要多播的事件
*/
	void multicastEvent(ApplicationEvent event);

/**
* 将给定的应用程序事件多播给适当的侦听器。
* <p>如果{@code eventType}为{@code null}，则构建默认类型
* 基于 {@code event} 实例。
* @param event 要多播的事件
* @param eventType 事件类型（可以是{@code null}）
*/
	void multicastEvent(ApplicationEvent event, @Nullable ResolvableType eventType);

}

系统事件

系统事件类图

EventObject 事件对象
ApplicationEvent 应用事件
SpringApplicationEvent Spring中的系统事件
ApplicationPreparedEvent 该事件表示：应用已经准备好
ApplicationReadyEvent 该事件表示：应用已经就绪
ApplicationStartedEvent 该事件表示：容器已经启动
ApplicationFailedEvent 该事件表示：容器启动失败
ApplicationEnvironmentPreparedEvent 该事件表示：应用上下文环境已经准备完成
ApplicationContextInitializedEvent 该事件表示：应用启动完成

Spring系统事件发送顺序

在这里插入图片描述

starting：环境一启动就发出
environmentPrepared：环境已准备妥当，即已将系统和自定义的的一些属性已加载到容器内
contextInitialized：springboot已经启动，并且准备好了上下文，这个是在加载bean之前发布的
prepared：应用上下文已经创建完毕，但bean还没有完全加载完成
started： springboot已经将bean实例化完成了，但是还没调用CommandLineRunner和ApplicationRunner 这两个接口
ready：CommandLineRunner和ApplicationRunner 调用完毕后发出
failed：启动运行中如果发生错误会发送该事件

系统事件监听器的注册

此处和系统初始化器中的注册的方式完全一致，唯一不同的是：

	@SuppressWarnings({ "unchecked", "rawtypes" })
	public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
		/*......*/
		//此方法调用是 注册系统初始化器
		setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
		//此方法调用是 注册系统监听器
		setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
		/*......*/
	}

监听事件触发机制

SpringApplication.run(MystuflinkApplication.class, args);

	public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
		return run(new Class<?>[] { primarySource }, args);
	}

	public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
		return new SpringApplication(primarySources).run(args);
	}

public ConfigurableApplicationContext run(String... args) {
		StopWatch stopWatch = new StopWatch();
		stopWatch.start();
		DefaultBootstrapContext bootstrapContext = createBootstrapContext();
		ConfigurableApplicationContext context = null;
		configureHeadlessProperty();
		SpringApplicationRunListeners listeners = getRunListeners(args);
		//start事件发布
		listeners.starting(bootstrapContext, this.mainApplicationClass);
		/*......*/
	}

	void starting(ConfigurableBootstrapContext bootstrapContext, Class<?> mainApplicationClass) {
	    //调用 (EventPublishingRunListener)listener.starting 方法
		doWithListeners("spring.boot.application.starting", (listener) -> listener.starting(bootstrapContext),
				(step) -> {
					if (mainApplicationClass != null) {
						step.tag("mainApplicationClass", mainApplicationClass.getName());
					}
				});
	}

	@Override
	public void starting(ConfigurableBootstrapContext bootstrapContext) {
	    //调用SimpleApplicationEventMulticaster的multicastEvent进行广播事件
		this.initialMulticaster
				//new 好一个ApplicationStartingEvent事件对象，调用multicastEvent进行广播
				.multicastEvent(new ApplicationStartingEvent(bootstrapContext, this.application, this.args));
	}

	@Override
	public void multicastEvent(ApplicationEvent event) {
		multicastEvent(event, resolveDefaultEventType(event));
	}

	@Override
	public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
		ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
		Executor executor = getTaskExecutor();
		//getApplicationListeners 方法获取对该event事件感兴趣的监听器，并循环
		for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {
			if (executor != null) {
			    //invokeListener方法进行对循环到的指定的监听器进行广播
				executor.execute(() -> invokeListener(listener, event));
			}
			else {
				invokeListener(listener, event);
			}
		}
	}

   //获得对event事件感兴趣的监听器
	protected Collection<ApplicationListener<?>> getApplicationListeners(
		ApplicationEvent event, ResolvableType eventType) {
		//获得该事件的自定义key
		ListenerCacheKey cacheKey = new ListenerCacheKey(eventType, sourceType);
		//查看是否有缓存
		CachedListenerRetriever existingRetriever = this.retrieverCache.get(cacheKey);
		if (existingRetriever != null) {
			Collection<ApplicationListener<?>> result = existingRetriever.getApplicationListeners();
			if (result != null) {
			    //有的话直接返回
				return result;
			}
		}
		//否则继续寻找
		return retrieveApplicationListeners(eventType, sourceType, newRetriever);
	}

	private Collection<ApplicationListener<?>> retrieveApplicationListeners(
			ResolvableType eventType, @Nullable Class<?> sourceType, @Nullable CachedListenerRetriever retriever) {
		/*......*/
		Set<ApplicationListener<?>> listeners;
		Set<String> listenerBeans;
		synchronized (this.defaultRetriever) {
			listeners = new LinkedHashSet<>(this.defaultRetriever.applicationListeners);
			listenerBeans = new LinkedHashSet<>(this.defaultRetriever.applicationListenerBeans);
		}
		/*......*/
		for (ApplicationListener<?> listener : listeners) {
			//supportsEvent 判断该监听器是否对该事件感兴趣
			if (supportsEvent(listener, eventType, sourceType)) {
				if (retriever != null) {
					filteredListeners.add(listener);
				}
				allListeners.add(listener);
			}
		}
		/*......*/
		//一般listenerBeans为空，此处不再拓展
		if (!listenerBeans.isEmpty()) {
			/*......*/
		}
    }

	protected boolean supportsEvent(
			ApplicationListener<?> listener, ResolvableType eventType, @Nullable Class<?> sourceType) {
		//注：GenericApplicationListenerAdapter 是 GenericApplicationListener的接口实现
		//注：GenericApplicationListener接口继承自SmartApplicationListener接口
		//注：SmartApplicationListener接口继承自 ApplicationListener<ApplicationEvent>, Ordered 两个接口
		GenericApplicationListener smartListener = (listener instanceof GenericApplicationListener ?
				(GenericApplicationListener) listener : new GenericApplicationListenerAdapter(listener));
		return (smartListener.supportsEventType(eventType) && smartListener.supportsSourceType(sourceType));
	}

	@Override
	@SuppressWarnings("unchecked")
	public boolean supportsEventType(ResolvableType eventType) {
		if (this.delegate instanceof GenericApplicationListener) {
			return ((GenericApplicationListener) this.delegate).supportsEventType(eventType);
		}
		else if (this.delegate instanceof SmartApplicationListener) {
			Class<? extends ApplicationEvent> eventClass = (Class<? extends ApplicationEvent>) eventType.resolve();
			return (eventClass != null && ((SmartApplicationListener) this.delegate).supportsEventType(eventClass));
		}
		else {
			return (this.declaredEventType == null || this.declaredEventType.isAssignableFrom(eventType));
		}
	}

    //使用指定的事件触发指定的监听器
	protected void invokeListener(ApplicationListener<?> listener, ApplicationEvent event) {
		ErrorHandler errorHandler = getErrorHandler();
		if (errorHandler != null) {
			try {
			    //触发调用
				doInvokeListener(listener, event);
			}
			catch (Throwable err) {
				errorHandler.handleError(err);
			}
		}
		else {
			doInvokeListener(listener, event);
		}
	}

	private void doInvokeListener(ApplicationListener listener, ApplicationEvent event) {
		try {
		    //监听器onApplicationEvent方法的调用
			listener.onApplicationEvent(event);
		}
		catch (ClassCastException ex) {
			/*......*/
		}
	}

获取监听列表

获取监听器列表

通用触发条条件

自定义监听器实战

第一种：spring.factories中配置

FirstListener类

import org.springframework.boot.context.event.ApplicationStartedEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.core.annotation.Order;

@Order(1)
public class FirstListener implements ApplicationListener<ApplicationStartedEvent> {

    @Override
    public void onApplicationEvent(ApplicationStartedEvent event) {
        System.out.println("FirstListener : hello " + event.getClass());
    }
}

resources目录下新建： META-INF/spring.factories

org.springframework.context.ApplicationListener=com.wwy.myspringboot.customListener.FirstListener

第二种：启动类中配置

SecondListener类

import org.springframework.boot.context.event.ApplicationStartedEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.core.annotation.Order;

@Order(2)
public class SecondListener implements ApplicationListener<ApplicationStartedEvent> {

    @Override
    public void onApplicationEvent(ApplicationStartedEvent event) {
        System.out.println("SecondListener : hello2 " + event.getClass());
    }

}

启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication springApplication = new SpringApplication(Application.class);
        springApplication.addListeners(new SecondListener());
        springApplication.run(args);
    }

}

第三种：application.properties中配置

ThridListener类

import org.springframework.boot.context.event.ApplicationStartedEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.core.annotation.Order;

@Order(3)
public class ThridListener implements ApplicationListener<ApplicationStartedEvent> {

    @Override
    public void onApplicationEvent(ApplicationStartedEvent event) {
        System.out.println("ThridListener : hello " + event.getClass());
    }
}

application.properties

context.listener.classes=com.wwy.myspringboot.customListener.ThridListener

第四种：继承SmartApplicationListener，并application.properties中配置

FourthListener类

import org.springframework.boot.context.event.ApplicationPreparedEvent;
import org.springframework.boot.context.event.ApplicationStartedEvent;
import org.springframework.context.ApplicationEvent;
import org.springframework.context.event.SmartApplicationListener;
import org.springframework.core.annotation.Order;

@Order(4)
public class FourthListener implements SmartApplicationListener {
	//注册感兴趣的事件
    @Override
    public boolean supportsEventType(Class<? extends ApplicationEvent> eventType) {
        return ApplicationStartedEvent.class.isAssignableFrom(eventType) ||
                ApplicationPreparedEvent.class.isAssignableFrom(eventType);
    }
	//接收到事件后的动作
    @Override
    public void onApplicationEvent(ApplicationEvent event) {
        System.out.println("FourthListener : hello " + event.getClass());
    }
}

application.properties

context.listener.classes=com.wwy.myspringboot.customListener.ThridListener,com.wwy.myspringboot.customListener.FourthListener

Console

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::                (v2.5.5)

run FirstInitializer
2021-09-30 23:42:32.480  WARN 3713 --- [           main] o.s.boot.StartupInfoLogger               : InetAddress.getLocalHost().getHostName() took 5006 milliseconds to respond. Please verify your network configuration (macOS machines may need to add entries to /etc/hosts).
2021-09-30 23:42:37.491  INFO 3713 --- [           main] c.w.m.customListener.Application         : Starting Application using Java 1.8.0_231 on wangwenyong with PID 3713 (/Users/wangwenyong/ideaProject/mystuflink/target/classes started by wangwenyong in /Users/wangwenyong/ideaProject/mystuflink)
2021-09-30 23:42:37.492  INFO 3713 --- [           main] c.w.m.customListener.Application         : No active profile set, falling back to default profiles: default
FourthListener : hello class org.springframework.boot.context.event.ApplicationPreparedEvent
2021-09-30 23:42:38.028  INFO 3713 --- [           main] .s.d.r.c.RepositoryConfigurationDelegate : Multiple Spring Data modules found, entering strict repository configuration mode!
2021-09-30 23:42:38.030  INFO 3713 --- [           main] .s.d.r.c.RepositoryConfigurationDelegate : Bootstrapping Spring Data Redis repositories in DEFAULT mode.
2021-09-30 23:42:38.048  INFO 3713 --- [           main] .s.d.r.c.RepositoryConfigurationDelegate : Finished Spring Data repository scanning in 7 ms. Found 0 Redis repository interfaces.
2021-09-30 23:42:38.394  INFO 3713 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port(s): 8080 (http)
2021-09-30 23:42:38.402  INFO 3713 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
2021-09-30 23:42:38.402  INFO 3713 --- [           main] org.apache.catalina.core.StandardEngine  : Starting Servlet engine: [Apache Tomcat/9.0.53]
2021-09-30 23:42:38.470  INFO 3713 --- [           main] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
2021-09-30 23:42:38.470  INFO 3713 --- [           main] w.s.c.ServletWebServerApplicationContext : Root WebApplicationContext: initialization completed in 927 ms
2021-09-30 23:42:39.129  INFO 3713 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
2021-09-30 23:42:39.138  INFO 3713 --- [           main] c.w.m.customListener.Application         : Started Application in 22.035 seconds (JVM running for 27.73)
ThridListener : hello class org.springframework.boot.context.event.ApplicationStartedEvent
FourthListener : hello class org.springframework.boot.context.event.ApplicationStartedEvent
FirstListener : hello class org.springframework.boot.context.event.ApplicationStartedEvent
SecondListener : hello2 class org.springframework.boot.context.event.ApplicationStartedEvent

TIPS

实现ApplicationListener接口针对单一事件监听
实现SmartApplicationListener接口针对多事件监听
Order值越小越先执行
application.properties中定义的优于其他方式

面试问题

介绍下监听器模式
SpringBoot关于监听器相关的实现类有哪些
SpringBoot框架有哪些框架事件以及他们的顺序
介绍下监听事件触发机制
如何自定义实现系统监听器及注意事项
实现ApplicationListener接口与SmartApplicationListener接口区别

焦虑的二狗

关注

3
点赞
踩
18

收藏

觉得还不错? 一键收藏
0
评论
springboot监听器

监听器模式介绍监听器模式的四要素事件监听器广播器触发机制手动实现一个监听器（天气预报的模拟）定义事件//事件接口public interface WeatherEvent { String getWeather();}//下雨事件public class RainWeatherEvent implements WeatherEvent { @Override public String getWeather() { return "
复制链接

扫一扫