Spring Framework源代码解析之IOC容器（三）

      在Spring Framework源代码解析之IOC容器（一）和Spring Framework源代码解析之IOC容器（二），我们对Spring IOC做了简单介绍以及熟悉了一些支持IOC的关键类，本文将对IOC的依赖注入特性进行解析，欢迎指正。

载入和注册

     在上文中，我们介绍到XmlBeanFactory对资源文件的载入，并最后引出了一个高帅富——ApplicationContext。接着上文来看，其实我们平时最常用的是Application，因为它不仅具备BeanFactory的全部能力，还为应用程序提供了很多的便利，上文已经说过了，它继承了很多父类，使它可以具备支持国际化、支持多方式定义资源，支持事件等。我们可以认为BeanFactory和Application是两个层面的IOC容器，而我们平时开发应用程序就是使用Application。Application有很多抽象子类，如AbstractApplicationContext，在该抽象子类下又有很多具体的实现类，如FileSystemXmlApplicationContext、ClassPathXmlApplicationContext等。我们以FileSystemXmlApplicationContext为例，来看看它载入和注册资源的过程。

    首先通过FileSystemXmlApplicationContext来建立IOC容器：

ApplicationContext = new FileSystemXmlApplicationContext(xmlPath);

调用构造函数：

/**
* Create a new FileSystemXmlApplicationContext, loading the definitions
* from the given XML files and automatically refreshing the context.
* @param configLocations array of file paths
* @throws BeansException if context creation failed
 */
public FileSystemXmlApplicationContext(String... configLocations) throws BeansException {
		this(configLocations, true, null);
	}

实际调用：

public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
			throws BeansException {

		super(parent);
		setConfigLocations(configLocations);
		if (refresh) {
			refresh();
		}
	}

注意方法refresh(),这里使用了一个“模板方法”的设计模式，refresh()是一个模板方法，具体实现在FileSystemXmlApplicationContext的若干级父类AbstractXmlApplicationContext中：

public void refresh() throws BeansException, IllegalStateException {  
     synchronized (this.startupShutdownMonitor) {  
         synchronized (this.activeMonitor) {  
             this.active = true;  
         }  
   
        // 这里需要子类来协助完成资源位置定义,bean 载入和向 IOC 容器注册的过程   
        refreshBeanFactory();  
         ............  
}

refresh()方法包含了整个IOC容器的初始化过程，资源的定位由refreshBeanFactory()来实现，而在AbstractXmlApplicationContext中定义了对资源的读取过程，默认由 XmlBeanDefinitionReader 来读取：

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws IOException {  
     // 这里使用 XMLBeanDefinitionReader 来载入 bean 定义信息的 XML 文件   
     XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);   
    
     //这里配置 reader 的环境，其中 ResourceLoader 是我们用来定位 bean 定义信息资源位置的   
     ///因为上下文本身实现了 ResourceLoader 接口，所以可以直接把上下文作为 ResourceLoader 传递给 XmlBeanDefi
nitionReader   
     beanDefinitionReader.setResourceLoader(this);  
     beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));  
   
     initBeanDefinitionReader(beanDefinitionReader);  
     //这里转到定义好的 XmlBeanDefinitionReader 中对载入 bean 信息进行处理  
     loadBeanDefinitions(beanDefinitionReader);  
}

转到beanDefinitionReader中进行处理：

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOExcepti
on {   
     Resource[] configResources = getConfigResources();  
     if (configResources != null) {  
         //调用 XmlBeanDefinitionReader 来载入 bean 定义信息。  
         reader.loadBeanDefinitions(configResources);  
     }  
     String[] configLocations = getConfigLocations();  
     if (configLocations != null) {  
         reader.loadBeanDefinitions(configLocations);  
     }  
}

完成了载入，我们来分析注册，来到DefaultListableBeanFactory中，它通过HashMap来持有载入的BeanDefinition：

/** Map of bean definition objects, keyed by bean name */
	private final Map beanDefinitionMap = new ConcurrentHashMap();

跟踪代码，找到注册的具体实现类DefaultListableBeanFactoy:

//---------------------------------------------------------------------
	// Implementation of BeanDefinitionRegistry interface
	//---------------------------------------------------------------------

	public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
			throws BeanDefinitionStoreException {

		Assert.hasText(beanName, "Bean name must not be empty");
		Assert.notNull(beanDefinition, "BeanDefinition must not be null");

		if (beanDefinition instanceof AbstractBeanDefinition) {
			try {
				((AbstractBeanDefinition) beanDefinition).validate();
			}
			catch (BeanDefinitionValidationException ex) {
				throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
						"Validation of bean definition failed", ex);
			}
		}

		synchronized (this.beanDefinitionMap) {
			//这里检查是不是有名字相同的BeanDefinition已经在IOC容器中注册，如果有但不允许覆盖则抛出异常
			Object oldBeanDefinition = this.beanDefinitionMap.get(beanName);
			if (oldBeanDefinition != null) {
				if (!this.allowBeanDefinitionOverriding) {
					throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
							"Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
							"': There is already [" + oldBeanDefinition + "] bound.");
				}
				else {
					if (this.logger.isInfoEnabled()) {
						this.logger.info("Overriding bean definition for bean '" + beanName +
								"': replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]");
					}
				}
			}
			else {
				this.beanDefinitionNames.add(beanName);
				this.frozenBeanDefinitionNames = null;
			}
			this.beanDefinitionMap.put(beanName, beanDefinition);

			resetBeanDefinition(beanName);
		}
	}

完成了注册，此时我们就是从容器中使用对象了，万事具备只欠getBean了。

依赖注入

    我们记得在BeanFactory中有一个getBean方法，它其实就是触发依赖注入的入口，getBean的实现我们具体看看DefaultListableBeanFactory的父类AbstractBeanFactory，看看其中getBean的是如何实现的：

public Object getBean(String name) throws BeansException {
		return doGetBean(name, null, null, false);
	}

接着看doGetBean：

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.
        // 先从缓存里面取，处理已经被创建过的单件模式的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");
                } 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);
            }
            // 这里根据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();
            if (dependsOn != null) {
                for (String dependsOnBean : dependsOn) {
                    getBean(dependsOnBean);
                    registerDependentBean(dependsOnBean, beanName);
                }
            }

            // Create bean instance.
            // 这里创建单例的实例，调用createBean方法
            if (mbd.isSingleton()) {
                sharedInstance = getSingleton(beanName,
                        new ObjectFactory<Object>() {
                            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);
            }
            // 这里则是创建prototype bean的地方
            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 '" + scopeName + "'");
                }
                try {
                    Object scopedInstance = scope.get(beanName,
                            new ObjectFactory<Object>() {
                                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);
                }
            }
        }

        // Check if required type matches the type of the actual bean instance.
        // 这里对创建出来bean进行类型的检查，如果没有问题，就返回这个新创建的bean
        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;
    }

具体创建对象在createBean里面，来看看createBean：

protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
            throws BeanCreationException {

        if (logger.isDebugEnabled()) {
            logger.debug("Creating instance of bean '" + beanName + "'");
        }
        // Make sure bean class is actually resolved at this point.
        resolveBeanClass(mbd, beanName);

        // Prepare method overrides.
        try {
            mbd.prepareMethodOverrides();
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanDefinitionStoreException(mbd.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, mbd);
            if (bean != null) {
                return bean;
            }
        }
        catch (Throwable ex) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                    "BeanPostProcessor before instantiation of bean failed", ex);
        }
        //这里是创建bean的调用
        Object beanInstance = doCreateBean(beanName, mbd, args);
        if (logger.isDebugEnabled()) {
            logger.debug("Finished creating instance of bean '" + beanName + "'");
        }
        return beanInstance;
    }

又看doCreateBean，^_^遭不住啊。。

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
        // Instantiate the bean.
        BeanWrapper instanceWrapper = null;
        if (mbd.isSingleton()) {
            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
        }
        if (instanceWrapper == null) {
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        }
        .........

    }

具体创建对象的方法是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());
        }
        //这里使用工厂方法对bean进行实例化
        if (mbd.getFactoryMethodName() != null)  {
            return instantiateUsingFactoryMethod(beanName, mbd, args);
        }

        // Shortcut when re-creating the same bean...
        boolean resolved = false;
        boolean autowireNecessary = false;
        if (args == null) {
            synchronized (mbd.constructorArgumentLock) {
                if (mbd.resolvedConstructorOrFactoryMethod != null) {
                    resolved = true;
                    autowireNecessary = mbd.constructorArgumentsResolved;
                }
            }
        }
        if (resolved) {
            if (autowireNecessary) {
                return autowireConstructor(beanName, mbd, null, null);
            }
            else {
                return instantiateBean(beanName, mbd);
            }
        }

        // Need to determine the constructor...
        //使用构造函数进行实例化
        Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
        if (ctors != null ||
                mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
                mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
            return autowireConstructor(beanName, mbd, ctors, args);
        }

        // No special handling: simply use no-arg constructor.
        //使用默认的构造函数对bean进行实例化
        return instantiateBean(beanName, mbd);
    }

来看看使用默认的构造函数对bean进行实例化的代码instantiateBean：

protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
        try {
            //使用默认的实例化策略对bean进行实例化，默认的实例化策略是CglibSubclassingInstantiationStrategy,也就是用cglib来对bean进行实例化
            Object beanInstance;
            final BeanFactory parent = this;
            if (System.getSecurityManager() != null) {
                beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
                    public Object run() {
                        return getInstantiationStrategy().instantiate(mbd, beanName, parent);
                    }
                }, getAccessControlContext());
            }
            else {
                beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
            }
            BeanWrapper bw = new BeanWrapperImpl(beanInstance);
            initBeanWrapper(bw);
            return bw;
        }
        catch (Throwable ex) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
        }
    }

    这里用cglib对bean进行实例化，cglib是一个常用的字节码生成器的类库，它提供了一系列的API来提供java字节码生成和转换的功能，如果有兴趣可以查看cglib的使用文档。另外生成bean的策略还有很多种，这里只是选了最常用的方法来介绍。至此，bean实例创建过程就算完成了，然后通过populateBean方法将创建好的实例的依赖关系设置好，最终完成依赖注入的过程，由于篇幅关系这里就不详细列举了，populateBean方法可以在AbstractAutowireCapableBeanFactory中找到。

小结

    自己对Spring IOC代码的学习暂时就到这里，要搞懂一个特性，确实需要花费很大的功夫，Spring代码量比较大，而且各个特性之间又有交叉，要梳理清楚不是件容易的事，不过回头来看自己还是有收获的，希望对看它的朋友也有一点收获。