BeanFactory接口提供了使用IOC容器的规范。在这个基础上，Spring还提供了符合这个IOC容器借口了的一系列容器的实现供开发人员使用。先以XmlBeanFactory的实现为例来
说明简单IOC容器的设计原理，。下图为XmlBeanFactory设计的类继承关系。
可以看到，作为一个简单IOC容器系列最底层实现的XmlBeanFactory，与我们在Spring应用中用到的上下文相比，有一个明显的特点：它只提供最基本IOC容器的功能。
我们可以认为直接的BeanFactory实现是IOC容器的基本形式，而各种ApplicationContext的实现是IOC容器的高级表现形式。下面是XmlBeanFactory源码：
1 public class XmlBeanFactory extends DefaultListableBeanFactory { 2 3 private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this); 4 5 6 /** 7 * Create a new XmlBeanFactory with the given resource, 8 * which must be parsable using DOM. 9 * @param resource XML resource to load bean definitions from 10 * @throws BeansException in case of loading or parsing errors 11 */ 12 public XmlBeanFactory(Resource resource) throws BeansException { 13 this(resource, null); 14 } 15 16 /** 17 * Create a new XmlBeanFactory with the given input stream, 18 * which must be parsable using DOM. 19 * @param resource XML resource to load bean definitions from 20 * @param parentBeanFactory parent bean factory 21 * @throws BeansException in case of loading or parsing errors 22 */ 23 public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException { 24 super(parentBeanFactory); 25 this.reader.loadBeanDefinitions(resource); 26 } 27 28 }
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这个容器了。