前言
Github：https://github.com/yihonglei/thinking-in-spring
在前面文章中分析了容器初始化过程，已经建立了一个可以使用的容器。
1）BeanDefinition的Resource定位
2）BeanDefinition的载入和解析
3）BeanDefinition的注册
容器初始化的工作主要是在IOC容器中建立了BeanDefinition数据映射，并通过HashMap持有数据，
BeanDefinition都在beanDefinitionMap里被检索和使用。在IOC容器BeanFactory中，有一个getBean的接口定义，
通过这个接口实现可以获取到Bean对象。但是，这个Bean对象并不是一个普通的Bean对象，它是一个处理完依赖关系
后的Bean对象。所以一个getBean()实现里面，分为两个大步骤来处理返回用户需要的Bean对象：
1）根据BeanDefinition创建Bean对象，也即Bean对象的创建。
2）创建出来的Bean是一个还没有建立依赖关系的Bean，所有需要完成依赖关系建立，叫做Bean依赖注入。
本文先分析如何根据BeanDefinition数据结构创建用户需要的Bean，下面从就从BeanFactory入手去看getBean的实现。
BeanFactory源码：
-
package org.springframework.beans.factory;
-
import org.springframework.beans.BeansException;
-
import org.springframework.core.ResolvableType;
-
public
interface BeanFactory {
-
String FACTORY_BEAN_PREFIX =
"&";
-
Object getBean(String name) throws BeansException;
-
<T>
T getBean(String name, Class<T> requiredType) throws BeansException;
-
<T>
T getBean(Class<T> requiredType) throws BeansException;
-
Object getBean(String name, Object... args) throws BeansException;
-
<T>
T getBean(Class<T> requiredType, Object... args) throws BeansException;
-
boolean containsBean(String name);
-
boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
-
boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
-
boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
-
boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
-
Class<?> getType(String name)
throws NoSuchBeanDefinitionException;
-
String[] getAliases(String name);
-
从getBean(String name)最简单明了的方法入手看实现，该方法在很多类中有实现，重点研究AbstractBeanFactory
中的实现方法。
AbstractBeanFactory.getBean()方法源码：
-
-
public Object getBean(String name) throws BeansException {
-
return doGetBean(name,
null,
null,
false);
-
AbstractBeanFactory.doGetBean()方法源码：
-
protected <T>
T doGetBean(
-
final String name,
final Class<T> requiredType,
final Object[] args,
boolean typeCheckOnly)
-
-
-
final String beanName = transformedBeanName(name);
-
-
-
// Eagerly check singleton cache for manually registered singletons.
-
// 先从缓存中获得Bean，处理那些已经被创建过的单间模式的Bean,对这种Bean的请求不需要重复地创建
-
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");
-
-
-
logger.debug(
"Returning cached instance of singleton bean '" + beanName +
"'");
-
-
-
// 这里的getObjectForBeanInstance完成的是FactoryBean的相关处理，以取得FactoryBean的生产结果
-
bean = getObjectForBeanInstance(sharedInstance, name, beanName,
null);
-
-
-
-
// 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.
-
-
* 对IOC容器中的BeanDefinition是否存在进行检查，检查是否能在当前的BeanFactory中取得需要的Bean。
-
* 如果在当前的工厂中取不到，则到双亲BeanFactory中去取；
-
* 如果当前的双亲工厂取不到，就顺着双亲BeanFactory链一直向上查找
-
-
BeanFactory parentBeanFactory = getParentBeanFactory();
-
if (parentBeanFactory !=
null && !containsBeanDefinition(beanName)) {
-
// Not found -> check parent.
-
String nameToLookup = originalBeanName(name);
-
-
// Delegation to parent with explicit args.
-
return (T) parentBeanFactory.getBean(nameToLookup, args);
-
-
-
// No args -> delegate to standard getBean method.
-
return parentBeanFactory.getBean(nameToLookup, requiredType);
-
-
-
-
-
markBeanAsCreated(beanName);
-
-
-
-
// 根据Bean的名字获取BeanDefinition
-
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
-
checkMergedBeanDefinition(mbd, beanName, args);
-
-
// Guarantee initialization of beans that the current bean depends on.
-
// 获取当前Bean的所有依赖Bean，这样会触发getBean的递归调用，直到渠道一个没有任何依赖的Bean为止
-
String[] dependsOn = mbd.getDependsOn();
-
-
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);
-
-
-
-
-
-
-
-
-
sharedInstance = getSingleton(beanName,
new ObjectFactory<Object>() {
-
-
public Object getObject() throws BeansException {
-
-
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);
-
-
-
-
-
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
-
-
-
else
if (mbd.isPrototype()) {
-
// It's a prototype -> create a new instance.
-
Object prototypeInstance =
null;
-
-
beforePrototypeCreation(beanName);
-
prototypeInstance = createBean(beanName, mbd, args);
-
-
-
afterPrototypeCreation(beanName);
-
-
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
-
-
-
-
String scopeName = mbd.getScope();
-
final Scope scope =
this.scopes.get(scopeName);
-
-
throw
new IllegalStateException(
"No Scope registered for scope name '" + scopeName +
"'");
-
-
-
Object scopedInstance = scope.get(beanName,
new ObjectFactory<Object>() {
-
-
public Object getObject() throws BeansException {
-
beforePrototypeCreation(beanName);
-
-
return createBean(beanName, mbd, args);
-
-
-
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",
-
-
-
-
-
catch (BeansException ex) {
-
cleanupAfterBeanCreationFailure(beanName);
-
-
-
-
-
// Check if required type matches the type of the actual bean instance.
-
// 对创建的Bean进行类型检查，如果没有问题，就返回这个新创建的Bean，这个Bean已经是包含依赖关系的Bean
-
if (requiredType !=
null && bean !=
null && !requiredType.isAssignableFrom(bean.getClass())) {
-
-
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());
-
-
-
-
getBean()方法只是创建对象的起点，doGetBean()只是getBean()的具体执行，在doGetBean()中会调用createBean()
方法，在这个过程中，Bean对象会依据BeanDefinition定义的要求生成。AbstractBeanFactory中的createBean是一个
抽象方法，具体的实现在AbstractAutowireCapableBeanFactory中。
AbstractAutowireCapableBeanFactory.createBean()方法源码：
-
-
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.
-
-
mbdToUse.prepareMethodOverrides();
-
-
catch (BeanDefinitionValidationException ex) {
-
throw
new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
-
beanName,
"Validation of method overrides failed", ex);
-
-
-
-
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
-
// 如果Bean配置了PostProcessor，则返回一个proxy代理对象
-
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
-
-
-
-
-
-
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 +
"'");
-
-
-
AbstractAutowireCapableBeanFactory.doCreateBean()方法源码：
-
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
-
throws BeanCreationException {
-
-
-
// 这个BeanWrapper是用来持有创建出来的Bean对象
-
BeanWrapper instanceWrapper =
null;
-
// 如果是Singleton，先把缓存中的同名Bean清除
-
-
instanceWrapper =
this.factoryBeanInstanceCache.remove(beanName);
-
-
// 通过createBeanInstance()创建Bean
-
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) {
-
-
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
-
-
-
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>() {
-
-
public Object getObject() throws BeansException {
-
return getEarlyBeanReference(beanName, mbd, bean);
-
-
-
-
-
// Initialize the bean instance.
-
// 对Bean进行初始化，这个exposedObject在初始化以后会返回座位依赖注入完成后的Bean
-
Object exposedObject = bean;
-
-
populateBean(beanName, mbd, instanceWrapper);
-
if (exposedObject !=
null) {
-
exposedObject = initializeBean(beanName, exposedObject, mbd);
-
-
-
-
if (ex
instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
-
throw (BeanCreationException) ex;
-
-
-
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.
-
-
registerDisposableBeanIfNecessary(beanName, bean, mbd);
-
-
catch (BeanDefinitionValidationException ex) {
-
throw
new BeanCreationException(
-
mbd.getResourceDescription(), beanName,
"Invalid destruction signature", ex);
-
-
-
-
看下真正创建Bean对象的方法createBeanInstance()，该方法会生成包含Java对象的Bean，这个Bean生成有很多
中方式，可以通过工厂方法生成，也可以通过容器的Autowire特性生成，这些生成方式都是由相关的BeanDefinition
来指定的。看下以下正在创建对象的源码。
AbstractAutowireCapableBeanFactory.createBeanInstance()方法源码：
-
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
-
// Make sure bean class is actually resolved at this point.
-
-
Class<?> beanClass = resolveBeanClass(mbd, beanName);
-
-
if (beanClass !=
null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
-
throw
new BeanCreationException(mbd.getResourceDescription(), beanName,
-
"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
-
-
-
if (mbd.getFactoryMethodName() !=
null) {
-
return instantiateUsingFactoryMethod(beanName, mbd, args);
-
-
-
// Shortcut when re-creating the same bean...
-
-
boolean resolved =
false;
-
boolean autowireNecessary =
false;
-
-
synchronized (mbd.constructorArgumentLock) {
-
if (mbd.resolvedConstructorOrFactoryMethod !=
null) {
-
-
autowireNecessary = mbd.constructorArgumentsResolved;
-
-
-
-
-
-
return autowireConstructor(beanName, mbd,
null,
null);
-
-
-
return instantiateBean(beanName, mbd);
-
-
-
-
// Need to determine the constructor...
-
-
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
-
-
mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
-
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
-
return autowireConstructor(beanName, mbd, ctors, args);
-
-
-
// No special handling: simply use no-arg constructor.
-
-
return instantiateBean(beanName, mbd);
-
instantiateBean()方法采用默认构造器实例化bean的过程。
AbstractAutowireCapableBeanFactory.instantiateBean()方法源码：
-
protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
-
-
-
final BeanFactory parent =
this;
-
if (System.getSecurityManager() !=
null) {
-
beanInstance = AccessController.doPrivileged(
new PrivilegedAction<Object>() {
-
-
-
return getInstantiationStrategy().instantiate(mbd, beanName, parent);
-
-
}, getAccessControlContext());
-
-
-
beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
-
-
BeanWrapper bw =
new BeanWrapperImpl(beanInstance);
-
-
-
-
-
throw
new BeanCreationException(
-
mbd.getResourceDescription(), beanName,
"Instantiation of bean failed", ex);
-
-
类中使用默认的实例化策略进行实例化，默认采用CGLIB对Bean进行实例化。CGLIB是一个常用的字节码
生成器的类库，它提供了一些列的API来提供生成和转换Java的字节码的功能。
SimpleInstantiationStrategy.instantiate()方法源码：
-
-
public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner) {
-
// Don't override the class with CGLIB if no overrides.
-
if (bd.getMethodOverrides().isEmpty()) {
-
// 获取指定的构造器或者生产对象工厂方法来对Bean进行实例化
-
Constructor<?> constructorToUse;
-
synchronized (bd.constructorArgumentLock) {
-
constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
-
if (constructorToUse ==
null) {
-
final Class<?> clazz = bd.getBeanClass();
-
if (clazz.isInterface()) {
-
throw
new BeanInstantiationException(clazz,
"Specified class is an interface");
-
-
-
if (System.getSecurityManager() !=
null) {
-
constructorToUse = AccessController.doPrivileged(
new PrivilegedExceptionAction<Constructor<?>>() {
-
-
public Constructor<?> run()
throws Exception {
-
return clazz.getDeclaredConstructor((Class[])
null);
-
-
-
-
-
constructorToUse = clazz.getDeclaredConstructor((Class[])
null);
-
-
bd.resolvedConstructorOrFactoryMethod = constructorToUse;
-
-
-
throw
new BeanInstantiationException(clazz,
"No default constructor found", ex);
-
-
-
-
// 通过BeanUtils进行实例化，这个BeanUtils实例化通过Constructor来实例化Bean，
-
// 在BeanUtils中可以看到具体的调用ctor.newInstance(args)
-
return BeanUtils.instantiateClass(constructorToUse);
-
-
-
// Must generate CGLIB subclass.
-
-
return instantiateWithMethodInjection(bd, beanName, owner);
-
-
BeanUtils.instantiateClass()源码：
-
public
static <T>
T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
-
Assert.notNull(ctor,
"Constructor must not be null");
-
-
ReflectionUtils.makeAccessible(ctor);
-
return ctor.newInstance(args);
-
-
catch (InstantiationException ex) {
-
throw
new BeanInstantiationException(ctor,
"Is it an abstract class?", ex);
-
-
catch (IllegalAccessException ex) {
-
throw
new BeanInstantiationException(ctor,
"Is the constructor accessible?", ex);
-
-
catch (IllegalArgumentException ex) {
-
throw
new BeanInstantiationException(ctor,
"Illegal arguments for constructor", ex);
-
-
catch (InvocationTargetException ex) {
-
throw
new BeanInstantiationException(ctor,
"Constructor threw exception", ex.getTargetException());
-
-
如果感兴趣，可以一直追溯newInstance()方法，最后调用一个Native方法创建对象。
到此，Bean对象创建完成。
参考文献：
1、《Spring技术内幕》
2、《Spring实战》
3、Spring官网API
4、Spring源码
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)
