@Override @Nullable public Object getSingleton(String beanName) { return getSingleton(beanName, true); } /** * singletonObjects 缓存：beanName -> 单例 bean 对象。 * earlySingletonObjects 缓存：beanName -> 单例 bean 对象，该缓存存放的是早期单例 bean 对象，可以理解成还未进行属性填充、初始化。 * singletonFactories 缓存：beanName -> ObjectFactory。 * singletonsCurrentlyInCreation 缓存：当前正在创建单例 bean 对象的 beanName 集合。 * singletonObjects、earlySingletonObjects、singletonFactories 在这边构成了一个类似于 “三级缓存” 的概念。 */ @Nullable protected Object getSingleton(String beanName, boolean allowEarlyReference) { // 1.【从一级缓存里面获取】从单例对象缓存中获取beanName对应的单例对象 Object singletonObject = this.singletonObjects.get(beanName); if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) { // 3.加锁进行操作 synchronized (this.singletonObjects) {// 4.【从二级缓存里面获取】从早期单例对象缓存中获取单例对象 // 之所称成为早期单例对象，是因为earlySingletonObjects里的对象的都是通过提前曝光的ObjectFactory创建出来的，还未进行属性填充等操作 singletonObject = this.earlySingletonObjects.get(beanName); // 5.如果在早期单例对象缓存中也没有，并且允许创建早期单例对象引用 if (singletonObject == null && allowEarlyReference) {// 6.【从三级缓存里面获取】从单例工厂缓存中获取beanName的单例工厂 ObjectFactory singletonFactory = this.singletonFactories.get(beanName); if (singletonFactory != null) {// 7.如果存在单例对象工厂，则通过工厂创建一个单例对象 singletonObject = singletonFactory.getObject(); // 8.将通过单例对象工厂创建的单例对象，放到早期单例对象缓存中 this.earlySingletonObjects.put(beanName, singletonObject); // 9.移除该beanName对应的单例对象工厂，因为该单例工厂已经创建了一个实例对象，并且放到earlySingletonObjects缓存了， // 因此，后续获取beanName的单例对象，可以通过earlySingletonObjects缓存拿到，不需要在用到该单例工厂 this.singletonFactories.remove(beanName); } } } } return singletonObject; }

/** * 真正创建bean的方法 */ protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args) throws BeanCreationException {// 封装被创建的bean对象 BeanWrapper instanceWrapper = null; if (mbd.isSingleton()) { instanceWrapper = this.factoryBeanInstanceCache.remove(beanName); } if (instanceWrapper == null) { // TODO【重要】 这一步创建了bean实例，只是一个早期的对象，还没有填充属性值 instanceWrapper = createBeanInstance(beanName, mbd, args); } final Object bean = instanceWrapper.getWrappedInstance(); // 获取实例化对象的类型 Class beanType = instanceWrapper.getWrappedClass(); if (beanType != NullBean.class) { mbd.resolvedTargetType = beanType; }// 调用post-processors后置处理器 synchronized (mbd.postProcessingLock) { if (!mbd.postProcessed) { try { applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); } catch (Throwable ex) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", ex); } mbd.postProcessed = true; } }// 向容器中缓存单例模式的bean，防止循环引用 boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName)); if (earlySingletonExposure) { if (logger.isDebugEnabled()) { logger.debug("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references"); } // TODO【重要】 向三级缓存添加bean实例 匿名内部类，防止循环引用，尽早持有对象的引用 addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); }// 初始化bean实例，exposedObject在初始化完成之后返回依赖注入完成之后的bean Object exposedObject = bean; try { // TODO 【重要】 bean属性依赖注入，并且将bean定义中配置的属性值赋值给实例对象 populateBean(beanName, mbd, instanceWrapper); // TODO 【重要】开始初始化bean对象 调用Aware接口方法 -> 调用BeanPostProcessor.before方法 -> 调用init-method方法 ->调用BeanPostProcessor.after方法 exposedObject = initializeBean(beanName, exposedObject, mbd); } catch (Throwable ex) { if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) { throw (BeanCreationException) ex; } else { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex); } }if (earlySingletonExposure) { // 获取指定名称的已注册的单例bean Object earlySingletonReference = getSingleton(beanName, false); if (earlySingletonReference != null) { // 根据名称获取已注册的bean和正在实例化的bean是同一个 if (exposedObject == bean) { // 当前实例化的bean初始完成 exposedObject = earlySingletonReference; } // 当前bean依赖其他bean，且当发送循环引用时，不允许创建新的实例对象 else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) { // 获取当前bean所依赖的其他bean String[] dependentBeans = getDependentBeans(beanName); Set actualDependentBeans = new LinkedHashSet<>(dependentBeans.length); for (String dependentBean : dependentBeans) { // 对依赖bean进行类型检查 if (!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."); } } } }// 注册完成依赖注入的bean try { registerDisposableBeanIfNecessary(beanName, bean, mbd); } catch (BeanDefinitionValidationException ex) { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex); }return exposedObject; }

/** * 通过singletonFactory创建bean实例，并存入一级缓存singletonObjects */ public Object getSingleton(String beanName, ObjectFactory singletonFactory) { Assert.notNull(beanName, "Bean name must not be null"); synchronized (this.singletonObjects) { Object singletonObject = this.singletonObjects.get(beanName); if (singletonObject == null) { // 如果当前工厂单例正在销毁，则不允许创建，抛出异常 if (this.singletonsCurrentlyInDestruction) { throw new BeanCreationNotAllowedException(beanName, "Singleton bean creation not allowed while singletons of this factory are in destruction " + "(Do not request a bean from a BeanFactory in a destroy method implementation!)"); } if (logger.isDebugEnabled()) { logger.debug("Creating shared instance of singleton bean '" + beanName + "'"); }// 校验是否已经在创建中，抛出异常 beforeSingletonCreation(beanName); boolean newSingleton = false; boolean recordSuppressedExceptions = (this.suppressedExceptions == null); if (recordSuppressedExceptions) { this.suppressedExceptions = new LinkedHashSet<>(); }try { // 【在这里创建实例】singletonFactory创建bean实例 singletonObject = singletonFactory.getObject(); newSingleton = true; } catch (IllegalStateException ex) { // Has the singleton object implicitly appeared in the meantime -> // if yes, proceed with it since the exception indicates that state. singletonObject = this.singletonObjects.get(beanName); if (singletonObject == null) { throw ex; } } catch (BeanCreationException ex) { if (recordSuppressedExceptions) { for (Exception suppressedException : this.suppressedExceptions) { ex.addRelatedCause(suppressedException); } } throw ex; } finally { if (recordSuppressedExceptions) { this.suppressedExceptions = null; } afterSingletonCreation(beanName); } if (newSingleton) { // TODO【重要】把bean实例加入缓存 addSingleton(beanName, singletonObject); } } return singletonObject; } }