使用Spring注解@EventListener实现监听原理

package com.cyl.listener;

import org.springframework.context.applicationevent;
import org.springframework.context.payloadapplicationevent;
import org.springframework.context.event.eventlistener;
import org.springframework.stereotype.component;

@component
public class cylorderseclistener {

	@eventlistener
	public void listen(applicationevent event) {
		system.out.println(event);
	}
}

package com.cyl;

import org.springframework.context.annotation.annotationconfigapplicationcontext;

public class test {

	public static void main(string[] args) {
		// 创建一个spring容器
		annotationconfigapplicationcontext context = new annotationconfigapplicationcontext();
		context.register(appconfig.class);
		context.refresh();
    }
}

org.springframework.context.support.postprocessorregistrationdelegate#invokebeanfactorypostprocessors(org.springframework.beans.factory.config.configurablelistablebeanfactory, java.util.list<org.springframework.beans.factory.config.beanfactorypostprocessor>)

org.springframework.beans.factory.support.defaultlistablebeanfactory#preinstantiatesingletons

org.springframework.beans.factory.support.defaultlistablebeanfactory#preinstantiatesingletons

@override
	public void preinstantiatesingletons() throws beansexception {
		if (logger.istraceenabled()) {
			logger.trace("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<>(this.beandefinitionnames);

		// trigger initialization of all non-lazy singleton beans...
		for (string beanname : beannames) {
			// 获取合并后的beandefinition
			rootbeandefinition bd = getmergedlocalbeandefinition(beanname);

			if (!bd.isabstract() && bd.issingleton() && !bd.islazyinit()) {
				if (isfactorybean(beanname)) {
					// 获取factorybean对象
					object bean = getbean(factory_bean_prefix + beanname);
					if (bean instanceof factorybean) {
						factorybean<?> factory = (factorybean<?>) bean;
						boolean iseagerinit;
						if (system.getsecuritymanager() != null && factory instanceof smartfactorybean) {
							iseagerinit = accesscontroller.doprivileged(
									(privilegedaction<boolean>) ((smartfactorybean<?>) factory)::iseagerinit,
									getaccesscontrolcontext());
						}
						else {
							iseagerinit = (factory instanceof smartfactorybean &&
									((smartfactorybean<?>) factory).iseagerinit());
						}
						if (iseagerinit) {
							// 创建真正的bean对象(getobject()返回的对象)
							getbean(beanname);
						}
					}
				}
				else {
					// 创建bean对象
					getbean(beanname);
				}
			}
		}

		// 所有的非懒加载单例bean都创建完了后
		// trigger post-initialization callback for all applicable beans...
		for (string beanname : beannames) {
			object singletoninstance = getsingleton(beanname);
			if (singletoninstance instanceof smartinitializingsingleton) {
				startupstep smartinitialize = this.getapplicationstartup().start("spring.beans.smart-initialize")
						.tag("beanname", beanname);
				smartinitializingsingleton smartsingleton = (smartinitializingsingleton) singletoninstance;
				if (system.getsecuritymanager() != null) {
					accesscontroller.doprivileged((privilegedaction<object>) () -> {
						smartsingleton.aftersingletonsinstantiated();
						return null;
					}, getaccesscontrolcontext());
				}
				else {
					smartsingleton.aftersingletonsinstantiated();
				}
				smartinitialize.end();
			}
		}
	}

org.springframework.context.event.eventlistenermethodprocessor#aftersingletonsinstantiated

@override
	public void aftersingletonsinstantiated() {
		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)) {

				// 拿到当前bean对象的类型
				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 {
                        //关键方法
						processbean(beanname, type);
					}
					catch (throwable ex) {
						throw new beaninitializationexception("failed to process @eventlistener " +
								"annotation on bean with name '" + beanname + "'", ex);
					}
				}
			}
		}
	}

private void processbean(final string beanname, final class<?> targettype) {
		if (!this.nonannotatedclasses.contains(targettype) &&
				annotationutils.iscandidateclass(targettype, eventlistener.class) &&
				!isspringcontainerclass(targettype)) {

			// 找到所有加了@eventlistener注解的方法
			map<method, eventlistener> annotatedmethods = null;
			try {
				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) {
						// 利用eventlistenerfactory来对加了@eventlistener注解的方法生成applicationlistener对象
						if (factory.supportsmethod(method)) {
							method methodtouse = aoputils.selectinvocablemethod(method, context.gettype(beanname));
							applicationlistener<?> applicationlistener =
									factory.createapplicationlistener(beanname, targettype, methodtouse);
							if (applicationlistener instanceof applicationlistenermethodadapter) {
								((applicationlistenermethodadapter) applicationlistener).init(context, this.evaluator);
							}
							context.addapplicationlistener(applicationlistener);
							break;
						}
					}
				}
				if (logger.isdebugenabled()) {
					logger.debug(annotatedmethods.size() + " @eventlistener methods processed on bean '" +
							beanname + "': " + annotatedmethods);
				}
			}
		}
	}