spring注解驱动:容器创建的原码全过程

BeanFactory创建和预准备

refresh()

这里debug跟踪下spring容器创建的整个过程
首先还是Spring容器的refresh(),创建刷新,进入到refresh()方法里面
先synchronized (this.startupShutdownMonitor) 给这个方法加了线程安全锁
然后是刷新前的预处理

			// Prepare this context for refreshing.
			prepareRefresh();

prepareRefresh();

进入prepareRefresh();
首先是清缓存,然后调用父类的prepareRefresh();

	@Override
	protected void prepareRefresh() {
    
    
		this.scanner.clearCache();
		super.prepareRefresh();
	}

父类的方法中,首先是记录时间,还有记录容器是否关闭,是否活跃等状态,然后打印一些日记

进入到initPropertySources();(初始化一些属性设置)
发现里面是一个空的方法,根据注释可以得出这是留给子类去实现的
子类继承这个类,然后重写这个方法就能自定义个性化的属性设置方法

	/**
	 * <p>Replace any stub property sources with actual instances.
	 * @see org.springframework.core.env.PropertySource.StubPropertySource
	 * @see org.springframework.web.context.support.WebApplicationContextUtils#initServletPropertySources
	 */
	protected void initPropertySources() {
    
    
		// For subclasses: do nothing by default.
	}

下一步是属性的校验工作,就是上面如果自定义了属性,这里就会对属性进行校验,拿到属性校验器来校验

		// Validate that all properties marked as required are resolvable
		// see ConfigurablePropertyResolver#setRequiredProperties
		getEnvironment().validateRequiredProperties();

下一步是
根据注解的意思是创建一个list来收集容器早期的事件,如果以后事件派发器好了之后就将这些事件都派发出去

		// Allow for the collection of early ApplicationEvents,
		// to be published once the multicaster is available...
		this.earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>();

然后prepareRefresh();就是做了这么点的事情

obtainFreshBeanFactory();

下一步是获取BeanFactory

			// Tell the subclass to refresh the internal bean factory.
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

进入obtainFreshBeanFactory();
发现里面有一个refreshBeanFactory();刷新BeanFactory

	protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    
    
		refreshBeanFactory();
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		if (logger.isDebugEnabled()) {
    
    
			logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
		}
		return beanFactory;
	}

进入refreshBeanFactory();
发现里面就已经有了beanFactory,这个方法是在org.springframework.context.support.GenericApplicationContext类里面的
里面的this.beanFactory = new DefaultListableBeanFactory();方法就创建了一个无参的DefaultListableBeanFactory
然后refreshBeanFactory()就给它设置了一个序列号

	@Override
	protected final void refreshBeanFactory() throws IllegalStateException {
    
    
		if (!this.refreshed.compareAndSet(false, true)) {
    
    
			throw new IllegalStateException(
					"GenericApplicationContext does not support multiple refresh attempts: just call 'refresh' once");
		}
		this.beanFactory.setSerializationId(getId());
	}

下一步就是返回刚才创建的beanFactory,然后是整个方法返回这个beanFactory

ConfigurableListableBeanFactory beanFactory = getBeanFactory();

prepareBeanFactory(beanFactory);

下一步是prepareBeanFactory(beanFactory);这个方法,主要是BeanFactory的预准备工作,就是对刚刚创建的BeanFactory进行一些设置
进入prepareBeanFactory(beanFactory);
可以发现就是设置BeanFactory的类加载器
beanFactory.setBeanClassLoader(getClassLoader());
支持表达式的解析器
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
还有添加了部分的BeanPostProcessor
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
然后设置一些忽略的自动装配的接口
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
然后是注册可以解析的自动装配,就是我们能在任何组件中自动注入这些组件
比如有BeanFactory,ResourceLoader,ApplicationEventPublisher,ApplicationContext
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
然后再添加了一个后置处理器
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
然后是添加编译时的AspectJ的支持

		// Detect a LoadTimeWeaver and prepare for weaving, if found.
		if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
    
    
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			// Set a temporary ClassLoader for type matching.
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}

然后下面是给BeanFactory中注册一些能用的组件,比如:
environment[ConfigurableEnvironment类型]
systemProperties[Map<String, Object>类型]
systemEnvironment[Map<String, Object>类型]

		// Register default environment beans.
		if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
    
    
			beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
		}
		if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
    
    
			beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
		}
		if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
    
    
			beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
		}

然后prepareBeanFactory(beanFactory);完美地结束

postProcessBeanFactory(beanFactory);

BeanFactory准备工作完成后进行的后置处理工作,
子类通过重写这个方法在BeanFactory创建和预准备完成以后进一步的设置

创建各种组件

invokeBeanFactoryPostProcessors(beanFactory);

执行BeanFactoryPostProcessors,
BeanFactoryPostProcessors是BeanFactory的后置处理器,在BeanFactory标准初始化之后执行的,而标准初始化就是上面的初始化
BeanFactoryPostProcessors有两个接口

进入invokeBeanFactoryPostProcessors()
首先是getBeanFactoryPostProcessors,但是默认是没有的,返回的是空的值

	public List<BeanFactoryPostProcessor> getBeanFactoryPostProcessors() {
    
    
		return this.beanFactoryPostProcessors;
	}

然后进入invokeBeanFactoryPostProcessors
先是判断是不是BeanDefinitionRegistry,我们创建的DefaultListableBeanFactory就是这个
然后获取所有的beanFactoryPostProcessors,然后再判断是不是BeanDefinitionRegistryPostProcessor类型的后置处理器,如果是就加入到registryProcessors中,如果不是就加入到regularPostProcessors中

然后到下面的
先获取所有的BeanDefinitionRegistryPostProcessor方法
1)先执行实现了PriorityOrdered优先级接口的BeanDefinitionRegistryPostProcessor
然后执行invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
2)再执行实现了Ordered顺序接口的
3)最后执行没有实现任何优先级或是顺序接口的

然后获取BeanFactoryPostProcessor的方法
然后类似上面
1)先执行实现了PriorityOrdered接口的
2)然后执行实现了Ordered顺序接口的
3)最后执行没有实现任何优先级或是顺序接口的

registerBeanPostProcessors(beanFactory);

注册BeanPostProcessor(bean的后置处理器),正如注释一样,是用来拦截bean的创建的

	// Register bean processors that intercept bean creation.
	registerBeanPostProcessors(beanFactory);

BeanPostProcessors有不同的接口类型,不同的接口在bean创建前后执行时机不一样

进入registerBeanPostProcessors(beanFactory);

	/**
	 * Instantiate and invoke all registered BeanPostProcessor beans,
	 * respecting explicit order if given.
	 * <p>Must be called before any instantiation of application beans.
	 */
	protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    
    
		PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
	}

进入registerBeanPostProcessors
可以发现,它首先获取所有的后置处理器的名字,然后统计数量啥的,
然后注册了一个BeanPostProcessorChecker,bean后置处理器的检测器
后置处理器默认可以通过PriorityOrdered,Ordered接口来指定优先级的
然后如果是MergedBeanDefinitionPostProcessor的bean,就放在internalPostProcessors里面
然后是按照优先级,先注册实现了PriorityOrdered的后置处理器
beanFactory.addBeanPostProcessor(postProcessor);
然后注册实现了Ordered接口的
最后注册没有实现任何优先级接口的
然后在最后还重新注册MergedBeanDefinitionPostProcessor的后置处理器

	// Finally, re-register all internal BeanPostProcessors.
	sortPostProcessors(internalPostProcessors, beanFactory);
	registerBeanPostProcessors(beanFactory, internalPostProcessors);

然后还加入了一个ApplicationListenerDetector
在bean创建完成后检查是否是ApplicationListenerDetector,如果是就加入到容器中

/ Re-register post-processor for detecting inner beans as ApplicationListeners,
		// moving it to the end of the processor chain (for picking up proxies etc).
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));

initMessageSource();

由名知意,就是初始化MessageSource组件,这个组件一般用来做国际化功能,消息绑定,消息解析
进入initMessageSource();
可以看出首先获取BeanFactory
然后看容器中是否有一个id是messageSource,类型是MessageSource的组件
如果有就赋值给messageSource,如果没有就自己创建一个DelegatingMessageSource
MessageSource能取出国际化配置文件中的某个key的值,能按照区域信息获取
然后将刚才创建好的MessageSource注册到容器中,然后获取国际化配置文件的值的时候,可以自动注入MessageSource
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);

initApplicationEventMulticaster();

进入initApplicationEventMulticaster();
之前也看过了,这就是初始化事件派发器
首先获取BeanFactory
然后从BeanFactory中获取id是applicationEventMulticaster,类型是ApplicationEventMulticaster的组件
如果没有就自己创建一个SimpleApplicationEventMulticaster
然后将创建好的事件派发器注册到容器之中
beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);

onRefresh();

根据注释可以看出这个方法是留给子容器,就是子类来实现的,子类重写这个方法,在容器刷新的时候可以自定义一些自己花里胡哨的东西

// Initialize other special beans in specific context subclasses.
onRefresh();

registerListeners();

根据注释可以看出是给容器注册ApplicationListener

// Check for listener beans and register them.
registerListeners();

进入registerListeners();
老套路,先getApplicationListeners,就是想获取ApplicationListener
然后再从容器中获取ApplicationListener,然后将这些监听器都添加到事件派发器中
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
然后是派发之前步骤产生的事件

// Publish early application events now that we finally have a multicaster...
		Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
		this.earlyApplicationEvents = null;
		if (earlyEventsToProcess != null) {
    
    
			for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
    
    
				getApplicationEventMulticaster().multicastEvent(earlyEvent);
			}
		}

finishBeanFactoryInitialization(beanFactory);

进入finishBeanFactoryInitialization(beanFactory);
前面都是一些其他的处理,就最后一步是初始化剩下的单实例bean

// Instantiate all remaining (non-lazy-init) singletons.
	beanFactory.preInstantiateSingletons();

进入beanFactory.preInstantiateSingletons();
可以发现首先是获取容器中所有的bean的定义信息
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);

然后判断Bean不是抽象的,是单实例的,是懒加载的,如果上面都符合,就是需要创建的bean
然后再判断是不是FactoryBean,isFactoryBean(beanName)里面的核心代码就是beanInstance instanceof FactoryBean,就是判断是否是实现了FactoryBean接口的bean,如果是工厂bean的话会调用工厂bean对应的创建实例的方法,就是那个getObject()方法
如果不是工厂bean,就调用getBean(beanName);来创建对象
容器中我们有自己想添加的一个car组件,我们来看看它是如何创建的

进入getBean(beanName);这和我们之前使用的getBean是一样的

进入doGetBean(name, null, null, false);
可以发现,首先是获取bean的名字,然后Object sharedInstance = getSingleton(beanName);根据注释// Eagerly check singleton cache for manually registered singletons.是先从缓存中保存的单实例Bean获取,如果能获取到就说明这个Bean之前被创建过,之前也说过所有创建过的单实例Bean都会被缓存起来

我们进入getSingleton(beanName);看一下如何从缓存中拿的

	@Override
	public Object getSingleton(String beanName) {
    
    
		return getSingleton(beanName, true);
	}

进入getSingleton(beanName, true);
它是从singletonObjects中获取的,singletonObjects就是缓存,是一个Map缓存,键值对的方式来保存bean名字和bean对象

/** Cache of singleton objects: bean name --> bean instance */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);

上面当然是从缓存中拿不到,然后开始Bean的创建对象流程
BeanFactory parentBeanFactory = getParentBeanFactory();
想获取父工厂
然后markBeanAsCreated(beanName);标记当前bean已经被创建,为了防止多线程的问题,防止多个线程一起创建这个bean
然后获取bean定义信息
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
然后获取当前bean的依赖的bean
String[] dependsOn = mbd.getDependsOn();
如果有依赖的bean就又调用getBean(dep);来创建依赖的bean
然后就到了真正单实例bean的创建流程
1)createBean(beanName, mbd, args);
createBean里面有一步重要的,根据注释,就是给bean的后置处理器一个拦截的机会来创建代理对象

进入resolveBeforeInstantiation(beanName, mbdToUse);看看是哪一个后置处理器在起作用

我们可以发现是hasInstantiationAwareBeanPostProcessors这个鬼在搞事情
先触发applyBeanPostProcessorsBeforeInstantiation
有返回值的话再触发applyBeanPostProcessorsAfterInitialization
然后到下一步,如果前面的hasInstantiationAwareBeanPostProcessors有返回代理对象就直接返回,如果没有返回,就调用
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
进入doCreateBean,然后进入里面的instanceWrapper = createBeanInstance(beanName, mbd, args);创建bean的实例
进入看看

也是先解析bean的类型,然后

if (mbd.getFactoryMethodName() != null)  {
    
    
	return instantiateUsingFactoryMethod(beanName, mbd, args);
}

利用工厂方法或者对象的构造器创建出Bean实例,
这个工厂方法名的值就是car,就是我们在配置类里面写的方法的名称

进入instantiateUsingFactoryMethod

然后就调用配置类里面写的new Car();

createBeanInstance(beanName, mbd, args);就执行完了,Car实例对象也创建出来了
然后

// Allow post-processors to modify the merged bean definition.
又有后置处理器来工作了
进入applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);

进去发现就是MergedBeanDefinitionPostProcessor在进行工作
调用bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);方法

applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);结束
然后到populateBean(beanName, mbd, instanceWrapper);
就是bean的属性赋值
进入populateBean(beanName, mbd, instanceWrapper);
先获取所有的属性PropertyValues pvs = mbd.getPropertyValues();
然后

拿到InstantiationAwareBeanPostProcessor后置处理器,调用这个后置处理器的postProcessAfterInstantiation方法
然后

拿到InstantiationAwareBeanPostProcessor后置处理器,调用这个后置处理器的postProcessPropertyValues方法
前面都是还没有属性赋值的,到最后的
applyPropertyValues(beanName, mbd, bw, pvs);才真正为属性赋值

现在populateBean(beanName, mbd, instanceWrapper);才结束
现在到initializeBean(beanName, exposedObject, mbd);
就是Bean的初始化
进入initializeBean(beanName, exposedObject, mbd);

首先是执行xxxAware接口的方法
invokeAwareMethods(beanName, bean);

看你是不是BeanNameAware,BeanClassLoaderAware,BeanFactoryAware这些接口,如果是就帮你进行回调
然后又来一个这样的后置处理器
applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
进入

调用BeanPostProcessor.postProcessBeforeInitialization()的方法

现在到了invokeInitMethods(beanName, wrappedBean, mbd);方法
这个是执行bean的初始化方法,就是那些初始化方法,销毁方法之类的
进入

首先判断是不是InitializingBean接口,执行接口规定的方法
然后判断是不是有自定义的初始化方法
String initMethodName = mbd.getInitMethodName();

现在invokeInitMethods(beanName, wrappedBean, mbd);结束
然后到applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);方法
执行后置处理器初始化之后的方法
执行BeanPostProcessor.postProcessAfterInitialization()方法

现在initializeBean(beanName, exposedObject, mbd);终于结束
后面到

// Register bean as disposable.
try {
    
    
	registerDisposableBeanIfNecessary(beanName, bean, mbd);
}

注册bean的销毁方法

现在doCreateBean(beanName, mbdToUse, args);方法终于结束
现在createBean(beanName, mbd, args);终于结束
已经将bean实例创建出来

然后addSingleton(beanName, singletonObject);

就是将创建的bean添加到缓存中,就是singletonObjects
ioc容器就是这些Map,很多的Map里面保存了单实例bean,环境信息之类的

然后
bean已经全部创建完成,遍历所有的bean,检查它们是不是SmartInitializingSingleton接口的,如果是就执行接口的afterSingletonsInstantiated()方法

然后现在beanFactory.preInstantiateSingletons();终于结束
然后现在finishBeanFactoryInitialization(beanFactory);终于完成

finishRefresh();

进入finishRefresh();

initLifecycleProcessor();
初始化和生命周期有关的后置处理器
默认是先在容器中找是否有id是lifecycleProcessor,类型LifecycleProcessor的组件
如果没有就自己创建一个DefaultLifecycleProcessor,然后加入到容器中
这就说明我们可以写一个LifecycleProcessor的实现类,可以在BeanFactory的onRefresh(),onClose();方法执行时进行回调

getLifecycleProcessor().onRefresh();
拿到前面定义的生命周期处理器,BeanFactory的生命周期,回调onRefresh()方法
publishEvent(new ContextRefreshedEvent(this));
发布容器刷新完成事件

容器全部创建完成

/*
 * 容器创建过程的总结:
 * 1.spring容器在启动的时候,先会保存所有注册进来的bean的定义信息
 * 		1)xml注册bean
 * 		2)注解注册bean,@Component,@Bean,......
 * 2.spring容器会在适当的时候创建这些bean
 * 		1)用到的时候利用getbean创建bean,创建好后保存到容器中
 * 		2)统一创建剩下所有的bean的时候
 * 3.核心的后置处理器,BeanPostProcessor
 * 		1)每一个bean创建完成都会使用各种后置处理器进行处理,这样增强bean的功能
 * 				比如AutowiredAnnotationBeanPostProcessor:处理自动注入
 * 					AnnotationAwareAspectJAutoProxyCreator:做AOP功能
 * 					AsyncAnnotationBeanPostProcessor:增强的功能注解
 * 4.事件驱动模型:
 * 		ApplicationListener:事件监听
 * 		ApplicationEventMulticaster:事件派发
 */