Spring注解系列三十：@EventListener原理

柔光的暖阳◎ 2022-01-14 04:23 431阅读 0赞

一、@EventListener

@Service
    public class UserService {
    	
    	@EventListener(classes={ApplicationEvent.class})
    	public void listen(ApplicationEvent event){
    		System.out.println("UserService。。监听到的事件："+event);
    	}
    
    }

测试：

@Test
    public void test01(){
    	AnnotationConfigApplicationContext applicationContext  = new AnnotationConfigApplicationContext(ExtConfig.class);
    
    	//发布事件；
    	applicationContext.publishEvent(new ApplicationEvent(new String("我发布的时间")){});
    
    	applicationContext.close();
    }

控制台输出：

UserService。。监听到的事件：org.springframework.context.event.ContextRefreshedEvent[source=org.springframework.context.annotation.AnnotationConfigApplicationContext@532760d8: startup date [Sun Jun 16 11:01:47 CST 2019]; root of context hierarchy]

二、@EventListener源码解析  
使用EventListenerMethodProcessor处理器来解析方法上的@EventListener；

public class EventListenerMethodProcessor implements SmartInitializingSingleton, ApplicationContextAware {
    
    	@Override
    	public void afterSingletonsInstantiated() {
    		List<EventListenerFactory> factories = getEventListenerFactories();
    		String[] beanNames = this.applicationContext.getBeanNamesForType(Object.class);
    		for (String beanName : beanNames) {
    			if (!ScopedProxyUtils.isScopedTarget(beanName)) {
    				Class<?> type = null;
    				try {
    					type = AutoProxyUtils.determineTargetClass(this.applicationContext.getBeanFactory(), 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 {
    							type = AutoProxyUtils.determineTargetClass(this.applicationContext.getBeanFactory(),
    									ScopedProxyUtils.getTargetBeanName(beanName));
    						}
    						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 {
    						processBean(factories, beanName, type);
    					}
    					catch (Throwable ex) {
    						throw new BeanInitializationException("Failed to process @EventListener " +
    								"annotation on bean with name '" + beanName + "'", ex);
    					}
    				}
    			}
    		}
    	}
    }

1、ioc容器创建对象并refresh()；

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
    	this();
    	register(annotatedClasses);
    	refresh();
    }

2、finishBeanFactoryInitialization(beanFactory)；初始化剩下的单实例bean；

@Override
    public void refresh() throws BeansException, IllegalStateException {
    	synchronized (this.startupShutdownMonitor) {
    		// Prepare this context for refreshing.
    		prepareRefresh();
    
    		// Tell the subclass to refresh the internal bean factory.
    		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    
    		// Prepare the bean factory for use in this context.
    		prepareBeanFactory(beanFactory);
    
    		try {
    			// Allows post-processing of the bean factory in context subclasses.
    			postProcessBeanFactory(beanFactory);
    
    			// Invoke factory processors registered as beans in the context.
    			invokeBeanFactoryPostProcessors(beanFactory);
    
    			// Register bean processors that intercept bean creation.
    			registerBeanPostProcessors(beanFactory);
    
    			// Initialize message source for this context.
    			initMessageSource();
    
    			// Initialize event multicaster for this context.
    			initApplicationEventMulticaster();
    
    			// Initialize other special beans in specific context subclasses.
    			onRefresh();
    
    			// Check for listener beans and register them.
    			registerListeners();
    
    			// Instantiate all remaining (non-lazy-init) singletons.
    			finishBeanFactoryInitialization(beanFactory);
    
    			// Last step: publish corresponding event.
    			finishRefresh();
    		}
    
    		catch (BeansException ex) {
    			if (logger.isWarnEnabled()) {
    				logger.warn("Exception encountered during context initialization - " +
    						"cancelling refresh attempt: " + ex);
    			}
    
    			// Destroy already created singletons to avoid dangling resources.
    			destroyBeans();
    
    			// Reset 'active' flag.
    			cancelRefresh(ex);
    
    			// Propagate exception to caller.
    			throw ex;
    		}
    
    		finally {
    			// Reset common introspection caches in Spring's core, since we
    			// might not ever need metadata for singleton beans anymore...
    			resetCommonCaches();
    		}
    	}
    }

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(new StringValueResolver() {
    			@Override
    			public String resolveStringValue(String strVal) {
    				return 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();
    
    	// Instantiate all remaining (non-lazy-init) singletons.
    	beanFactory.preInstantiateSingletons();
    }

（1）、先创建所有的单实例bean；getBean()；  
 （2）、获取所有创建好的单实例bean，判断是否是SmartInitializingSingleton类型的；如果是就调用afterSingletonsInstantiated()；

@Override
    public void preInstantiateSingletons() throws BeansException {
    	if (this.logger.isDebugEnabled()) {
    		this.logger.debug("Pre-instantiating singletons in " + this);
    	}
    
    	// Iterate over a copy to allow for init methods which in turn register new bean definitions.
    	// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
    	List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);
    
    	// Trigger initialization of all non-lazy singleton beans...
    	for (String beanName : beanNames) {
    		RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
    		if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
    			if (isFactoryBean(beanName)) {
    				final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
    				boolean isEagerInit;
    				if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
    					isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
    						@Override
    						public Boolean run() {
    							return ((SmartFactoryBean<?>) factory).isEagerInit();
    						}
    					}, getAccessControlContext());
    				}
    				else {
    					isEagerInit = (factory instanceof SmartFactoryBean &&
    							((SmartFactoryBean<?>) factory).isEagerInit());
    				}
    				if (isEagerInit) {
    					getBean(beanName);
    				}
    			}
    			else {
    				getBean(beanName);
    			}
    		}
    	}
    
    	// Trigger post-initialization callback for all applicable beans...
    	for (String beanName : beanNames) {
    		Object singletonInstance = getSingleton(beanName);
    		if (singletonInstance instanceof SmartInitializingSingleton) {
    			final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
    			if (System.getSecurityManager() != null) {
    				AccessController.doPrivileged(new PrivilegedAction<Object>() {
    					@Override
    					public Object run() {
    						smartSingleton.afterSingletonsInstantiated();
    						return null;
    					}
    				}, getAccessControlContext());
    			}
    			else {
    				smartSingleton.afterSingletonsInstantiated();
    			}
    		}
    	}
    }