Spring Framework（十四）Spring Framework 获取 Bean 之一探究竟

超、凢脫俗 2023-06-20 06:25 18阅读 0赞

### GetBeanByClass ###

public <T> T getBean(Class<T> requiredType, Object... args) throws BeansException { 
    		// 1. 解析为namedBean
    		NamedBeanHolder<T> namedBean = resolveNamedBean(requiredType, args);
    		if (namedBean != null) { 
    			return namedBean.getBeanInstance();
    		}
    		// 2. 获取父BeanFactory,然后从父BeanFactory获取Bean
    		BeanFactory parent = getParentBeanFactory();
    		if (parent != null) { 
    			return parent.getBean(requiredType, args);
    		}
    		// 3. 还是找不到的话，抛出异常。
    		throw new NoSuchBeanDefinitionException(requiredType);
    	}

在这里面可以看到实际的他和类加载机制不一样，而是优先从本地获取Bean。所以这里是可以简单的理解为，存在这么以下的场景的时候比较合适的，父工厂里面存放一些commonbean，然后子工厂可以根据自己的实际需求去覆盖。

下面详细看一下。

#### resolveNamedBean ####

private <T> NamedBeanHolder<T> resolveNamedBean(Class<T> requiredType, Object... args) throws BeansException { 
    		Assert.notNull(requiredType, "Required type must not be null");
    		// 1. 获取候选者的bean名称
    		String[] candidateNames = getBeanNamesForType(requiredType);
            // 2. 
    		if (candidateNames.length > 1) { 
    			List<String> autowireCandidates = new ArrayList<String>(candidateNames.length);
    			for (String beanName : candidateNames) { 
    				if (!containsBeanDefinition(beanName) || getBeanDefinition(beanName).isAutowireCandidate()) { 
    					autowireCandidates.add(beanName);
    				}
    			}
    			if (!autowireCandidates.isEmpty()) { 
    				candidateNames = autowireCandidates.toArray(new String[autowireCandidates.size()]);
    			}
    		}
    
    		if (candidateNames.length == 1) { 
    			String beanName = candidateNames[0];
    			return new NamedBeanHolder<T>(beanName, getBean(beanName, requiredType, args));
    		}
    		else if (candidateNames.length > 1) { 
    			Map<String, Object> candidates = new LinkedHashMap<String, Object>(candidateNames.length);
    			for (String beanName : candidateNames) { 
    				if (containsSingleton(beanName)) { 
    					candidates.put(beanName, getBean(beanName, requiredType, args));
    				}
    				else { 
    					candidates.put(beanName, getType(beanName));
    				}
    			}
    			String candidateName = determinePrimaryCandidate(candidates, requiredType);
    			if (candidateName == null) { 
    				candidateName = determineHighestPriorityCandidate(candidates, requiredType);
    			}
    			if (candidateName != null) { 
    				Object beanInstance = candidates.get(candidateName);
    				if (beanInstance instanceof Class) { 
    					beanInstance = getBean(candidateName, requiredType, args);
    				}
    				return new NamedBeanHolder<T>(candidateName, (T) beanInstance);
    			}
    			throw new NoUniqueBeanDefinitionException(requiredType, candidates.keySet());
    		}
    
    		return null;
    	}

1.  获取这个Class类型的所有的Bean名称数组。
2.  如果候选者只有一个的话，直接返回。
3.  如果存在多个Bean，是否指定了PrimaryBean（@Primary），就返回Primary，
4.  否则继续按照优先级进行排序，还是搞不出来的话抛出异常NoUniqueBeanDefinitionException。
5.  正常会返回一个NamedHBeanHodler,然后执行整个getBean流程。这个方式根据名称获取Bean的方法。所以这也是为什么叫做NamedBean了。

public class NamedBeanHolder<T> implements NamedBean { 
    
    	private final String beanName;
    
    	private final T beanInstance;
    	}

--------------------

下面看看这个方法。

### GetBeanByName ###

@Override
    	public Object getBean(String name) throws BeansException { 
    		return doGetBean(name, null, null, false);
    	}
    
    	@Override
    	public <T> T getBean(String name, Class<T> requiredType) throws BeansException { 
    		return doGetBean(name, requiredType, null, false);
    	}
    
    	@Override
    	public Object getBean(String name, Object... args) throws BeansException { 
    		return doGetBean(name, null, args, false);
    	}
    	
    	public <T> T getBean(String name, Class<T> requiredType, Object... args) throws BeansException { 
    		return doGetBean(name, requiredType, args, false);
    	}

可以看到这里是直接调用了`doGetBean`方法。

--------------------

### doGetBean 真正执行Bean的方法 ###

> 这里有个有意思的东西，在Spring里面在真正的执行逻辑的方法基本上都叫做doXxx。

protected <T> T doGetBean(
    			final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
    			throws BeansException { 
    
    		final String beanName = transformedBeanName(name);
    		Object bean;
    
    		// Eagerly check singleton cache for manually registered singletons.
    		Object sharedInstance = getSingleton(beanName);
    		if (sharedInstance != null && args == null) { 
    			if (logger.isDebugEnabled()) { 
    				if (isSingletonCurrentlyInCreation(beanName)) { 
    					logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
    							"' that is not fully initialized yet - a consequence of a circular reference");
    				}
    				else { 
    					logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
    				}
    			}
    			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    		}
    
    		else { 
    			// Fail if we're already creating this bean instance:
    			// We're assumably within a circular reference.
    			if (isPrototypeCurrentlyInCreation(beanName)) { 
    				throw new BeanCurrentlyInCreationException(beanName);
    			}
    
    			// Check if bean definition exists in this factory.
    			BeanFactory parentBeanFactory = getParentBeanFactory();
    			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { 
    				// Not found -> check parent.
    				String nameToLookup = originalBeanName(name);
    				if (args != null) { 
    					// Delegation to parent with explicit args.
    					return (T) parentBeanFactory.getBean(nameToLookup, args);
    				}
    				else { 
    					// No args -> delegate to standard getBean method.
    					return parentBeanFactory.getBean(nameToLookup, requiredType);
    				}
    			}
    
    			if (!typeCheckOnly) { 
    				markBeanAsCreated(beanName);
    			}
    
    			try { 
    				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
    				checkMergedBeanDefinition(mbd, beanName, args);
    
    				// Guarantee initialization of beans that the current bean depends on.
    				String[] dependsOn = mbd.getDependsOn();
    				if (dependsOn != null) { 
    					for (String dep : dependsOn) { 
    						if (isDependent(beanName, dep)) { 
    							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    									"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
    						}
    						registerDependentBean(dep, beanName);
    						getBean(dep);
    					}
    				}
    
    				// Create bean instance.
    				if (mbd.isSingleton()) { 
    					sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() { 
    						@Override
    						public Object getObject() throws BeansException { 
    							try { 
    								return createBean(beanName, mbd, args);
    							}
    							catch (BeansException ex) { 
    								// Explicitly remove instance from singleton cache: It might have been put there
    								// eagerly by the creation process, to allow for circular reference resolution.
    								// Also remove any beans that received a temporary reference to the bean.
    								destroySingleton(beanName);
    								throw ex;
    							}
    						}
    					});
    					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
    				}
    
    				else if (mbd.isPrototype()) { 
    					// It's a prototype -> create a new instance.
    					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();
    					final 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>() { 
    							@Override
    							public Object getObject() throws BeansException { 
    								beforePrototypeCreation(beanName);
    								try { 
    									return createBean(beanName, mbd, args);
    								}
    								finally { 
    									afterPrototypeCreation(beanName);
    								}
    							}
    						});
    						bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
    					}
    					catch (IllegalStateException ex) { 
    						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);
    					}
    				}
    			}
    			catch (BeansException ex) { 
    				cleanupAfterBeanCreationFailure(beanName);
    				throw ex;
    			}
    		}
    
    		// Check if required type matches the type of the actual bean instance.
    		if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) { 
    			try { 
    				return getTypeConverter().convertIfNecessary(bean, requiredType);
    			}
    			catch (TypeMismatchException ex) { 
    				if (logger.isDebugEnabled()) { 
    					logger.debug("Failed to convert bean '" + name + "' to required type '" +
    							ClassUtils.getQualifiedName(requiredType) + "'", ex);
    				}
    				throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
    			}
    		}
    		return (T) bean;
    	}

下面拆开来看一下这个方法，

#### transformedBeanName ####

这个方法的作用： 把bean的name转换为真实的name，为什么会有这么一说呢？  
因为在FactoryBean注册到Bean工厂的时候，名字会加一个`&`前缀，比如`FactoryBean<A>`,那么里面会注册名称为`&a`的一个FactoryBean。

protected String transformedBeanName(String name) { 
    		return canonicalName(BeanFactoryUtils.transformedBeanName(name));
    	}
    
    	/** * Determine the original bean name, resolving locally defined aliases to canonical names. * @param name the user-specified name * @return the original bean name */
    	protected String originalBeanName(String name) { 
    		String beanName = transformedBeanName(name);
    		if (name.startsWith(FACTORY_BEAN_PREFIX)) { 
    			beanName = FACTORY_BEAN_PREFIX + beanName;
    		}
    		return beanName;
    	}

#### getSingleton ####

@Override
    	public Object getSingleton(String beanName) { 
    		return getSingleton(beanName, true);
    	}
    /** * Return the (raw) singleton object registered under the given name. * <p>Checks already instantiated singletons and also allows for an early * reference to a currently created singleton (resolving a circular reference). * @param beanName the name of the bean to look for * @param allowEarlyReference whether early references should be created or not * @return the registered singleton object, or {@code null} if none found */
    	protected Object getSingleton(String beanName, boolean allowEarlyReference) { 
    		Object singletonObject = this.singletonObjects.get(beanName);
    		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) { 
    			synchronized (this.singletonObjects) { 
    				singletonObject = this.earlySingletonObjects.get(beanName);
    				if (singletonObject == null && allowEarlyReference) { 
    					ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
    					if (singletonFactory != null) { 
    						singletonObject = singletonFactory.getObject();
    						this.earlySingletonObjects.put(beanName, singletonObject);
    						this.singletonFactories.remove(beanName);
    					}
    				}
    			}
    		}
    		return (singletonObject != NULL_OBJECT ? singletonObject : null);
    	}

1.  首先看一下`allowEarlyReference`这个参数，是否创建**提前引用**，可能你听说过这个问题《spring怎么解决循环引用的问题？》。那么就是在这里解决这个问题的，下面看看它们的思路？
2.  首先从看已经创建的单例里面获取Bean
3.  如果不为null，直接返回。
4.  如果为null并且没有在创建中的情况下，那么就开始新建bean。
5.  同步锁住，防止多线程创建的出现一些不一致的问题。
6.  判断当前bean是否已经被提前初始化过了，如果没有初始化过的话？并且允许提前初始化的情况下，提前初始化。

**看了以上的流程，现在回想一下有名的循环依赖问题。就是A依赖B，B依赖A。通过上面的流程可以模拟一下初始化流程，就是在创建A的时候，先把A提前初始化出来，因为对象都是地址，所以在B初始化的时候可以拿到A的地址，然后B初始化完之后，然后再把B的地址赋给A。**

#### getObjectForBeanInstance ####

这个方法的作用： 获取给定bean实例的对象，如果是FactoryBean，则为bean实例本身或其创建的对象。

protected Object getObjectForBeanInstance(
    			Object beanInstance, String name, String beanName, RootBeanDefinition mbd) { 
    
    		// Don't let calling code try to dereference the factory if the bean isn't a factory.
    		if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) { 
    			throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
    		}
    
    		// Now we have the bean instance, which may be a normal bean or a FactoryBean.
    		// If it's a FactoryBean, we use it to create a bean instance, unless the
    		// caller actually wants a reference to the factory.
    		if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) { 
    			return beanInstance;
    		}
    
    		Object object = null;
    		if (mbd == null) { 
    			object = getCachedObjectForFactoryBean(beanName);
    		}
    		if (object == null) { 
    			// Return bean instance from factory.
    			FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
    			// Caches object obtained from FactoryBean if it is a singleton.
    			if (mbd == null && containsBeanDefinition(beanName)) { 
    				mbd = getMergedLocalBeanDefinition(beanName);
    			}
    			boolean synthetic = (mbd != null && mbd.isSynthetic());
    			object = getObjectFromFactoryBean(factory, beanName, !synthetic);
    		}
    		return object;
    	}

以上是获取已经初始化完成的Bean。其实还是没有真正的有解决依赖注入、填充bean属性等的动作

#### 初始化Bean ####

##### 检查 #####

// Fail if we're already creating this bean instance:
    			// We're assumably within a circular reference.
    			if (isPrototypeCurrentlyInCreation(beanName)) {
    				throw new BeanCurrentlyInCreationException(beanName);
    			}
    
    			// Check if bean definition exists in this factory.
    			BeanFactory parentBeanFactory = getParentBeanFactory();
    			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
    				// Not found -> check parent.
    				String nameToLookup = originalBeanName(name);
    				if (args != null) {
    					// Delegation to parent with explicit args.
    					return (T) parentBeanFactory.getBean(nameToLookup, args);
    				}
    				else {
    					// No args -> delegate to standard getBean method.
    					return parentBeanFactory.getBean(nameToLookup, requiredType);
    				}
    			}
    
    			if (!typeCheckOnly) {
    				markBeanAsCreated(beanName);
    			}

1.  检查是否存在Prototype类型的Bean循环依赖。意味当时原型模式的情况下，没有办法通过提前初始化来解决这个问题，因为他们在整个JVM里面会存在多份实例。这个问题从原理上将是没有办法解决的，所以上面的循环依赖解决的只是单例Bean场景下的问题。
2.  检查bean是否存在父工厂里面。如果是父工厂包含此Bean，优先从父工厂里面加载。

##### 加载 #####

try { 
    				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
    				checkMergedBeanDefinition(mbd, beanName, args);
    
    				// Guarantee initialization of beans that the current bean depends on.
    				String[] dependsOn = mbd.getDependsOn();
    				if (dependsOn != null) { 
    					for (String dep : dependsOn) { 
    						if (isDependent(beanName, dep)) { 
    							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    									"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
    						}
    						registerDependentBean(dep, beanName);
    						getBean(dep);
    					}
    				}
    
    				// Create bean instance.
    				if (mbd.isSingleton()) { 
    					sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() { 
    						@Override
    						public Object getObject() throws BeansException { 
    							try { 
    								return createBean(beanName, mbd, args);
    							}
    							catch (BeansException ex) { 
    								// Explicitly remove instance from singleton cache: It might have been put there
    								// eagerly by the creation process, to allow for circular reference resolution.
    								// Also remove any beans that received a temporary reference to the bean.
    								destroySingleton(beanName);
    								throw ex;
    							}
    						}
    					});
    					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
    				}
    
    				else if (mbd.isPrototype()) { 
    					// It's a prototype -> create a new instance.
    					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();
    					final 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>() { 
    							@Override
    							public Object getObject() throws BeansException { 
    								beforePrototypeCreation(beanName);
    								try { 
    									return createBean(beanName, mbd, args);
    								}
    								finally { 
    									afterPrototypeCreation(beanName);
    								}
    							}
    						});
    						bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
    					}
    					catch (IllegalStateException ex) { 
    						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);
    					}
    				}
    			}
    			catch (BeansException ex) { 
    				cleanupAfterBeanCreationFailure(beanName);
    				throw ex;
    			}

1.  首先创建了BeanDefinition
2.  读取依赖的Bean，把依赖的bean都给初始化掉
3.  根据`scope`创建bean

##### 创建bean #####

protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException { 
    		if (logger.isDebugEnabled()) { 
    			logger.debug("Creating instance of bean '" + beanName + "'");
    		}
    		RootBeanDefinition mbdToUse = mbd;
    
    		// Make sure bean class is actually resolved at this point, and
    		// clone the bean definition in case of a dynamically resolved Class
    		// which cannot be stored in the shared merged bean definition.
    		Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
    		if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) { 
    			mbdToUse = new RootBeanDefinition(mbd);
    			mbdToUse.setBeanClass(resolvedClass);
    		}
    
    		// Prepare method overrides.
    		try { 
    			mbdToUse.prepareMethodOverrides();
    		}
    		catch (BeanDefinitionValidationException ex) { 
    			throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
    					beanName, "Validation of method overrides failed", ex);
    		}
    
    		try { 
    			// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
    			Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
    			if (bean != null) { 
    				return bean;
    			}
    		}
    		catch (Throwable ex) { 
    			throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
    					"BeanPostProcessor before instantiation of bean failed", ex);
    		}
    
    		Object beanInstance = doCreateBean(beanName, mbdToUse, args);
    		if (logger.isDebugEnabled()) { 
    			logger.debug("Finished creating instance of bean '" + beanName + "'");
    		}
    		return beanInstance;
    	}

1.  确保此时确实解析了bean类，并且如果动态解析的Class 无法存储在共享的合并bean定义中，则克隆bean定义。
2.  解析 method override这个配置，现在已经不常用了
3.  resolveBeforeInstantiation 给BeanPostProcessors一个返回代理而不是目标bean实例的机会。也就是`InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation`,并且如果Bean不等于null的情况下，把后置方法也执行掉。

##### 真实创建bean doCreateBean #####

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
    			throws BeanCreationException { 
    
    		// Instantiate the bean.
    		BeanWrapper instanceWrapper = null;
    		if (mbd.isSingleton()) { 
    			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    		}
    		if (instanceWrapper == null) { 
    			instanceWrapper = createBeanInstance(beanName, mbd, args);
    		}
    		final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
    		Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
    		mbd.resolvedTargetType = beanType;
    
    		// Allow post-processors to modify the merged bean definition.
    		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;
    			}
    		}
    
    		// Eagerly cache singletons to be able to resolve circular references
    		// even when triggered by lifecycle interfaces like BeanFactoryAware.
    		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");
    			}
    			addSingletonFactory(beanName, new ObjectFactory<Object>() { 
    				@Override
    				public Object getObject() throws BeansException { 
    					return getEarlyBeanReference(beanName, mbd, bean);
    				}
    			});
    		}
    
    		// Initialize the bean instance.
    		Object exposedObject = bean;
    		try { 
    			populateBean(beanName, mbd, instanceWrapper);
    			if (exposedObject != null) { 
    				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) { 
    			Object earlySingletonReference = getSingleton(beanName, false);
    			if (earlySingletonReference != null) { 
    				if (exposedObject == bean) { 
    					exposedObject = earlySingletonReference;
    				}
    				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) { 
    					String[] dependentBeans = getDependentBeans(beanName);
    					Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);
    					for (String dependentBean : dependentBeans) { 
    						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.");
    					}
    				}
    			}
    		}
    
    		// Register bean as disposable.
    		try { 
    			registerDisposableBeanIfNecessary(beanName, bean, mbd);
    		}
    		catch (BeanDefinitionValidationException ex) { 
    			throw new BeanCreationException(
    					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    		}
    
    		return exposedObject;
    	}

1.  使用适当的实例化策略为指定的bean创建一个新实例：工厂方法，构造函数自动装配或简单实例化。
2.  applyMergedBeanDefinitionPostProcessors 使用后置处理器处理BeanDefinition
3.  填充Bean
4.  initializeBean 执行
    
     *  invokeAwareMethods 执行BeanNameAware、BeanClassLoaderAware、BeanFactoryAware
     *  applyBeanPostProcessorsBeforeInitialization， 执行PostProcessor的 before方法
     *  invokeInitMethods 执行配置的initMethod和afterPropertiesSet
     *  applyBeanPostProcessorsAfterInitialization 执行PostProcessor的 after方法
5.  如果是提前暴露了bean，但是却没有Bean依赖它，报错。
6.  注册为disposable

##### 填充bean #####

protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) { 
    		PropertyValues pvs = mbd.getPropertyValues();
    
    		if (bw == null) { 
    			if (!pvs.isEmpty()) { 
    				throw new BeanCreationException(
    						mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
    			}
    			else { 
    				// Skip property population phase for null instance.
    				return;
    			}
    		}
    
    		// 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.
    		boolean continueWithPropertyPopulation = true;
    
    		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { 
    			for (BeanPostProcessor bp : getBeanPostProcessors()) { 
    				if (bp instanceof InstantiationAwareBeanPostProcessor) { 
    					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
    					if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) { 
    						continueWithPropertyPopulation = false;
    						break;
    					}
    				}
    			}
    		}
    
    		if (!continueWithPropertyPopulation) { 
    			return;
    		}
    
    		if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
    				mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) { 
    			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
    
    			// Add property values based on autowire by name if applicable.
    			if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) { 
    				autowireByName(beanName, mbd, bw, newPvs);
    			}
    
    			// Add property values based on autowire by type if applicable.
    			if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) { 
    				autowireByType(beanName, mbd, bw, newPvs);
    			}
    
    			pvs = newPvs;
    		}
    
    		boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
    		boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);
    
    		if (hasInstAwareBpps || needsDepCheck) { 
    			PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
    			if (hasInstAwareBpps) { 
    				for (BeanPostProcessor bp : getBeanPostProcessors()) { 
    					if (bp instanceof InstantiationAwareBeanPostProcessor) { 
    						InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
    						pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
    						if (pvs == null) { 
    							return;
    						}
    					}
    				}
    			}
    			if (needsDepCheck) { 
    				checkDependencies(beanName, mbd, filteredPds, pvs);
    			}
    		}
    
    		applyPropertyValues(beanName, mbd, bw, pvs);
    	}

1.  InstantiationAwareBeanPostProcessor\#postProcessAfterInstantiation  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly93dWh1bGFsYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70]
2.  自动注入，解决@Autowired和@Resource

### 总结 ###

以上就是整个geBean的整个流程，其中解释了

1.  整个bean初始化的过程中的一些扩展点如`InstantiationAwareBeanPostProcessor`、`MergedBeanDefinitionPostProcessor`,以及`init-method`等
2.  初始化bean实例，以及填充属性的细节。
3.  如何解决的单例Bean的循环依赖

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly93dWh1bGFsYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 1]  
图片来自https://www.cnblogs.com/javazhiyin/p/10905294.html ，侵删！！！

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly93dWh1bGFsYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191208212736892.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly93dWh1bGFsYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly93dWh1bGFsYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/2019120821371324.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly93dWh1bGFsYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70