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
0. pre: 如果 bean 已经注册过，就从缓存中获取 bean 的实例
1. 在 parentBeanFactory 中如果存在 beanName，则直接返回父容器里面的 bean
2. 初始化当前 bean 依赖的 bean
3. 创建 bean 的实例
3.1 单例类型的 bean 创建
3.2 原型类型的 bean 创建
3.3 其他 scope 类型（request、session等）的 bean 创建
4. 将新创建的 bean 的实例保存到缓存 singletonObjects 中
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 // 从缓存中获取 bean 的实例（已经注册过的 bean 都保存在 singletonObjects 中） 8 Object sharedInstance = getSingleton(beanName); 9 if (sharedInstance != null && args == null) { 10 bean = getObjectForBeanInstance(sharedInstance, name, beanName, null); 11 } else { 12 13 // Check if bean definition exists in this factory. 14 // 1. 在 parentBeanFactory 中如果存在 beanName，则直接返回父容器里面的 bean 15 BeanFactory parentBeanFactory = getParentBeanFactory(); 16 if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { 17 // Not found -> check parent. 18 String nameToLookup = originalBeanName(name); 19 if (parentBeanFactory instanceof AbstractBeanFactory) { 20 return ((AbstractBeanFactory) parentBeanFactory).doGetBean( 21 nameToLookup, requiredType, args, typeCheckOnly); 22 } else if (args != null) { 23 // Delegation to parent with explicit args. 24 return (T) parentBeanFactory.getBean(nameToLookup, args); 25 } else if (requiredType != null) { 26 // No args -> delegate to standard getBean method. 27 return parentBeanFactory.getBean(nameToLookup, requiredType); 28 } else { 29 return (T) parentBeanFactory.getBean(nameToLookup); 30 } 31 } 32 33 try { 34 final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); 35 checkMergedBeanDefinition(mbd, beanName, args); 36 37 // Guarantee initialization of beans that the current bean depends on. 38 // 2. 初始化当前 bean 依赖的 bean 39 String[] dependsOn = mbd.getDependsOn(); 40 if (dependsOn != null) { 41 for (String dep : dependsOn) { 42 if (isDependent(beanName, dep)) { 43 throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'"); 44 } 45 registerDependentBean(dep, beanName); 46 try { 47 // getBean() 会再递归调用 doGetBean()，以确保所依赖的 bean 全部初始化 48 getBean(dep); 49 } 50 catch (NoSuchBeanDefinitionException ex) { 51 throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", ex); 52 } 53 } 54 } 55 56 // Create bean instance. 57 // 3. 创建 bean 的实例 58 if (mbd.isSingleton()) { // 单例类型的 bean 59 sharedInstance = getSingleton(beanName, () -> { 60 try { 61 // 创建 bean 的实例 62 return createBean(beanName, mbd, args); 63 } catch (BeansException ex) { 64 destroySingleton(beanName); 65 throw ex; 66 } 67 }); 68 // 如果 bean 为 FactoryBean 的话，则调用 FactoryBean.getObject() 来创建 bean 实例 69 bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); 70 } else if (mbd.isPrototype()) { // 原型类型的 bean 71 // It's a prototype -> create a new instance. 72 Object prototypeInstance = null; 73 try { 74 beforePrototypeCreation(beanName); 75 prototypeInstance = createBean(beanName, mbd, args); 76 } finally { 77 afterPrototypeCreation(beanName); 78 } 79 bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd); 80 } else { // 其他 scope 类型的 bean 81 String scopeName = mbd.getScope(); 82 final Scope scope = this.scopes.get(scopeName); 83 if (scope == null) { 84 throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'"); 85 } 86 try { 87 Object scopedInstance = scope.get(beanName, () -> { 88 beforePrototypeCreation(beanName); 89 try { 90 return createBean(beanName, mbd, args); 91 } finally { 92 afterPrototypeCreation(beanName); 93 } 94 }); 95 bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd); 96 } catch (IllegalStateException ex) { 97 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", ex); 98 } 99 } 100 } 101 catch (BeansException ex) { 102 cleanupAfterBeanCreationFailure(beanName); 103 throw ex; 104 } 105 } 106 107 ...... 108 return (T) bean; 109 }
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 7 // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance. 8 // BeanPostProcessor 可以创建一个代理 bean 返回 9 // 执行 InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation -- bean 实例化前置处理 10 // 执行 InstantiationAwareBeanPostProcessor.postProcessAfterInitialization -- bean 初始化后置处理 11 Object bean = resolveBeforeInstantiation(beanName, mbdToUse); 12 if (bean != null) { 13 return bean; 14 } 15 16 // 创建 bean 17 Object beanInstance = doCreateBean(beanName, mbdToUse, args); 18 return beanInstance; 19 }
代理 bean 是通过 AbstractAutoProxyCreator 来创建的：
org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator.postProcessBeforeInstantiation(Class<?> beanClass, String beanName)
1 public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) { 2 Object cacheKey = getCacheKey(beanClass, beanName); 3 4 if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) { 5 if (this.advisedBeans.containsKey(cacheKey)) { 6 return null; 7 } 8 if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) { 9 this.advisedBeans.put(cacheKey, Boolean.FALSE); 10 return null; 11 } 12 } 13 14 // Create proxy here if we have a custom TargetSource. 15 // Suppresses unnecessary default instantiation of the target bean: 16 // The TargetSource will handle target instances in a custom fashion. 17 TargetSource targetSource = getCustomTargetSource(beanClass, beanName); 18 if (targetSource != null) { 19 if (StringUtils.hasLength(beanName)) { 20 this.targetSourcedBeans.add(beanName); 21 } 22 Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource); 23 Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource); 24 this.proxyTypes.put(cacheKey, proxy.getClass()); 25 return proxy; 26 } 27 28 return null; 29 }
org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator.postProcessAfterInitialization(@Nullable Object bean, String beanName)
1 /** 2 * Create a proxy with the configured interceptors if the bean is 3 * identified as one to proxy by the subclass. 4 * @see #getAdvicesAndAdvisorsForBean 5 */ 6 @Override 7 public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) { 8 if (bean != null) { 9 Object cacheKey = getCacheKey(bean.getClass(), beanName); 10 if (this.earlyProxyReferences.remove(cacheKey) != bean) { 11 return wrapIfNecessary(bean, beanName, cacheKey); 12 } 13 } 14 return bean; 15 } 16 17 protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) { 18 if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) { 19 return bean; 20 } 21 if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) { 22 return bean; 23 } 24 if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) { 25 this.advisedBeans.put(cacheKey, Boolean.FALSE); 26 return bean; 27 } 28 29 // Create proxy if we have advice. 30 Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null); 31 if (specificInterceptors != DO_NOT_PROXY) { 32 this.advisedBeans.put(cacheKey, Boolean.TRUE); 33 Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean)); 34 this.proxyTypes.put(cacheKey, proxy.getClass()); 35 return proxy; 36 } 37 38 this.advisedBeans.put(cacheKey, Boolean.FALSE); 39 return bean; 40 }
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 6 if (instanceWrapper == null) { 7 // 创建 bean 的实例：通过默认构造函数反射生成、通过配置的构造函数生成（构造方法注入）、通过 factoryMethod 生成 8 // 最终会生成一个 BeanWrapper 9 instanceWrapper = createBeanInstance(beanName, mbd, args); 10 } 11 final Object bean = instanceWrapper.getWrappedInstance(); 12 Class<?> beanType = instanceWrapper.getWrappedClass(); 13 14 // Allow post-processors to modify the merged bean definition. 15 // 允许 post-processors 修改 bean 的定义 16 synchronized (mbd.postProcessingLock) { 17 if (!mbd.postProcessed) { 18 // 执行 MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition 19 applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); 20 mbd.postProcessed = true; 21 } 22 } 23 24 // Eagerly cache singletons to be able to resolve circular references 25 // even when triggered by lifecycle interfaces like BeanFactoryAware. 26 boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName)); 27 if (earlySingletonExposure) { 28 // 解决循环依赖相关 29 addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); 30 } 31 32 // Initialize the bean instance. 33 Object exposedObject = bean; 34 try { 35 // 填充 bean 属性，处理属性注入：@Value, @Autowired, @Resource 等 36 populateBean(beanName, mbd, instanceWrapper); 37 // 初始化 bean：执行 aware 方法 --> BeanPostProcessor --> 初始化方法 --> afterPropertiesSet() 38 exposedObject = initializeBean(beanName, exposedObject, mbd); 39 } catch (Throwable ex) { 40 if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) { 41 throw (BeanCreationException) ex; 42 } 43 else { 44 throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex); 45 } 46 } 47 48 ...... 49 50 return exposedObject; 51 }