BeanFactory容器的设计原理

BeanFactory接口提供了使用IOC容器的规范。在这个基础上，Spring还提供了符合这个IOC容器借口了的一系列容器的实现供开发人员使用。先以XmlBeanFactory的实现为例来

说明简单IOC容器的设计原理，。下图为XmlBeanFactory设计的类继承关系。

可以看到，作为一个简单IOC容器系列最底层实现的XmlBeanFactory，与我们在Spring应用中用到的上下文相比，有一个明显的特点：它只提供最基本IOC容器的功能。

我们可以认为直接的BeanFactory实现是IOC容器的基本形式，而各种ApplicationContext的实现是IOC容器的高级表现形式。下面是XmlBeanFactory源码：

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继承自DefaultListableBeanFactory这个类，后者很重要，是我们经常要用到的IOC容器的实现，比如在设计应用上下文ApplicationContext时就会用到它。

在Spring中，实际上是把DefaultListableBeanFactory作为一个默认功能完整的IOC容器来使用的。XmlBeanFactory继承DefaultListableBeanFactory容器功能的同时，增加

了新的功能。从名字我们可以看出，它是一个与XML相关的BeanFactory，也就是说它是一个可以读取以XML文件方式定义的BeanDefinition的IOC容器。（关于BeanDefinition，我们可以理解为spring ioc的bean配置文件）

在XmlBeanFactory中，初始化了一个XmlBeanDefinitionReader对象，有了这个Reader对象，那些以XML方式定义的BeanDefinition就有了处理的地方。我们可以看到，对这

些XML形式的信息的处理实际上是由这个XmlBeanDefinitionReader来完成的。

构造XmlBeanFactory这个IOC容器时，需要指定BeanDefinition的信息来源，而这个信息来源需要封装成Spring中的Resource类，下面为Resource源码：

public interface Resource extends InputStreamSource {

    /**
     * Return whether this resource actually exists in physical form.
     * <p>This method performs a definitive existence check, whereas the
     * existence of a {@code Resource} handle only guarantees a
     * valid descriptor handle.
     */
    boolean exists();

    /**
     * Return whether the contents of this resource can be read,
     * e.g. via {@link #getInputStream()} or {@link #getFile()}.
     * <p>Will be {@code true} for typical resource descriptors;
     * note that actual content reading may still fail when attempted.
     * However, a value of {@code false} is a definitive indication
     * that the resource content cannot be read.
     * @see #getInputStream()
     */
    boolean isReadable();

    /**
     * Return whether this resource represents a handle with an open
     * stream. If true, the InputStream cannot be read multiple times,
     * and must be read and closed to avoid resource leaks.
     * <p>Will be {@code false} for typical resource descriptors.
     */
    boolean isOpen();

    /**
     * Return a URL handle for this resource.
     * @throws IOException if the resource cannot be resolved as URL,
     * i.e. if the resource is not available as descriptor
     */
    URL getURL() throws IOException;

    /**
     * Return a URI handle for this resource.
     * @throws IOException if the resource cannot be resolved as URI,
     * i.e. if the resource is not available as descriptor
     */
    URI getURI() throws IOException;

    /**
     * Return a File handle for this resource.
     * @throws IOException if the resource cannot be resolved as absolute
     * file path, i.e. if the resource is not available in a file system
     */
    File getFile() throws IOException;

    /**
     * Determine the content length for this resource.
     * @throws IOException if the resource cannot be resolved
     * (in the file system or as some other known physical resource type)
     */
    long contentLength() throws IOException;

    /**
     * Determine the last-modified timestamp for this resource.
     * @throws IOException if the resource cannot be resolved
     * (in the file system or as some other known physical resource type)
     */
    long lastModified() throws IOException;

    /**
     * Create a resource relative to this resource.
     * @param relativePath the relative path (relative to this resource)
     * @return the resource handle for the relative resource
     * @throws IOException if the relative resource cannot be determined
     */
    Resource createRelative(String relativePath) throws IOException;

    /**
     * Determine a filename for this resource, i.e. typically the last
     * part of the path: for example, "myfile.txt".
     * <p>Returns {@code null} if this type of resource does not
     * have a filename.
     */
    String getFilename();

    /**
     * Return a description for this resource,
     * to be used for error output when working with the resource.
     * <p>Implementations are also encouraged to return this value
     * from their {@code toString} method.
     * @see Object#toString()
     */
    String getDescription();

}

public interface InputStreamSource {

    /**
     * Return an {@link InputStream}.
     * <p>It is expected that each call creates a <i>fresh</i> stream.
     * <p>This requirement is particularly important when you consider an API such
     * as JavaMail, which needs to be able to read the stream multiple times when
     * creating mail attachments. For such a use case, it is <i>required</i>
     * that each {@code getInputStream()} call returns a fresh stream.
     * @return the input stream for the underlying resource (must not be {@code null})
     * @throws IOException if the stream could not be opened
     * @see org.springframework.mail.javamail.MimeMessageHelper#addAttachment(String, InputStreamSource)
     */
    InputStream getInputStream() throws IOException;

}

Resource是Spring用来封装I/O操作的类。比如我们的BeanDefinition信息的以XML文件的形式存在的，那么可以使用像ClassPathResource res = new ClassPathResource

("beans.xml")这样具体的ClassPathResource来构造需要的Resource，然后将Resource作为构造参数传递给XmlBeanFactory构造函数。这样，IOC容器就可以方便地定位到

需要的BeanDefinition信息来对Bean完成容器的初始化和依赖注入过程。

XmlBeanFactory的功能是建立在DefaultListableBeanFactory这个基本容器基础上的，并在这个基本容器的基本上实现了诸如XML读取的附加功能。如代码清单所示，在

XmlBeanFactory构造方法中需要得到Resource对象。对XmlBeanDefinitionReader初始化，以及使用这个对象来完成loadBeanDefinitions的调用，就是这个调用启动从

Resource中载人BeanDefinition的过程，loadBeanDefinitions同时也是IOC初始化的重要组成部分。

    public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
        return loadBeanDefinitions(new EncodedResource(resource));
    }

    public EncodedResource(Resource resource) {
        Assert.notNull(resource, "Resource must not be null");
        this.resource = resource;
    }

我们可以看到XmlBeanFactory使用了DefaultListableBeanFactory作为基类，DefaultListableBeanFactory是很重要的一个IOC实现，在其他IOC容器中，比如ApplicationContext，其实现的基本原理和XmlBeanFactory一样，不过ApplicationContext是继承了其他BeanFactory。

参考XmlBeanFactory的实现，我们以编程的方式使用DefaultListableBeanFactory。从中我们可以看到IOC容器使用的一些基本过程。尽管应用中我们很少会使用这样的原始

方式，但了解这个基本过程，对我们了解IOC容器的工作原理是有帮助的。因为这个编程式使用容器的过程，很清楚揭示了在IOC容器实现中的那些关键的类（比如Resource，

XmlBeanDefinitionReader，DefaultListableBeanFactory）之间的相互关系，例如它们是如何把IOC容器的功能解耦的，又是如何结合在一起为IOC容器服务的，等等。在代码

清单中我们可以看到编程式使用IOC容器的过程。

    　　 //指定文件
        ClassPathResource res= new ClassPathResource("beans.xml");
        //初始化DefaultListableBeanFactory
        DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
        //初始化构造XmlBeanDefinitionReader
        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);
        //加载BeanDefinition
        reader.loadBeanDefinitions(res)

这样，我们就可以通过factory对象来使用DefaultListableBeanFactory这个容器了。