Spring Bean 的初始化是在 Spring 容器 refresh() 时进行的。
Spring 容器 refresh 时会调用 finishBeanFactoryInitialization() 来初始化所有非延迟加载的 bean。
1 org.springframework.context.support.AbstractApplicationContext.refresh() 2 --> org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization // 初始化bean(延迟加载除外) 3 --> org.springframework.beans.factory.config.ConfigurableListableBeanFactory.preInstantiateSingletons() 4 --> org.springframework.beans.factory.support.AbstractBeanFactory.getBean 5 --> org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean 6 --> org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean // 创建 bean(实例化 bean)
1. org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean
1 protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType, @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException { 2 3 final String beanName = transformedBeanName(name); 4 Object bean; 5 6 // Eagerly check singleton cache for manually registered singletons. 7 Object sharedInstance = getSingleton(beanName); 8 if (sharedInstance != null && args == null) { 9 bean = getObjectForBeanInstance(sharedInstance, name, beanName, null); 10 } 11 12 else { 13 // Fail if we're already creating this bean instance: 14 // We're assumably within a circular reference. 15 if (isPrototypeCurrentlyInCreation(beanName)) { 16 throw new BeanCurrentlyInCreationException(beanName); 17 } 18 19 // Check if bean definition exists in this factory. 20 // 在 parentBeanFactory 中如果存在 beanName,则直接返回父容器里面的 bean 21 BeanFactory parentBeanFactory = getParentBeanFactory(); 22 if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { 23 // Not found -> check parent. 24 String nameToLookup = originalBeanName(name); 25 if (parentBeanFactory instanceof AbstractBeanFactory) { 26 return ((AbstractBeanFactory) parentBeanFactory).doGetBean( 27 nameToLookup, requiredType, args, typeCheckOnly); 28 } 29 else if (args != null) { 30 // Delegation to parent with explicit args. 31 return (T) parentBeanFactory.getBean(nameToLookup, args); 32 } 33 else if (requiredType != null) { 34 // No args -> delegate to standard getBean method. 35 return parentBeanFactory.getBean(nameToLookup, requiredType); 36 } 37 else { 38 return (T) parentBeanFactory.getBean(nameToLookup); 39 } 40 } 41 42 if (!typeCheckOnly) { 43 markBeanAsCreated(beanName); 44 } 45 46 try { 47 final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); 48 checkMergedBeanDefinition(mbd, beanName, args); 49 50 // Guarantee initialization of beans that the current bean depends on. 51 // 初始化当前 bean 依赖的 bean 52 String[] dependsOn = mbd.getDependsOn(); 53 if (dependsOn != null) { 54 for (String dep : dependsOn) { 55 if (isDependent(beanName, dep)) { 56 throw new BeanCreationException(mbd.getResourceDescription(), beanName, 57 "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'"); 58 } 59 registerDependentBean(dep, beanName); 60 try { 61 // getBean() 会再递归调用 doGetBean(),以确保所依赖的 bean 全部初始化 62 getBean(dep); 63 } 64 catch (NoSuchBeanDefinitionException ex) { 65 throw new BeanCreationException(mbd.getResourceDescription(), beanName, 66 "'" + beanName + "' depends on missing bean '" + dep + "'", ex); 67 } 68 } 69 } 70 71 // Create bean instance. 72 if (mbd.isSingleton()) { // 单例类型的 bean 73 sharedInstance = getSingleton(beanName, () -> { 74 try { 75 // 创建 bean 的实例 76 return createBean(beanName, mbd, args); 77 } 78 catch (BeansException ex) { 79 // Explicitly remove instance from singleton cache: It might have been put there 80 // eagerly by the creation process, to allow for circular reference resolution. 81 // Also remove any beans that received a temporary reference to the bean. 82 destroySingleton(beanName); 83 throw ex; 84 } 85 }); 86 // 如果 bean 为 FactoryBean 的话,则调用 FactoryBean.getObject() 来创建 bean 实例 87 bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); 88 } 89 90 else if (mbd.isPrototype()) { // 原型类型的 bean 91 // It's a prototype -> create a new instance. 92 Object prototypeInstance = null; 93 try { 94 beforePrototypeCreation(beanName); 95 prototypeInstance = createBean(beanName, mbd, args); 96 } 97 finally { 98 afterPrototypeCreation(beanName); 99 } 100 bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd); 101 } 102 103 else { // 其他 scope 类型的 bean 104 String scopeName = mbd.getScope(); 105 final Scope scope = this.scopes.get(scopeName); 106 if (scope == null) { 107 throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'"); 108 } 109 try { 110 Object scopedInstance = scope.get(beanName, () -> { 111 beforePrototypeCreation(beanName); 112 try { 113 return createBean(beanName, mbd, args); 114 } 115 finally { 116 afterPrototypeCreation(beanName); 117 } 118 }); 119 bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd); 120 } 121 catch (IllegalStateException ex) { 122 throw new BeanCreationException(beanName, 123 "Scope '" + scopeName + "' is not active for the current thread; consider " + 124 "defining a scoped proxy for this bean if you intend to refer to it from a singleton", 125 ex); 126 } 127 } 128 } 129 catch (BeansException ex) { 130 cleanupAfterBeanCreationFailure(beanName); 131 throw ex; 132 } 133 } 134 135 // Check if required type matches the type of the actual bean instance. 136 if (requiredType != null && !requiredType.isInstance(bean)) { 137 try { 138 T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType); 139 if (convertedBean == null) { 140 throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass()); 141 } 142 return convertedBean; 143 } 144 catch (TypeMismatchException ex) { 145 throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass()); 146 } 147 } 148 return (T) bean; 149 }
2. org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean
1 protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) 2 throws BeanCreationException { 3 4 RootBeanDefinition mbdToUse = mbd; 5 6 // Make sure bean class is actually resolved at this point, and 7 // clone the bean definition in case of a dynamically resolved Class 8 // which cannot be stored in the shared merged bean definition. 9 Class<?> resolvedClass = resolveBeanClass(mbd, beanName); 10 if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) { 11 mbdToUse = new RootBeanDefinition(mbd); 12 mbdToUse.setBeanClass(resolvedClass); 13 } 14 15 // Prepare method overrides. 16 try { 17 mbdToUse.prepareMethodOverrides(); 18 } 19 catch (BeanDefinitionValidationException ex) { 20 throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", ex); 21 } 22 23 try { 24 // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance. 25 // BeanPostProcessor 可以创建一个代理 bean 返回 26 // 执行 InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation 27 // 执行 InstantiationAwareBeanPostProcessor.postProcessAfterInitialization 28 Object bean = resolveBeforeInstantiation(beanName, mbdToUse); 29 if (bean != null) { 30 return bean; 31 } 32 } 33 catch (Throwable ex) { 34 throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", ex); 35 } 36 37 try { 38 // 创建 bean 39 Object beanInstance = doCreateBean(beanName, mbdToUse, args); 40 return beanInstance; 41 } 42 catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) { 43 // A previously detected exception with proper bean creation context already, 44 // or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry. 45 throw ex; 46 } 47 catch (Throwable ex) { 48 throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex); 49 } 50 }
3. org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean
1 protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args) throws BeanCreationException { 2 3 // Instantiate the bean. 4 BeanWrapper instanceWrapper = null; 5 if (mbd.isSingleton()) { 6 instanceWrapper = this.factoryBeanInstanceCache.remove(beanName); 7 } 8 if (instanceWrapper == null) { 9 // 创建 bean 的实例:通过默认构造函数反射生成、通过配置的构造函数生成(构造方法注入)、通过 factoryMethod 生成 10 // 最终会生成一个 BeanWrapper 11 instanceWrapper = createBeanInstance(beanName, mbd, args); 12 } 13 final Object bean = instanceWrapper.getWrappedInstance(); 14 Class<?> beanType = instanceWrapper.getWrappedClass(); 15 if (beanType != NullBean.class) { 16 mbd.resolvedTargetType = beanType; 17 } 18 19 // Allow post-processors to modify the merged bean definition. 20 synchronized (mbd.postProcessingLock) { 21 if (!mbd.postProcessed) { 22 try { 23 // 允许 post-processors 修改 bean 的定义 24 // 执行 MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition 25 applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); 26 } 27 catch (Throwable ex) { 28 throw new BeanCreationException(mbd.getResourceDescription(), beanName, 29 "Post-processing of merged bean definition failed", ex); 30 } 31 mbd.postProcessed = true; 32 } 33 } 34 35 // Eagerly cache singletons to be able to resolve circular references 36 // even when triggered by lifecycle interfaces like BeanFactoryAware. 37 boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName)); 38 if (earlySingletonExposure) { 39 if (logger.isTraceEnabled()) { 40 logger.trace("Eagerly caching bean '" + beanName + 41 "' to allow for resolving potential circular references"); 42 } 43 addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); 44 } 45 46 // Initialize the bean instance. 47 Object exposedObject = bean; 48 try { 49 // 填充 bean 属性,处理属性注入:@Value, @Autowired, @Resource 等 50 populateBean(beanName, mbd, instanceWrapper); 51 // 初始化 bean:执行 aware 方法,BeanPostProcessor,初始化方法 52 exposedObject = initializeBean(beanName, exposedObject, mbd); 53 } 54 catch (Throwable ex) { 55 if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) { 56 throw (BeanCreationException) ex; 57 } 58 else { 59 throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex); 60 } 61 } 62 63 if (earlySingletonExposure) { 64 Object earlySingletonReference = getSingleton(beanName, false); 65 if (earlySingletonReference != null) { 66 if (exposedObject == bean) { 67 exposedObject = earlySingletonReference; 68 } 69 else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) { 70 String[] dependentBeans = getDependentBeans(beanName); 71 Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length); 72 for (String dependentBean : dependentBeans) { 73 if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) { 74 actualDependentBeans.add(dependentBean); 75 } 76 } 77 if (!actualDependentBeans.isEmpty()) { 78 throw new BeanCurrentlyInCreationException(beanName, 79 "Bean with name '" + beanName + "' has been injected into other beans [" + 80 StringUtils.collectionToCommaDelimitedString(actualDependentBeans) + 81 "] in its raw version as part of a circular reference, but has eventually been " + 82 "wrapped. This means that said other beans do not use the final version of the " + 83 "bean. This is often the result of over-eager type matching - consider using " + 84 "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example."); 85 } 86 } 87 } 88 } 89 90 // Register bean as disposable. 91 try { 92 registerDisposableBeanIfNecessary(beanName, bean, mbd); 93 } 94 catch (BeanDefinitionValidationException ex) { 95 throw new BeanCreationException( 96 mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex); 97 } 98 99 return exposedObject; 100 }