前言
在面向对象系统中，对象封装了数据和对数据的处理，对象的依赖关系常常体现在对数据和方法的依赖上，这些依赖关系可以通过把对象的依赖注入交给框架或IoC容器来完成。
依赖控制反转的实现有很多种方式，在spring中，IoC容器是实现这个模式的载体，它可以在对象生成或初始化时直接将数据注入对象中，也可以通过将对象引用注入到对象数据域中的方式来注入对方法调用的依赖。这种方案把对象的依赖关系有序地建立起来，简化了对象依赖关系的管理，很大程度上简化了面向对象系统的复杂性。
IoC容器和依赖反转模式
控制反转时关于一个对象如何获取它所依赖的对象的引用，反转指的是责任的反转。通过使用IoC容器，对象依赖关系的管理被反转了，转到IoC容器中来了，对象之间的相互依赖关系由IoC容器进行管理，并由IoC容器完成对象的注入，这样很大程度上简化了应用的开发，把应用从复杂的对象依赖关系管理中解放出来。
BeanFactory和ApplicationContext
BeanFactory系列容器，这种容器只实现了容器的最基本功能，另一个是ApplicationContext应用上下文，作为容器的高级形态存在。它在简单容器的基础上增加了许多面向框架的特性。
Spring的IoC容器系列
BeanFactory和ApplicationContext可以看做容器的具体表现形式，面对不同的业务需求，作为IoC容器，也需要为它的具体实现指定基本的功能规范，这个功能规范的设计表现为接口类BeanFactory。
在基本IoC容器的接口定义和实现的基础上，spring通过定义BeanDefinition来管理基于spring的应用中各种对象以及它们之间的相互依赖关系。BeanDefinition抽象了我们队Bean的定义。对IoC容器来说，BeanDefinition就是对依赖反转模式中管理的对象依赖关系的数据抽象，也是容器实现依赖反转功能的核心数据结构。
Spring IoC容器的设计
BeanFactory的应用场景
BeanFactory定义了IoC容器最基本的形式，然而BeanFactory只是一个接口类，并没有给出容器的具体实现。
而DefaultListableBeanFactory、XMLBeanFactory、ApplicationBeanFactory等都可以看成时容器附加了某种功能的具体实现。
BeanFactory是怎样定义IoC容器的基本接口的
/**
* 根据bean名称返回一个Bean实例，如果是别名则转换回规范的名称
*/
Object getBean(String name) throws BeansException;
// 根据名称返回一个Bean实例，根据类型检索，如果类型不匹配则抛出BeansException异常
<T> T getBean(String name, Class<T> requiredType) throws BeansException;
// 同上，根据构造器参数或工厂方法参数匹配，如果不匹配则抛出BeansException
Object getBean(String name, Object... args) throws BeansException;
// 根据给定类型检索
<T> T getBean(Class<T> requiredType) throws BeansException;
// 根据构造器参数、工厂方法参数匹配
<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
// 根据名称判断是否包含此bean实例 如果给定别名则转换为规范名称
/**
*如果找到与给定名称匹配的bean定义或单例实例，则无论该命名bean定义是具体的还是抽 象的，惰性的或渴望的，此方法都将返回{@code true}。因此，请注意，此方法的{@code true} *返回值不一定表示{@link #getBean} *将能够获得具有相同名称的实例。
*/
boolean containsBean(String name);
// 返回{@code false}的方法不能清楚地表明是独立实例。它表示非单个实例，也可能对应于作用域bean。使用{@link #isPrototype}操作来显式*检查独立实例。
boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
// 检查对给定名称的getBean调用是否将返回可分配给指定目标类型的对象。
boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
// 根据名称获取类型
Class<?> getType(String name) throws NoSuchBeanDefinitionException;
// 返回给定bean名称的别名
String[] getAliases(String name);
这里定义的一系列接口方法，通过这一系列的BeanFactory接口，可以使用不同的Bean的检索方法，从而忽略具体的IoC容器实现，这些检索方法代表的是最为基本的容器入口。
BeanFactory容器的设计原理
以XMLBeanFactory为例，XMLBeanFactory继承自DefaultListanleBeanFactory，DefaultListanleBeanFactory作为一个默认的功能完整的IoC容器来使用的，XmlBeanFactory在继承了DefaultListanleBeanFactory容器的功能同时，增加了新的功能。它是一个与XML相关的BeanFactory，也就是可以以XML文件方式定义BeanDefinition的IoC容器。
在XMLBeanFactory中，初始化一个XMLBeanDefinationReader对象，对Xml形式的信息的处理实际上由这个对象来完成。
public class XmlBeanFactory extends DefaultListableBeanFactory {
private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);
public XmlBeanFactory(Resource resource) throws BeansException {
this(resource, null);
}
public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
super(parentBeanFactory);
this.reader.loadBeanDefinitions(resource);
}
}
构造XMLBeanFactory这个IoC容器时，需要指定BeanDefinition的信息来源，这个信息来源需要封装成spring中的Resource类来给出，Resource是spring用来封装IO操作的类。
BeanDefinition信息以XML文件形式存在的，Resource作为构造参数传递给XMLBeanFactory构造函数，这样IoC容器就可以方便地定位到需要的BeanDefinition信息来对Bean完成容器的初始化和依赖注入过程。
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="myTestBean" class="com.example.spring.MyTestBean"/>
</beans>
public class AppTest {
public static void main(String[] args) {
ClassPathResource res = new ClassPathResource("spring-config.xml");
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);
reader.loadBeanDefinitions(res);
MyTestBean myTestBean = (MyTestBean) factory.getBean("myTestBean");
System.out.println("******************"+myTestBean.getName());
}
}
在使用IoC容器时，需要如下几个步骤：
- 创建IoC配置文件的抽象资源，这个抽象资源包含了BeanDefinition的定义信息；
- 创建一个BeanFactory，这里使用DefaultListableBeanFactory；
- 创建一个载入BeanDefination的读取器，这里使用XMLBeanDefinitionReader来载入Xml文件形式的BeanDefination，通过一个回调配置给BeanFactory；
- 从定义好的资源位置读入配置信息，具体的解析过程由XMLBeanDefinitionReader来完成，完成整个载入和注册Bean定义之后，需要的IoC容器就建立起来了，这时候可以直接使用IoC容器。
ApplicationContext的应用场景
在spring中，系统已经为用户提供了许多已经定义好的容器实现，而不需要开发人员事必躬亲，ApplicationContext相比于基本IoC容器，除了能够提供基本功能，还为用户提供以下的附加服务。ApplicationContext是一个高级形态意义的IoC容器。
- 支持不同的信息源；扩展了MessageSource接口，支持国际化的实现；
- 访问资源；对ResourceLoader和Resource的支持，从不同地方得到Bean定义资源。
- 支持应用事件；继承接口ApplicationEventPublisher，从而在上下文中引入事件机制。
IoC容器的初始化过程
refresh()方法标志着IoC容器的正式启动，这个启动包括BeanDefination的Resouce定位、载入和注册三个基本过程。值得注意的是，这里的IoC初始化过程一般不包含bean依赖注入的实现，在IoC设计中，Bean定义的载入和依赖注入是两个独立的过程。除了被设置了lazyinit属性的bean，这种Bean的依赖注入在IoC容器初始化时就预先完成了。
BeanDefinition的Resource定位
ClassPathResource res = new ClassPathResource("spring-config.xml");
spring会在类路径中去寻找以文件形式存在的BeanDefination信息。
以FileSystemXMLApplicationContext为例，通过分析这个ApplicationContext的实现来看看它怎样完成这个Resouce定位过程。
public FileSystemXmlApplicationContext() {
}
/**
* Create a new FileSystemXmlApplicationContext for bean-style configuration.
* 为bean样式的配置创建
*/
public FileSystemXmlApplicationContext(ApplicationContext parent) {
super(parent);
}
/**
* Create a new FileSystemXmlApplicationContext, loading the definitions
* from the given XML file and automatically refreshing the context.
* 从给定的xml文件中加载定义context 并且自动刷新
*/
public FileSystemXmlApplicationContext(String configLocation) throws BeansException {
this(new String[] {configLocation}, true, null);
}
/**
* Create a new FileSystemXmlApplicationContext, loading the definitions
* from the given XML files and automatically refreshing the context.
* 从给定的xml文件中加载定义context 可加载多个xml配置 并且自动刷新到context
*/
public FileSystemXmlApplicationContext(String... configLocations) throws BeansException {
this(configLocations, true, null);
}
/**
* Create a new FileSystemXmlApplicationContext with the given parent,
* loading the definitions from the given XML files and automatically
* refreshing the context.
* 允许包含多个BeanDefination文件路径的同时，还可以指定自己的父类IoC容器
*/
public FileSystemXmlApplicationContext(String[] configLocations, ApplicationContext parent) throws BeansException {
this(configLocations, true, parent);
}
/**
* Create a new FileSystemXmlApplicationContext, loading the definitions
* from the given XML files.
* 从多个xml配置中加载BeanDefinition 并且可以指定是否自动刷新
*/
public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh) throws BeansException {
this(configLocations, refresh, null);
}
/**
* 在对象的初始化过程中，电泳refresh函数载入BeanDefinition，这个refresh启动了
* BeanDefinition的载入过程
*/
public FileSystemXmlApplicationContext(
String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
throws BeansException {
super(parent);
setConfigLocations(configLocations);
if (refresh) {
refresh();
}
}
/**
* 这时应用于文件系统中Resource的实现，通过构造一个FileSystemResource来得到一个在
* 文件系统中定位的BeanDefinition，这个getResourceByPath是BeanDefinitionReader
* 的loadBeanDefinition中被调用的。
* loadBeanDefinition采用了末班模式，具体的定位实现实际上是由各个子类来完成的
*/
@Override
protected Resource getResourceByPath(String path) {
if (path.startsWith("/")) {
path = path.substring(1);
}
return new FileSystemResource(path);
}
在构造函数中，实现了对configuration进行处理，让所有配置在文件系统中，以xml文件方式存在的BeanDefinition都能够得到有效的处理。
对BeanDefinition资源定位的过程，最初是由refresh来触发的，这个refresh的调用是在FileSystemXMLBeanFactory的构造函数中启动的。
那么，FileSystemXMLApplicationContext在什么地方定义了BeanDefination德福如期BeanDefinitionReader，从而完成BeanDefination信息的读入呢？
AbstractRefreshableApplicationContext的refreshBeanFactory被FileSystemCM了ApplicationContext的构造函数中的refresh调用。在这个方法中，通过createBeanFactory构建了一个IoC容器供ApplicationContext使用，这就是之前提过的DefaultListableBeanFactory,同事启动了loadBeanDefinitions来载入BeanDefination。
在初始化FileSystemXMLApplicationContext的过程中，通过IoC容器的初始化的refresh来启动整个调用，具体的资源载入在XMLBeanDefinitionReader的基类AbstractBeanDefinationReader中可以看到载入过程的具体实现。
@Override
/**
* 此实现对此上下文的基础bean工厂执行实际的刷新，关闭前一个bean工厂（如果有），
* 并为上下文生命周期的下一阶段初始化一个新bean工厂。
*/
@Override
protected final void refreshBeanFactory() throws BeansException {
// 如果已经建立BeanFactory 则销毁并关闭该BeanFactory
if (hasBeanFactory()) {
destroyBeans();
closeBeanFactory();
}
try {
// 创建并设置持有DefaultListableBeanFactory的地方
// 同时调用loadBeanDefinitions再载入BeanDefinition的信息
DefaultListableBeanFactory beanFactory = createBeanFactory();
beanFactory.setSerializationId(getId());
customizeBeanFactory(beanFactory);
loadBeanDefinitions(beanFactory);
this.beanFactory = beanFactory;
}
catch (IOException ex) {
throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
}
}
/**
* 为此上下文创建一个内部工厂 根据容器已有双亲IoC容器的信息来生成DefaultListableBeanFactory的双亲容器
*/
protected DefaultListableBeanFactory createBeanFactory() {
return new DefaultListableBeanFactory(getInternalParentBeanFactory());
}
/**
* 对Resource的路径模式进行解析 得到需要的Resource集合 这些Resource集合指向我们定义的BeanDefinition信息
* 可以是多个文件
*/
public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException {
ResourceLoader resourceLoader = getResourceLoader();
if (resourceLoader == null) {
throw new BeanDefinitionStoreException(
"Cannot load bean definitions from location [" + location + "]: no ResourceLoader available");
}
if (resourceLoader instanceof ResourcePatternResolver) {
// Resource pattern matching available.
try {
// 调用DefaultResourceLoader完成具体的Resource定位
Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
int count = loadBeanDefinitions(resources);
if (actualResources != null) {
Collections.addAll(actualResources, resources);
}
if (logger.isTraceEnabled()) {
logger.trace("Loaded " + count + " bean definitions from location pattern [" + location + "]");
}
return count;
}
catch (IOException ex) {
throw new BeanDefinitionStoreException(
"Could not resolve bean definition resource pattern [" + location + "]", ex);
}
}
else {
// Can only load single resources by absolute URL.
Resource resource = resourceLoader.getResource(location);
int count = loadBeanDefinitions(resource);
if (actualResources != null) {
actualResources.add(resource);
}
if (logger.isTraceEnabled()) {
logger.trace("Loaded " + count + " bean definitions from location [" + location + "]");
}
return count;
}
}
@Override
public Resource getResource(String location) {
Assert.notNull(location, "Location must not be null");
for (ProtocolResolver protocolResolver : getProtocolResolvers()) {
Resource resource = protocolResolver.resolve(location, this);
if (resource != null) {
return resource;
}
}
if (location.startsWith("/")) {
return getResourceByPath(location);
}
// 这里处理带有classpath标识的Resource
else if (location.startsWith(CLASSPATH_URL_PREFIX)) {
return new ClassPathResource(location.substring(CLASSPATH_URL_PREFIX.length()), getClassLoader());
}
else {
try {
// Try to parse the location as a URL...
// 这里的处理URL标识的Resource定位
URL url = new URL(location);
return (ResourceUtils.isFileURL(url) ? new FileUrlResource(url) : new UrlResource(url));
}
catch (MalformedURLException ex) {
// No URL -> resolve as resource path.
// 如果既不是classpath标识 又不是URL标识的Resource定位 则把getResource的
// 重任交给getResourceByPath 默认的实现是得到一个ClassPathContextResource 常常用子类来实现
return getResourceByPath(location);
}
}
}
getResourceByPath会被子类FileSystemXmlApplicationContext实现，这个方法返回的是一个FileSystemResource对象，通过这个对象，spring可以进行相关的IO操作，完成BeanDefinition定位。
@Override
protected Resource getResourceByPath(String path) {
if (path.startsWith("/")) {
path = path.substring(1);
}
return new FileSystemResource(path);
}
如果是其他的ApplicationContext，那么会对应生成其他种类的Resource，如ClassPathResource、ServletContextResource等。
至此，BeanDefinition定位已经完成，在此基础上，就可以通过返回的Resource对象来进行BeanDefinition的载入了，为BeanDefination的载入创造了IO操作的条件，但是具体的数据还没有开始读入，这些数据的读入将在BeanDefinition的载入和解析中来完成。
BeanDefinition的载入和解析
在完成对代表BeanDefinition的Resource定位的分析后，接下来据了解BeanDefinition信息的载入过程。
对IoC容器来说这个载入过程相当于把定义的BeanDefination在IoC容器中转化成一个Spring内部表示的数据结构的过程。IoC容器对Bean的管理和依赖注入功能的实现，是通过对其持有的BeanDefinition进行各种相关操作来完成的。这些BeanDefinition数据在IoC容器中通过一个HashMap来保持和维护。
refresh()方法的调用标志着容器初始化的开始，这些初始化对象就是BeanDefinition数据。该方法在AbstractApplicationContext类中，它详细描述了整个ApplicationContext的初始化过程，这些过程为Bean的生命周期管理提供了条件。
/**
* 加载或刷新配置的持久性表示形式，它可能来自基于Java的配置，XML文件，属性文件，关系数据库模式或其他格式。
*/
void refresh() throws BeansException, IllegalStateException;
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
prepareRefresh();
// 在子类中启动refreshBeanFactory()的地方，告诉子类刷新内部BeanFactory
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// 配置工厂的标准上下文特征，例如上下文的ClassLoader和后处理器。
prepareBeanFactory(beanFactory);
try {
// 在标准初始化之后，修改应用程序上下文的内部bean工厂。所有bean定义都将被加载，
// 但是还没有实例化bean
postProcessBeanFactory(beanFactory);
StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
// 实例化并调用已经注册的BeanFactory后置处理器
invokeBeanFactoryPostProcessors(beanFactory);
// 实例化并调用Bean后置处理器
registerBeanPostProcessors(beanFactory);
beanPostProcess.end();
// 对上下文中的消息源进行初始化
initMessageSource();
// 初始化上下文汇总的事件机制
initApplicationEventMulticaster();
// 初始化其他特殊Bean
onRefresh();
// 检查监听Bean并将这些Bean向容器中注册
registerListeners();
// 实例化所有的（non-lazy-init）单件
finishBeanFactoryInitialization(beanFactory);
// 发布容器事件 结束Refresh过程
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// 为防止bean资源占用，在异常处理中，销毁已经在前面过程中生成的单例Bean
destroyBeans();
// 重置 `active`标志
cancelRefresh(ex);
throw ex;
}
finally {
resetCommonCaches();
contextRefresh.end();
}
}
}
refreshBeanFactory()
refreshBeanFactory()中创建了BeanFactory。
@Override
protected final void refreshBeanFactory() throws BeansException {
// 如果已经建立BeanFactory 则销毁并关闭该BeanFactory
if (hasBeanFactory()) {
destroyBeans();
closeBeanFactory();
}
try {
// 创建并设置持有DefaultListableBeanFactory的地方
// 同时调用loadBeanDefinitions再载入BeanDefinition的信息
DefaultListableBeanFactory beanFactory = createBeanFactory();
beanFactory.setSerializationId(getId());
customizeBeanFactory(beanFactory);
// 启动对BeanDefinition的载入
loadBeanDefinitions(beanFactory);
this.beanFactory = beanFactory;
}
catch (IOException ex) {
throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
}
}
这里调用的loadBeanDefinitions()实际上是一个抽象方法，实际的载入过程在AbstractRefreshableApplicationContext的子类AbstractXmlApplicationContext中实现。
/**
* 通过xmlBeanDefinition读取器 将Bean定义加载到给定的BeanFactory中。
*/
@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
// 创建XMLBeanDefinitionReader 并通过回调设置到BeanFactory中去
XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
// 设置XmlBeanDefinitionReader 为其配置ResourceLoader
// 因为DefaultResourceLoader是父类，所以this可以直接被调用
beanDefinitionReader.setEnvironment(this.getEnvironment());
beanDefinitionReader.setResourceLoader(this);
beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
// 启动Bean定义信息载入的过程
initBeanDefinitionReader(beanDefinitionReader);
loadBeanDefinitions(beanDefinitionReader);
}
接着就是loadBeanDefinitions()调用的地方，首先得到BeanDefinition信息的Resource定位，然后直接调用XMLBeanDefinitionReader来读取，具体的载入过程是委托给BeanDefinitionReader完成的，因为这里的BeanDefinition是通过Xml文件定义的，所以这里使用XmlBeanDefinitionReader来载入到BeanDefinition容器中。
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
// 以Resource的方式获得配置文件的资源位置
Resource[] configResources = getConfigResources();
if (configResources != null) {
reader.loadBeanDefinitions(configResources);
}
// 以string的形式获得配置文件的位置
String[] configLocations = getConfigLocations();
if (configLocations != null) {
reader.loadBeanDefinitions(configLocations);
}
}
到此为止，我们知道了：
- 在FileSystemXmlApplicationContext的过程是通过调用IoC容器的refresh来启动整个BeanDefinition的载入过程的；
- 这个载入过程是通过定义的XMLBeanDefinitionReader来完成的；
- 实际使用的IoC容器是DefaultListableBeanFactory；
因为spring可以对应不同形式的BeanDefinition，由于这里使用的是Xml方式的定义，所以需要使用XMLBeanDefinitionReader，如果使用了其他BeanDefinition形式就得使用对应的BeanDefinitionReader来完成数据载入工作。
可以看出是在reader.loadBeanDefinitions()中开始载入的。
@Override
public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {
// 如果Resource为空 则停止BeanDefinition的载入
// 然后启动载入BeanDefinition的过程，这个过程会遍历整个Resource集合所包含的BeanDefinition信息
Assert.notNull(resources, "Resource array must not be null");
int count = 0;
for (Resource resource : resources) {
count += loadBeanDefinitions(resource);
}
return count;
}
这里调用的是int loadBeanDefinitions(Resource resource)方法，这个方法是一个接口方法，具体实现在XmlBeanDefinitionReader中。
在读取器中，需要得到代表XML文件的Resource，因为这个Resource对象封装了对XML文件的IO操作，所以读取器可以再打开IO流后得到XML的文件对象，有了这个文件对象，就可以按照spring的Bean定义规则来对这个XML文档树进行解析，这个解析是交给
BeanDefinationParserDelegate来完成的。
public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
Assert.notNull(encodedResource, "EncodedResource must not be null");
if (logger.isTraceEnabled()) {
logger.trace("Loading XML bean definitions from " + encodedResource);
}
Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
if (!currentResources.add(encodedResource)) {
throw new BeanDefinitionStoreException(
"Detected cyclic loading of " + encodedResource + " - check your import definitions!");
}
// 这里得到XML文件，并得到IO的InputSource准备进行读取
try (InputStream inputStream = encodedResource.getResource().getInputStream()) {
InputSource inputSource = new InputSource(inputStream);
if (encodedResource.getEncoding() != null) {
inputSource.setEncoding(encodedResource.getEncoding());
}
return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
}
catch (IOException ex) {
throw new BeanDefinitionStoreException(
"IOException parsing XML document from " + encodedResource.getResource(), ex);
}
finally {
currentResources.remove(encodedResource);
if (currentResources.isEmpty()) {
this.resourcesCurrentlyBeingLoaded.remove();
}
}
}
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
throws BeanDefinitionStoreException {
try {
// 这里取得XML文件的Document对象，这个解析过程是由documentLoader完成的
Document doc = doLoadDocument(inputSource, resource);
// 这里启动的是对BeanDefination解析的详细过程，这个解析会使用到Spring的Bean配置规则
int count = registerBeanDefinitions(doc, resource);
if (logger.isDebugEnabled()) {
logger.debug("Loaded " + count + " bean definitions from " + resource);
}
return count;
}
catch (BeanDefinitionStoreException ex) {
throw ex;
}
catch (SAXParseException ex) {
throw new XmlBeanDefinitionStoreException(resource.getDescription(),
"Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);
}
catch (SAXException ex) {
throw new XmlBeanDefinitionStoreException(resource.getDescription(),
"XML document from " + resource + " is invalid", ex);
}
catch (ParserConfigurationException ex) {
throw new BeanDefinitionStoreException(resource.getDescription(),
"Parser configuration exception parsing XML from " + resource, ex);
}
catch (IOException ex) {
throw new BeanDefinitionStoreException(resource.getDescription(),
"IOException parsing XML document from " + resource, ex);
}
catch (Throwable ex) {
throw new BeanDefinitionStoreException(resource.getDescription(),
"Unexpected exception parsing XML document from " + resource, ex);
}
spring的BeanDefinition是怎样按照Spring的Bean语义要求进行解析并转化为容器内部数据结构的？
这个过程在registryBeanDefinition(doc,resource)中完成；
/**
* 注册给定DOM文档中包含的bean定义
*/
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
// 这里得到DocumentReader来对XML的BeanDefinition进行解析
BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
int countBefore = getRegistry().getBeanDefinitionCount();
// 具体的解析过程在registerBeanDefinitions中完成
documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
return getRegistry().getBeanDefinitionCount() - countBefore;
}
BeanDefinition的载入分为两个部分，首先通过调用XML的解析器得到document对象，在完成通用的XML解析以后，按照spring的Bean规则进行解析，这个过程在documentReader中实现，设置DefaultBeanDefinitionDocumentReader，然后再完成BeanDefinition的处理，处理结果由BeanDefinitionHolder对象来持有，它的生成是通过对Document文档树的内容解析来完成的。
@Override
public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
this.readerContext = readerContext;
doRegisterBeanDefinitions(doc.getDocumentElement());
}
/**
* 在给定的根bean元素中注册每个bean定义。
*/
@SuppressWarnings("deprecation") // for Environment.acceptsProfiles(String...)
protected void doRegisterBeanDefinitions(Element root) {
BeanDefinitionParserDelegate parent = this.delegate;
this.delegate = createDelegate(getReaderContext(), root, parent);
//...
preProcessXml(root);
parseBeanDefinitions(root, this.delegate);
postProcessXml(root);
this.delegate = parent;
}
/**
* 处理给定的bean元素，解析BeanDefinition并将其注册到注册表中。
*/
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
// BeanDefinitionHolder是BeanDefinition的封装类，封装了BeanDefinition Bean的名字和别名
// 用它来完成向IoC容器的注册 得到这个BeanDefinitionHolder就意味着BeanDefinition是通过
// BeanDefinitionParserDelegate对XML元素的信息按照spring的Bean规则进行解析得到的
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
// 向IoC容器注册解析得到的BeanDefinition
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
}
catch (BeanDefinitionStoreException ex) {
getReaderContext().error("Failed to register bean definition with name '" +
bdHolder.getBeanName() + "'", ele, ex);
}
// 在BeanDefinition向IoC容器注册完以后，发送消息
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}
具体的Spring BeanDefination的解析是在BeanDefinitionParserDelegate中完成的，这个类包含了对各种spring Bean定义规则的处理。
@Nullable
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
// 获取<bean>元素中定义的id、name和aliase 属性值
String id = ele.getAttribute(ID_ATTRIBUTE);
String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
List<String> aliases = new ArrayList<>();
if (StringUtils.hasLength(nameAttr)) {
String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
aliases.addAll(Arrays.asList(nameArr));
}
String beanName = id;
if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
beanName = aliases.remove(0);
if (logger.isTraceEnabled()) {
logger.trace("No XML 'id' specified - using '" + beanName +
"' as bean name and " + aliases + " as aliases");
}
}
if (containingBean == null) {
checkNameUniqueness(beanName, aliases, ele);
}
// 引发对Bean元素的详细解析
AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
if (beanDefinition != null) {
if (!StringUtils.hasText(beanName)) {
try {
if (containingBean != null) {
beanName = BeanDefinitionReaderUtils.generateBeanName(
beanDefinition, this.readerContext.getRegistry(), true);
}
else {
beanName = this.readerContext.generateBeanName(beanDefinition);
// Register an alias for the plain bean class name, if still possible,
// if the generator returned the class name plus a suffix.
// This is expected for Spring 1.2/2.0 backwards compatibility.
String beanClassName = beanDefinition.getBeanClassName();
if (beanClassName != null &&
beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
!this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
aliases.add(beanClassName);
}
}
if (logger.isTraceEnabled()) {
logger.trace("Neither XML 'id' nor 'name' specified - " +
"using generated bean name [" + beanName + "]");
}
}
catch (Exception ex) {
error(ex.getMessage(), ele);
return null;
}
}
String[] aliasesArray = StringUtils.toStringArray(aliases);
return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
}
return null;
}
Bean元素解析的过程也就是BeanDefinition依据XML的<bean>定义被创建的过程，这个BeanDefinition可以看成是对<bean>定义的抽象。BeanDefinition数据类型是非常重要的，它封装了很多基本数据，这些基本数据都是IoC容器需要的，有了这些基本数据，IoC容器才能对Bean配置进行处理，实现相应的容器特性。
/**
* 解析bean定义本身，而不考虑名称或别名。如果在bean定义的解析过程中发生问题，则可能返回null
*/
@Nullable
public AbstractBeanDefinition parseBeanDefinitionElement(
Element ele, String beanName, @Nullable BeanDefinition containingBean) {
this.parseState.push(new BeanEntry(beanName));
// 这里只读取定义的<bean>中设置的class名字，然后载入到BeanDefinition中去，
// 只是做个记录并不涉及对象的实例化过程，对象的实例化实际上是在依赖注入时完成的
String className = null;
if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
}
String parent = null;
if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
parent = ele.getAttribute(PARENT_ATTRIBUTE);
}
try {
// 生成需要的BeanDefinition对象，为Bean定义信息的载入做准备
AbstractBeanDefinition bd = createBeanDefinition(className, parent);
// 对当前Bean元素进行属性解析 并设置描述信息
parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
// 对各种<bean>元素的信息进行解析的地方
parseMetaElements(ele, bd);
parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
// 解析<bean>的构造函数设置
parseConstructorArgElements(ele, bd);
// 解析<bean>的property设置
parsePropertyElements(ele, bd);
parseQualifierElements(ele, bd);
bd.setResource(this.readerContext.getResource());
bd.setSource(extractSource(ele));
return bd;
}
// 下面这些异常是在配置Bean出现问题时经常会看到
catch (ClassNotFoundException ex) {
error("Bean class [" + className + "] not found", ele, ex);
}
catch (NoClassDefFoundError err) {
error("Class that bean class [" + className + "] depends on not found", ele, err);
}
catch (Throwable ex) {
error("Unexpected failure during bean definition parsing", ele, ex);
}
finally {
this.parseState.pop();
}
return null;
}
接下来举一个对property进行解析的例子来完成对整个BeanDefinition载入过程的分析。
/**
* 对指定Bean元素的property子元素集合进行解析
*/
public void parsePropertyElements(Element beanEle, BeanDefinition bd) {
// 遍历所有Bean元素下定义的property
NodeList nl = beanEle.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
// 判断是否为property元素
if (isCandidateElement(node) && nodeNameEquals(node, PROPERTY_ELEMENT)) {
parsePropertyElement((Element) node, bd);
}
}
}
/**
* 解析property元素
*/
public void parsePropertyElement(Element ele, BeanDefinition bd) {
// 取得property的名字
String propertyName = ele.getAttribute(NAME_ATTRIBUTE);
if (!StringUtils.hasLength(propertyName)) {
error("Tag 'property' must have a 'name' attribute", ele);
return;
}
this.parseState.push(new PropertyEntry(propertyName));
try {
// 如果同一个Bean中已经有同名的property存在，则不进行解析直接返回
// 也就是说如果property名字重复，那么起作用的只有第一个
if (bd.getPropertyValues().contains(propertyName)) {
error("Multiple 'property' definitions for property '" + propertyName + "'", ele);
return;
}
// 这里是解析property值得地方，返回的对象对应对Bean定义的property属性设置的解析结果
// 这个解析结果会封装到PropertyValue对象中，然后设置到BeanDefinitionHolder中去
Object val = parsePropertyValue(ele, bd, propertyName);
PropertyValue pv = new PropertyValue(propertyName, val);
parseMetaElements(ele, pv);
pv.setSource(extractSource(ele));
bd.getPropertyValues().addPropertyValue(pv);
}
finally {
this.parseState.pop();
}
}
/**
* 获取属性元素的值，可能是列表等
*/
@Nullable
public Object parsePropertyValue(Element ele, BeanDefinition bd, @Nullable String propertyName) {
String elementName = (propertyName != null ?
"<property> element for property '" + propertyName + "'" :
"<constructor-arg> element");
NodeList nl = ele.getChildNodes();
Element subElement = null;
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT) &&
!nodeNameEquals(node, META_ELEMENT)) {
if (subElement != null) {
error(elementName + " must not contain more than one sub-element", ele);
}
else {
subElement = (Element) node;
}
}
}
// 判断property的属性是ref还是value 不允许同时是ref和value
boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE);
boolean hasValueAttribute = ele.hasAttribute(VALUE_ATTRIBUTE);
if ((hasRefAttribute && hasValueAttribute) ||
((hasRefAttribute || hasValueAttribute) && subElement != null)) {
error(elementName +
" is only allowed to contain either 'ref' attribute OR 'value' attribute OR sub-element", ele);
}
// 如果是ref创建一个ref的数据对象RuntimeBeanDefinition 这个对象封装了ref的信息
if (hasRefAttribute) {
String refName = ele.getAttribute(REF_ATTRIBUTE);
if (!StringUtils.hasText(refName)) {
error(elementName + " contains empty 'ref' attribute", ele);
}
RuntimeBeanReference ref = new RuntimeBeanReference(refName);
ref.setSource(extractSource(ele));
return ref;
}
// 如果是value 创建一个value的数据对象TypedStringValue 这个对象封装了value的信息
else if (hasValueAttribute) {
TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));
valueHolder.setSource(extractSource(ele));
return valueHolder;
}
// 如果该节点还有子元素 触发对子元素的解析
else if (subElement != null) {
return parsePropertySubElement(subElement, bd);
}
else {
// Neither child element nor "ref" or "value" attribute found.
error(elementName + " must specify a ref or value", ele);
return null;
}
}
接下来是对property子元素的解析过程，Array、List、Set、Map、Prop等各种元素都会在这里进行解析，生成对应的数据对象，如ManagedList、ManagedArray等。这些Managed类是spring对具体BeanDefinition的数据封装。
/**
* 解析property或constructor-arg的ref、value或子元素
*/
@Nullable
public Object parsePropertySubElement(Element ele, @Nullable BeanDefinition bd, @Nullable String defaultValueType) {
if (!isDefaultNamespace(ele)) {
return parseNestedCustomElement(ele, bd);
}
else if (nodeNameEquals(ele, BEAN_ELEMENT)) {
BeanDefinitionHolder nestedBd = parseBeanDefinitionElement(ele, bd);
if (nestedBd != null) {
nestedBd = decorateBeanDefinitionIfRequired(ele, nestedBd, bd);
}
return nestedBd;
}
else if (nodeNameEquals(ele, REF_ELEMENT)) {
// A generic reference to any name of any bean.
String refName = ele.getAttribute(BEAN_REF_ATTRIBUTE);
boolean toParent = false;
if (!StringUtils.hasLength(refName)) {
// A reference to the id of another bean in a parent context.
refName = ele.getAttribute(PARENT_REF_ATTRIBUTE);
toParent = true;
if (!StringUtils.hasLength(refName)) {
error("'bean' or 'parent' is required for <ref> element", ele);
return null;
}
}
if (!StringUtils.hasText(refName)) {
error("<ref> element contains empty target attribute", ele);
return null;
}
RuntimeBeanReference ref = new RuntimeBeanReference(refName, toParent);
ref.setSource(extractSource(ele));
return ref;
}
else if (nodeNameEquals(ele, IDREF_ELEMENT)) {
return parseIdRefElement(ele);
}
else if (nodeNameEquals(ele, VALUE_ELEMENT)) {
return parseValueElement(ele, defaultValueType);
}
else if (nodeNameEquals(ele, NULL_ELEMENT)) {
// It's a distinguished null value. Let's wrap it in a TypedStringValue
// object in order to preserve the source location.
TypedStringValue nullHolder = new TypedStringValue(null);
nullHolder.setSource(extractSource(ele));
return nullHolder;
}
else if (nodeNameEquals(ele, ARRAY_ELEMENT)) {
return parseArrayElement(ele, bd);
}
else if (nodeNameEquals(ele, LIST_ELEMENT)) {
return parseListElement(ele, bd);
}
else if (nodeNameEquals(ele, SET_ELEMENT)) {
return parseSetElement(ele, bd);
}
else if (nodeNameEquals(ele, MAP_ELEMENT)) {
return parseMapElement(ele, bd);
}
else if (nodeNameEquals(ele, PROPS_ELEMENT)) {
return parsePropsElement(ele);
}
else {
error("Unknown property sub-element: [" + ele.getNodeName() + "]", ele);
return null;
}
}
/**
* Parse a list element.
*/
public List<Object> parseListElement(Element collectionEle, @Nullable BeanDefinition bd) {
String defaultElementType = collectionEle.getAttribute(VALUE_TYPE_ATTRIBUTE);
NodeList nl = collectionEle.getChildNodes();
ManagedList<Object> target = new ManagedList<>(nl.getLength());
target.setSource(extractSource(collectionEle));
target.setElementTypeName(defaultElementType);
target.setMergeEnabled(parseMergeAttribute(collectionEle));
// 具体的List元素解析过程
parseCollectionElements(nl, target, bd, defaultElementType);
return target;
}
protected void parseCollectionElements(
NodeList elementNodes, Collection<Object> target, @Nullable BeanDefinition bd, String defaultElementType) {
// 遍历所有的元素节点 并判断其类型是否为Element
for (int i = 0; i < elementNodes.getLength(); i++) {
Node node = elementNodes.item(i);
if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT)) {
// 加入到target中，target是一个ManagedList 同时触发对下一层子元素的解析过程 递归调用
target.add(parsePropertySubElement((Element) node, bd, defaultElementType));
}
}
}
经过这样逐层地解析，我们在XML文件中定义的BeanDefinition就被整个载入到IoC容器中，并在容器中建立了数据映射。这些数据以AbstractBeanDefinition为入口，让IoC容器执行索引、查询和操作。经过以上的载入过程，IoC容器大致完成了管理Bean对象的数据准备工作。但是重要的依赖注入实际上还未发生，现在IoC容器BeanDefinition中存在的还只是一些静态配置的信息。容器还没有完全起作用，要完全发挥容器的作用，还需完成数据向容器的注册。
BeanDefinition在IoC容器中的注册
在载入和解析过程完成后，用户自定义的BeanDefinition信息已经在IoC容器内建立起自己的数据结构以及相应的数据表示，但是此时这些数据还不能供IOC容器直接使用，需要在IoC容器中对这些BeanDefinition进行注册。
这个注册为IoC容器提供了更友好的使用方式，在DefaultListableBeanFactory中，是通过一个HashMap来持有载入的BeanDefinition。
/** Map of bean definition objects, keyed by bean name. */
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);
将解析得到的BeanDefinition向IoC容器中的BeanDefinitionMap注册的过程是在载入BeanDefinition完后才进行的。
在DefaultListableBeanFactory中实现了BeanDefinitionRegistry的接口，这个接口的实现完成BeanDefinition向容器的注册，这个过程简单来说就是将解析得到的BeanDefinition设置到concurrentHashMap中去(以前是HashMap需要进行手动加锁处理)。
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);
}
}
BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
if (existingDefinition != null) {
// 检查是不是有相同名字的BeanDefinition已经在IoC容器中注册了，如果有相同名字的
// BeanDefinition 但又不允许覆盖，就会抛出异常
if (!isAllowBeanDefinitionOverriding()) {
throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
}
// BeanDefinition的Role 用户定义的Bean不能覆盖容器内部使用的
else if (existingDefinition.getRole() < beanDefinition.getRole()) {
// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
/**
* //Bean角色：
* //用户
* int ROLE_APPLICATION = 0;
* //某些复杂的配置
* int ROLE_SUPPORT = 1;
* //完全内部使用
* int ROLE_INFRASTRUCTURE = 2;
*/
if (logger.isInfoEnabled()) {
logger.info("Overriding user-defined bean definition for bean '" + beanName +
"' with a framework-generated bean definition: replacing [" +
existingDefinition + "] with [" + beanDefinition + "]");
}
}
// 同名称获取得到不同的BeanDefinition说明 名称重复
else if (!beanDefinition.equals(existingDefinition)) {
if (logger.isDebugEnabled()) {
logger.debug("Overriding bean definition for bean '" + beanName +
"' with a different definition: replacing [" + existingDefinition +
"] with [" + beanDefinition + "]");
}
}
else {
if (logger.isTraceEnabled()) {
logger.trace("Overriding bean definition for bean '" + beanName +
"' with an equivalent definition: replacing [" + existingDefinition +
"] with [" + beanDefinition + "]");
}
}
this.beanDefinitionMap.put(beanName, beanDefinition);
}
else {
// 检查该工厂的Bean创建阶段是否已经开始，即在此期间是否已将任何Bean标记为已创建。
if (hasBeanCreationStarted()) {
// Cannot modify startup-time collection elements anymore (for stable iteration)
synchronized (this.beanDefinitionMap) {
this.beanDefinitionMap.put(beanName, beanDefinition);
List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
updatedDefinitions.addAll(this.beanDefinitionNames);
updatedDefinitions.add(beanName);
this.beanDefinitionNames = updatedDefinitions;
// 更新工厂内部的手动单例名称集。
removeManualSingletonName(beanName);
}
}
else {
// Still in startup registration phase
// 将beanName作为key BeanDefinition对象作为value 放入容器内部指定的Map中
this.beanDefinitionMap.put(beanName, beanDefinition);
// 记录添加的beanName
this.beanDefinitionNames.add(beanName);
// 更新工厂内部的手动单例名称集合
removeManualSingletonName(beanName);
}
this.frozenBeanDefinitionNames = null;
}
// 如果容器内存在该BeanName对应的BeanDefinition 并且该BeanName已经注册
// 则重置给定bean的所有BeanDefinition缓存，包括从其派生的bean的缓存。
if (existingDefinition != null || containsSingleton(beanName)) {
resetBeanDefinition(beanName);
}
// 如果所有的Bean都被缓存 则删除有关按类型映射的所有内容。
else if (isConfigurationFrozen()) {
clearByTypeCache();
}
}
完成了BeanDefinition的注册，就完成了IoC容器的初始化过程，此时使用的IoC容器DefaultListableBeanFactory中已经建立了整个Bean的配置信息。这些信息时容器建立依赖反转的基础，有了这些基础数据接下来进行依赖注入。
1410
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
