spring源码——事件监听器（注解方式）

最新推荐文章于 2024-09-17 01:34:53 发布
最新推荐文章于 2024-09-17 01:34:53 发布
阅读量488 收藏 1
点赞数
分类专栏： 源码 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m1f2c3/article/details/110306109
版权
java 同时被 2 个专栏收录
24 篇文章 0 订阅
订阅专栏
源码
14 篇文章 0 订阅
订阅专栏

代码：https://github.com/shangjianan2/NormalTechnology.git

EventListener

使用

定义事件

需要继承ApplicationEvent

package com.ework.upms.server.event;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
import org.springframework.context.ApplicationEvent;

@Getter
public class UserDTO extends ApplicationEvent {
    private Integer userId;
    private String name;
    private Integer age;

    public UserDTO(Object source, Integer userId, String name, Integer age) {
        super(source);
        this.userId = userId;
        this.name = name;
        this.age = age;
    }
}

监听器

package com.ework.upms.server.event;

import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

// 通过实现接口实现监听器
@Component
public class UserRegisterEmailListener implements ApplicationListener<UserDTO> {
    @Override
    public void onApplicationEvent(UserDTO userDTO){
        System.out.println("监听到用户注册，准备发送邮件，user:" + userDTO.toString());
    }
}

发布事件的服务

package com.ework.upms.server.event;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Service;

@Service
@Slf4j
public class UserServiceImpl implements UserService{
    @Autowired
    private ApplicationEventPublisher eventPublisher;
    @Override
    public void register(){
        UserDTO userDTO = new UserDTO(this, 18, "精灵王jinglingwang.cn", 1001);
//        userDTO.setAge(18);
//        userDTO.setName("精灵王jinglingwang.cn");
//        userDTO.setUserId(1001);
        System.out.println("register user");
        eventPublisher.publishEvent(userDTO);
    }
}

单元测试

package com.ework.upms.server.event;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.testng.AbstractTestNGSpringContextTests;
import org.testng.annotations.Test;

@ContextConfiguration(locations = {"classpath:spring-servlet.xml"})
public class UserServiceImplTest extends AbstractTestNGSpringContextTests {
    private Logger logger = LoggerFactory.getLogger(this.getClass());

    @Autowired
    private UserService userService;

    @Test
    public void testUserEvent(){
        userService.register();
    }
}

分析

调用堆栈

handleUserEvent:15, UserRegisterSmsListener (com.ework.upms.server.event)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
doInvoke:253, ApplicationListenerMethodAdapter (org.springframework.context.event)
processEvent:174, ApplicationListenerMethodAdapter (org.springframework.context.event)
onApplicationEvent:137, ApplicationListenerMethodAdapter (org.springframework.context.event)
invokeListener:167, SimpleApplicationEventMulticaster (org.springframework.context.event)
multicastEvent:139, SimpleApplicationEventMulticaster (org.springframework.context.event)
publishEvent:393, AbstractApplicationContext (org.springframework.context.support)
publishEvent:347, AbstractApplicationContext (org.springframework.context.support)
register:20, UserServiceImpl (com.ework.upms.server.event)
testUserEvent:19, UserServiceImplTest (com.ework.upms.server.event)

multicastEvent:139, SimpleApplicationEventMulticaster (org.springframework.context.event)中遍历了所有已经注册的且符合事件类型的监听器

	@Override
	public void multicastEvent(final ApplicationEvent event, ResolvableType eventType) {
		ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
		for (final ApplicationListener<?> listener : getApplicationListeners(event, type)) {//遍历监听器
			Executor executor = getTaskExecutor();
			if (executor != null) {
				executor.execute(new Runnable() {
					@Override
					public void run() {
						invokeListener(listener, event);
					}
				});
			}
			else {
				invokeListener(listener, event);//第139行，运行过程中实际运行的位置
			}
		}
	}

Async+EventListener

待续

TransactionalEventListener

使用这个注解之后，整个事务正常提交之后才会触发事件监听

使用

与EventListener大致相同。但是要注意，事件触发时需要包装在事务中。

服务

package com.ework.upms.server.service;

import com.ework.upms.server.annotation.MyAnnotation;
import com.ework.upms.server.event.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class TestTransaction {

    @Autowired
    private UserService userService;

    @Transactional(transactionManager = "adsTm")//需要在事务中调用事件
    public String helloWorld() {
        userService.register();
        return "adsf";
    }

}

单元测试

package com.ework.upms.server.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.testng.AbstractTestNGSpringContextTests;
import org.testng.annotations.Test;

@ContextConfiguration(locations = {"classpath:spring-servlet.xml"})
public class testAspectTest extends AbstractTestNGSpringContextTests {
    @Autowired
    private TestAspect testAspect;
    @Autowired
    private TestTransaction testTransaction;

    @Test
    public void test() {
//        testAspect.helloWorld();
        testTransaction.helloWorld();
    }
}

分析

调用堆栈

handleUserEvent:15, UserRegisterSmsListener (com.ework.upms.server.event)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
doInvoke:253, ApplicationListenerMethodAdapter (org.springframework.context.event)
processEvent:174, ApplicationListenerMethodAdapter (org.springframework.context.event)//从此之后与使用EventListener时的调用堆栈相同
processEvent:127, ApplicationListenerMethodTransactionalAdapter$TransactionSynchronizationEventAdapter (org.springframework.transaction.event)
afterCompletion:116, ApplicationListenerMethodTransactionalAdapter$TransactionSynchronizationEventAdapter (org.springframework.transaction.event)
invokeAfterCompletion:168, TransactionSynchronizationUtils (org.springframework.transaction.support)//此处遍历触发事件
invokeAfterCompletion:1002, AbstractPlatformTransactionManager (org.springframework.transaction.support)
triggerAfterCompletion:977, AbstractPlatformTransactionManager (org.springframework.transaction.support)//从ThreadLocal中获取所有事件
processCommit:806, AbstractPlatformTransactionManager (org.springframework.transaction.support)
commit:730, AbstractPlatformTransactionManager (org.springframework.transaction.support)
commitTransactionAfterReturning:504, TransactionAspectSupport (org.springframework.transaction.interceptor)
invokeWithinTransaction:292, TransactionAspectSupport (org.springframework.transaction.interceptor)//事务正常提交之后运行这段代码
invoke:96, TransactionInterceptor (org.springframework.transaction.interceptor)
proceed:179, ReflectiveMethodInvocation (org.springframework.aop.framework)
intercept:673, CglibAopProxy$DynamicAdvisedInterceptor (org.springframework.aop.framework)
helloWorld:-1, TestTransaction$$EnhancerBySpringCGLIB$$7bdc734c (com.ework.upms.server.service)
test:18, testAspectTest (com.ework.upms.server.service)

1、invokeWithinTransaction:292, TransactionAspectSupport (org.springframework.transaction.interceptor)在事务正常提交之后触发事件监听

	protected Object invokeWithinTransaction(Method method, Class<?> targetClass, final InvocationCallback invocation)
			throws Throwable {

		........................

		if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {
			// Standard transaction demarcation with getTransaction and commit/rollback calls.
			TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
			Object retVal = null;
			try {
				// This is an around advice: Invoke the next interceptor in the chain.
				// This will normally result in a target object being invoked.
				retVal = invocation.proceedWithInvocation();
			}
			catch (Throwable ex) {
				// target invocation exception
				completeTransactionAfterThrowing(txInfo, ex);
				throw ex;
			}
			finally {
				cleanupTransactionInfo(txInfo);
			}
			commitTransactionAfterReturning(txInfo);//第292行
			return retVal;
		}

		else {
			// It's a CallbackPreferringPlatformTransactionManager: pass a TransactionCallback in.
			............................
		}
	}

2、triggerAfterCompletion:977, AbstractPlatformTransactionManager (org.springframework.transaction.support)，此处开始使用ThreadLocal

	private void triggerAfterCompletion(DefaultTransactionStatus status, int completionStatus) {
		if (status.isNewSynchronization()) {
			List<TransactionSynchronization> synchronizations = TransactionSynchronizationManager.getSynchronizations();//从ThreadLocal中获取所有事件
			TransactionSynchronizationManager.clearSynchronization();
			if (!status.hasTransaction() || status.isNewTransaction()) {
				if (status.isDebug()) {
					logger.trace("Triggering afterCompletion synchronization");
				}
				// No transaction or new transaction for the current scope ->
				// invoke the afterCompletion callbacks immediately
				invokeAfterCompletion(synchronizations, completionStatus);//第977行
			}
			else if (!synchronizations.isEmpty()) {
				// Existing transaction that we participate in, controlled outside
				// of the scope of this Spring transaction manager -> try to register
				// an afterCompletion callback with the existing (JTA) transaction.
				registerAfterCompletionWithExistingTransaction(status.getTransaction(), synchronizations);
			}
		}
	}

synchronizations的声明为

private static final ThreadLocal<Set<TransactionSynchronization>> synchronizations =
			new NamedThreadLocal<Set<TransactionSynchronization>>("Transaction synchronizations");

事件触发时会插入到这个ThreadLocal中
触发前
在这里插入图片描述 触发后
在这里插入图片描述
在这里插入图片描述
之后在TransactionAspectSupport中会调用

		if (txAttr == null || !(tm instanceof > CallbackPreferringPlatformTransactionManager)) {
			// Standard transaction demarcation with getTransaction and commit/rollback calls.
			TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
			Object retVal = null;
			try {
				// This is an around advice: Invoke the next interceptor in the chain.
				// This will normally result in a target object being invoked.
				retVal = invocation.proceedWithInvocation();
			}
			catch (Throwable ex) {
				// target invocation exception
				completeTransactionAfterThrowing(txInfo, ex);
				throw ex;
			}
			finally {
				cleanupTransactionInfo(txInfo);
			}
			commitTransactionAfterReturning(txInfo);//在这里触发
			return retVal;
		}

3、invokeAfterCompletion:168, TransactionSynchronizationUtils (org.springframework.transaction.support)，遍历事件

	public static void invokeAfterCompletion(List<TransactionSynchronization> synchronizations, int completionStatus) {
		if (synchronizations != null) {
			for (TransactionSynchronization synchronization : synchronizations) {
				try {
					synchronization.afterCompletion(completionStatus);//第168行，completionStatus=0
				}
				catch (Throwable tsex) {
					logger.error("TransactionSynchronization.afterCompletion threw exception", tsex);
				}
			}
		}
	}

4、processEvent:174, ApplicationListenerMethodAdapter (org.springframework.context.event)，此处之后，与EventListener相同

	public void processEvent(ApplicationEvent event) {
		Object[] args = resolveArguments(event);//第174行
		if (shouldHandle(event, args)) {
			Object result = doInvoke(args);
			if (result != null) {
				handleResult(result);
			}
			else {
				logger.trace("No result object given - no result to handle");
			}
		}
	}

多个Listener

this.eventPublisher.applicationEventMulticaster.defaultRetriever.applicationListeners中记录所有的listener
在这里插入图片描述multicastEvent:139, SimpleApplicationEventMulticaster (org.springframework.context.event)中遍历了所有已经注册的且符合事件类型的监听器

而过滤出监听器的责任由getApplicationListeners负责

	public void multicastEvent(final ApplicationEvent event, ResolvableType eventType) {
		ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
		//下面getApplicationListeners将符合要求的监听器过滤出来
		for (final ApplicationListener<?> listener : getApplicationListeners(event, type)) {
			Executor executor = getTaskExecutor();
			if (executor != null) {
				executor.execute(new Runnable() {
					@Override
					public void run() {
						invokeListener(listener, event);
					}
				});
			}
			else {
				invokeListener(listener, event);
			}
		}
	}

retrieveApplicationListeners:220, AbstractApplicationEventMulticaster (org.springframework.context.event)//遍历所有监听器，寻找符合要求的
getApplicationListeners:192, AbstractApplicationEventMulticaster (org.springframework.context.event)
multicastEvent:128, SimpleApplicationEventMulticaster (org.springframework.context.event)
publishEvent:393, AbstractApplicationContext (org.springframework.context.support)
publishEvent:347, AbstractApplicationContext (org.springframework.context.support)
publish:14, MyEventPublisher (com.ework.upms.server.event.event2)
test:21, MyEventTest (com.ework.upms.server.event.event2)

retrieveApplicationListeners:220, AbstractApplicationEventMulticaster (org.springframework.context.event)从上下文中遍历出所有符合要求的，然后在multicastEvent:128, SimpleApplicationEventMulticaster (org.springframework.context.event)中触发。

SqlSessionFactoryBean好像是所有事件的监听器

m1f2c3
关注
专栏目录
浅析Spring-kafka源码——消费者模型的实现
WannaRunning的博客
06-17 2534
在使用Spring-kafka时，一般都是通过使用@KafkaListener注解的方法来实现消息监听和消费。今天写一下基于这个注解实现的消费端模型和实现的原理。
spring事件监听器系列二：@EventListener注解原理
小小少年的博客
08-01 4341
前面的笔记中，有写过，我们要在spring中声明一个事件监听器，有两种方式，一种是实现ApplicationListener接口，一种是通过@EventListener注解来修饰一个方法，并在该注解中，指定要监听的事件，那这个方法在事件发生的时候，会被回调 这两种机制，其实我们先不看代码，去考虑下，实现的方式很有可能就是： 对于实现接口这种方式，是ApplicationListenerDetector这个类来完成解析的 对于注解这种方式，是EventListenerMethodProcessor和Defau
Spring之事件监听
weoln的专栏
05-04 1374
Spring借助于org.springframework.context.event.ApplicationEvent抽象类及其子类实现事件的发布；借助于org.springframework.context.ApplicationListener接口及其实现者实现事件的监听。这两者构成了观察者模式（Observer）。ApplicationContext提供了publishEvent方法，实
【使用Spring事件监听机制实现业务解耦+相关拓展】
最新发布
weixin_44585177的博客
09-17 1142
了解Spring的发布事件及事件侦听机制，相关拓展等等
spring 事件监听
宏轩ＪＡＶＡ技术专栏
03-25 7732
用一个简单的例子来实现spring事件监听的功能 这个例子主要功能是，记录那些用户是第一次登入系统，如果用户是第一次登入系统，则调用spring的事件监听，记录这些用户。 主要用到的spring的类和接口有：   org.springframework.context.event.ApplicationEvent抽象类及其子类来实现事件；   org.springframe
Spring事件监听
Shawn的个人博客
07-29 1515
Spring的事件监听机制和发布订阅机制是很相似的发布了一个事件后，监听该类型事件的所有监听器会触发相应的处理逻辑。正如Spring官方文档上所说的，整个上就是一个观察者的模式。那么，我们不妨猜测下，Spring是如何来实现事件发布监听的底层使用一个集合存储了所有的监听器，当发布了一个事件后，遍历事件监听器集合，然后过滤符合事件类型的监听器，最后触发相应的事件处理逻辑。//必须继承实现publicMyEvent(Objectsource,Stringmsg){}}...
Spring源码——AOP
等一杯咖啡的博客
10-21 2279
前言 内容主要参考自《Spring源码深度解析》一书，算是读书笔记或是原书的补充。进入正文后可能会引来各种不适，毕竟阅读源码是件极其痛苦的事情。 本文主要涉及书中第七章的部分，依照书中内容以及个人理解对Spring源码进行了注释，详见Github仓库：https://github.com/MrSorrow/spring-framework 正式进入正文前，强烈推荐先阅读文末参考阅读第一篇：关于 S...
Spring源码——Spring MVC
等一杯咖啡的博客
11-22 1649
前言 内容主要参考自《Spring源码深度解析》一书，算是读书笔记或是原书的补充。进入正文后可能会引来各种不适，毕竟阅读源码是件极其痛苦的事情。 本文主要涉及书中第十一章的部分，依照书中内容以及个人理解对Spring源码进行了注释，详见Github仓库：https://github.com/MrSorrow/spring-framework Spring框架提供了构建Web应用程序的全功能MVC模...
Spring源码（五）Spring 事件监听器的两种注册方式
weixin_39997751的博客
09-30 838
了解专栏完整的内容，请点击跳转： Spring Framework专栏导航页 作为一款优先的框架，怎么能少得了监听器呢？虽然说现基于web开发的项目很少用到监听器（大多使用消息队列），但是有些时候又需要用到。以及我们想监听Spring容器的初始化相关事件时候，就可以用到Spring自带的的监听器实现方式。 重要组件：事件多播器 监听器思维导图 两种监听器实现方式 接口方式 @Lazy @Component public class ContextRefreshedInterfaceListener i
Spring源码——容器扩展ApplicationContext
等一杯咖啡的博客
10-06 4390
Spring源码——容器扩展ApplicationContext 前言 内容主要参考自《Spring源码深度解析》一书，算是读书笔记或是原书的补充。进入正文后可能会引来各种不适，毕竟阅读源码是件极其痛苦的事情。 本文主要涉及书中第六章的部分，依照书中内容以及个人理解对Spring进行了注释，详见Github仓库：https://github.com/MrSorrow/spring-framewor...
Spring中的事件监听
技术积累，技术分享
05-16 3925
案例分析引入事件监听 首先我们假定一个场景，我们此时有一个登录的功能，根据用户名和密码进行登录。然后此时想要添加一个新的功能，如果一个用户登录成功就给这个用户发送短信提醒该用户（正常情况是异地登录才会发送短信提醒，这里为了简化需求，只要登录就发送短信提醒用户） 我们先来看一种实现方式： // 注意这里是伪代码 public void login(String username, String password) { if(根据username查看数据库当中是否有这个用户) { 获取这个用户的数据库中的
spring中事件机制
热门推荐
专注海量数据
03-16 1万+
一、事件机制　事件是可以被控件识别的操作，如按下确定按钮，选择某个单选按钮或者复选框。每一种控件有自己可以识别的事件，如窗体的加载、单击、双击等事件，编辑框(文本框)的文本改变事，等等。事件有系统事件和用户事件。系统事件由系统激发，如时间每隔24小时，银行储户的存款日期增加一天。用户事件由用户激发，如用户点击按钮，在文本框中显示特定的文本。事件驱动控件执行某项功能。
Spring 事件监听
不务正业的野猴子
08-19 176
/** * Created by liuquan on 2019/3/19. */ @Service("userService") public class UserServiceImpl implements UserService { private static final Logger LOGGER = LoggerFactory.getLogger(UserServiceImpl.class); @Autowired private UserDao userDao;
Spring的事件监听器
qingfeng2556的博客
01-16 133
Spring的事件监听器_weixin_39102174的博客-CSDN博客_spring事件监听器 定义applicationevent，publishEvent event,ApplicationListener
Spring 自定义事件，通过注解的方式来实现事件监听
Wayfreem的博客
07-01 1133
使用 spring 框架的 event，实现程序的松耦合，以及发送事件之后能从接受到事件的返回值
【RuoYi-Vue-Plus】学习笔记 45 - Spring 事件监听器 @EventListener 注解简单分析
MichelleChung的星球
12-20 2275
简单分析 Spring 事件监听器 @EventListener 注解初始化流程以及事件发布流程。
Spring事件之注解@EventListener讲解
上善若泪
02-03 5919
当我们观察方法的时候，会发现这个方法它主要是在对这个缓存在搞事情。这个缓存里面放的就是在项目启动过程中已经触发过的框架自带的listener对象：调用的时候，如果能从缓存中拿到对应的listener，则直接返回。而我们Demo中的自定义listener是第一次触发，所以肯定是没有的。因此关键逻辑就在方法里面：这个方法里面的逻辑较多，只说一下这个关键的 for 循环：这个 for 循环在干啥事呢？就是循环当前所有的listener，过滤出能处理当前这个事件的listener。
Spring事件驱动实战：自定义注解与接口实现详解
使用这个注解，开发者可以指定哪个方法应在何时被调用，实现了事件监听器的动态注册。 接着，定义了一个名为`IEvent`的接口，所有事件都必须实现这个接口，这是为了支持泛型和类型安全的事件传递。`MethodInfo`类...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值