二、容器的基本实现

2.1 容器的基本用法

package com.xxx;
public class Hello {public void sayHello() {System.out.println("Hello, spring");}
}
public static void main(String[] args) {//XmlBeanFactory 在 Spring3.1 以后废弃BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("spring-config.xml"));Hello hello = (Hello)beanFactory.getBean("hello");hello.sayHello();//现在推荐使用的是 ApplicationContextApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-config.xml");Hello hello = (Hello)applicationContext.getBean("hello");hello.sayHello();
}

<?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="hello" class="com.xxx.Hello"></bean></beans>

2.2 功能分析

2.4 Spring的结构组成

2.4.1 beans包的层级结构

2.4.2 核心类介绍

 上面类图中各个类及接口的作用如下：

XmlBeanFactory对DefaultListableBeanFactory类进行了扩展，主要用于从XML文档中读取BeanDefinition，对于注册及获取Bean都是使用从父类DefaultListableBeanFactory继承的方法去实现，而唯独与父类不同的个性化实现就是增加了XmlBeanDefinitionReader类型的reader属性。在XmlBeanFactory中主要使用reader属性对资源文件进行读取和注册。

 经过以上分析可以梳理出整个XML配置文件读取的大致力流程：

2.5 容器的基础XmlBeanFactory（Spring3.1后废弃）

通过上面的内容我们对spring的容器已经有了大致的了解，接下来我们详细探索每个步骤的详细实现，接下来要分析的功能都是基于如下代码：

BeanFactory bf = new XmlBeanFactory( new ClassPathResource("spring-config.xml"));

首先调用ClassPathResource的构造函数来构造Resource资源文件的实例对象，这样后续的资源处理就可以用Resource提供的各种服务来操作了。有了Resource后就可以对BeanFactory进行初始化操作，那配置文件是如何封装的呢？

2.5.1 配置文件封装

Spring的配置文件读取是通过ClassPathResource进行封装的，Spring对其内部使用到的资源实现了自己的抽象结构：Resource接口来封装底层资源，如下源码：

public interface InputStreamSource {InputStream getInputStream() throws IOException;
}
public interface Resource extends InputStreamSource {boolean exists();default boolean isReadable() {return true;}default boolean isOpen() {return false;}default boolean isFile() {return false;}URL getURL() throws IOException;URI getURI() throws IOException;File getFile() throws IOException;default ReadableByteChannel readableChannel() throws IOException {return Channels.newChannel(getInputStream());}long contentLength() throws IOException;long lastModified() throws IOException;Resource createRelative(String relativePath) throws IOException;String getFilename();String getDescription();
}

 InputStreamSource封装任何能返回InputStream的类，比如File、Classpath下的资源和Byte Array等， 它只有一个方法定义：getInputStream()，该方法返回一个新的InputStream对象 。

Resource接口抽象了所有Spring内部使用到的底层资源：File、URL、Classpath等。首先，它定义了3个判断当前资源状态的方法：存在性(exists)、可读性(isReadable)、是否处于打开状态(isOpen)。另外，Resource接口还提供了不同资源到URL、URI、File类型的转换，以及获取lastModified属性、文件名(不带路径信息的文件名，getFilename())的方法，为了便于操作，Resource还提供了基于当前资源创建一个相对资源的方法：createRelative()，还提供了getDescription()方法用于在错误处理中的打印信息。

对不同来源的资源文件都有相应的Resource实现：文件(FileSystemResource)、Classpath资源(ClassPathResource)、URL资源(UrlResource)、InputStream资源(InputStreamResource)、Byte数组(ByteArrayResource)等，相关类图如下所示：

在日常开发中我们可以直接使用spring提供的类来加载资源文件，比如在希望加载资源文件时可以使用下面的代码：

Resource resource = new ClassPathResource("spring-config.xml");
InputStream is = resource.getInputStream();

有了 Resource 接口便可以对所有资源文件进行统一处理 至于实现，其实是非常简单的，以 getlnputStream 为例，ClassPathResource 中的实现方式便是通 class 或者 classLoader 提供的底层方法进行调用，而对于 FileSystemResource 其实更简单，直接使用 FileInputStream 对文件进行实例化。

# ClassPathResource.java
public InputStream getInputStream() throws IOException {InputStream is;if (this.clazz != null) {is = this.clazz.getResourceAsStream(this.path);}else if (this.classLoader != null) {is = this.classLoader.getResourceAsStream(this.path);}else {is = ClassLoader.getSystemResourceAsStream(this.path);}if (is == null) {throw new FileNotFoundException(getDescription() + " cannot be opened because it does not exist");}return is;
}

# FileSystemResource.java
public InputStream getinputStream () throws IOException {return new FilelnputStream(this file) ; 
}

当通过Resource相关类完成了对配置文件进行封装后，配置文件的读取工作就全权交给XmlBeanDefinitionReader来处理了。

接下来就进入到XmlBeanFactory的初始化过程了，XmlBeanFactory的初始化有若干办法，Spring提供了很多的构造函数，在这里分析的是使用Resource实例作为构造函数参数的办法，代码如下：

public XmlBeanFactory(Resource resource) throws BeansException {this(resource, null);
}
public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {super(parentBeanFactory);this.reader.loadBeanDefinitions(resource);
}

上面函数中的代码this.reader.loadBeanDefinitions(resource)才是资源加载的真正实现，但是在XmlBeanDefinitionReader加载数据前还有一个调用父类构造函数初始化的过程：super(parentBeanFactory)，我们按照代码层级进行跟踪，首先跟踪到如下父类代码：

public DefaultListableBeanFactory(@Nullable BeanFactory parentBeanFactory) {super(parentBeanFactory);
}

然后继续跟踪，跟踪代码到父类AbstractAutowireCapableBeanFactory的构造函数中：

public AbstractAutowireCapableBeanFactory(@Nullable BeanFactory parentBeanFactory) {this();setParentBeanFactory(parentBeanFactory);
}
public AbstractAutowireCapableBeanFactory() {super();ignoreDependencyInterface(BeanNameAware.class);ignoreDependencyInterface(BeanFactoryAware.class);ignoreDependencyInterface(BeanClassLoaderAware.class);
}

这里有必要提及 ignoreDependencylnterface() 方法，ignoreDependencylnterface() 的主要功能是 忽略给定接口的自动装配功能，那么，这样做的目的是什么呢？会产生什么样的效果呢？

举例来说，当 A 中有属性 B ，那么当 Spring 在获取 A的 Bean 的时候如果其属性 B 还没有 初始化，那么 Spring 会自动初始化 B，这也是 Spring 提供的一个重要特性 。但是，某些情况 下， B不会被初始化，其中的一种情况就是B 实现了 BeanNameAware 接口 。Spring 中是这样介绍的：自动装配时忽略给定的依赖接口，典型应用是边过其他方式解析 Application 上下文注册依赖，类似于 BeanFactory 通过 BeanFactoryAware 进行注入或者ApplicationContext 通过 ApplicationContextAware 进行注入。

调用ignoreDependencyInterface方法后，被忽略的接口会存储在BeanFactory的名为ignoredDependencyInterfaces的Set集合中：

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactoryimplements AutowireCapableBeanFactory {private final Set<Class<?>> ignoredDependencyInterfaces = new HashSet<>();public void ignoreDependencyInterface(Class<?> ifc) {this.ignoredDependencyInterfaces.add(ifc);}
...
}

ignoredDependencyInterfaces集合在同类中被使用仅在一处——isExcludedFromDependencyCheck() 方法中：

protected boolean isExcludedFromDependencyCheck(PropertyDescriptor pd) {return (AutowireUtils.isExcludedFromDependencyCheck(pd) || this.ignoredDependencyTypes.contains(pd.getPropertyType()) || AutowireUtils.isSetterDefinedInInterface(pd, this.ignoredDependencyInterfaces));
}

而 ignoredDependencyInterface() 的真正作用还得看 AutowireUtils#isSetterDefinedInInterface() 方法：

public static boolean isSetterDefinedInInterface(PropertyDescriptor pd, Set<Class<?>> interfaces) {//获取bean中某个属性对象在bean类中的setter方法Method setter = pd.getWriteMethod();if (setter != null) {// 获取bean的类型Class<?> targetClass = setter.getDeclaringClass();for (Class<?> ifc : interfaces) {if (ifc.isAssignableFrom(targetClass) && // bean类型是否接口的实现类ClassUtils.hasMethod(ifc, setter.getName(), setter.getParameterTypes())) { // 接口是否有入参和bean类型完全相同的setter方法return true;}}}return false;
}

ignoredDependencyInterface方法并不是让我们在自动装配时直接忽略实现了该接口的依赖。这个方法的真正意思是忽略该接口的实现类中和接口setter方法入参类型相同的依赖，也就是忽略该接口实现类中存在的依赖外部的bean属性注入。

典型应用就是BeanFactoryAware和ApplicationContextAware接口。

首先看该两个接口的源码：

public interface BeanFactoryAware extends Aware {void setBeanFactory(BeanFactory beanFactory) throws BeansException;
}public interface ApplicationContextAware extends Aware {void setApplicationContext(ApplicationContext applicationContext) throws BeansException;
}

在Spring源码中在不同的地方忽略了该两个接口：

beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
ignoreDependencyInterface(BeanFactoryAware.class);

使得我们的 BeanFactoryAware 接口实现类在自动装配时不能被注入 BeanFactory 对象的依赖：

public class MyBeanFactoryAware implements BeanFactoryAware {private BeanFactory beanFactory; // 自动装配时忽略注入@Overridepublic void setBeanFactory(BeanFactory beanFactory) throws BeansException {this.beanFactory = beanFactory;}public BeanFactory getBeanFactory() {return beanFactory;}
}

ApplicationContextAware接口实现类中的ApplicationContext对象的依赖同理：

public class MyApplicationContextAware implements ApplicationContextAware {private ApplicationContext applicationContext; // 自动装配时被忽略注入@Overridepublic void setApplicationContext(ApplicationContext applicationContext) throws BeansException {this.applicationContext = applicationContext;}public ApplicationContext getApplicationContext() {return applicationContext;}
}

这样的做法使得ApplicationContextAware和BeanFactoryAware中的ApplicationContext或BeanFactory依赖在自动装配时被忽略，而统一由框架设置依赖，如ApplicationContextAware接口的设置会在ApplicationContextAwareProcessor类中完成：

private void invokeAwareInterfaces(Object bean) {if (bean instanceof Aware) {if (bean instanceof EnvironmentAware) {((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());}if (bean instanceof EmbeddedValueResolverAware) {((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);}if (bean instanceof ResourceLoaderAware) {((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);}if (bean instanceof ApplicationEventPublisherAware) {((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);}if (bean instanceof MessageSourceAware) {((MessageSourceAware) bean).setMessageSource(this.applicationContext);}if (bean instanceof ApplicationContextAware) {((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);}}
}

通过这种方式保证了ApplicationContextAware和BeanFactoryAware中的容器保证是生成该bean的容器。

2.5.2 加载Bean——解析配置文件+注册BeanDefinitions

在之前XmlBeanFactory构造函数中调用了XmlBeanDefinitionReader类型的reader属性提供的方法this.reader.loadBeanDefinitions(resource)，而这句代码则是整个资源加载的切入点，这个方法的时序图如下：

我们来梳理下上述时序图的处理过程：

（1）封装资源文件。当进入XmlBeanDefinitionReader后首先对参数Resource使用EncodedResource类进行封装

# XmlBeanDefinitionReader
@Override
public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {return loadBeanDefinitions(new EncodedResource(resource));
}

（2）获取输入流。从Resource中获取对应的InputStream并构造InputSource

（3）通过构造的InputSource实例和Resource实例继续调用函数doLoadBeanDefinitions() ，loadBeanDefinitions() 函数具体的实现过程：

# XmlBeanDefinitionReader
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 == null) {currentResources = new HashSet<>(4);this.resourcesCurrentlyBeingLoaded.set(currentResources);}if (!currentResources.add(encodedResource)) {throw new BeanDefinitionStoreException("Detected cyclic loading of " + encodedResource + " - check your import definitions!");}try {//从encodedResource中获取已经封装的Resource对象并再次从Resource中获取InputStreamInputStream inputStream = encodedResource.getResource().getInputStream();try {//InputSource这个类并不来自Spring，它的全路径是org.xml.sax.InputSourceInputSource inputSource = new InputSource(inputStream);if (encodedResource.getEncoding() != null) {inputSource.setEncoding(encodedResource.getEncoding());}//逻辑核心部分return doLoadBeanDefinitions(inputSource, encodedResource.getResource());}finally {inputStream.close();}}...
}

EncodedResource的作用是对资源文件的编码进行处理的，其中的主要逻辑体现在getReader()方法中，当设置了编码属性的时候Spring会使用相应的编码作为输入流的编码，在构造好了encodeResource对象后，再次转入了可复用方法loadBeanDefinitions(new EncodedResource(resource))，这个方法内部才是真正的数据准备阶段，代码如下：

# XmlBeanDefinitionReader
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)throws BeanDefinitionStoreException {try {// 获取 Document 实例Document doc = doLoadDocument(inputSource, resource);// 根据 Document 实例****解析及注册BeanDefinitionsreturn registerBeanDefinitions(doc, resource);}...
}

protected Document doLoadDocument(InputSource inputSource, Resource resource) throws Exception {return this.documentLoader.loadDocument(inputSource, getEntityResolver(), this.errorHandler,getValidationModeForResource(resource), isNamespaceAware());
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//Spring//DTD BEAN 2.0//EN" "http://www.Springframework.org/dtd/Spring-beans-2.0.dtd">

<?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.chenhao.spring.MyTestBean"/></beans>

# XmlBeanDefinitionReader
protected int getValidationModeForResource(Resource resource) {int validationModeToUse = getValidationMode();if (validationModeToUse != VALIDATION_AUTO) {return validationModeToUse;}int detectedMode = detectValidationMode(resource);if (detectedMode != VALIDATION_AUTO) {return detectedMode;}// Hmm, we didn't get a clear indication... Let's assume XSD,// since apparently no DTD declaration has been found up until// detection stopped (before finding the document's root tag).return VALIDATION_XSD;
}protected int detectValidationMode(Resource resource) {if (resource.isOpen()) {throw new BeanDefinitionStoreException("Passed-in Resource [" + resource + "] contains an open stream: " +"cannot determine validation mode automatically. Either pass in a Resource " +"that is able to create fresh streams, or explicitly specify the validationMode " +"on your XmlBeanDefinitionReader instance.");}InputStream inputStream;try {inputStream = resource.getInputStream();}catch (IOException ex) {throw new BeanDefinitionStoreException("Unable to determine validation mode for [" + resource + "]: cannot open InputStream. " +"Did you attempt to load directly from a SAX InputSource without specifying the " +"validationMode on your XmlBeanDefinitionReader instance?", ex);}try {return this.validationModeDetector.detectValidationMode(inputStream);}catch (IOException ex) {throw new BeanDefinitionStoreException("Unable to determine validation mode for [" +resource + "]: an error occurred whilst reading from the InputStream.", ex);}
}

# XmlValidationModeDetector
public int detectValidationMode(InputStream inputStream) throws IOException {// Peek into the file to look for DOCTYPE.BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));try {boolean isDtdValidated = false;String content;while ((content = reader.readLine()) != null) {content = consumeCommentTokens(content);if (this.inComment || !StringUtils.hasText(content)) {continue;}if (hasDoctype(content)) {isDtdValidated = true;break;}if (hasOpeningTag(content)) {// End of meaningful data...break;}}return (isDtdValidated ? VALIDATION_DTD : VALIDATION_XSD);}catch (CharConversionException ex) {// Choked on some character encoding...// Leave the decision up to the caller.return VALIDATION_AUTO;}finally {reader.close();}
}

# DefaultDocumentLoader
public Document loadDocument(InputSource inputSource, EntityResolver entityResolver,ErrorHandler errorHandler, int validationMode, boolean namespaceAware) throws Exception {DocumentBuilderFactory factory = createDocumentBuilderFactory(validationMode, namespaceAware);if (logger.isDebugEnabled()) {logger.debug("Using JAXP provider [" + factory.getClass().getName() + "]");}DocumentBuilder builder = createDocumentBuilder(factory, entityResolver, errorHandler);return builder.parse(inputSource);
}

protected EntityResolver getEntityResolver() {if (this.entityResolver == null) {// Determine default EntityResolver to use.ResourceLoader resourceLoader = getResourceLoader();if (resourceLoader != null) {this.entityResolver = new ResourceEntityResolver(resourceLoader);}else {this.entityResolver = new DelegatingEntityResolver(getBeanClassLoader());}}return this.entityResolver;
}

 这个entityResolver是做什么用的呢，接下来我们详细分析下。

2.7.1 EntityResolver 的用法

对于解析一个XML，SAX首先读取该XML文档上的声明，根据声明去寻找相应的DTD定义，以便对文档进行一个验证，默认的寻找规则，即通过网络(实现上就是声明DTD的URI地址)来下载相应的DTD声明，并进行认证。下载的过程是一个漫长的过程，而且当网络中断或不可用时，这里会报错，就是因为相应的DTD声明没有被找到的原因。

EntityResolver的作用是项目本身就可以提供一个如何寻找DTD声明的方法，即由程序来实现寻找DTD声明的过程，比如将DTD文件放到项目中某处，在实现时直接将此文档读取并返回给SAX即可，在EntityResolver的接口只有一个方法声明：

public abstract InputSource resolveEntity (String publicId, String systemId)throws SAXException, IOException;

它接收两个参数publicId和systemId，并返回一个InputSource对象，以特定配置文件来进行讲解

（1）如果在解析验证模式为XSD的配置文件，代码如下：

<?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/beanshttp://www.Springframework.org/schema/beans/Spring-beans.xsd">
....
</beans>

• publicId：null
• systemId：http://www.Springframework.org/schema/beans/Spring-beans.xsd

（2）如果解析验证模式为DTD的配置文件，代码如下：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//Spring//DTD BEAN 2.0//EN" "http://www.Springframework.org/dtd/Spring-beans-2.0.dtd">
....
</beans>

# DelegatingEntityResolver
public DelegatingEntityResolver(@Nullable ClassLoader classLoader) {this.dtdResolver = new BeansDtdResolver();this.schemaResolver = new PluggableSchemaResolver(classLoader);
}@Override
@Nullable
public InputSource resolveEntity(String publicId, @Nullable String systemId) throws SAXException, IOException {if (systemId != null) {if (systemId.endsWith(DTD_SUFFIX)) {return this.dtdResolver.resolveEntity(publicId, systemId);}else if (systemId.endsWith(XSD_SUFFIX)) {return this.schemaResolver.resolveEntity(publicId, systemId);}}return null;
}

# BeansDtdResolver
private static final String DTD_EXTENSION = ".dtd";
private static final String DTD_NAME = "spring-beans";public InputSource resolveEntity(String publicId, @Nullable String systemId) throws IOException {if (logger.isTraceEnabled()) {logger.trace("Trying to resolve XML entity with public ID [" + publicId +"] and system ID [" + systemId + "]");}if (systemId != null && systemId.endsWith(DTD_EXTENSION)) {int lastPathSeparator = systemId.lastIndexOf('/');int dtdNameStart = systemId.indexOf(DTD_NAME, lastPathSeparator);if (dtdNameStart != -1) {String dtdFile = DTD_NAME + DTD_EXTENSION;if (logger.isTraceEnabled()) {logger.trace("Trying to locate [" + dtdFile + "] in Spring jar on classpath");}try {Resource resource = new ClassPathResource(dtdFile, getClass());InputSource source = new InputSource(resource.getInputStream());source.setPublicId(publicId);source.setSystemId(systemId);if (logger.isDebugEnabled()) {logger.debug("Found beans DTD [" + systemId + "] in classpath: " + dtdFile);}return source;}catch (IOException ex) {if (logger.isDebugEnabled()) {logger.debug("Could not resolve beans DTD [" + systemId + "]: not found in classpath", ex);}}}}return null;
}

# PluggableSchemaResolver
public static final String DEFAULT_SCHEMA_MAPPINGS_LOCATION = "META-INF/spring.schemas";
public InputSource resolveEntity(String publicId, @Nullable String systemId) throws IOException {if (logger.isTraceEnabled()) {logger.trace("Trying to resolve XML entity with public id [" + publicId +"] and system id [" + systemId + "]");}if (systemId != null) {String resourceLocation = getSchemaMappings().get(systemId);if (resourceLocation != null) {Resource resource = new ClassPathResource(resourceLocation, this.classLoader);try {InputSource source = new InputSource(resource.getInputStream());source.setPublicId(publicId);source.setSystemId(systemId);if (logger.isDebugEnabled()) {logger.debug("Found XML schema [" + systemId + "] in classpath: " + resourceLocation);}return source;}catch (FileNotFoundException ex) {if (logger.isDebugEnabled()) {logger.debug("Couldn't find XML schema [" + systemId + "]: " + resource, ex);}}}}return null;
}

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {//实例化BeanDefinitionDocumentReader为DefaultBeanDefinitionDocumentReaderBeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();int countBefore = getRegistry().getBeanDefinitionCount();//加载和注册beanDefinitionsdocumentReader.registerBeanDefinitions(doc, createReaderContext(resource));//记录本次加载的BeanDefinition个数return getRegistry().getBeanDefinitionCount() - countBefore;
}

public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {this.readerContext = readerContext;logger.debug("Loading bean definitions");Element root = doc.getDocumentElement();doRegisterBeanDefinitions(root);
}

protected void doRegisterBeanDefinitions(Element root) {BeanDefinitionParserDelegate parent = this.delegate;this.delegate = createDelegate(getReaderContext(), root, parent);if (this.delegate.isDefaultNamespace(root)) {//处理profile属性String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);if (StringUtils.hasText(profileSpec)) {String[] specifiedProfiles = StringUtils.tokenizeToStringArray(profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {if (logger.isInfoEnabled()) {logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec +"] not matching: " + getReaderContext().getResource());}return;}}}//解析前处理，留给子类实现preProcessXml(root);parseBeanDefinitions(root, this.delegate);//解析后处理，留给子类实现postProcessXml(root);this.delegate = parent;
}

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {if (delegate.isDefaultNamespace(root)) {NodeList nl = root.getChildNodes();for (int i = 0; i < nl.getLength(); i++) {Node node = nl.item(i);if (node instanceof Element) {Element ele = (Element) node;if (delegate.isDefaultNamespace(ele)) {parseDefaultElement(ele, delegate);}else {delegate.parseCustomElement(ele);}}}}else {delegate.parseCustomElement(root);}
}

<!-- 开发环境配置文件 -->
<beans profile="development"><context:property-placeholderlocation="classpath*:config_common/*.properties, classpath*:config_development/*.properties"/>
</beans><!-- 测试环境配置文件 -->
<beans profile="test"><context:property-placeholderlocation="classpath*:config_common/*.properties, classpath*:config_test/*.properties"/>
</beans><!-- 生产环境配置文件 -->
<beans profile="production"><context:property-placeholderlocation="classpath*:config_common/*.properties, classpath*:config_production/*.properties"/>
</beans>

<!-- 多环境配置 在上下文context-param中设置profile.default的默认值 -->
<context-param><param-name>spring.profiles.default</param-name><param-value>production</param-value>
</context-param><!-- 多环境配置 在上下文context-param中设置profile.active的默认值 -->
<!-- 设置active后default失效，web启动时会加载对应的环境信息 -->
<context-param><param-name>spring.profiles.active</param-name><param-value>test</param-value>
</context-param>