Spring事件发布原理

已于 2024-01-25 00:26:23 修改
阅读量543 收藏 9
点赞数 8
文章标签： spring java 后端
于 2024-01-22 23:39:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43185254/article/details/135760449
版权

借鉴：https://blog.csdn.net/zxfhahaha/article/details/112558429
https://blog.csdn.net/qq_46940224/article/details/131043987
https://blog.csdn.net/weixin_37672801/article/details/128803430
https://www.cnblogs.com/shamo89/p/15715091.html
https://blog.csdn.net/laohuangaa/article/details/119772453

Spring事件发布原理(ApplicationEventPublisher接口)

1.事件发布的使用：

事件驱动机制其实是观察者模式（又称发布订阅）具体实现，事件对象（HtwBikeRoadSignEvent）相当于被观察对象, 事件监听器(EventListener) 相当于观察者。@EventListener（）括号里面是哪个对象就是监听哪个对象。

HtwBikeRoadSignAction.java: 自己定义的类，在方法中发布事件

@Service
public class HtwBikeRoadSignAction implements AssetInBoundAction {
    @Autowired
    private HtwBikeRepository htwBikeRepository;
    @Resource
    private ApplicationContext applicationContext;
    @Resource
    private CityExtInfoIntegrationService cityExtInfoIntegrationService;
    @Autowired
    private AssetAddressAndStatusConvertManager convertManager;

    @Override
    public AssetsInBoundResult apply(AssetContext context, AssetsInBoundParam param) {
        AssetsInBoundResult assetsResult = new AssetsInBoundResult();
        List<Long> bikeIds = Collections.emptyList();
        bikeIds.add(12245L);
        List<HtwBikeEntity> htwBikeEntityList = htwBikeRepository.getByIds(bikeIds);
        HtwBikeRoadSignEvent htwBikeRoadSignEvent = HtwBikeRoadSignEvent.builder()
                .context(context)
                .htwBikeEntities(htwBikeEntityList)
                .build();
        //更新车辆信息
        modifyHtwBikeInfo(context, htwBikeEntityList);
         */
        // 5.发送车辆绑定事件
        applicationContext.publishEvent(htwBikeRoadSignEvent);

        assetsResult.setInBoundResult(true);
        return assetsResult;
    }
}

HtwBikeRoadSignEvent.java:

/**
 * 路面签收事件
 */
@Data
@Builder
public class HtwBikeRoadSignEvent extends AssetSopEvent {
    /**
     * 操作上下文
     */
    private AssetContext context;
    /**
     * 车辆信息
     */
    private List<HtwBikeEntity> htwBikeEntities;
    /**
     * 车辆更新字段
     */
    private Map<String,Object> bikeUpdateMap;
    /**
     * 锁更新字段
     */
    private Map<String,Object> lockUpdateMap;
}

HtwBikeRoadSignSrmHandler.java:

/**
 * 车辆路面签收通知
 */
@Component
public class HtwBikeRoadSignSrmHandler {

    @Value("${srm.producer.topic}")
    private String                  srmGatewayTopic;

    /*@Resource(name = "exporterBlocMessageProducer")
    private BlocMessageProducerImpl producer;*/
    @Async
    @EventListener(HtwBikeRoadSignEvent.class)
    public void onRoadSign(HtwBikeRoadSignEvent event) {

        AssetContext context = event.getContext();
        List<HtwBikeEntity> htwBikeEntities = event.getHtwBikeEntities();

        AssetChangeOrderMessageDTO assetChangeOrderMessageDTO = new AssetChangeOrderMessageDTO();
        assetChangeOrderMessageDTO.setChangeType(1);
        //producer.sendMessage(srmGatewayTopic, assetChangeOrderMessageDTO);
    }



}

@Async 添加注解表示这个方法要异步执行

2.Spring的两种监听器的实现有两种方式：

实现ApplicationListener接口 ：方法是onApplicationEvent(E event);
注解@EventListener

3.原理： 也可以看这个里面的有源码贴图： https://www.cnblogs.com/shamo89/p/15715091.html 或者 https://blog.csdn.net/laohuangaa/article/details/119772453

第一部分原理：发布事件 applicationContext.publishEvent(htwBikeRoadSignEvent)方法：

ApplicationContext接口： 继承了ApplicationEventPublisher接口。ApplicationContext接口的对象在SpringBoot启动的时候自动装配有初始化。

public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory,
		MessageSource, ApplicationEventPublisher, ResourcePatternResolver {

	@Nullable
	String getId();

	String getApplicationName();

	String getDisplayName();

	long getStartupDate();

	@Nullable
	ApplicationContext getParent();
	
	AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException;

}

ApplicationEventPublisher接口：

public interface ApplicationEventPublisher {

	default void publishEvent(ApplicationEvent event) {
		publishEvent((Object) event);
	}

	void publishEvent(Object event);  //本文以看这个方法源码分析

}

AbstractApplicationContext.java:

public abstract class AbstractApplicationContext extends DefaultResourceLoader
		implements ConfigurableApplicationContext {
		
	@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");

		ApplicationEvent applicationEvent;
		if (event instanceof ApplicationEvent) {
			applicationEvent = (ApplicationEvent) event;
		}
		else {
			applicationEvent = new PayloadApplicationEvent<>(this, event);
			if (eventType == null) {
				eventType = ((PayloadApplicationEvent<?>) applicationEvent).getResolvableType();
			}
		}

		if (this.earlyApplicationEvents != null) {
			this.earlyApplicationEvents.add(applicationEvent);
		}
		else {
		//重点看这个：调用了SimpleApplicationEventMulticaster类的multicastEvent()
			getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
		}

		if (this.parent != null) {
			if (this.parent instanceof AbstractApplicationContext) {
				((AbstractApplicationContext) this.parent).publishEvent(event, eventType);
			}
			else {
				this.parent.publishEvent(event);
			}
		}
	}
}

SimpleApplicationEventMulticaster.java: 事件广播器

public class SimpleApplicationEventMulticaster extends AbstractApplicationEventMulticaster {

	@Nullable
	private Executor taskExecutor;

	@Nullable
	private ErrorHandler errorHandler;
	
	public SimpleApplicationEventMulticaster() {
	}

	@Override
	public void multicastEvent(ApplicationEvent event) {
	//调了下一个multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) 方法
		multicastEvent(event, resolveDefaultEventType(event));
	}

	@Override
	public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
		ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
		Executor executor = getTaskExecutor();
		for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {//感兴趣可以继续看getApplicationListeners方法获取所有的监听器
		//根据监听对象类型返回所有的监听器，循环调用
			if (executor != null) {
			//线程池异步调用invokeListener（）
				executor.execute(() -> invokeListener(listener, event));
			}
			else {
				invokeListener(listener, event);
			}
		}
	}
	
	//执行invokeListener（）
	protected void invokeListener(ApplicationListener<?> listener, ApplicationEvent event) {
		ErrorHandler errorHandler = getErrorHandler();
		if (errorHandler != null) {
			try {
			//调用doInvokeListener（）
				doInvokeListener(listener, event);
			}
			catch (Throwable err) {
				errorHandler.handleError(err);
			}
		}
		else {
			doInvokeListener(listener, event);
		}
	}
	
	//执行（）
	@SuppressWarnings({"rawtypes", "unchecked"})
	private void doInvokeListener(ApplicationListener listener, ApplicationEvent event) {
		try {
		//这个地方调了监听器所实现的接口ApplicationListener的onApplicationEvent（）。注解@EventListener其实就是生成了一个代理类，代理类也实现了接口ApplicationListener的onApplicationEvent（）方法，所以原理一样
			listener.onApplicationEvent(event);
		}
		catch (ClassCastException ex) {
			String msg = ex.getMessage();
			if (msg == null || matchesClassCastMessage(msg, event.getClass())) {
				Log logger = LogFactory.getLog(getClass());
				if (logger.isTraceEnabled()) {
					logger.trace("Non-matching event type for listener: " + listener, ex);
				}
			}
			else {
				throw ex;
			}
		}
	}

}

第二部分原理：事件广播器的初始化：

SpringApplication.java: SpringApplication.run(UsualServiceApplication.class, args)启动的入口

public class SpringApplication {

	public ConfigurableApplicationContext run(String... args) {
		StopWatch stopWatch = new StopWatch();
		stopWatch.start();
		ConfigurableApplicationContext context = null;
		Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
		configureHeadlessProperty();
		SpringApplicationRunListeners listeners = getRunListeners(args);
		listeners.starting();
		try {
			ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
			ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
			configureIgnoreBeanInfo(environment);
			Banner printedBanner = printBanner(environment);
			context = createApplicationContext();
			exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
					new Class[] { ConfigurableApplicationContext.class }, context);
			prepareContext(context, environment, listeners, applicationArguments, printedBanner);
			//重点在这个方法里面
			refreshContext(context);
			afterRefresh(context, applicationArguments);
			stopWatch.stop();
			if (this.logStartupInfo) {
				new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
			}
			listeners.started(context);
			callRunners(context, applicationArguments);
		}
		catch (Throwable ex) {
			handleRunFailure(context, ex, exceptionReporters, listeners);
			throw new IllegalStateException(ex);
		}

		try {
			listeners.running(context);
		}
		catch (Throwable ex) {
			handleRunFailure(context, ex, exceptionReporters, null);
			throw new IllegalStateException(ex);
		}
		return context;
	}


	private void refreshContext(ConfigurableApplicationContext context) {
	//调用refresh（）
		refresh((ApplicationContext) context);
		if (this.registerShutdownHook) {
			try {
				context.registerShutdownHook();
			}
			catch (AccessControlException ex) {
				// Not allowed in some environments.
			}
		}
	}
	//执行refresh（）
	@Deprecated
	protected void refresh(ApplicationContext applicationContext) {
		Assert.isInstanceOf(ConfigurableApplicationContext.class, applicationContext);
		//调用refresh((ConfigurableApplicationContext) applicationContext)
		refresh((ConfigurableApplicationContext) applicationContext);
	}
	//执行refresh((ConfigurableApplicationContext) applicationContext)
	protected void refresh(ConfigurableApplicationContext applicationContext) {
	//调用的是AbstractApplicationContext.java抽象类的refresh（）
		applicationContext.refresh();
	}
}

AbstractApplicationContext.java抽象类:

//执行AbstractApplicationContext.java抽象类的refresh（）
public abstract class AbstractApplicationContext extends DefaultResourceLoader implements ConfigurableApplicationContext {
	@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {

			prepareRefresh();
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
			prepareBeanFactory(beanFactory);

			try {
				postProcessBeanFactory(beanFactory);
				invokeBeanFactoryPostProcessors(beanFactory);
				registerBeanPostProcessors(beanFactory);
				initMessageSource();
				//调用初始化事件广播器方法
				initApplicationEventMulticaster();
				onRefresh();
				registerListeners();
				finishBeanFactoryInitialization(beanFactory);
				finishRefresh();
			}

			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}
				destroyBeans();
				cancelRefresh(ex);
				throw ex;
			}
			finally {
				resetCommonCaches();
			}
		}
	}
	//执行初始化事件广播器的方法
	protected void initApplicationEventMulticaster() {
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
			this.applicationEventMulticaster =
					beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
			if (logger.isTraceEnabled()) {
				logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
			}
		}
		else {
			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() + "]");
			}
		}
	}
}

ConfigurableApplicationContext接口： 继承了ApplicationContext接口

public interface ConfigurableApplicationContext extends ApplicationContext, Lifecycle, Closeable {

}

ApplicationContext接口：

public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory,
		MessageSource, ApplicationEventPublisher, ResourcePatternResolver {
}

4.观察者模式：

包含观察者和目标(被观察者)两种对象。目标和观察者之间存在一对多的关系，通过建立目标与观察者之间的联系，当目标的某个状态发生变化时，所有与之关联的观察者都会得到通知并执行各自的任务。

也称 发布-订阅模式：
订阅：观察者向目标对象注册自己，告诉目标对象自己在观察它。
发布：当目标对象的状态发生改变时，向它所有的观察者发送通知，观察者收到通知后执行各自的操作。

优点：降低了目标与观察者之间的耦合关系。
缺点：目标与观察者之间没有完全解耦，还可能出现循环引用；当观察者对象很多时，通知的发布可能会很耗时。

5.Spring5种标准事件： Spring源码中也是用了事件发布，下面的是监听对象即事件

上下文更新事件（ContextRefreshedEvent）： ApplicationContext初始化或刷新，或者说在容器实例化(refresh())时发布事件；
上下文开始事件（ContextStartedEvent）：Spring容器启动时，即调用ConfigurableApplicationContext接口的start()时发布事件；
上下文停止事件（ContextStoppedEvent）：Spring容器停止时，即调用ConfigurableApplicationContext接口的stop()时发布事件，关闭的容器可以通过start()重启；
上下文关闭事件（ContextClosedEvent）：Spring容器关闭时，即调用ConfigurableApplicationContext接口的close()时发布事件，所有的Bean已被销毁，无法重启容器；
请求处理事件（RequestHandledEvent）：当一个请求被处理完成时发布事件。

若不你突然闯进我心窝
关注
spring 事件监听发布原理
sjtu_chenchen的专栏
06-10 1042
【事件派发器】 * 1）、容器启动：refresh(); * 2）、initApplicationEventMulticaster();初始化ApplicationEventMulticaster； * 1）、先去容器中找有没有id=“applicationEventMulticaster”的组件； * 2）、如果没有this.app...
spring监听器原理
qq_30364247的博客
02-27 1429
1. 使用Spring 事件 Spring事件体系包括三个组件：事件，事件监听器，事件广播器。 2.Spring内置事件 内置事件中由系统内部进行发布，只需注入监听器 监听器简单使用 自定义事件 public class BigEvent extends ApplicationEvent { private String name; public BigEvent(Object source, String name) { super(source).
Spring系列17：Spring事件发布详解
qq_21579619的博客
02-17 2366
本文内容 实现原理和标准事件 编程式实现自定义事件 基于注解的自定义事件 通用事件 实现原理和标准事件 Spring中的事件发布本质上是标准的观察者设计模式。ApplicationContext 中的事件处理是通过 ApplicationEvent 类和 ApplicationListener 接口提供的。如果将实现 ApplicationListener 接口的bean部署到上下文中，则每次将 ApplicationEvent 发布到 ApplicationContext 时，该bean都会得到通知。
Spring 的事件发布机制
JavaJasper的博客
02-04 1717
Spring 事件发布机制详解
Spring组件实现事件发布订阅-全网最详细介绍
最新发布
weixin_40892351的博客
07-28 1281
使用org.springframework.context包下的类实现订阅发布机制：ApplicationEvent：一个抽象类，继承自java.util.EventObject，它提供了关于事件的基本信息，比如事件的时间戳。一般在实际项目里实现这个抽象类来传递具体的事件数据。ApplicationEventPublisher：一个接口，它定义了发布事件的方法。一般在项目里调用它的publishEvent方法来发布事件。
spring事件发布
zhouyi_YYDS的博客
04-25 911
1.事件管理初始化 // Initialize event multicaster for this context. //初始化事件传播 initApplicationEventMulticaster(); a.初始化详解 protected void initApplicationEventMulticaster() { ConfigurableListableBeanFactory beanFactory = getBeanFactory(); ...
Spring 事件发布
2301_76607156的博客
04-24 459
事件发布是 Spring 框架中最容易被忽视的功能之一，但实际上它是一个很有用的功能。使用事件机制可以将同一个应用系统内互相耦合的代码进行解耦，并且可以将事件与 Spring 事务结合起来，实现我们工作中的一些业务需求。和 Spring 的事务类似，Spring 事务有编程式事务、声明式事务，Spring 事件也分为编程式事件和声明式事件，本篇主要讲解使用注解实现声明式事件发布和监听。Spring事件发布适用于小型项目，对于高并发流量的业务还是需要专业的消息中间件来支撑。不过通常我们会将Spring。
Spring事件Application Event原理详解
08-25
Spring 事件 Application Event 原理详解 Spring 事件 Application Event 是 Spring 框架中的一种消息通信机制，用于实现 Bean 之间的消息传递。该机制基于观察者模式，允许一个 Bean 处理完一个任务之后，通知...
EventBus与Spring Event区别详解(EventBus 事件机制,Spring Event事件机制)
08-25
EventBus的使用非常简单，只需要定义事件对象、事件监听器和事件发布者。 在上面的代码示例中，我们定义了一个HelloEvent事件对象和一个WorldEvent事件对象，它们之间有继承关系。然后，我们定义了一个...
Spring事件发布
root_zhb的博客
07-06 332
Spring事件发布，Event、Publisher、Listener
Spring IoC 源码系列（三）Spring 事件发布机制原理分析
点滴记录
03-14 584
在 IoC 容器启动流程中有一个 finishRefresh 方法，具体实现如下： protected void finishRefresh() { clearResourceCaches(); initLifecycleProcessor(); getLifecycleProcessor().onRefresh(); // 向所有监听 ContextRefreshedEvent...
Spring 事件发布机制
weixin_46058921的博客
09-21 1313
Spring 事件发布机制使用教程
Spring事件发布机制
weixin_44399827的博客
06-30 2791
目录 前言一、事件驱动机制​编辑 二、Spring的事件发布机制 三、Spring事件使用实例四、Spring事件驱动的实现原理总结： 在设计模式中有一种设计模式叫做观察者设计模式，观察者模式的大致思想是这样的：有两个比较中重要的概念 一个是：被观察的对象（Subject） 一个是观察的对象（Observer）。 当被观察的对象有变更和改动的时候，能够及时的通知给Observer。 大家细品，是不是有点消息队列的味道。是的，没错。消息队列MQ的思想和观察者模式的思想是一样的。Subject的改动可以通过到每
Spring---事件发布
ranxiaochuan1994的博客
04-03 308
spring事件发布机制如何在spring框架中使用监听机制spring监听器原理容器默认事件发布者类SimpleApplicationEventMulticaster   这篇文章主要是讲解spring的事务发布机制，也顺带讲一些ApplicationContest容器启动过程。Spring事件发布机制是基于观察者模式的。其实现类图如下：   如上图所示，抽象类AbstractApplicat...
如何掌握Spring事件发布和监听机制？
2401_83062316的博客
05-31 1192
通过本讲内容的学习，我们掌握了Spring中事件处理的实现过程，这也为实现自定义的事件驱动架构提供了很好的基础，很多实现上的细节可供我们参考。我们已经明白了事件发布的独立过程，现在回到Spring容器来获取用于事件发布的ApplicationEventMulticaster以及各个用于事件监听的ApplicationListener的具体方式。用户发布事件的ApplicationEventPublisher和用于监听事件的ApplicationListener是Spring框架中实现事件驱动编程的核心类。
spring事件发布器ApplicationEventPublisher的使用
minyunfei6的博客
07-18 1025
spring中有一个事件发布器,使用了观察者模式,当有事件发布的时候,事件监听者会立刻收到发布的事件。今天我们来介绍下这个事件发布器怎么使用。
spring事件发布器
09-17
Spring事件发布器的工作原理如下：首先，我们需要定义一个事件类，这个事件类可以是继承自ApplicationEvent类的自定义事件，也可以是Spring提供的一些内置事件，例如ContextStartedEvent、ContextClosedEvent等。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值