源码成神之路:Spring Framework源代码解析之IOC容器(二)

在上文（Spring Framework源代码解析之IOC容器（一））中，我们简单了解了Spring的IOC特性，但对Spring相关源码没有做详细的分析，本文将对支持IOC特性的重要代码进行分析，有不对的地方请指正。

水桶的标准——BeanFactory

我们说Spring中包含了IOC的容器，倒不如说它包含了一系列容器的集合，因为IOC容器不只一个，像ConfigurableBeanFactory、XmlBeanFactory、ApplicationContext都是IOC容器。它们就像一个个水桶，都能够装水（放置Java Bean），但外观、样式、使用场景可能有所不同，使用者可以根据自己的需求使用不同的“水桶”。但不管是哪个“水桶”，它们都会一些基本的功能，比如装水。所以我们发现这些容器它们都实现了一个相同的接口—— BeanFactory。BeanFactory定义了这些容器基本的功能，比如getBean、containsBean、isSingleton等等。

getBean是BeanFactory最重要一个方法，作用是从IOC容器中取得指定的Bean，它还有一个重载方法可以指定类型来获取Bean。

containsBean是用来判断容器中是否包含指定的Bean。

isSingleton是用来判断指定的Bean是否是单例类型的Bean。

……

这些方法指定了每一个容器都必须实现的一些功能，也是支持IOC容器的最基本功能。

BeanFactory源码清单：

public interface BeanFactory {
 
    String FACTORY_BEAN_PREFIX = "&";
 
    Object getBean(String name) throws BeansException;
 
     T getBean(String name, Class requiredType) throws BeansException;
     
     T getBean(Class requiredType) throws BeansException;
 
    Object getBean(String name, Object... args) throws BeansException;
 
    boolean containsBean(String name);
 
    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
 
    boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
 
    boolean isTypeMatch(String name, Class<?> targetType) throws NoSuchBeanDefinitionException;
 
    Class<?> getType(String name) throws NoSuchBeanDefinitionException;
 
    String[] getAliases(String name);
 
}

说完水桶的标准，我们眼前出现各式各样的“水桶”，但有些水桶功能过于复杂，有些又实用性不好，我们得选一个经济实用的水桶来研究，XmlBeanFactory就是这样的水桶。

屌丝版水桶——XmlBeanFactory

之所以称为屌丝版，是因为XmlBeanFactory只提供了最基本的IOC容器的功能，从名字来看，这个IOC容器可以读取XML文件定义的BeanDefinition（XML文件中对bean的描述）。什么是BeanDefinition呢，我们说IOC容器是用来装对象的，而具体描述装了哪些对象，对象之间的依赖关系又是什么？则是用BeanDefinition来描述，可以结合XML文件来理解它。

我们看一下XmlBeanFactory的继承关系：

BeanFactory不用说了，AutowireCapableBeanFactory、AbstractAutowireCapableBeanFactory最主要的功能就是实现bean创建方法createBean()。

T createBean(Class beanClass) throws BeansException;

接下来是DefaultListableBeanFactory,它很重要，很多容器都会继承它。从名字上看，它应该是一个默认的功能完备的BeanFactory，我们可以把它当做为水桶的半成品，功能健全，但使用的时候还需要包装。XmlBeanFactory就是包装它实现的一个基本容器。XmlBeanFactory除了包含DefaultListableBeanFactory的功能外，最重要的它支持以XML目录文件方式定义BeanDefinition。

XmlBeanFactory怎么读取Xml文件？

XmlBeanFactory源文件中，并看到读取Xml文件的具体实现，可见读取Xml文件并不是由XmlBeanFactory直接完成的。

XmlBeanFactory.java

public class XmlBeanFactory extends DefaultListableBeanFactory {
 
    private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);
 
 
    /**
     * Create a new XmlBeanFactory with the given resource,
     * which must be parsable using DOM.
     * @param resource XML resource to load bean definitions from
     * @throws BeansException in case of loading or parsing errors
     */
    public XmlBeanFactory(Resource resource) throws BeansException {
        this(resource, null);
    }
 
    /**
     * Create a new XmlBeanFactory with the given input stream,
     * which must be parsable using DOM.
     * @param resource XML resource to load bean definitions from
     * @param parentBeanFactory parent bean factory
     * @throws BeansException in case of loading or parsing errors
     */
    public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
        super(parentBeanFactory);
        this.reader.loadBeanDefinitions(resource);
    }
 
}

我们注意到XmlBeanFactory.java开始实例化了一个XmlBeanDefinitionReader对象reader。实际上Xml文件的处理就是由这个reader来完成的。接着往下看XmlBeanFactory构造函数中需要一个Resource对象，它包含了BeanDefinition的信息，也就是在Xml配置文件当中的定义的Bean信息。Spring需要把它封装成Resource对象进行处理。

从XML文件读取Bean信息保存在Resource对象当中的方法：

ClassPathResource resource = new ClassPathResource(
            "application-context.xml");

有了Resource对象，reader执行loadBeanDefinitions方法。

this.reader.loadBeanDefinitions(resource);

就是这个方法从Resource载入BeanDefinition到读取器（XmlBeanDefinitionReader）中。

我们再来梳理一下XmlBeanFactory的整个流程：

ClassPathResource resource = new ClassPathResource(
            "application-context.xml");
    DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
    XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);
    reader.loadBeanDefinitions(resource);

1）根据Xml配置文件创建Resource资源对象，该对象中包含了BeanDefinition的信息。

2）创建DefaultListableBeanFactory。

3）创建XmlBeanDefinitionReader读取器，用于载入BeanDefinition。之所以需要BeanFactory作为参数，是因为会将读取的信息回调配置给factory。

4）XmlBeanDefinitionReader执行载入BeanDefinition的方法，最后会完成Bean的载入和注册。完成后Bean就成功的放置到IOC容器当中，以后我们就可以从中取得Bean来使用。

水桶中的高帅富——ApplicationContext

如果说XmlBeanFactory是容器中的屌丝，ApplicationContext应该算容器中的高帅富，浏览一下ApplicationContext。

ApplicationContext.java

public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory,
        MessageSource, ApplicationEventPublisher, ResourcePatternResolver {
 
    /**
     * Return the unique id of this application context.
     * @return the unique id of the context, or null if none
     */
    String getId();
 
    /**
     * Return a friendly name for this context.
     * @return a display name for this context (never null)
    */
    String getDisplayName();
 
    /**
     * Return the timestamp when this context was first loaded.
     * @return the timestamp (ms) when this context was first loaded
     */
    long getStartupDate();
 
    /**
     * Return the parent context, or null if there is no parent
     * and this is the root of the context hierarchy.
     * @return the parent context, or null if there is no parent
     */
    ApplicationContext getParent();
 
    /**
     * Expose AutowireCapableBeanFactory functionality for this context.
     * This is not typically used by application code, except for the purpose
     * of initializing bean instances that live outside the application context,
     * applying the Spring bean lifecycle (fully or partly) to them.
     * Alternatively, the internal BeanFactory exposed by the
     * {@link ConfigurableApplicationContext} interface offers access to the
     * AutowireCapableBeanFactory interface too. The present method mainly
     * serves as convenient, specific facility on the ApplicationContext
     * interface itself.
     * @return the AutowireCapableBeanFactory for this context
     * @throws IllegalStateException if the context does not support
     * the AutowireCapableBeanFactory interface or does not hold an autowire-capable
     * bean factory yet (usually if refresh() has never been called)
     * @see ConfigurableApplicationContext#refresh()
     * @see ConfigurableApplicationContext#getBeanFactory()
     */
    AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException;
 
}

ApplicationContext是一个接口，它定义了一组实现高级IOC容器的标准，看看它的配置：

public interface ApplicationContext extends
 
EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory,
        MessageSource, ApplicationEventPublisher, ResourcePatternResolver {……}

比较XmlBeanFactory只继承DefaultListableBeanFactory,它显得豪华得多。可以看到它继承MessageSource，这样他支持不同的信息源，国际化实现也依赖它。它还继承ApplicationEventPublisher，这让它支持事件机制，可以利用它根据生命周期做更多的事……

总之ApplicationContext是一个高级形式的IOC容器，再以后的学习中它的出场率会很高，我们慢慢了解它。

小结

本问介绍了与IOC容器相关的基础类，主要为后面学习依赖注入做铺垫，下文将重点介绍依赖注入的详细实现。