主要关注容器的refresh()方法。
1.BeanFactory预准备
this.prepareRefresh();
protected void prepareRefresh() {
this.startupDate = System.currentTimeMillis();
this.closed.set(false);
this.active.set(true);
if (this.logger.isInfoEnabled()) {
this.logger.info("Refreshing " + this);
}
// 初始化参数设置，方法体是空的，用于子类重写该方法进行属性设置
this.initPropertySources();
// 校验属性的合法性
this.getEnvironment().validateRequiredProperties();
// 用来保存容器中的早期事件
this.earlyApplicationEvents = new LinkedHashSet();
}ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
// 给beanFactory设置了一个序列化id，这里的beanFactory是refresh()方法前的this()调用了AnnotationConfigApplicationContext父类GenericApplicationContext的无参构造创建了一个DefaultListableBeanFactory对象
this.refreshBeanFactory();
// 获取刚才的beanFactory
ConfigurableListableBeanFactory beanFactory = this.getBeanFactory();
if (this.logger.isDebugEnabled()) {
this.logger.debug("Bean factory for " + this.getDisplayName() + ": " + beanFactory);
}
// 将beanFactory返回
return beanFactory;
}this.prepareBeanFactory(beanFactory);
- 设置bean的类加载器，表达式解析器
- 添加BeanPostProcessor(ApplicationContextAwareProcessor)
- 设置忽略的自动装配接口
- 注册可以解析的自动装配，可以在任何组件中自动注入
- 添加BeanPostProcessor(ApplicationListenerDetector)
- 添加编译时AspectJ
- 给BeanFactory中注册组件：environment、systemProperties、systemEnvironment
this.postProcessBeanFactory(beanFactory);
BeanFactory准备工作完成后进行后置处理工作，子类可以通过重写这个方法，在BeanFactory对象创建预准备完成以后做进一步的设置。
2.执行BeanFactoryPostProcessor
this.invokeBeanFactoryPostProcessors(beanFactory);
执行BeanFactoryPostProcessor的方法。
// BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor是后置处理器的两大接口
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
// 获取所有的BeanDefinitionRegistryPostProcessor，并根据实现的接口进行分类，优先执行实现PriorityOrdered接口的，其次实现Ordered接口的，最后是其他的，通过调用invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);来执行，也就是方法里的postProcessor.postProcessBeanDefinitionRegistry(registry);
// 获取所有的BeanFactoryPostProcessor，和上面类似，按照实现的接口进行分类，按照顺序依次执行invokeBeanFactoryPostProcessors()方法里的postProcessor.postProcessBeanFactory(beanFactory);
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, this.getBeanFactoryPostProcessors());
if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean("loadTimeWeaver")) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
}3.注册BeanPostProcessors
this.registerBeanPostProcessors(beanFactory);
注册beanPostProcessor的方法，拦截bean的创建过程。
public static void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
// 获取所有的BeanPostProcessor
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
beanFactory.addBeanPostProcessor(new PostProcessorRegistrationDelegate.BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
// 用于分类存放BeanPostProcessor
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList();
List<BeanPostProcessor> internalPostProcessors = new ArrayList();
List<String> orderedPostProcessorNames = new ArrayList();
List<String> nonOrderedPostProcessorNames = new ArrayList();
String[] var8 = postProcessorNames;
int var9 = postProcessorNames.length;
String ppName;
BeanPostProcessor pp;
// 根据实现接口的不同，分类存放BeanPostProcessor
for(int var10 = 0; var10 < var9; ++var10) {
ppName = var8[var10];
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
pp = (BeanPostProcessor)beanFactory.getBean(ppName, BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
} else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
} else {
nonOrderedPostProcessorNames.add(ppName);
}
}
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 优先注册实现了PriorityOrdered接口的BeanPostProcessor，也就是执行beanFactory.addBeanPostProcessor(postProcessor);将BeanPostProcessor添加到BeanFactory中
registerBeanPostProcessors(beanFactory, (List)priorityOrderedPostProcessors);
List<BeanPostProcessor> orderedPostProcessors = new ArrayList();
Iterator var14 = orderedPostProcessorNames.iterator();
while(var14.hasNext()) {
String ppName = (String)var14.next();
BeanPostProcessor pp = (BeanPostProcessor)beanFactory.getBean(ppName, BeanPostProcessor.class);
orderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
sortPostProcessors(orderedPostProcessors, beanFactory);
// 其次注册实现了Ordered接口的BeanPostProcessor
registerBeanPostProcessors(beanFactory, (List)orderedPostProcessors);
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList();
Iterator var17 = nonOrderedPostProcessorNames.iterator();
while(var17.hasNext()) {
ppName = (String)var17.next();
pp = (BeanPostProcessor)beanFactory.getBean(ppName, BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
// 最后注册没有实现接口的BeanPostProcessor
registerBeanPostProcessors(beanFactory, (List)nonOrderedPostProcessors);
sortPostProcessors(internalPostProcessors, beanFactory);
// 最最后注册internalPostProcessor，也就是MergedBeanDefinitionPostProcessor
registerBeanPostProcessors(beanFactory, (List)internalPostProcessors);
// 注册一个ApplicationListenerDetector
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}4.初始化MessageSource
this.initMessageSource();
初始化MessageSource组件，用来做国际化，消息绑定，消息解析等。
protected void initMessageSource() {
// 获取BeanFactory
ConfigurableListableBeanFactory beanFactory = this.getBeanFactory();
// 判断容器中是否有id为messageSource的组件
if (beanFactory.containsLocalBean("messageSource")) {
// 如果有，赋值给messageSource，常用来取出国际化配置文件中某个key的值，能按照区域信息获取
this.messageSource = (MessageSource)beanFactory.getBean("messageSource", MessageSource.class);
if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
HierarchicalMessageSource hms = (HierarchicalMessageSource)this.messageSource;
if (hms.getParentMessageSource() == null) {
hms.setParentMessageSource(this.getInternalParentMessageSource());
}
}
if (this.logger.isDebugEnabled()) {
this.logger.debug("Using MessageSource [" + this.messageSource + "]");
}
} else {// 如果没有id为messageSource的组件，就创建一个DelegatingMessageSource的组件
DelegatingMessageSource dms = new DelegatingMessageSource();
dms.setParentMessageSource(this.getInternalParentMessageSource());
// 把新建的DelegatingMessageSource组件赋值给messageSource
this.messageSource = dms;
// 把这个组件注册到容器中，后序获取配置文件时候，可以自动注入
beanFactory.registerSingleton("messageSource", this.messageSource);
if (this.logger.isDebugEnabled()) {
this.logger.debug("Unable to locate MessageSource with name 'messageSource': using default [" + this.messageSource + "]");
}
}
}5.初始化事件派发器、监听器等
this.initApplicationEventMulticaster();
初始化事件多播器。
protected void initApplicationEventMulticaster() {
// 获取BeanFactory
ConfigurableListableBeanFactory beanFactory = this.getBeanFactory();
// 检查容器中是否存在id为applicationEventMulticaster的事件多播器
if (beanFactory.containsLocalBean("applicationEventMulticaster")) {
this.applicationEventMulticaster = (ApplicationEventMulticaster)beanFactory.getBean("applicationEventMulticaster", ApplicationEventMulticaster.class);
if (this.logger.isDebugEnabled()) {
this.logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
}
} else {// 如果不存在applicationEventMulticaster，就创建一个SimpleApplicationEventMulticaster，并把它注册到容器中，方便下次获取
this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
beanFactory.registerSingleton("applicationEventMulticaster", this.applicationEventMulticaster);
if (this.logger.isDebugEnabled()) {
this.logger.debug("Unable to locate ApplicationEventMulticaster with name 'applicationEventMulticaster': using default [" + this.applicationEventMulticaster + "]");
}
}
}this.onRefresh();
留给子类做自定义操作。
this.registerListeners();
向容器中注册ApplicationListener对象。
protected void registerListeners() {
Iterator var1 = this.getApplicationListeners().iterator();
while(var1.hasNext()) {
ApplicationListener<?> listener = (ApplicationListener)var1.next();
this.getApplicationEventMulticaster().addApplicationListener(listener);
}
// 获取所有的ApplicationListener组件
String[] listenerBeanNames = this.getBeanNamesForType(ApplicationListener.class, true, false);
String[] var7 = listenerBeanNames;
int var3 = listenerBeanNames.length;
for(int var4 = 0; var4 < var3; ++var4) {
String listenerBeanName = var7[var4];
// 将Listener添加到ApplicationEventMulticaster中
this.getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
}
Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
this.earlyApplicationEvents = null;
if (earlyEventsToProcess != null) {
Iterator var9 = earlyEventsToProcess.iterator();
while(var9.hasNext()) {
ApplicationEvent earlyEvent = (ApplicationEvent)var9.next();
// 派发之前步骤产生的事件
this.getApplicationEventMulticaster().multicastEvent(earlyEvent);
}
}
}6.创建Bean准备
this.finishBeanFactoryInitialization(beanFactory);
初始化所有的单实例Bean，完成所有Bean的初始化工作。
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// 类型转换组件相关
if (beanFactory.containsBean("conversionService") && beanFactory.isTypeMatch("conversionService", ConversionService.class)) {
beanFactory.setConversionService((ConversionService)beanFactory.getBean("conversionService", ConversionService.class));
}
// 嵌入式值解析器相关
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(new StringValueResolver() {
public String resolveStringValue(String strVal) {
return AbstractApplicationContext.this.getEnvironment().resolvePlaceholders(strVal);
}
});
}
// AspectJ相关
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
String[] var3 = weaverAwareNames;
int var4 = weaverAwareNames.length;
for(int var5 = 0; var5 < var4; ++var5) {
String weaverAwareName = var3[var5];
this.getBean(weaverAwareName);
}
beanFactory.setTempClassLoader((ClassLoader)null);
beanFactory.freezeConfiguration();
// 初始化剩余的单实例bean
beanFactory.preInstantiateSingletons();
}在preInstantiateSingletons()方法中，获取容器中的所有Bean依次进行初始化和创建对象。判断是否是FactoryBean，也就是看当前bean是否实现了FactoryBean接口，如果是，就会通过FactoryBean的getObject()方法创建对象，否则，通过this.getBean()创建对象，getBean()方法会调用doGetBean()方法。
protected <T> T doGetBean(String name, Class<T> requiredType, final Object[] args, boolean typeCheckOnly) throws BeansException {
final String beanName = this.transformedBeanName(name);
// 先尝试从缓存中获取Bean对象
Object sharedInstance = this.getSingleton(beanName);
Object bean;
if (sharedInstance != null && args == null) {
if (this.logger.isDebugEnabled()) {
if (this.isSingletonCurrentlyInCreation(beanName)) {
this.logger.debug("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference");
} else {
this.logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
}
}
bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);
} else {// 缓存中没有获取到，下面开始创建Bean对象
if (this.isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// 先获取BeanFactory，通过BeanFactory进行创建
BeanFactory parentBeanFactory = this.getParentBeanFactory();
if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {
String nameToLookup = this.originalBeanName(name);
if (args != null) {
return parentBeanFactory.getBean(nameToLookup, args);
}
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
// 先将当前Bean标记为已创建，避免多线程情况下重复创建Bean对象
if (!typeCheckOnly) {
this.markBeanAsCreated(beanName);
}
try {
// 获取Bean的定义信息
final RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
this.checkMergedBeanDefinition(mbd, beanName, args);
// 获取Bean的依赖信息
String[] dependsOn = mbd.getDependsOn();
String[] var11;
if (dependsOn != null) {
var11 = dependsOn;
int var12 = dependsOn.length;
for(int var13 = 0; var13 < var12; ++var13) {
String dep = var11[var13];
if (this.isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
this.registerDependentBean(dep, beanName);
// 如果有依赖的Bean，那么就先获取依赖的Bean，这里又会调用doGetBean()，是一个递归的过程
this.getBean(dep);
}
}
if (mbd.isSingleton()) {
// 通过getSingleton()方法创建单实例Bean对象，实际上是调用了createBean()方法创建
sharedInstance = this.getSingleton(beanName, new ObjectFactory<Object>() {
public Object getObject() throws BeansException {
try {
return AbstractBeanFactory.this.createBean(beanName, mbd, args);
} catch (BeansException var2) {
AbstractBeanFactory.this.destroySingleton(beanName);
throw var2;
}
}
});
bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
} else if (mbd.isPrototype()) {
var11 = null;
Object prototypeInstance;
try {
this.beforePrototypeCreation(beanName);
prototypeInstance = this.createBean(beanName, mbd, args);
} finally {
this.afterPrototypeCreation(beanName);
}
bean = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
} else {
String scopeName = mbd.getScope();
Scope scope = (Scope)this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
public Object getObject() throws BeansException {
AbstractBeanFactory.this.beforePrototypeCreation(beanName);
Object var1;
try {
var1 = AbstractBeanFactory.this.createBean(beanName, mbd, args);
} finally {
AbstractBeanFactory.this.afterPrototypeCreation(beanName);
}
return var1;
}
});
bean = this.getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
} catch (IllegalStateException var21) {
throw new BeanCreationException(beanName, "Scope '" + scopeName + "' is not active for the current thread; consider defining a scoped proxy for this bean if you intend to refer to it from a singleton", var21);
}
}
} catch (BeansException var23) {
this.cleanupAfterBeanCreationFailure(beanName);
throw var23;
}
}createBean()方法。
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
Class<?> resolvedClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
try {
mbdToUse.prepareMethodOverrides();
} catch (BeanDefinitionValidationException var7) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", var7);
}
Object beanInstance;
try {
// 让BeanPostProcessor拦截代理对象，看它能否返回一个代理对象
beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
if (beanInstance != null) {
return beanInstance;
}
} catch (Throwable var8) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", var8);
}
// 如果没有返回代理对象，那么，执行doCreateBean()方法
beanInstance = this.doCreateBean(beanName, mbdToUse, args);
if (this.logger.isDebugEnabled()) {
this.logger.debug("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}resolveBeforeInstantiation()方法，此时的BeanPostProcessor是InstantiationAwareBeanPostProcessor。
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
Object bean = null;
if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
if (!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) {
Class<?> targetType = this.determineTargetType(beanName, mbd);
if (targetType != null) {
// 先触发applyBeanPostProcessorsBeforeInstantiation()方法
bean = this.applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
// 后触发applyBeanPostProcessorsAfterInitialization()方法
bean = this.applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
mbd.beforeInstantiationResolved = bean != null;
}
return bean;
}7.Bean创建完成
doCreateBean()方法。
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
// 创建Bean实例
instanceWrapper = this.createBeanInstance(beanName, mbd, args);
}
final Object bean = instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null;
Class<?> beanType = instanceWrapper != null ? instanceWrapper.getWrappedClass() : null;
mbd.resolvedTargetType = beanType;
synchronized(mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
// 调用MergedBeanDefinitionPostProcessor对象的postProcessMergedBeanDefinition()方法
this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
} catch (Throwable var17) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", var17);
}
mbd.postProcessed = true;
}
}
// 是否需要提前暴露
boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
if (earlySingletonExposure) {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
}
this.addSingletonFactory(beanName, new ObjectFactory<Object>() {
public Object getObject() throws BeansException {
return AbstractAutowireCapableBeanFactory.this.getEarlyBeanReference(beanName, mbd, bean);
}
});
}
Object exposedObject = bean;
try {
// 给bean的属性赋值，拿到InstantiationAwareBeanPostProcessor，执行postProcessAfterInstantiation()方法，后面又执行postProcessPropertyValues()方法，最后通过applyPropertyValues()方法，利用反射给属性赋值
this.populateBean(beanName, mbd, instanceWrapper);
if (exposedObject != null) {
// 初始化Bean
exposedObject = this.initializeBean(beanName, exposedObject, mbd);
}
} catch (Throwable var18) {
if (var18 instanceof BeanCreationException && beanName.equals(((BeanCreationException)var18).getBeanName())) {
throw (BeanCreationException)var18;
}
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", var18);
}
if (earlySingletonExposure) {
// 获取单实例bean
Object earlySingletonReference = this.getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
} else if (!this.allowRawInjectionDespiteWrapping && this.hasDependentBean(beanName)) {
String[] dependentBeans = this.getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet(dependentBeans.length);
String[] var12 = dependentBeans;
int var13 = dependentBeans.length;
for(int var14 = 0; var14 < var13; ++var14) {
String dependentBean = var12[var14];
if (!this.removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
if (!actualDependentBeans.isEmpty()) {
throw new BeanCurrentlyInCreationException(beanName, "Bean with name '" + beanName + "' has been injected into other beans [" + StringUtils.collectionToCommaDelimitedString(actualDependentBeans) + "] in its raw version as part of a circular reference, but has eventually been wrapped. This means that said other beans do not use the final version of the bean. This is often the result of over-eager type matching - consider using 'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
try {
// 注册Bean的销毁方法
this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
return exposedObject;
} catch (BeanDefinitionValidationException var16) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", var16);
}
}initializeBean()方法。
protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged(new PrivilegedAction<Object>() {
public Object run() {
AbstractAutowireCapableBeanFactory.this.invokeAwareMethods(beanName, bean);
return null;
}
}, this.getAccessControlContext());
} else {// 执行invokeAwareMethods()方法
this.invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
// 执行applyBeanPostProcessorsBeforeInitialization()方法，也就让所有的后置处理器执行postProcessBeforeInitialization()方法
wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);
}
try {
// 执行invokeInitMethods()方法，回调bean的自定义初始化方法
this.invokeInitMethods(beanName, wrappedBean, mbd);
} catch (Throwable var6) {
throw new BeanCreationException(mbd != null ? mbd.getResourceDescription() : null, beanName, "Invocation of init method failed", var6);
}
if (mbd == null || !mbd.isSynthetic()) {
// 执行applyBeanPostProcessorsAfterInitialization()方法，也就让所有的后置处理器执行postProcessAfterInitialization()方法
wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}8.容器创建完成
preInstantiateSingletons()方法中，创建完成bean之后，判断bean是否实现了SmartInitializingSingleton接口，如果实现了，就执行smartSingleton.afterSingletonsInstantiated()方法。
this.finishRefresh();
完成BeanFactory的初始化创建工作，IOC容器创建完成。
protected void finishRefresh() {
// 初始化和生命周期有关的后置处理器，查看容器中是否有id为lifecycleProcessor的组件，如果有，可以执行它的onRefresh()和onClose()方法，如果没有，就创建一个DefaultLifecycleProcessor组件添加到容器中
this.initLifecycleProcessor();
// 拿到声明周期处理器回调onRefresh()
this.getLifecycleProcessor().onRefresh();
// 发布容器刷新完成的事件
this.publishEvent((ApplicationEvent)(new ContextRefreshedEvent(this)));
LiveBeansView.registerApplicationContext(this);
}9.总结
Spring容器在启动的时候，先保存所有注册进来的Bean定义信息，可以通过xml注册，也可以通过注解注册。
Spring选择合适的时机创建这些Bean，有些Bean是在用到的时候进行创建，有些Bean是统一进行创建。
Bean创建完成后，检查是否需要后置处理器进行处理，来增强Bean的功能。
AutowiredAnnotationBeanPostProcessor处理自动注入功能；AnnotationAwareAspectJAutoProxyCreator处理AOP功能。
ApplicationListener：事件监听；ApplicationEventMulticaster：事件派发。
扫一扫
206
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
