Spring事件监听流程分析【源码浅析】

最新推荐文章于 2025-03-27 17:24:52 发布
原创 最新推荐文章于 2025-03-27 17:24:52 发布 · 792 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #spring

本文深入解析Spring框架中事件监听机制的实现，从@EventListener注解的使用，到事件注册及监听流程的源码分析，全面阐述Spring如何通过观察者模式进行事件的发布与订阅。

一、简介

  • Spring早期是通过实现ApplicationListener接口来定义监听事件，在spring4.2的时候开始我们可以通过@EventListener注解来定义监听事件，ApplicationListener接口定义如下：
@FunctionalInterface
public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {
	/**
	 * 处理Spring监听事件，监听 ApplicationEvent 及其下面的子事件
	 * 这里的ApplicationListener接口相当于观察者模式中的观察者Obverse接口，
	 * 且此处使用的是观察者模式的“推-拉”模型中的“拉”模型， 主题对象在通知观察者
	 * 的时候，只传递少量信息。如果观察者需要更具体的信息， 由观察者主动到主题对
	 * 象中获取，相当于是观察者从主题对象中拉数据。一般这种 模型的实现中，会把主
	 * 题对 象自身通过update()方法传递给观察者，这样在观察 者需要获取数据的时候，
	 * 就可以通过这个引用来获取了。
	 * Handle an application event.
	 * @param event the event to respond to
	 */
	void onApplicationEvent(E event);
}
  • Spring为我们提供的一个事件监听、订阅的实现，内部实现原理是观察者设计模式（拉模型）；为的就是业务系统逻辑的解耦,提高可扩展性以及可维护性。事件发布者并不需要考虑谁去监听，监听具体的实现内容是什么，发布者的工作只是为了发布事件而已。
  • 比如在我们的系统中，我们需要记录某一些比较重要方法的调用日志，我们就可以通过自定义注解+实现自定义监听事件即可。
  • 本篇文章我们通过@EventListener注解来分析Spring的事件注册及监听流程

二、使用@EventListener注解

  1. 建立事件对象，当调用publishEvent方法是会通过这个bean对象找对应事件的监听。
package com.asiainfo.gridtask.event;

import com.asiainfo.gridtask.entity.log.SysLog;
import org.springframework.context.ApplicationEvent;

/**
 * 系统日志事件，ApplicationEvent相当于观察者模式中的Subject主题对象，Spring容器
 * 发布监听事件后，
 * @author Jack.Cheng
 * @date 2020/1/7 15:04
 **/
public class SysLogEvent extends ApplicationEvent {

    public SysLogEvent(SysLog sysLog) {
        super(sysLog);
    }
}
  • 看一看SysLogEvent类的继承图，SysLogEvent继承至ApplicationEvent，ApplicationEvent 继承至EventObject，EventObject对象中定义了一个Object类型的source变量用于存放事件的消息。
    在这里插入图片描述
  • 新增对应的监听类
package com.asiainfo.gridtask.event;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.asiainfo.gridtask.common.constant.CommonConstant;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.event.EventListener;
import org.springframework.core.annotation.Order;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

/**
 * @author Jack.Cheng
 * @date 2020/1/7 15:08
 **/
@Slf4j
@Component
public class SysLogListener {

    @EventListener(SysLogEvent.class)
    public void saveSysLog(SysLogEvent event) {
        log.info("收到调用日志信息:info:{}" , JSON.toJSONString(event));
    }
}
  • 建立对应的测试类
package com.asiainfo.gridtask.controller;

import com.asiainfo.gridtask.entity.log.SysLog;
import com.asiainfo.gridtask.event.SysLogEvent;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author Jack.Cheng
 * @date 2020/4/7 16:34
 **/
@RestController
public class TestController {

    @Autowired
    private ApplicationContext applicationContext;

    @GetMapping("testEvent.do")
    public void testEvent(){
        SysLog sysLog = new SysLog();
        sysLog.setLogId("123456789")
              .setStaffCode("jack")
              .setPhoneNo("13378224441");
        applicationContext.publishEvent(new SysLogEvent(sysLog));
    }
}
  • 调用Restful接口后结果如下：
    在这里插入图片描述

三、源码解析

  • 在AnnotationConfigUtils#registerAnnotationConfigProcessors注册了EventListenerMethodProcessor 的BeanDefinition信息， 初始化SpringIOC容器的时候会将EventListenerMethodProcessor注册到容器中。
  • AnnotationConfigUtils是在AnnotationConfigServletWebServerApplicationContext构造方法里被加载。AnnotationConfigServletWebServerApplicationContext，他是spring boot启动入口的重要类(我这里用的是spring boot所以是这个类),可以相当于用xml的ClassPathXmlApplicationContext。
AnnotationConfigUtils类
	/**
	 * 内部管理@EventListener注解处理器的bean名称
	 * The bean name of the internally managed @EventListener annotation processor.
	 */
	public static final String EVENT_LISTENER_PROCESSOR_BEAN_NAME =
			"org.springframework.context.event.internalEventListenerProcessor";

	public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
			BeanDefinitionRegistry registry, @Nullable Object source) {

		...........省略...............
		
		// 注册EventListenerMethodProcessor对象
		if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
		}

		if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
		}

		return beanDefs;
	}
  • 注册的EventListenerMethodProcessor对象会在初始化非懒加载对象的时候执行它的afterSingletonsInstantiated方法。这里通过AbstractApplicationContext类的refresh() 方法中的 finishBeanFactoryInitialization(beanFactory) 去做初始化。
  • AbstractApplicationContext#refresh()
public void refresh() throws BeansException, IllegalStateException {

   synchronized (this.startupShutdownMonitor) {
      // 记录容器的启动时间、标记“已启动”状态、检查环境变量
      prepareRefresh();
      // 初始化BeanFactory容器（DefaultListableBeanFactory）、注册BeanDefinition
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
      // 设置 BeanFactory 的类加载器，添加几个 BeanPostProcessor，手动注册几个特殊的 bean
      prepareBeanFactory(beanFactory);
      try {
         // 扩展点，具体逻辑由子类去实现
         postProcessBeanFactory(beanFactory);
         // 调用 BeanFactoryPostProcessor 各个实现类的 postProcessBeanFactory(factory) 方法
         invokeBeanFactoryPostProcessors(beanFactory);
         // 注册 BeanPostProcessor 的实现类
         registerBeanPostProcessors(beanFactory);
         // 初始化MessageSource
         initMessageSource();
         // 注册Spring事件派发多播器
         initApplicationEventMulticaster();
         // 扩展点，交由子类实现
         onRefresh();
         // 注册事件监听器
         registerListeners();
         // 初始化所有的 singleton beans
         finishBeanFactoryInitialization(beanFactory);
         // 广播事件
         finishRefresh();
      }catch (BeansException ex) {
         if (logger.isWarnEnabled()) {
            logger.warn("Exception encountered during context initialization - " +
                  "cancelling refresh attempt: " + ex);
         }
         // 销毁已经初始化的的Bean
         destroyBeans();
         // 设置 'active' 状态
         cancelRefresh(ex);
         throw ex;
      }finally {
         // 清除缓存
         resetCommonCaches();
      }
   }
}
  • 这里我们重点关注refresh()#finishBeanFactoryInitialization(beanFactory)#preInstantiateSingletons() 方法
	protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		// Initialize conversion service for this context.
		if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
				beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
			beanFactory.setConversionService(
					beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
		}

		// Register a default embedded value resolver if no bean post-processor
		// (such as a PropertyPlaceholderConfigurer bean) registered any before:
		// at this point, primarily for resolution in annotation attribute values.
		if (!beanFactory.hasEmbeddedValueResolver()) {
			beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
		}

		// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
		String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
		for (String weaverAwareName : weaverAwareNames) {
			getBean(weaverAwareName);
		}

		// Stop using the temporary ClassLoader for type matching.
		beanFactory.setTempClassLoader(null);

		// Allow for caching all bean definition metadata, not expecting further changes.
		beanFactory.freezeConfiguration();

		// 初始化非懒加载对象
		beanFactory.preInstantiateSingletons();
	}
  • DefaultListableBeanFactory#preInstantiateSingletons()
	@Override
	public void preInstantiateSingletons() throws BeansException {
		..........省略非必要代码...........
		// 将注册的beanDefinition类信息封装到集合中
		List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);
		..........省略非必要代码...........
		// 触发所有适用bean的初始化后回调 主要是afterSingletonsInstantiated方法
		for (String beanName : beanNames) {
			Object singletonInstance = getSingleton(beanName);
	        /**
	         * 处理SmartInitializingSingleton的实现类，调用其afterSingletonsInstantiated()方法，该方法
	         * 会将带有EventListener注解的方法包装为ApplicationListenerMethodAdapter类，Spring容器发布
	         * 事件后将通过多播器触发调用这个类的onApplicationEvent(ApplicationEvent event)方法，这个方法
	         * 最终会通过反射的方式对应的调用我们加了EventListener注解的方法，最终完成事件的发布调用流程
	         */
			if (singletonInstance instanceof SmartInitializingSingleton) {
				final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
				if (System.getSecurityManager() != null) {
					AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
						smartSingleton.afterSingletonsInstantiated();
						return null;
					}, getAccessControlContext());
				}
				else {
					// 调用afterSingletonsInstantiated方法(EventListenerMethodProcessor类)
					smartSingleton.afterSingletonsInstantiated();
				}
			}
		}
	}
  • EventListenerMethodProcessor类图如下，这里可以看到其实现了SmartInitializingSingleton接口
    在这里插入图片描述
  • EventListenerMethodProcessor#afterSingletonsInstantiated，敲黑板，这里开始注册带有@EventListener注解的方法了
	@Override
	public void afterSingletonsInstantiated() {
		// 获取EventListenerFactory工厂类
		ConfigurableListableBeanFactory beanFactory = this.beanFactory;
		Assert.state(this.beanFactory != null, "No ConfigurableListableBeanFactory set");
		String[] beanNames = beanFactory.getBeanNamesForType(Object.class);
		for (String beanName : beanNames) {
			if (!ScopedProxyUtils.isScopedTarget(beanName)) {
				Class<?> type = null;
				try {
					type = AutoProxyUtils.determineTargetClass(beanFactory, beanName);
				}
				catch (Throwable ex) {
					// An unresolvable bean type, probably from a lazy bean - let's ignore it.
					if (logger.isDebugEnabled()) {
						logger.debug("Could not resolve target class for bean with name '" + beanName + "'", ex);
					}
				}
				if (type != null) {
					if (ScopedObject.class.isAssignableFrom(type)) {
						try {
							Class<?> targetClass = AutoProxyUtils.determineTargetClass(
									beanFactory, ScopedProxyUtils.getTargetBeanName(beanName));
							if (targetClass != null) {
								type = targetClass;
							}
						}
						catch (Throwable ex) {
							// An invalid scoped proxy arrangement - let's ignore it.
							if (logger.isDebugEnabled()) {
								logger.debug("Could not resolve target bean for scoped proxy '" + beanName + "'", ex);
							}
						}
					}
					try {
						// 重点是这个方法处理Bean
						processBean(beanName, type);
					}
					catch (Throwable ex) {
						throw new BeanInitializationException("Failed to process @EventListener " +
								"annotation on bean with name '" + beanName + "'", ex);
					}
				}
			}
		}
	}
  • EventListenerMethodProcessor#processBean，这里会将带有EventListener注解的方法包装为ApplicationListenerMethodAdapter类，Spring容器在发布事件后会通过多播器触发调用这个类的onApplicationEvent(ApplicationEvent event)方法，这个方法最终会通过反射的方式对应的调用我们加了EventListener注解的方法，最终完成整个事件的发布调用流程。
private void processBean(final String beanName, final Class<?> targetType) {
    if (!this.nonAnnotatedClasses.contains(targetType) && !isSpringContainerClass(targetType)) {
        Map<Method, EventListener> annotatedMethods = null;
        try {
            // 拿到使用了@EventListener注解的方法
            annotatedMethods = MethodIntrospector.selectMethods(targetType,
                    (MethodIntrospector.MetadataLookup<EventListener>) method ->
                            AnnotatedElementUtils.findMergedAnnotation(method, EventListener.class));
        }
        catch (Throwable ex) {
            // An unresolvable type in a method signature, probably from a lazy bean - let's ignore it.
            if (logger.isDebugEnabled()) {
                logger.debug("Could not resolve methods for bean with name '" + beanName + "'", ex);
            }
        }
        if (CollectionUtils.isEmpty(annotatedMethods)) {
            this.nonAnnotatedClasses.add(targetType);
            if (logger.isTraceEnabled()) {
                logger.trace("No @EventListener annotations found on bean class: " + targetType.getName());
            }
        }
        else {
            // Non-empty set of methods
            ConfigurableApplicationContext context = this.applicationContext;
            Assert.state(context != null, "No ApplicationContext set");
            List<EventListenerFactory> factories = this.eventListenerFactories;
            Assert.state(factories != null, "EventListenerFactory List not initialized");
            for (Method method : annotatedMethods.keySet()) {
                for (EventListenerFactory factory : factories) {
                    // 判断是否支持该方法  这里用的DefaultEventListenerFactory spring5.0.8 写死的返回true
                    if (factory.supportsMethod(method)) {
                        // 获取类上标注了@EventListener注解的方法
                        Method methodToUse = AopUtils.selectInvocableMethod(method, context.getType(beanName));
                        // 将该类和方法包装为ApplicationListenerMethodAdapter对象
                        ApplicationListener<?> applicationListener = factory.createApplicationListener(beanName, targetType, methodToUse);
                        if (applicationListener instanceof ApplicationListenerMethodAdapter) {
                            // 如果是ApplicationListenerMethodAdapter对象 就把context和evaluator传进去
                            ((ApplicationListenerMethodAdapter) applicationListener).init(context, this.evaluator);
                        }
                        // 添加到ApplicationListener事件Set集合中去
                        context.addApplicationListener(applicationListener);
                        break;
                    }
                }
            }
            if (logger.isDebugEnabled()) {
                logger.debug(annotatedMethods.size() + " @EventListener methods processed on bean '" +
                        beanName + "': " + annotatedMethods);
            }
        }
    }
}

// 封装ApplicationListenerMethodAdapter对象
public ApplicationListener<?> createApplicationListener(String beanName, Class<?> type, Method method) {
    return new ApplicationListenerMethodAdapter(beanName, type, method);
}
  • ApplicationListenerMethodAdapter类的UML图
    在这里插入图片描述
  • ApplicationListenerMethodAdapter类的属性及部分关键方法。
public class ApplicationListenerMethodAdapter implements GenericApplicationListener {

	protected final Log logger = LogFactory.getLog(getClass());

	// 当前监听器在容器中类名，Spring容器可以通过beanName获取该类
	private final String beanName;
	// 监听器中被@EventListener注解修饰的方法
	private final Method method;

	private final Method targetMethod;

	private final AnnotatedElementKey methodKey;

	private final List<ResolvableType> declaredEventTypes;

	@Nullable
	private final String condition;

	private final int order;

	@Nullable
	private ApplicationContext applicationContext;

	@Nullable
	private EventExpressionEvaluator evaluator;
	.........省略不相关方法...........
	
	/**
	 * 该方法是实现了ApplicationListener接口的onApplicationEvent方法，当ApplicationContext容器
	 * publishEvent事件后，最后具体执行的方法，相当于观察者模式中的ConcreteObverse对象实现
	 * Obverse接口的方法。
	 */
	@Override
	public void onApplicationEvent(ApplicationEvent event) {
		processEvent(event);
	}
	
	/**
	 * Process the specified {@link ApplicationEvent}, checking if the condition
	 * match and handling non-null result, if any.
	 */
	public void processEvent(ApplicationEvent event) {
		// 解析ApplicationContext发布的事件参数信息
		Object[] args = resolveArguments(event);
		if (shouldHandle(event, args)) {
			// 通过反射的形式执行通过@EventListener注解修饰的方法
			Object result = doInvoke(args);
			if (result != null) {
				handleResult(result);
			}
			else {
				logger.trace("No result object given - no result to handle");
			}
		}
	}

	@Nullable
	protected Object doInvoke(Object... args) {
		//获取@EventListener注解修饰方法所在的Bean
		Object bean = getTargetBean();
		//将@EventListener注解修饰方法的权限设置可访问
		ReflectionUtils.makeAccessible(this.method);
		try {
			//通过反射执行该方法
			return this.method.invoke(bean, args);
		}
		catch (IllegalArgumentException ex) {
			assertTargetBean(this.method, bean, args);
			throw new IllegalStateException(getInvocationErrorMessage(bean, ex.getMessage(), args), ex);
		}
		catch (IllegalAccessException ex) {
			throw new IllegalStateException(getInvocationErrorMessage(bean, ex.getMessage(), args), ex);
		}
		catch (InvocationTargetException ex) {
			// Throw underlying exception
			Throwable targetException = ex.getTargetException();
			if (targetException instanceof RuntimeException) {
				throw (RuntimeException) targetException;
			}
			else {
				String msg = getInvocationErrorMessage(bean, "Failed to invoke event listener method", args);
				throw new UndeclaredThrowableException(targetException, msg);
			}
		}
	}
	
	// 获取目标类
	protected Object getTargetBean() {
		Assert.notNull(this.applicationContext, "ApplicationContext must no be null");
		return this.applicationContext.getBean(this.beanName);
	}
}
  • 最后面就是触发事件监听了AbstractApplicationContext#publishEvent
public abstract class AbstractApplicationContext extends DefaultResourceLoader
		implements ConfigurableApplicationContext {
	.........省略非必要代码........
	@Override
	public void publishEvent(ApplicationEvent event) {
		publishEvent(event, null);
	}
	/**
	 * Publish the given event to all listeners.
	 * @param event the event to publish (may be an {@link ApplicationEvent}
	 * or a payload object to be turned into a {@link PayloadApplicationEvent})
	 * @param eventType the resolved event type, if known
	 * @since 4.2
	 */
	protected void publishEvent(Object event, @Nullable ResolvableType eventType) {
		Assert.notNull(event, "Event must not be null");

		// 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 {
			// 进入multicastEvent
			getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
		}

		// Publish event via parent context as well...
		if (this.parent != null) {
			if (this.parent instanceof AbstractApplicationContext) {
				((AbstractApplicationContext) this.parent).publishEvent(event, eventType);
			}
			else {
				this.parent.publishEvent(event);
			}
		}
	}
}
  • SimpleApplicationEventMulticaster#multicastEvent->invokeListener->doInvokeListener
	@Override
	public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
		ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
		//获取所有监听器，遍历，广播事件
		for (final ApplicationListener<?> listener : getApplicationListeners(event, type)) {
			//如果自定义实现了SimpleApplicationEventMulticaster类，并设置了线程池
			//则通过线程池异步的广播事件
			Executor executor = getTaskExecutor();
			if (executor != null) {
				executor.execute(() -> invokeListener(listener, event));
			}
			else {
				//未实现线程池，同步的执行广播事件
				invokeListener(listener, event);
			}
		}
	}
	//invokeListener方法，调用此类的doInvokeListener方法
	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);
		}
	}
	
	@SuppressWarnings({"unchecked", "rawtypes"})
	private void doInvokeListener(ApplicationListener listener, ApplicationEvent event) {
		try {
			//由实现了ApplicationListener接口的类执行该方法，这里是
			//ApplicationListenerMethodAdapter类，该方法在上面已经详细讲解过了
			listener.onApplicationEvent(event);
		}
		catch (ClassCastException ex) {
			String msg = ex.getMessage();
			if (msg == null || matchesClassCastMessage(msg, event.getClass())) {
				// Possibly a lambda-defined listener which we could not resolve the generic event type for
				// -> let's suppress the exception and just log a debug message.
				Log logger = LogFactory.getLog(getClass());
				if (logger.isDebugEnabled()) {
					logger.debug("Non-matching event type for listener: " + listener, ex);
				}
			}
			else {
				throw ex;
			}
		}
	}
  • 到这里整个事件监听的方法都已执行完毕，本篇内容为博主的第一篇博客，限于博主知识水平有限，如有错误欢迎大家及时指正，谢谢大家。
SpringBoot 事件发布监听机制使用、分析、注意点 （一篇到位）
默默不代表沉默
11-15 1万+
事件发布监听机制使用、分析、注意点
浅析Spring-kafka源码——消费者模型的实现
WannaRunning的博客
06-17 2842
在使用Spring-kafka时，一般都是通过使用@KafkaListener注解的方法来实现消息监听和消费。今天写一下基于这个注解实现的消费端模型和实现的原理。
Spring事件监听机制
weixiaohuai的博客
01-07 2297
目录 一、概要 二、观察者模式 三、Spring事件监听相关角色 四、Spring事件监听案例 五、Spring事件监听源码剖析 六、总结 一、概要 Spring提供了一套完整的事件发布和监听机制，它在JDK事件监听的基础上进行了一些扩展，并使用IOC容器来管理相关组件，如监听器、事件发布器等，使得用户不需要关心事件发布和监听的具体细节，降低了开发难度。 如果项目中有这样的场景，当一个 Bean 处理完一个任务之后，希望另一个 Bean 知道并能做相应的处理逻辑，这时我们就可以使用Sp
Spring 中的事件监听的实现
blueboz的博客
11-20 2万+
Spring 中的事件监听的实现这里我们不讨论事件监听的机制的原理，我们只讨论如何在项目中实现时间监听。 Spring的事件监听是基于观察者模式。设计开发中。如下类与接口是我们必须要使用的。ApplicationContext首先我们了解一下ApplicationContext，还记得ApplicationContext ac=new ClassPathXmlApplicationContext(
spring 事件执行流程源码解析
lujia_loney的博客
04-08 670
spring事件 观察者模式observer 观察者（Observer）模式的定义：指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。这种模式有时又称作发布-订阅模式、模型-视图模式，它是对象行为型模式。 spring事件机制，mq 都是 观察者模式的实现 spring event 核心类 1、ApplicationEvent 继承自JDK自带的 EventObject, 抽象事件类，自定事件可以继承该类，例如订单创建事件，订单更新事件，由某个动作出发
Spring注解开发——41-42、ApplicationListener事件监听器用法
zongx的博客
03-26 424
41、扩展原理-ApplicationListener用法 ApplicationListener 监听容器中发布的事件。事件驱动模型开发； public interface ApplicationListener<E extends ApplicationEvent> 监听 ApplicationEvent 及其下面的子事件； 步骤： 1）、写一个监听器（Appli...
基于Spring Cloud和ES事件流构建的商城微服务
07-27
基于Spring Cloud和ES事件流构建的商城微服务英文文档Event Sourcing in Microservices Using Spring Cloud and Reactor.pdf
spring 监听器浅析.docx
09-03
本文将对Spring监听器进行深入浅析，包括其工作原理、源码解析以及如何使用。 首先，Spring监听器是基于事件驱动模型的，这种模式在多线程和分布式系统中非常常见。在Spring中，当一个特定的事件发生时，如bean的...
SpringKafka原理解析及源码学习-Spring生态(一)
Java Developer Blog
07-21 6012
Kafka 作为老牌消息中间件, 高吞吐是它的拿手好戏. Spring 的生态中也有官方提供的 spring-kafka.jar. 本文主要学习 Spring 官方提供的 spring-kafka.jar 是怎么实现的. 环境 下面将本文用到的一些环境版本贴出来, Spring Kafka 在 1.X 版本和 2.X 源码上区别还是挺大的. 本文拉取的是当时的最新版. linux kafka server: kafka_2.13-2.7.0(注: 2.13 是 scala version, 2.7.0
Nacos 服务注册注销源码浅析
格物致知，知行合一。
09-11 1836
对 Nacos 注册中心的注册和注销做了简单的源码分析，欢迎阅读斧正。
Spring源码-事件监听机制（@EventListener实现方式）
热门推荐
it_lihongmin的博客
11-06 2万+
在看@EventListener之前需要先知道 继承EventListener方式在底层是怎么实现了，可以参见前一篇博客Spring源码-事件监听机制（实现EventListener接口）。 先梳理一下，首先Ioc容器启动的时候，ApplicationContext的refresh模板方法中，initApplicationEventMulticaster()方法中那个初始化了Sim...
java关于SSO过滤拦截器类实现
aw277866304的博客
01-25 1285
此篇文章主要通过实现javax.servlet.Filter接口，实现对token、地址白名单的过滤拦截功能。 PS：代码中有自定义的一些七七八八的类和代码无需关心，在保证代码不报错的情况下，删减无关的业务代码即可。 1. CommonConstant（常量类） package com.xxx.modules.chunjun.common.constant; public abstract interface CommonConstant { public static final Int
SpringBoot中的SmartInitializingSingleton接口的使用
daxues_的博客
07-12 2547
SmartInitializingSingleton 接口 的常规使用
【Spring源码分析】27-基于注解@Scheduled定时任务实现
通往神秘的道路的专栏
01-05 8543
1、概述 @EnableScheduling启用Spring的定时任务功能，这允许检测容器中@Scheduled注释的bean。执行定时任务还需要一个调度器TaskScheduler，默认情况下，将在容器中搜索一个关联的scheduler定义：要么是一个唯一的TaskScheduler类型的bean，要么是一个bean name是taskScheduler的TaskScheduler。这两种查找...
Spring ApplicationListener
weixin_56594835的博客
07-30 137
在spring 中，一个事件被发布后，当被对应的监听器监听到时，会执行对应的方法。其实该机制就是Observer Pattern (观察者模式) 设计的实现，下面我们通过一个简单的例子进行分析。
Spring 事件监听机制介绍以及源码分析
最新发布
weixin_46619605的博客
03-27 1268
Spring 事件监听机制介绍以及源码分析
Spring源码分析衍生篇六：Spring监听事件
猫吻鱼的博客
06-06 2135
本文是 Spring源码分析：[Spring源码分析六：Spring 的刷新 - refresh()](https://blog.csdn.net/qq_36882793/article/details/106441853) 的衍生文章。主要是因为本人菜鸡，在分析源码的过程中还有一些其他的内容不理解，故开设衍生篇来完善内容以学习。
Spring事件监听器使用
m0_62396648的博客
05-02 1264
Spring事件监听器使用 1.Spring事件监听体系包括三个组件：事件、事件监听器，事件广播器。 事件：定义事件类型和事件源，需要继承ApplicationEvent。 package com.ybe.eventLisitener; import org.springframework.context.ApplicationEvent; public class OrderEvent extends ApplicationEvent { private String name;
Spring源码-事件监听机制（实现EventListener接口）
it_lihongmin的博客
11-06 5890
目录 一、Spring实现自定义事件的发布订阅 1、事件定义 2、事件监听（泛型） 3、模拟事件发送 4、启动项目，调用 127.0.0.1:8080/publishOrderEvent 二、Spring事件驱动原理分析（Spring版本为5.1.7） 1、ApplicationContext委派ApplicationEventPublisher发送事件 2、Application...
Spring ApplicationContext事件监听实现消息队列效果
1. `ApplicationEvent`：这是所有Spring事件的基类，所有自定义事件都应该继承这个类。自定义事件可以携带任何需要的数据，从而允许在事件发布者和监听者之间传递信息。 2. `ApplicationListener`：这是监听应用...
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值