国内漂亮网站欣赏企业网站如何找词

当前位置： 首页 > news >正文

国内漂亮网站欣赏,企业网站如何找词,wordpress用户10亿,网站开发的技术可行性怎么写文章目录 7.11 初始化所有剩下的单实例bean对象7.11.1 beanFactory.preInstantiateSingletons7.11.2 getBean7.11.2.1 别名的解析处理7.11.2.2 判断是否已注册过7.11.2.3 创建前的检查7.11.2.4 标记准备创建的bean对象7.11.2.5 合并BeanDefinition7.11.2.6 bean对象的创建7.11.… 文章目录 7.11 初始化所有剩下的单实例bean对象7.11.1 beanFactory.preInstantiateSingletons7.11.2 getBean7.11.2.1 别名的解析处理7.11.2.2 判断是否已注册过7.11.2.3 创建前的检查7.11.2.4 标记准备创建的bean对象7.11.2.5 合并BeanDefinition7.11.2.6 bean对象的创建7.11.2.7 getSingleton控制单实例对象 7.11.3 createBean7.11.3.1 resolveBeforeInstantiation7.11.3.2 doCreateBean1.实例化bean对象1解析bean对象的类型2处理Supplier创建和工厂方法创建3原型Bean的创建优化4实例化bean对象的真实动作 2.属性赋值前的注解信息收集1InitDestroyAnnotationBeanPostProcessor2CommonAnnotationBeanPostProcessor3AutowiredAnnotationBeanPostProcessor 3.早期bean对象引用的获取与缓存4.属性赋值和依赖注入1回调InstantiationAwareBeanPostProcessor2再次回调InstantiationAwareBeanPostProcessor3属性赋值 5.bean对象的初始化1invokeAwareMethods——执行Aware类型接口的回调2applyBeanPostProcessorsBeforeInitialization——执行BeanPostProcessor的前置回调3invokeInitMethods——执行初始化生命周期回调4applyBeanPostProcessorsAfterInitialization——执行BeanPostProcessor的后置回调 6.注册销毁时的回调 7.11.4 SmartInitializingSingleton 前面四节详细梳理了IOC容器刷新的前面十步7.1-7.10以及一个重要的后置处理器ConfigurationClassPostProcessor详见 SpringBoot源码解读与原理分析(二十)IOC容器的刷新(一) SpringBoot源码解读与原理分析(二十一)IOC容器的刷新(二) SpringBoot源码解读与原理分析(二十二)IOC容器的刷新(三)ConfigurationClassPostProcessor SpringBoot源码解读与原理分析(二十三)IOC容器的刷新(四) 这一节继续梳理第十一步7.11。 本文超长预警有1400行。 代码清单1AbstractApplicationContext.javapublic void refresh() throws BeansException, IllegalStateException {synchronized (this.startupShutdownMonitor) {// Prepare this context for refreshing.// 7.1 初始化前的预处理prepareRefresh();// Tell the subclass to refresh the internal bean factory.// 7.2 获取BeanFactory加载所有bean的定义信息未实例化ConfigurableListableBeanFactory beanFactory obtainFreshBeanFactory();// Prepare the bean factory for use in this context.// 7.3 BeanFactory的预处理配置prepareBeanFactory(beanFactory);try {// Allows post-processing of the bean factory in context subclasses.// 7.4 BeanFactory准备工作完成后的后置处理postProcessBeanFactory(beanFactory);// Invoke factory processors registered as beans in the context.// 7.5 BeanFactory创建后的后置处理器的执行invokeBeanFactoryPostProcessors(beanFactory);// Register bean processors that intercept bean creation.// 7.6 初始化Bean的后置处理器registerBeanPostProcessors(beanFactory);// Initialize message source for this context.// 7.7 初始化MessageSourceinitMessageSource();// Initialize event multicaster for this context.// 7.8 初始化事件广播器initApplicationEventMulticaster();// Initialize other special beans in specific context subclasses.// 7.9 子类扩展的刷新动作onRefresh();// Check for listener beans and register them.// 7.10 注册监听器registerListeners();// 至此BeanFactory创建完成// Instantiate all remaining (non-lazy-init) singletons.// 7.11 初始化所有剩下的单实例bean对象finishBeanFactoryInitialization(beanFactory);// Last step: publish corresponding event.// 7.12 完成容器的创建工作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 Springs core, since we// might not ever need metadata for singleton beans anymore…// 7.13 清理缓存resetCommonCaches();}} }7.11 初始化所有剩下的单实例bean对象 // 7.11 初始化所有剩下的单实例bean对象 finishBeanFactoryInitialization(beanFactory);代码清单2AbstractApplicationContext.javaprotected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {// 初始化类型转换器ConversionServiceif (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {beanFactory.setConversionService(beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));}// 注册嵌入式值解析器EmbeddedValueResolverif (!beanFactory.hasEmbeddedValueResolver()) {beanFactory.addEmbeddedValueResolver(strVal - getEnvironment().resolvePlaceholders(strVal));}// 初始化LoadTimeWeaverAwareString[] weaverAwareNames beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);for (String weaverAwareName : weaverAwareNames) {getBean(weaverAwareName);}beanFactory.setTempClassLoader(null);// 冻结配置beanFactory.freezeConfiguration();// 实例化所有非延迟加载的单实例BeanbeanFactory.preInstantiateSingletons(); }由 代码清单2 可知finishBeanFactoryInitialization方法前面的逻辑都是预备性的其逻辑重点在最后一行beanFactory.preInstantiateSingletons实例化所有非延迟加载的单实例Bean。 7.11.1 beanFactory.preInstantiateSingletons 借助IDEA得知preInstantiateSingletons方法在ConfigurableListableBeanFactory中定义最终实现在DefaultListableBeanFactory中。 代码清单3DefaultListableBeanFactory.javaOverride public void preInstantiateSingletons() throws BeansException {// logger…ListString beanNames new ArrayList(this.beanDefinitionNames);for (String beanName : beanNames) {// 先合并BeanDefinitionRootBeanDefinition bd getMergedLocalBeanDefinition(beanName);// 不是抽象的、不是延迟加载的单实例Bean需要初始化if (!bd.isAbstract() bd.isSingleton() !bd.isLazyInit()) {if (isFactoryBean(beanName)) {Object bean getBean(FACTORY_BEAN_PREFIX beanName);// 如果是FactoryBean默认不立即初始化if (bean instanceof FactoryBean) {// FactoryBean的处理逻辑}} else {// 普通的Bean的初始化getBean(beanName);}}}// … }由 代码清单3 可知在初始化所有非延迟加载的单实例bean对象时会根据bean对象的类型分别处理。如果bean对象的类型是FactoryBean会有单独的处理逻辑而初始化普通bean对象时使用的是getBean方法。 7.11.2 getBean 代码清单4AbstractBeanFactory.javaOverride public Object getBean(String name) throws BeansException {return doGetBean(name, null, null, false); }由 代码清单4 可知getBean方法会转调doGetBean方法。doGetBean方法的逻辑复杂下面拆解来看。 7.11.2.1 别名的解析处理 代码清单5AbstractBeanFactory.javaprotected T T doGetBean(String name, Nullable ClassT requiredType, Nullable Object[] args, boolean typeCheckOnly)throws BeansException {// 别名的解析处理String beanName transformedBeanName(name);// ··· }protected String transformedBeanName(String name) {return canonicalName(BeanFactoryUtils.transformedBeanName(name)); }public String canonicalName(String name) {String canonicalName name;// Handle aliasing…String resolvedName;do {// 从别名集合中提取真实的名称resolvedName this.aliasMap.get(canonicalName);if (resolvedName ! null) {canonicalName resolvedName;}}while (resolvedName ! null);return canonicalName; }在使用Bean注解标注在方法上注册bean对象时可以通过设置其name或value属性为bean对象指定名称。而name或value属性可以传入一个数组意味着一个bean对象可以有多个名称默认情况下传入的第一个属性值是bean对象的名称其余的都是别名。 代码清单5 的逻辑就是处理这些别名如果参数name是一个别名则通过transformedBeanName方法转换为真正的名称。 7.11.2.2 判断是否已注册过 代码清单6AbstractBeanFactory.javaprotected T T doGetBean(String name, Nullable ClassT requiredType, Nullable Object[] args, boolean typeCheckOnly)throws BeansException {// ···// 先尝试从已经实例化好的Bean中找有没有当前Bean// 如果能找到说明Bean已经被实例化了直接返回Object sharedInstance getSingleton(beanName);if (sharedInstance ! null args null) {// logger ……bean getObjectForBeanInstance(sharedInstance, name, beanName, null);} else// ··· }protected Object getObjectForBeanInstance(Object beanInstance, String name, String beanName, Nullable RootBeanDefinition mbd) {// …// 如果不是FactoryBean直接返回if (!(beanInstance instanceof FactoryBean)) {return beanInstance;}// …// 如果是FactoryBean则调用getObject方法获取对象object getObjectFromFactoryBean(factory, beanName, !synthetic);return object; }
}由 代码清单6 可知第二步是尝试获取IOC容器中是否已创建并缓存当前正在获取的单实例bean对象如果成功获取到说明Bean已经被实例化了直接返回。getObjectForBeanInstance方法对返回的结果进行分类处理如果获取到的bean对象是一个FactoryBean则进行一些额外处理并通过调用getObject方法获取对象如果是普通的bean对象则直接返回。 7.11.2.3 创建前的检查 如果 代码清单6 中没有获取到bean对象说明当前处理的Bean还未创建即if逻辑判断为false则进入else结构部分开始创建该bean对象。 代码清单7AbstractBeanFactory.javaprotected T T doGetBean(String name, Nullable ClassT requiredType, Nullable Object[] args, boolean typeCheckOnly)throws BeansException {// ···else {// 如果当前创建的bean对象是一个原型Bean并且正在创建抛出异常if (isPrototypeCurrentlyInCreation(beanName)) {throw new BeanCurrentlyInCreationException(beanName);}BeanFactory parentBeanFactory getParentBeanFactory();// 如果当前BeanFactory没有当前bean对象的BeanDefinition// 则通过父级BeanFactory返回if (parentBeanFactory ! null !containsBeanDefinition(beanName)) {// Not found - check parent.String nameToLookup originalBeanName(name);if (parentBeanFactory instanceof AbstractBeanFactory) {return ((AbstractBeanFactory) parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly);} else if (args ! null) {// Delegation to parent with explicit args.return (T) parentBeanFactory.getBean(nameToLookup, args);} else if (requiredType ! null) {// No args - delegate to standard getBean method.return parentBeanFactory.getBean(nameToLookup, requiredType);} else {return (T) parentBeanFactory.getBean(nameToLookup);}}}// ··· }由 代码清单7 可知创建bean对象之前会进行校验判断当前要创建的bean对象是否是一个原型Bean并且已经在创建了如果是说明当前原型Bean在一次获取中将产生两个对象这种现象不合理所以会抛出异常。 第二项校验是判断当前BeanFactory是否包含当前bean对象的BeanDefinition如果没有则通过父级BeanFactory的doGetBean方法或getBean方法返回BeanFactory的层次性的体现。 7.11.2.4 标记准备创建的bean对象 代码清单8AbstractBeanFactory.javaprotected T T doGetBean(String name, Nullable ClassT requiredType, Nullable Object[] args, boolean typeCheckOnly)throws BeansException {// ···else {// …if (!typeCheckOnly) {markBeanAsCreated(beanName);}// …}// ··· }protected void markBeanAsCreated(String beanName) {if (!this.alreadyCreated.contains(beanName)) {synchronized (this.mergedBeanDefinitions) {if (!this.alreadyCreated.contains(beanName)) {clearMergedBeanDefinition(beanName);this.alreadyCreated.add(beanName);}}} }由 代码清单8 可知在确认Bean确需创建之后会对其名称进行标记。markBeanAsCreated方法会将当前正在处理的bean对象的名称放入alreadyCreated集合中代表该bean对象已被创建。 7.11.2.5 合并BeanDefinition 代码清单9AbstractBeanFactory.javaprotected T T doGetBean(String name, Nullable ClassT requiredType, Nullable Object[] args, boolean typeCheckOnly)throws BeansException {// ···else {// …try {// 合并BeanDefinitionRootBeanDefinition mbd getMergedLocalBeanDefinition(beanName);checkMergedBeanDefinition(mbd, beanName, args);// 处理当前bean对象的依赖DependsOn注解String[] dependsOn mbd.getDependsOn();if (dependsOn ! null) {for (String dep : dependsOn) {// 注册并初始化依赖的bean对象registerDependentBean(dep, beanName);try {getBean(dep);} // catch …}}}// …} // catch…}// ··· }由 代码清单9 可知合并BeanDefinition的getMergedLocalBeanDefinition方法可以得到当前正在创建的bean对象需要依赖哪些bean对象也就是在当前创建的bean对象中显式标注了DependsOn注解的属性。 由于标注了DependsOn注解的属性代表强制依赖IOC容器会优先处理这些被强制依赖的bean对象并将其初始化而初始化的方式依然是getBean方法。 7.11.2.6 bean对象的创建 代码清单10AbstractBeanFactory.javaprotected T T doGetBean(String name, Nullable ClassT requiredType, Nullable Object[] args, boolean typeCheckOnly)throws BeansException {// ···else {// …try {// …// 单实例singleton作用域if (mbd.isSingleton()) {// 每次调用createBean返回的都是同一个实例sharedInstance getSingleton(beanName, () - {try {return createBean(beanName, mbd, args);} // catch…});bean getObjectForBeanInstance(sharedInstance, name, beanName, mbd);} // 原型prototype作用域else if (mbd.isPrototype()) {// 每次调用createBean都会创建一个新的实例Object prototypeInstance null;try {beforePrototypeCreation(beanName);prototypeInstance createBean(beanName, mbd, args);} finally {afterPrototypeCreation(beanName);}bean getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);} // 其他作用域else {String scopeName mbd.getScope();// …try {Object scopedInstance scope.get(beanName, () - {beforePrototypeCreation(beanName);try {return createBean(beanName, mbd, args);} finally {afterPrototypeCreation(beanName);}});bean getObjectForBeanInstance(scopedInstance, name, beanName, mbd);} // catch…}} // catch…}// ··· }由 代码清单10 可知经过多步的检查和前置处理之后bean对象终于开始创建。IOC容器会根据当前正在创建的bean对象的作用域单实例singleton作用域、原型prototype作用域或其他决定如何创建对象。 但不管是哪些作用域底层都是调用createBean方法创建对象。不同的是对于单实例singleton作用域每次调用createBean方法返回的都是同一个实例对于原型prototype作用域每次调用createBean方法都会创建一个新的实例。 IOC容器中控制单实例对象的方式是使用getSingleton方法配合ObjectFactory实现的。 7.11.2.7 getSingleton控制单实例对象 代码清单11DefaultSingletonBeanRegistry.javaprivate final MapString, Object singletonObjects new ConcurrentHashMap(256); public Object getSingleton(String beanName, ObjectFactory? singletonFactory) {Assert.notNull(beanName, Bean name must not be null);synchronized (this.singletonObjects) {// 加锁后从缓存集合中提取bean对象实例Object singletonObject this.singletonObjects.get(beanName);if (singletonObject null) {// 如果缓存中没有则创建对象if (this.singletonsCurrentlyInDestruction) {// throw …}if (logger.isDebugEnabled()) {// logger …}beforeSingletonCreation(beanName);boolean newSingleton false;boolean recordSuppressedExceptions (this.suppressedExceptions null);if (recordSuppressedExceptions) {this.suppressedExceptions new LinkedHashSet();}try {// 调用getObject方法就是外层调用createBean方法singletonObject singletonFactory.getObject();newSingleton true;} // catch finally…// 新创建的单实例bean对象存入缓存中if (newSingleton) {addSingleton(beanName, singletonObject);}}return singletonObject;} }由 代码清单11 可知控制单实例bean对象的方式借助一个名为singletonObjects的Map集合充当缓存区在获取单实例bean对象时会先从缓存区中尝试获取如果没有获取到则会调用createBean方法创建对象并保存到singletonObjects缓存中。 简言之单实例bean对象在第一次创建时会调用createBean方法真正地创建对象创建完毕会存入IOC容器底层的singletonObjects缓存区后续再次获取时会直接从缓存区中取出bean对象并返回。 7.11.3 createBean 代码清单12AbstractAutowireCapableBeanFactory.javaprotected Object createBean(String beanName, RootBeanDefinition mbd, Nullable Object[] args)throws BeanCreationException {// logger …}RootBeanDefinition mbdToUse mbd;// 根据BeanDefinition获取当前正在创建的bean对象的类型Class? resolvedClass resolveBeanClass(mbd, beanName);if (resolvedClass ! null !mbd.hasBeanClass() mbd.getBeanClassName() ! null) {mbdToUse new RootBeanDefinition(mbd);mbdToUse.setBeanClass(resolvedClass);}// …try {// 后置处理器BeanPostProcessors拦截创建bean对象Object bean resolveBeforeInstantiation(beanName, mbdToUse);if (bean ! null) {return bean;}} // catch …try {// 真正创建bean对象Object beanInstance doCreateBean(beanName, mbdToUse, args);if (logger.isTraceEnabled()) {logger.trace(Finished creating instance of bean beanName );}return beanInstance;} // catch … }由 代码清单12 可知实际创建bean对象有两个切入点 通过resolveBeforeInstantiation方法创建bean对象由方法名可以理解为“实例化之前的处理”因此这只是创建bean对象之前的拦截。通过doCreateBean方法实际创建bean对象。 7.11.3.1 resolveBeforeInstantiation 代码清单13AbstractAutowireCapableBeanFactory.javaprotected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {Object bean null;if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {// Make sure bean class is actually resolved at this point.if (!mbd.isSynthetic() hasInstantiationAwareBeanPostProcessors()) {Class? targetType determineTargetType(beanName, mbd);if (targetType ! null) {// 执行所有InstantiationAwareBeanPostProcessorbean applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);if (bean ! null) {// 如果成功创建了bean对象则执行所有的BeanPostProcessorsbean applyBeanPostProcessorsAfterInitialization(bean, beanName);}}}mbd.beforeInstantiationResolved (bean ! null);}return bean; }protected Object applyBeanPostProcessorsBeforeInstantiation(Class? beanClass, String beanName) {// 循环找出所有的InstantiationAwareBeanPostProcessorfor (BeanPostProcessor bp : getBeanPostProcessors()) {if (bp instanceof InstantiationAwareBeanPostProcessor) {InstantiationAwareBeanPostProcessor ibp (InstantiationAwareBeanPostProcessor) bp;// 调用其postProcessBeforeInstantiation方法实例化对象Object result ibp.postProcessBeforeInstantiation(beanClass, beanName);if (result ! null) {return result;}}}return null; }Override public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)throws BeansException {Object result existingBean;// 循环找出所有的BeanPostProcessorfor (BeanPostProcessor processor : getBeanPostProcessors()) {// 调用其postProcessAfterInitialization方法增强对象Object current processor.postProcessAfterInitialization(result, beanName);if (current null) {return result;}result current;}return result; }由 代码清单14 可知拦截bean对象的创建行为有两步先执行所有InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation方法创建对象如果成功创建bean对象在执行所有BeanPostProcessors的postProcessAfterInitialization方法增强对象。 以上两个后置处理器的底层逻辑基本一致都是从IOC容器获取到所有注册的后置处理器并逐一回调。 7.11.3.2 doCreateBean 如果resolveBeforeInstantiation方法没有创建出bean对象则需要执行doCreateBean方法创建bean对象的实例。doCreateBean方法的逻辑非常长下面拆解来看。 1.实例化bean对象 代码清单14AbstractAutowireCapableBeanFactory.javaprotected Object doCreateBean(String beanName, RootBeanDefinition mbd, Nullable Object[] args)throws BeanCreationException {// …if (instanceWrapper null) {// 创建bean对象实例instanceWrapper createBeanInstance(beanName, mbd, args);}// 得到bean对象的引用Object bean instanceWrapper.getWrappedInstance();Class? beanType instanceWrapper.getWrappedClass();if (beanType ! NullBean.class) {mbd.resolvedTargetType beanType;}// … }由 代码清单14 可知实例化bean对象是创建对象的第一步即createBeanInstance方法。 1解析bean对象的类型 代码清单15AbstractAutowireCapableBeanFactory.javaprotected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Nullable Object[] args) {// 解析出bean对象的类型Class? beanClass resolveBeanClass(mbd, beanName);// 如果bean对象无法被访问则抛出异常if (beanClass ! null !Modifier.isPublic(beanClass.getModifiers()) !mbd.isNonPublicAccessAllowed()) {throw new BeanCreationException(mbd.getResourceDescription(), beanName,Bean class isnt public, and non-public access not allowed: beanClass.getName());}// … }由 代码清单15 可知createBeanInstance方法首先会检验当前要创建的bean对象所属类型是否可以被正常访问如果不可以则会抛出异常。 2处理Supplier创建和工厂方法创建 代码清单16AbstractAutowireCapableBeanFactory.javaprotected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Nullable Object[] args) {// …//如果制定了实例Supplier则通过Supplier实例化bean对象Supplier? instanceSupplier mbd.getInstanceSupplier();if (instanceSupplier ! null) {return obtainFromSupplier(instanceSupplier, beanName);}// 如果指定了工厂方法则通过工厂方法实例化bean对象if (mbd.getFactoryMethodName() ! null) {return instantiateUsingFactoryMethod(beanName, mbd, args);}// … }/*** Obtain a bean instance from the given supplier.*/ protected BeanWrapper obtainFromSupplier(Supplier? instanceSupplier, String beanName) {由 代码清单16 可知如果BeanDefinition中指定了实例Supplier则通过Supplier实例化bean对象。obtainFromSupplier方法的 javadoc 指出这个方法可以从给定的Supplier中得到bean实例。 如果BeanDefinition中指定了工厂方法则通过工厂方法实例化bean对象。 3原型Bean的创建优化 代码清单17AbstractAutowireCapableBeanFactory.javaprotected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Nullable Object[] args) {// …boolean resolved false;boolean autowireNecessary false;if (args null) {synchronized (mbd.constructorArgumentLock) {if (mbd.resolvedConstructorOrFactoryMethod ! null) {resolved true;autowireNecessary mbd.constructorArgumentsResolved;}}}if (resolved) {if (autowireNecessary) {// 直接从BeanDefinition中取出构造方法以实例化对象return autowireConstructor(beanName, mbd, null, null);}else {// 通过构造方法实例化对象return instantiateBean(beanName, mbd);}}// … }由 代码清单17 可知这一段代码是针对原型Bean而言的在第一次原型bean对象创建完成后将创建过程中引用的构造方法缓存到BeanDefinition中以备后续创建时可以直接取出。 4实例化bean对象的真实动作 代码清单18AbstractAutowireCapableBeanFactory.javaprotected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Nullable Object[] args) {// …// 回调SmartInstantiationAwareBeanPostProcessor寻找构造方法Constructor?[] ctors determineConstructorsFromBeanPostProcessors(beanClass, beanName);// 条件1通过SmartInstantiationAwareBeanPostProcessor找到了构造方法// 条件2配置自动注入方式为AUTOWIRE_CONSTRUCTOR// 条件3使用XML配置文件的方式定义Bean时指定了constructor-arg标签// 条件4调用getBean方法获取bean对象时传入了args参数if (ctors ! null || mbd.getResolvedAutowireMode() AUTOWIRE_CONSTRUCTOR ||mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {// 使用显式构造方法实例化bean对象return autowireConstructor(beanName, mbd, ctors, args);}// 如果BeanDefinition中指定了首选构造函数也使用显式构造方法实例化bean对象ctors mbd.getPreferredConstructors();if (ctors ! null) {return autowireConstructor(beanName, mbd, ctors, null);}// 使用无参数构造方法实例化bean对象return instantiateBean(beanName, mbd); }由 代码清单18 可知当触发一些条件时IOC容器会选择使用显式构造方法实例化bean对象。 条件1通过SmartInstantiationAwareBeanPostProcessor找到了构造方法条件2配置自动注入方式为AUTOWIRE_CONSTRUCTOR条件3使用XML配置文件的方式定义Bean时指定了constructor-arg标签条件4调用getBean方法获取bean对象时传入了args参数条件5BeanDefinition中指定了首选构造函数。 如果以上条件都不满足则会使用默认的无参构造方法创建对象。 代码清单19AbstractAutowireCapableBeanFactory.javaprotected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {try {Object beanInstance;// 借助InstantiationStrategy实例化对象if (System.getSecurityManager() ! null) {beanInstance AccessController.doPrivileged((PrivilegedActionObject) () - getInstantiationStrategy().instantiate(mbd, beanName, this),getAccessControlContext());} else {beanInstance getInstantiationStrategy().instantiate(mbd, beanName, this);}BeanWrapper bw new BeanWrapperImpl(beanInstance);initBeanWrapper(bw);return bw;} // catch … }Override public Object instantiate(RootBeanDefinition bd, Nullable String beanName, BeanFactory owner) {// …return BeanUtils.instantiateClass(constructorToUse); }由 代码清单19 可知instantiateBean的重点在于获取InstantiationStrategy使用BeanUtils.instantiateClass方法反射实例化bean对象。 经过createBeanInstance方法后即可得到一个对象内部没有任何额外注入的bean对象bean对象的实例化完毕。 2.属性赋值前的注解信息收集 回到doCreateBean方法实例化bean对象之后进入属性赋值前的注解信息收集。 代码清单20AbstractAutowireCapableBeanFactory.javaprotected Object doCreateBean(String beanName, RootBeanDefinition mbd, Nullable Object[] args)throws BeanCreationException {// …synchronized (mbd.postProcessingLock) {if (!mbd.postProcessed) {try {applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);} // catch …mbd.postProcessed true;}}// … }protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class? beanType, String beanName) {for (BeanPostProcessor bp : getBeanPostProcessors()) {if (bp instanceof MergedBeanDefinitionPostProcessor) {MergedBeanDefinitionPostProcessor bdp (MergedBeanDefinitionPostProcessor) bp;bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);}} }由 代码清单20 可知核心方法applyMergedBeanDefinitionPostProcessors会回调所有的MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition方法。借助IDEA可知有几个重要的后置处理器实现了该方法。 1InitDestroyAnnotationBeanPostProcessor 代码清单21InitDestroyAnnotationBeanPostProcessor.javaOverride public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class? beanType, String beanName) {LifecycleMetadata metadata findLifecycleMetadata(beanType);metadata.checkConfigMembers(beanDefinition); }private LifecycleMetadata findLifecycleMetadata(Class? clazz) {// …return buildLifecycleMetadata(clazz); }private LifecycleMetadata buildLifecycleMetadata(final Class? clazz) {// …ListLifecycleElement initMethods new ArrayList();ListLifecycleElement destroyMethods new ArrayList();Class? targetClass clazz;do {final ListLifecycleElement currInitMethods new ArrayList();final ListLifecycleElement currDestroyMethods new ArrayList();// 反射所有的public方法ReflectionUtils.doWithLocalMethods(targetClass, method - {// 寻找所有被PostConstruct注解标注的方法if (this.initAnnotationType ! null method.isAnnotationPresent(this.initAnnotationType)) {LifecycleElement element new LifecycleElement(method);currInitMethods.add(element);// logger …}// 寻找所有被PostDestroy注解标注的方法if (this.destroyAnnotationType ! null method.isAnnotationPresent(this.destroyAnnotationType)) {currDestroyMethods.add(new LifecycleElement(method));// logger …}});initMethods.addAll(0, currInitMethods);destroyMethods.addAll(currDestroyMethods);// 依次向上寻找父类targetClass targetClass.getSuperclass();}while (targetClass ! null targetClass ! Object.class);// return … }由 代码清单21 可知postProcessMergedBeanDefinition方法会扫描和收集当前正在创建的bean对象中标注了PostConstruct注解和PostDestroy注解的方法。源码中的initAnnotationType对应PostConstruct注解destroyAnnotationType对应PostDestroy注解。 2CommonAnnotationBeanPostProcessor 代码清单22CommonAnnotationBeanPostProcessor.javaOverride public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class? beanType, String beanName) {// 调用父类InitDestroyAnnotationBeanPostProcessor的postProcessMergedBeanDefinition方法super.postProcessMergedBeanDefinition(beanDefinition, beanType, beanName);InjectionMetadata metadata findResourceMetadata(beanName, beanType, null);metadata.checkConfigMembers(beanDefinition); }private InjectionMetadata findResourceMetadata(String beanName, final Class? clazz, Nullable PropertyValues pvs) {// …metadata buildResourceMetadata(clazz);// … }private InjectionMetadata buildResourceMetadata(final Class? clazz) {// …do {final ListInjectionMetadata.InjectedElement currElements new ArrayList();ReflectionUtils.doWithLocalFields(targetClass, field - {// WebServiceRefif (webServiceRefClass ! null field.isAnnotationPresent(webServiceRefClass)) {if (Modifier.isStatic(field.getModifiers())) {throw new IllegalStateException(WebServiceRef annotation is not supported on static fields);}currElements.add(new WebServiceRefElement(field, field, null));} // EJBelse if (ejbClass ! null field.isAnnotationPresent(ejbClass)) {if (Modifier.isStatic(field.getModifiers())) {throw new IllegalStateException(EJB annotation is not supported on static fields);}currElements.add(new EjbRefElement(field, field, null));} // Resourceelse if (field.isAnnotationPresent(Resource.class)) {if (Modifier.isStatic(field.getModifiers())) {throw new IllegalStateException(Resource annotation is not supported on static fields);}if (!this.ignoredResourceTypes.contains(field.getType().getName())) {currElements.add(new ResourceElement(field, field, null));}}});// …elements.addAll(0, currElements);// 依次向上寻找父类targetClass targetClass.getSuperclass();}while (targetClass ! null targetClass ! Object.class);return InjectionMetadata.forElements(elements, clazz); }由 代码清单22 可知CommonAnnotationBeanPostProcessor的父类是InitDestroyAnnotationBeanPostProcessor所以它也具备收集PostConstruct注解和PostDestroy注解的能力同时还具备收集JSR-250规范中的注解如WebServiceRef、EJB、 Resource的能力。 3AutowiredAnnotationBeanPostProcessor 代码清单23AutowiredAnnotationBeanPostProcessor.javapublic AutowiredAnnotationBeanPostProcessor() {this.autowiredAnnotationTypes.add(Autowired.class);this.autowiredAnnotationTypes.add(Value.class);try {this.autowiredAnnotationTypes.add((Class? extends Annotation)ClassUtils.forName(javax.inject.Inject, AutowiredAnnotationBeanPostProcessor.class.getClassLoader()));logger.trace(JSR-330 javax.inject.Inject annotation found and supported for autowiring);} // catch … }Override public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class? beanType, String beanName) {InjectionMetadata metadata findAutowiringMetadata(beanName, beanType, null);metadata.checkConfigMembers(beanDefinition); }由 代码清单24 可知AutowiredAnnotationBeanPostProcessor具备的能力是收集Autowired、Value、Inject注解收集原理和前面两者后置处理器的原理一致。 3.早期bean对象引用的获取与缓存 回到doCreateBean方法收集完属性赋值前的注解信息之后开始收集早期bean对象引用。 代码清单25AbstractAutowireCapableBeanFactory.javaprotected Object doCreateBean(String beanName, RootBeanDefinition mbd, Nullable Object[] args)throws BeanCreationException {// …boolean earlySingletonExposure (mbd.isSingleton() this.allowCircularReferences isSingletonCurrentlyInCreation(beanName));if (earlySingletonExposure) {if (logger.isTraceEnabled()) {logger.trace(Eagerly caching bean beanName to allow for resolving potential circular references);}// 处理循环依赖的问题addSingletonFactory(beanName, () - getEarlyBeanReference(beanName, mbd, bean));}// … }由 代码清单25 可知bean对象实例化之后虽然没有进行属性赋值和依赖注入但也已经是一个实实在在的对象。如果在此期间有另外的bean对象需要依赖它就不应该再创建一个新的bean对象而是直接获取当前bean对象的引用即可。 这个设计就是为了解决bean对象之间的循环依赖。 4.属性赋值和依赖注入 回到doCreateBean方法处理早期bean对象引用之后开始进行属性赋值和依赖注入。 代码清单26AbstractAutowireCapableBeanFactory.javaprotected Object doCreateBean(String beanName, RootBeanDefinition mbd, Nullable Object[] args)throws BeanCreationException {// …// Initialize the bean instance.Object exposedObject bean;try {// 属性赋值和依赖注入populateBean(beanName, mbd, instanceWrapper);// bean对象的初始化exposedObject initializeBean(beanName, exposedObject, mbd);} // catch …// … }1回调InstantiationAwareBeanPostProcessor 代码清单27AbstractAutowireCapableBeanFactory.javaprotected void populateBean(String beanName, RootBeanDefinition mbd, Nullable BeanWrapper bw) {// 前置检查 …// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the// state of the bean before properties are set. This can be used, for example,// to support styles of field injection.// 在设置属性之前让任何InstantiationAwareBeanPostProcessors都有机会修改// Bean的状态例如支持属性字段的注入。if (!mbd.isSynthetic() hasInstantiationAwareBeanPostProcessors()) {for (BeanPostProcessor bp : getBeanPostProcessors()) {if (bp instanceof InstantiationAwareBeanPostProcessor) {InstantiationAwareBeanPostProcessor ibp (InstantiationAwareBeanPostProcessor) bp;if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {return;}}}}// …由 代码清单27 可知InstantiationAwareBeanPostProcessors是一个可以干预Bean的属性、状态等信息的后置处理器。其postProcessAfterInstantiation方法的返回值是boolean类型当返回false时直接结束populateBean方法不再执行真正的属性赋值组件依赖注入的逻辑。 这样设计的目的在于允许开发者在bean对象已经实例化完毕但还没有开始属性赋值和依赖注入时切入自定义逻辑。 2再次回调InstantiationAwareBeanPostProcessor 代码清单28AbstractAutowireCapableBeanFactory.javaprotected void populateBean(String beanName, RootBeanDefinition mbd, Nullable BeanWrapper bw) {// …for (BeanPostProcessor bp : getBeanPostProcessors()) {if (bp instanceof InstantiationAwareBeanPostProcessor) {InstantiationAwareBeanPostProcessor ibp (InstantiationAwareBeanPostProcessor) bp;PropertyValues pvsToUse ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);// …}}// …由 代码清单28 可知populateBean方法会再一次回调InstantiationAwareBeanPostProcessor但这次调用的是其postProcessProperties方法作用是执行组件的依赖注入。 负责依赖注入的后置处理器是前面提到的AutowiredAnnotationBeanPostProcessor。 代码清单29AutowiredAnnotationBeanPostProcessor.javaOverride public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {InjectionMetadata metadata findAutowiringMetadata(beanName, bean.getClass(), pvs);try {metadata.inject(bean, beanName, pvs);} // catch … }public void inject(Object target, Nullable String beanName, Nullable PropertyValues pvs) throws Throwable {CollectionInjectedElement checkedElements this.checkedElements;// 取出在前面收集的Autowired、Value、Inject注解CollectionInjectedElement elementsToIterate (checkedElements ! null ? checkedElements : this.injectedElements);if (!elementsToIterate.isEmpty()) {// 逐个注入for (InjectedElement element : elementsToIterate) {element.inject(target, beanName, pvs);}} }由 代码清单29 可知在进行依赖注入时首先会取出前面步骤收集的所有标注了Autowired、Value、Inject注解的方法封装为InjectionMetadata并调用其inject方法进行依赖注入。 3属性赋值 代码清单30AbstractAutowireCapableBeanFactory.javaprotected void populateBean(String beanName, RootBeanDefinition mbd, Nullable BeanWrapper bw) {// …PropertyValues pvs (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);// …if (needsDepCheck) {if (filteredPds null) {filteredPds filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);}checkDependencies(beanName, mbd, filteredPds, pvs);}if (pvs ! null) {// 应用PropertyValues对象到当前正在创建的bean对象applyPropertyValues(beanName, mbd, bw, pvs);}由 代码清单30 可知经过前面几个步骤之后生成了一个PropertyValues对象该对象封装了当前正在创建的bean对象中需要依赖的所有属性赋值类元素最后执行的applyPropertyValues方法就是把前面准备好的PropertyValues对象封装的内容应用到当前正在创建的bean对象实例中。 在applyPropertyValues方法内部会将属性值反射注入bean对象的成员属性中。 经过该阶段bean对象的属性赋值和依赖注入工作完成。 5.bean对象的初始化 由 代码清单26 可知属性赋值和依赖注入完成后立刻开始初始化bean对象即initializeBean方法。 代码清单31AbstractAutowireCapableBeanFactory.javaprotected Object initializeBean(String beanName, Object bean, Nullable RootBeanDefinition mbd) {if (System.getSecurityManager() ! null) {AccessController.doPrivileged((PrivilegedActionObject) () - {// 执行Aware类型接口的回调invokeAwareMethods(beanName, bean);return null;}, getAccessControlContext());} else {invokeAwareMethods(beanName, bean);}Object wrappedBean bean;if (mbd null || !mbd.isSynthetic()) {// 执行BeanPostProcessor的前置回调wrappedBean applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);}try {// 执行生命周期回调invokeInitMethods(beanName, wrappedBean, mbd);} // catch …if (mbd null || !mbd.isSynthetic()) {// 执行BeanPostProcessor的后置回调wrappedBean applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);}return wrappedBean; }由 代码清单31 可知initializeBean方法包含4个回调逻辑。 1invokeAwareMethods——执行Aware类型接口的回调 代码清单32AbstractAutowireCapableBeanFactory.javaprivate void invokeAwareMethods(String beanName, Object bean) {if (bean instanceof Aware) {if (bean instanceof BeanNameAware) {((BeanNameAware) bean).setBeanName(beanName);}if (bean instanceof BeanClassLoaderAware) {ClassLoader bcl getBeanClassLoader();if (bcl ! null) {((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);}}if (bean instanceof BeanFactoryAware) {((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);}} }由 代码清单32 可知invokeAwareMethods方法会判断当前bean对象是否实现了特定的Aware接口如果实现了就强转后掉哟个对应的setter方法。 2applyBeanPostProcessorsBeforeInitialization——执行BeanPostProcessor的前置回调 代码清单33AbstractAutowireCapableBeanFactory.javapublic Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)throws BeansException {Object result existingBean;for (BeanPostProcessor processor : getBeanPostProcessors()) {Object current processor.postProcessBeforeInitialization(result, beanName);// 如果一个BeanPostProcessor处理bean对象后返回的结果为null// 则不再执行剩余的BeanPostProcessor// 而直接返回上一个BeanPostProcessor处理之后的bean对象if (current null) {return result;}result current;}return result; }由 代码清单33 可知该回调逻辑是执行BeanPostProcessor的postProcessBeforeInitialization方法。 在这中间有一个特殊的设计如果一个BeanPostProcessor处理bean对象后返回的结果为null则不再执行剩余的BeanPostProcessor而直接返回上一个BeanPostProcessor处理之后的bean对象。这样设计的目的是方便开发者在设计postProcessBeforeInitialization方法时可以通过控制其返回值以进行特殊处理。 下面介绍两个后置处理器实现类。 InitDestroyAnnotationBeanPostProcessor 代码清单34InitDestroyAnnotationBeanPostProcessor.javaOverride public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {// 收集标注了PostConstruct和PreDestroy的方法InitDestroyAnnotationBeanPostProcessor.LifecycleMetadata metadata findLifecycleMetadata(bean.getClass());try {// 执行初始化方法metadata.invokeInitMethods(bean, beanName);} // catch …return bean; }public void invokeInitMethods(Object target, String beanName) throws Throwable {CollectionInitDestroyAnnotationBeanPostProcessor.LifecycleElement checkedInitMethods this.checkedInitMethods;CollectionInitDestroyAnnotationBeanPostProcessor.LifecycleElement initMethodsToIterate (checkedInitMethods ! null ? checkedInitMethods : this.initMethods);if (!initMethodsToIterate.isEmpty()) {for (InitDestroyAnnotationBeanPostProcessor.LifecycleElement element : initMethodsToIterate) {// logger …element.invoke(target);}} }public void invoke(Object target) throws Throwable {ReflectionUtils.makeAccessible(this.method);this.method.invoke(target, (Object[]) null); }由 代码清单34 可知postProcessBeforeInitialization方法首先会收集标注了PostConstruct和PreDestroy的方法收集方法详见【7.11.3.2 2.属性赋值前的注解信息收集 (1)InitDestroyAnnotationBeanPostProcessor】然后回调bean对象中所有标注了PostConstruct注解的方法。 由ReflectionUtils.makeAccessible(this.method);可知反射执行目标方法时会先借助ReflectionUtils获取其访问权这意味着对于使用PostConstruct注解标注的方法的访问修饰符没有强限制。 由this.method.invoke(target, (Object[]) null);可知最终回调方法时传入的参数时空对象这也解释了为什么在使用PostConstruct注解标注方法时一定要设置为空参数方法。 ApplicationContextAwareProcessor 代码清单35ApplicationContextAwareProcessor.javaOverride Nullable public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {// 不是这6个Aware子接口的不予处理if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)){return bean;}// …else {invokeAwareInterfaces(bean);}return bean; }private void invokeAwareInterfaces(Object bean) {if (bean instanceof EnvironmentAware) {((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());}if (bean instanceof EmbeddedValueResolverAware) {((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);}if (bean instanceof ResourceLoaderAware) {((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);}if (bean instanceof ApplicationEventPublisherAware) {((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);}if (bean instanceof MessageSourceAware) {((MessageSourceAware) bean).setMessageSource(this.applicationContext);}if (bean instanceof ApplicationContextAware) {((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);} }由 代码清单35 可知ApplicationContextAwareProcessor支持6个Aware子接口的回调注入否则不予处理。执行Aware子接口时根据不同类型执行setter方法。 3invokeInitMethods——执行初始化生命周期回调 代码清单36AbstractAutowireCapableBeanFactory.javaprotected void invokeInitMethods(String beanName, Object bean, Nullable RootBeanDefinition mbd)throws Throwable {boolean isInitializingBean (bean instanceof InitializingBean);if (isInitializingBean (mbd null || !mbd.isExternallyManagedInitMethod(afterPropertiesSet))) {// …} else {// 回调InitializingBean的afterPropertiesSet方法((InitializingBean) bean).afterPropertiesSet();}}if (mbd ! null bean.getClass() ! NullBean.class) {String initMethodName mbd.getInitMethodName();if (StringUtils.hasLength(initMethodName) !(isInitializingBean afterPropertiesSet.equals(initMethodName)) !mbd.isExternallyManagedInitMethod(initMethodName)) {// 反射回调init-method方法invokeCustomInitMethod(beanName, bean, mbd);}} }由 代码清单36 可知初始化生命周期回调包括init-method方法和InitializingBean接口的初始化逻辑回调。 4applyBeanPostProcessorsAfterInitialization——执行BeanPostProcessor的后置回调 代码清单37AbstractAutowireCapableBeanFactory.javaOverride public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)throws BeansException {Object result existingBean;for (BeanPostProcessor processor : getBeanPostProcessors()) {Object current processor.postProcessAfterInitialization(result, beanName);if (current null) {return result;}result current;}return result; }由 代码清单37 可知回调BeanPostProcessor的后置拦截的逻辑和前置拦截几乎一致。重点关注两个后置处理器的实现。 AbstractAutoProxyCreator 所有以AutoProxyCreator结尾的类都与AOP相关且都是具备代理对象创建能力的后置处理器可以在bean对象本身的初始化逻辑完成后根据需要创建代理对象。 ApplicationListenerDetector ApplicationListenerDetector的作用是关联事件广播器和监听器的引用因此在创建ApplicationListener类型的bean对象时ApplicationListenerDetector会检测并将其添加到ApplicationContext中关联ApplicationEventMulticaster事件广播器。 6.注册销毁时的回调 回到doCreateBean方法bean对象初始化之后最后一步是注册销毁时的回调。 代码清单38AbstractAutowireCapableBeanFactory.javaprotected Object doCreateBean(String beanName, RootBeanDefinition mbd, Nullable Object[] args)throws BeanCreationException {// …try {// 注册销毁时的回调registerDisposableBeanIfNecessary(beanName, bean, mbd);} // catch …// … }protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {AccessControlContext acc (System.getSecurityManager() ! null ? getAccessControlContext() : null);// 不是原型Bean且定义了销毁类型的方法if (!mbd.isPrototype() requiresDestruction(bean, mbd)) {if (mbd.isSingleton()) {// 注册一个执行给定bean对象的所有销毁工作的DisposableBean实现Destruction// 通过实现DisposableBean接口或自定义销毁方法。registerDisposableBean(beanName,new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));} // else…} }由 代码清单38 可知如果一个bean对象的所属类型实现了DisposableBean接口或者内部方法中标注了PreDestory注解或者声明了destory-method方法则会在doCreateBean方法的最后阶段注册一个销毁bean对象的回调钩子在IOC容器关闭时这部分bean对象会回调其自定义的自毁逻辑。 至此doCreateBean方法执行完毕一个bean对象被创建完成并返回。 7.11.4 SmartInitializingSingleton 回到preInstantiateSingletons方法在bean对象创建完成后还有一段额外的逻辑。 代码清单39DefaultListableBeanFactory.javaOverride public void preInstantiateSingletons() throws BeansException {// …for (String beanName : beanNames) {Object singletonInstance getSingleton(beanName);if (singletonInstance instanceof SmartInitializingSingleton) {SmartInitializingSingleton smartSingleton (SmartInitializingSingleton) singletonInstance;if (System.getSecurityManager() ! null) {AccessController.doPrivileged((PrivilegedActionObject) () - {smartSingleton.afterSingletonsInstantiated();return null;}, getAccessControlContext());}else {smartSingleton.afterSingletonsInstantiated();}}} }由 代码清单39 可知如果bean对象实现了SmartInitializingSingleton接口则遍历回调其afterSingletonsInstantiated方法。这实际上是在非延迟加载的单实例bean对象全部创建完成后提供一个统一的扩展回调时机以便在ApplicationContext初始化完成之前处理一些特殊的逻辑。 经过上述一系列复杂逻辑后finishBeanFactoryInitialization方法执行完毕所有非延迟加载的单实例bean对象全部完成创建并初始化。 ······ 至此IOC容器的刷新完成了前面十一步分别是 7.1 初始化前的预处理 7.2 初始化BeanFactory 7.3 BeanFactory的预处理配置 7.4 BeanFactory准备工作完成后的后置处理 7.5 BeanFactory创建后的后置处理器的执行 7.6 初始化Bean的后置处理器 7.7 初始化国际化组件 7.8 初始化事件广播器 7.9 子类扩展的刷新动作 7.10 注册监听器 7.11 初始化所有剩下的单实例bean对象 本节完更多内容请查阅分类专栏SpringBoot源码解读与原理分析