最近想拿出一部分时间来学习一下spring的源码,还特意买了一本书结合来看,当然主要是学习并跟着作者的思路来踏上学习spring的源码的道路,特意在此记录一下,《spring源码深度解析》

一、spring的结构组成

  从简单的例子入手,从实际的开发中去解析、学习源码,结合工作中的内容,这样才能更好的、更加深入的学习,go go go!!!

1、容器的基本用法与功能分析

容器基本用法,代码如下:

 public class MyTestBean {
private String testStr = "testStr" ; public String getTestStr() {
return testStr;
} public void setTestStr(String testStr) {
this.testStr = testStr;
}
} ----------------------------------------------------------------------------- <bean id="myTestBean" class="com.ssc.springStudy.beans.MyTestBean"></bean> ------------------------------------------------------------------------- @Test
public void testSimpleLoad(){
BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("beanFactory.xml"));
MyTestBean bean = (MyTestBean) beanFactory.getBean("myTestBean");
System.out.println(bean.getTestStr());
}

功能解析:

(1)读取配置文件beanFactoryTest.xml

(2)根据beanFactoryTest.xml中的配置找到对应的类的配置,并实例化

(3)调用实例化后的实例

如果完成以上的功能,至少需要3个类:

ConfigReader:用于读取及验证配置文件,我们要用配置文件里面的东西,当然首先就是读取,然后放置到内存中

ReflectionUtil:用于根据配置文件中的配置进行反射实例化。

App:用于完成整个逻辑的串联

二、spring的结构组成

1、beans包的层级结构以及核心类

(1)DefaultListableBeanFactory

XmlBeanFactory继承自DefaultListableBeanFactory,而DefaultListableBeanFactory是整个bean加载的核心部分,是spring注册及加载bean的默认实现方式,而对XmlBeanFactory与DefaultListableBeanFactory不同的地方其实是在XmlBeanFactory中使用了自定义的XML读取器XmlBeanDefinitionReader,实现了个性化的BeanDefinitionReader读取,DefaultListableBeanFactory继承 了AbstractAutowireCapableBeanFactory并实现了ConfigurableListableBeanFactory以及BeanDefinitionRegistry接口。

全局角度了解DefaultListableBeanFactory:

A:AliasRegistry:定义对alias的简单的增删改查等操作

B:SimpleAliasRegistry:主要使用map作为alias的缓存,并对接口AlisaRegistry进行实现

C:SingletonBeanRegistry:定义对单例的注册和获取

D:BeanFactroy:定义获取bean以及bean的各种属性

E:DefaultSingletonBeanRegistry:对接口SingletonBeanRegistry各函数的实现

F:HierarchicalBeanFactory:继承BeanFactory,也就是在BeanFactory定义的功能的基础上增加了对ParentFactory的支持

G:BeanDefinitionRegistry:定义对BeanDefinition的各种增删改查操作

H:FactoryBeanRegistrySupport:在DefaultSingletonBeanRegistry基础上增加了对FactoryBean的特殊处理功能

I:ConfigurableBeanFactory:提供配置Factory的各种方法

J:ListableBeanFactory:根据各种条件获取bean的配置清单

K:AbstractBeanFactory:综合FactoryBeanRegistrySupport和ConfigurableBeanFactory的功能

L:AutowireCapableBeanFactory:提供创建bean、自动注入、初始化以及应用bean的后处理器

M:AbstractAutowireCapableBeanFactory:综合AbstractBeanFactory并对接口AutoWireCapableBeanFactory进行实现

N:ConfigurableListableBeanFactory:BeanFactory的配置清单,指定忽略类型及接口等

O:DefaultListableBeanFactory:综合上面所有的功能。主要是对bean注册后的处理

注意:

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

(2)XmlBeanDefinitionReader

XML配置文件的读取是spring中重要的功能,因为spring的大部分功能是以配置作为切入点的,那么我们可以从XmlBeanDefinitionReader中梳理一下资源文件读取、解析及注册的大致脉络,首先看看各个类的功能。

A:ResourceLoader:定义资源加载器,主要应用于根据给定的资源文件地址返回对应的Resource

B:BeanDefinitionReader:主要定义资源文件读取并装换为BeanDefinition的各个功能

C:EnvironmentCapable:定义获取Environment方法

D:DocumentLoader:定义从资源文件加载到转换为Document的功能

E:AbstractBeanDefinitionReader:对EnvironmentCapable、BeanDefinitionReader类定义的功能进行实现

F:BeanDefinitionDocumentReader:定义读取Document并注册BeanDefinition功能

G:BeanDefinitionParserDelegate:定义解析Element的各种方法

注意:

在XmlBeanDefinitionReader中主要包含以下几步的处理:

A:通过继承自AbstractBeanDefinitionReader中的方法,来使用ReaderLoader将资源文件路径转换为对应的Resource文件

B:通过DocumentLoader对Resource文件进行装换,将Resource文件转换为Document文件

C:通过实现接口BeanDefinitionDocumentReader的DefaultBeanDefinitionDocumentReader类对Document进行解析,并使用BeanDefinitionParserDelegate对Element进行解析

2、容器的基础XmlBeanFactory

这部分从下面的代码开始深入研究:

 BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("beanFactory.xml"));

(1)配置文件封装(xml文件如何封装?)

spring对其内部使用到的资源文件实现了自己的抽象结构:Resource接口封装底层资源。

 package org.springframework.core.io;

 import java.io.IOException;
import java.io.InputStream; public interface InputStreamSource { InputStream getInputStream() throws IOException; }
-------------------------------------------------------------------------------------------------------------------------------------
package org.springframework.core.io; import java.io.File;
import java.io.IOException;
import java.net.URI;
import java.net.URL; 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(); }

解析:

  InputStreamSource封装了任何能返回InputStream的类,比如File、ClassPath下的资源和ByteArray等。它只有一个方法定义:getInputStream()。该方法返回一个新的InputStream对象。

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

(2)加载bean

之前提到的再XmlBeanFactory构造函数中调用了XmlBeanDefinitionReader类型的reader属性提供的方法this.reader.loadBeanDefinitions(resource),而这句代码则是整个资源加载的切入点。

加载XML文件和解析注册Bean整个处理过程:

A:封装资源文件。当进入XmlBeanDefinitionReader后首先对参数Resource使用EncodeResource类进行封装。

B:获取输入流。从Resource中获取对应的InputStream并构造InputSource。

C:通过构造的InputSource实例和Resource实例继续调用doLoadBeanDefinitions

loadBeanDefinitions函数具体的实现过程:

   package org.springframework.beans.factory.xml;
/**
* Load bean definitions from the specified XML file.
* @param resource the resource descriptor for the XML file
* @return the number of bean definitions found
* @throws BeanDefinitionStoreException in case of loading or parsing errors
*/
@Override
public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
return loadBeanDefinitions(new EncodedResource(resource));
}

这个类用于对资源文件的编码进行处理。其中主要逻辑体现在getReader()方法中,当设置了编码属性的时候Spring会使用相应的编码作为输入流的编码

注意在EncodedResource类中:

  package org.springframework.core.io.support;

    /**
* Open a {@code java.io.Reader} for the specified resource, using the specified
* {@link #getCharset() Charset} or {@linkplain #getEncoding() encoding}
* (if any).
* @throws IOException if opening the Reader failed
* @see #requiresReader()
* @see #getInputStream()
*/
public Reader getReader() throws IOException {
if (this.charset != null) {
return new InputStreamReader(this.resource.getInputStream(), this.charset);
}
else if (this.encoding != null) {
return new InputStreamReader(this.resource.getInputStream(), this.encoding);
}
else {
return new InputStreamReader(this.resource.getInputStream());
}
}

上面代码构造了一个有编码的InputStreamReader。当构造好encodedResource对象后,再次转入可复用方法loadBeanDefinitions(new EncodeResource(resource))。

这个方法内部才是真正的数据准备阶段:

   package org.springframework.beans.factory.xml;

     /**
* Load bean definitions from the specified XML file.
* @param encodedResource the resource descriptor for the XML file,
* allowing to specify an encoding to use for parsing the file
* @return the number of bean definitions found
* @throws BeanDefinitionStoreException in case of loading or parsing errors
*/
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 {
InputStream inputStream = encodedResource.getResource().getInputStream();
try {
InputSource inputSource = new InputSource(inputStream);
if (encodedResource.getEncoding() != null) {
inputSource.setEncoding(encodedResource.getEncoding());
}
return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
}
finally {
inputStream.close();
}
}
catch (IOException ex) {
throw new BeanDefinitionStoreException(
"IOException parsing XML document from " + encodedResource.getResource(), ex);
}
finally {
currentResources.remove(encodedResource);
if (currentResources.isEmpty()) {
this.resourcesCurrentlyBeingLoaded.remove();
}
}
}

我们再次整理数据准备阶段的逻辑,首先传入的resource参数做封装,目的是考虑到Resource可能存在编码要求的情况,其次,通过SAX读取XML文件的方式来准备InputSource对象,最后将准备的数据通过参数传入真正的核心处理部分doLoadBeanDefinitions(inputSource, encodedResource.getResource())  代码如下:

 package org.springframework.beans.factory.xml;

 /**
* Actually load bean definitions from the specified XML file.
* @param inputSource the SAX InputSource to read from
* @param resource the resource descriptor for the XML file
* @return the number of bean definitions found
* @throws BeanDefinitionStoreException in case of loading or parsing errors
* @see #doLoadDocument
* @see #registerBeanDefinitions
*/
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
throws BeanDefinitionStoreException { try {
Document doc = doLoadDocument(inputSource, resource);
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);
}
} /**
* Actually load the specified document using the configured DocumentLoader.
* @param inputSource the SAX InputSource to read from
* @param resource the resource descriptor for the XML file
* @return the DOM Document
* @throws Exception when thrown from the DocumentLoader
* @see #setDocumentLoader
* @see DocumentLoader#loadDocument
*/
protected Document doLoadDocument(InputSource inputSource, Resource resource) throws Exception {
return this.documentLoader.loadDocument(inputSource, getEntityResolver(), this.errorHandler,
getValidationModeForResource(resource), isNamespaceAware());
} /**
* Determine the validation mode for the specified {@link Resource}.
* If no explicit validation mode has been configured, then the validation
* mode gets {@link #detectValidationMode detected} from the given resource.
* <p>Override this method if you would like full control over the validation
* mode, even when something other than {@link #VALIDATION_AUTO} was set.
* @see #detectValidationMode
*/
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;
} /**
* Register the bean definitions contained in the given DOM document.
* Called by {@code loadBeanDefinitions}.
* <p>Creates a new instance of the parser class and invokes
* {@code registerBeanDefinitions} on it.
* @param doc the DOM document
* @param resource the resource descriptor (for context information)
* @return the number of bean definitions found
* @throws BeanDefinitionStoreException in case of parsing errors
* @see #loadBeanDefinitions
* @see #setDocumentReaderClass
* @see BeanDefinitionDocumentReader#registerBeanDefinitions
*/
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
int countBefore = getRegistry().getBeanDefinitionCount();
documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
return getRegistry().getBeanDefinitionCount() - countBefore;
}

其实这段代码,这个方法大部分代码都是在处理异常情况,可以看出异常情况咋一个框架中是很重要的一个事情,其实只有三个事情:

A:获取对XML文件的验证模式

B:加载XML文件,并得到对应的Document

C:根据返回的Document注册Bean信息

这3个步骤支撑着真个spring容器的实现,尤其是第三步对配置文件的解析,逻辑非常的复杂,我们先从获取XML文件的验证模式说起

3、获取XML 的验证模式

(1)DTD和XSD区别

XML文件为保证其正确性,会有验证模式,比较常用的是两种验证模式:DTD和XSD

DTD: Document Type Definition 即文档类型定义,是一种XML约束模式语言,是XML文件的验证机制,属于XML文件组成的一部分。

一个DTD文档包含:元素定义规则,元素间关系的定义规则,元素可使用属性、可使用的实体或符号规则

XSD:XML Schemas Definition XML Schema描述了XML文档的结构。可以用一个指定的XML Schema来验证某个XML文档,以检查该XML文档是否符合其要求。

(2)验证模式的读取

spring通过getValidationModeForResource()来获取对应资源的验证模式,代码如下:

   package org.springframework.beans.factory.xml;

     /**
* Determine the validation mode for the specified {@link Resource}.
* If no explicit validation mode has been configured, then the validation
* mode gets {@link #detectValidationMode detected} from the given resource.
* <p>Override this method if you would like full control over the validation
* mode, even when something other than {@link #VALIDATION_AUTO} was set.
* @see #detectValidationMode
*/
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;
}

方法实现还是挺简单的,如果设定了验证模式则使用设定的验证模式(可以通过对调用XmlBeanDefinitionReader中的setValidationMode方法进行设定),否则使用自动检测的方式。而自动检测验证模式的功能是在函数deterValidationMode方法中实现的,在deterValidationMode函数中又将自动检测验证模式的工作委托费了专门处理类XmlValidationModelDetector,调用XmlValidationModelDetector的validationModeDetector方法,具体代码:

   package org.springframework.beans.factory.xml;

   /**
* Detect which kind of validation to perform on the XML file identified
* by the supplied {@link Resource}. If the file has a {@code DOCTYPE}
* definition then DTD validation is used otherwise XSD validation is assumed.
* <p>Override this method if you would like to customize resolution
* of the {@link #VALIDATION_AUTO} mode.
*/
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);
}
}   // 这个方法在其他的包中,如下:
  package org.springframework.util.xml; /**
* Detect the validation mode for the XML document in the supplied {@link InputStream}.
* Note that the supplied {@link InputStream} is closed by this method before returning.
* @param inputStream the InputStream to parse
* @throws IOException in case of I/O failure
* @see #VALIDATION_DTD
* @see #VALIDATION_XSD
*/
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();
}
}

4、获取Document

经过了验证模式准备的步骤就可以进行Document加载了,同样XmlBeanFactoryReader类对于文档读取并没有亲力亲为,而是委托给了DocumentLoader去执行,这里的DocumentLoader是个接口,而真正调用的是DefaultDocumentLoader,解析代码如下:

   package org.springframework.beans.factory.xml;

     /**
* Load the {@link Document} at the supplied {@link InputSource} using the standard JAXP-configured
* XML parser.
*/
@Override
public Document loadDocument(InputSource inputSource, EntityResolver entityResolver,
ErrorHandler errorHandler, int validationMode, boolean namespaceAware) throws Exception { DocumentBuilderFactory factory = createDocumentBuilderFactory(validationMode, namespaceAware);
if (logger.isTraceEnabled()) {
logger.trace("Using JAXP provider [" + factory.getClass().getName() + "]");
}
DocumentBuilder builder = createDocumentBuilder(factory, entityResolver, errorHandler);
return builder.parse(inputSource);
}

对于这部分代码,通过SAX解析XML文档的套路大致都差不多,spring在这里并没有什么特殊地方,同样首先创建DocumentBuilderFactory,再通过DocumentBuilderFactory创建DocumentBuilder,进而解析inputStream来返回Document对象。

对于参数entityResolver,传入的是通过getEntityResolver()函数获取的返回值,代码如下:

   package org.springframework.beans.factory.xml;

     /**
* Return the EntityResolver to use, building a default resolver
* if none specified.
*/
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的用法:

官方解释:如果SAX应用程序需要实现自定义处理外部实体,则必须使用此接口并使用setEntiryResolver方法向SAX驱动器注册一个实例。也就是说,对于解析一个XML,SAX首先读取该XML文档上的声明,根据声明去寻找相应的DTD定义,以便对文档进行一个验证。默认的寻找规则,即通过网络(实际上就是声明的DTD的URL地址)来下载相应的DTD声明,并进行验证。

EntityResolver的作用是项目本省就可以提供一个如何寻找DTD声明的方法,即由程序寻找DTD声明的过程,比如我们将DTD文件方法项目中某处,在实现时直接将此文档读取并返回给SAX即可。避免通过网络来寻找相应的声明。

直接看EntityResolver接口的实现类DelegatingEntityResolver中解析XSD或者DTD格式的声明

注意:至于publicId、systemId两个参数 对应着xml文件中命名空间中URL路径

  // spring中对EntityResolver类进行了实现,就是DelegatingEntityResolver EntityResolver类是jdk中的方法,包:org.xml.sax.EntityResolver;
  package org.springframework.beans.factory.xml; /**
* Create a new DelegatingEntityResolver that delegates to
* a default {@link BeansDtdResolver} and a default {@link PluggableSchemaResolver}.
* <p>Configures the {@link PluggableSchemaResolver} with the supplied
* {@link ClassLoader}.
* @param classLoader the ClassLoader to use for loading
* (can be {@code null}) to use the default ClassLoader)
*/
public DelegatingEntityResolver(ClassLoader classLoader) {
      // 分别解析XSD 与 DTD格式
this.dtdResolver = new BeansDtdResolver();
this.schemaResolver = new PluggableSchemaResolver(classLoader);
} @Override
public InputSource resolveEntity(String publicId, String systemId) throws SAXException, IOException {
if (systemId != null) {
if (systemId.endsWith(DTD_SUFFIX)) {
          // 如果是DTD 从这里解析
return this.dtdResolver.resolveEntity(publicId, systemId);
}
else if (systemId.endsWith(XSD_SUFFIX)) {
          // 通过调用META-INF/Spring.schema 解析
return this.schemaResolver.resolveEntity(publicId, systemId);
}
}
return null;
}

注意:

可以看到,对不同的验证模式,spring使用了不同的解析器解析。这里简单描述一下原理,加载DTD类型的BeanDtdResolver的resolverEntiry是直接截取systemId最后的xx.dtd然后去当前路径下寻找,而加载XSD类型的PluggableSchemaResolver类的resolverEntity是默认到META-INF/Spring.schemas文件中找到systemid所对应的XSD文件加载。

5、解析及注册BeanDefinitions

(1)当文件转换为Document后,接下来的提取及注册bean就是我们的重头戏。当程序已经拥有了XML文件文档文件的Document实例对象时,就会引入下面这个方法:

 package org.springframework.beans.factory.xml;
//XmlBeanDefinitionReader类 /**
* Register the bean definitions contained in the given DOM document.
* Called by {@code loadBeanDefinitions}.
* <p>Creates a new instance of the parser class and invokes
* {@code registerBeanDefinitions} on it.
* @param doc the DOM document
* @param resource the resource descriptor (for context information)
* @return the number of bean definitions found
* @throws BeanDefinitionStoreException in case of parsing errors
* @see #loadBeanDefinitions
* @see #setDocumentReaderClass
* @see BeanDefinitionDocumentReader#registerBeanDefinitions
*/
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
      // 使用DefinitionDocumentReader实例化BeanDefinitionDocumentReader
BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
      // 记录统计前BeanDefinnition的加载个数
int countBefore = getRegistry().getBeanDefinitionCount();
      // 加载及注册bean
documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
      // 记录本次加载到的BeanDefinition个数
return getRegistry().getBeanDefinitionCount() - countBefore;
}

其中参数doc是通过上一节loadDocument加载转换出来的。在这个方法中很好地应用了面向对象中单一职责的原则,将逻辑处理委托给单一的类进行处理,而这个逻辑处理类就是BeanDefinitionDocumentReader。BeanDefinitionDocumentReader是一个接口,而实例化工作就是在createBeanDefinitionDocumentReader()方法中完成的,而通过此方法,BeanDefinitionDocumentReader真正的类型其实已经是DefaultBeanDefinitionDocumentReader了,进入DefaultBeanDefinitionDocumentReader后,发现这个方法的重要目的之一就是提取root,以便于再次将root作为参数继续BeanDefinition的注册。

   package org.springframework.beans.factory.xml;
  // DefaultBeanDefinitionDocumentReader.java
/**
* This implementation parses bean definitions according to the "spring-beans" XSD
* (or DTD, historically).
* <p>Opens a DOM Document; then initializes the default settings
* specified at the {@code <beans/>} level; then parses the contained bean definitions.
*/
@Override
public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
this.readerContext = readerContext;
      // doc.getDocumentElement() 这个方法其实是得到Element root节点
doRegisterBeanDefinitions(doc.getDocumentElement());
}

终于到了doRegisterBeanDefinitions(doc.getDocumentElement())方法了,这个方法是真正进行解析了,核心方法:

// 与上面方法位于同一类中
/**
* Register each bean definition within the given root {@code <beans/>} element.
*/
@SuppressWarnings("deprecation") // for Environment.acceptsProfiles(String...)
protected void doRegisterBeanDefinitions(Element root) {
// Any nested <beans> elements will cause recursion in this method. In
// order to propagate and preserve <beans> default-* attributes correctly,
// keep track of the current (parent) delegate, which may be null. Create
// the new (child) delegate with a reference to the parent for fallback purposes,
// then ultimately reset this.delegate back to its original (parent) reference.
// this behavior emulates a stack of delegates without actually necessitating one.
    // 专门处理解析
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);
// We cannot use Profiles.of(...) since profile expressions are not supported
// in XML config. See SPR-12458 for details.
if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
if (logger.isDebugEnabled()) {
logger.debug("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;
}

首先是对profile的处理,然后开始进行解析,可是当我们跟进preProcessXml(root)和postProcessXml(root)发现代码是空的,这里是面向继承而设计的,如果继承自DefaultBeanDefinitionDocumentReader,只需要重写这两个方法就好了。

(2)profile属性的使用

profile 属性我是真的没用过,书中写的是大概就是用于生产环境与开发环境进行切换开发,最常用的是更换不同的数据库

(3)解析并注册BeanDefinition

处理完profile后就可以进行XML读取了,跟踪代码进入parseBeanDefinitions(root, this.delegate);

   // 和上一个方法位于同一个类中

     /**
* Parse the elements at the root level in the document:
* "import", "alias", "bean".
* @param root the DOM root element of the document
*/
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);
}
}

上面代码,解析bean的配置,spring的XML配置中有两大类Bean的声明,一个是默认的

<bean id="test" class=""  />

另一个是自定义的:

<tx:annotation-driven/> 这个。。。

而这两种方式的读取及解析差别是非常大的,如果采用spring默认的配置,spring当然知道怎么做,但如果是自定义的,那么就需要用户实现一些接口与配置了。对于根节点或者子节点如果是默认命名空间的话则采用parseDefaultElement方法进行解析,否则采用delegate.parseCustomElement方法对自定义命名空间进行解析。而判断是否默认命名空间还是自定义命名空间的办法其实使用node.getNamespaceURI()获取命名空间,并与spring中固定命名空间http://www.springframework.org/schema/beans 进行对比。如果一直则是默认,否则就是自定义的。

这写的,花费了挺长时间,然而我觉得并不是特别清楚,不过大概的思路还是能够捋顺清楚的。。。

spring源码学习之容器的基本实现的更多相关文章

  1. 创建ApplicationContext与BeanFactory时的区别-Spring源码学习之容器的基本实现

    传送门 可以加载XML两种方法 使用 BeanFactory 加载 XML BeanFactory bf = new XmlBeanFactory(new ClassPathResource(&quo ...

  2. Spring源码学习之容器的基本实现(一)

    前言 最近学习了<<Spring源码深度解析>>受益匪浅,本博客是对学习内容的一个总结.分享,方便日后自己复习或与一同学习的小伙伴一起探讨之用. 建议与源码配合使用,效果更嘉, ...

  3. spring源码学习之容器的扩展(二)

    六 BeanFactory的后处理BeanFactory作为spring容器的基础,用于存放所有已经加载的bean,为了保证程序上的高扩展性,spring针对BeanFactory做了大量的扩展,比如 ...

  4. spring源码学习之容器的扩展(一)

    在前面的章节,我们一直以BeanFactory接口以及它的默认实现XmlBeanFactory为例进行解析,但是,spring还提供了另一个接口ApplicationContext,用于扩展BeanF ...

  5. Spring 源码学习(一)-容器的基础结构

    关注公众号,大家可以在公众号后台回复“博客园”,免费获得作者 Java 知识体系/面试必看资料 展示的代码摘取了一些核心方法,去掉一些默认设置和日志输出,还有大多数错误异常也去掉了,小伙伴想看详细代码 ...

  6. Spring源码学习-容器BeanFactory(四) BeanDefinition的创建-自定义标签的解析.md

    写在前面 上文Spring源码学习-容器BeanFactory(三) BeanDefinition的创建-解析Spring的默认标签对Spring默认标签的解析做了详解,在xml元素的解析中,Spri ...

  7. Spring源码学习-容器BeanFactory(三) BeanDefinition的创建-解析Spring的默认标签

    写在前面 上文Spring源码学习-容器BeanFactory(二) BeanDefinition的创建-解析前BeanDefinition的前置操作中Spring对XML解析后创建了对应的Docum ...

  8. Spring源码学习-容器BeanFactory(二) BeanDefinition的创建-解析前BeanDefinition的前置操作

    写在前面 上文 Spring源码学习-容器BeanFactory(一) BeanDefinition的创建-解析资源文件主要讲Spring容器创建时通过XmlBeanDefinitionReader读 ...

  9. Spring源码学习-容器BeanFactory(一) BeanDefinition的创建-解析资源文件

    写在前面 从大四实习至今已一年有余,作为一个程序员,一直没有用心去记录自己工作中遇到的问题,甚是惭愧,打算从今日起开始养成写博客的习惯.作为一名java开发人员,Spring是永远绕不过的话题,它的设 ...

随机推荐

  1. hrbust1444 逃脱 【BFS】

    Description  这是mengxiang000和Tabris来到幼儿园的第四天,幼儿园老师在值班的时候突然发现幼儿园某处发生火灾,而且火势蔓延极快,老师在第一时间就发出了警报,位于幼儿园某处的 ...

  2. laravel C层 (控制器)

    <?php namespace App\Http\Controllers; use App\Index; use App\Http\Controllers\Controller; class I ...

  3. C/C++函数调用过程分析

    http://www.cnblogs.com/biyeymyhjob/archive/2012/07/20/2601204.html 这里以一个简单的C语言代码为例,来分析函数调用过程 代码: #in ...

  4. 【OpenJ_Bailian - 2797】最短前缀(贪心)

    最短前缀 Descriptions: 一个字符串的前缀是从该字符串的第一个字符起始的一个子串.例如 "carbon"的字串是: "c", "ca&qu ...

  5. 新建Podfile命令

    接下来,你需要建立一个主工程.建立成功以后,再次启动终端, 利用cd命令进入到工程文件夹内,此时需要创建一个特殊的文本文件,命令如下: 命令: touch Podfile 创建 命令: open -e ...

  6. 茅台【思维/数学/剪枝】By cellur925

    题目传送门 给你\(n\)根木棍,问有多少种方法,使得选出的三根木棍能组成三角形. 开始想要用搜索的,但是写着写着卡壳了(?),于是改用贪心,开始对拍,觉得很稳,只是最后两个数据可能有点卡.很第一题难 ...

  7. vijos次小生成树

    xiaomengxian的哥哥是一个游戏迷,他喜欢研究各种游戏.这天,xiaomengxian到他家玩,他便拿出了自己最近正在研究的一个游戏给xiaomengxian看.这个游戏是这样的:一个国家有N ...

  8. django_logging

    django使用python自带的logging打印日志 logging 是线程安全的,其主要由4部分组成: Logger 用户使用的直接接口,将日志传递给Handler Handler 控制日志输出 ...

  9. UWP Popup 弹出提示框

    一:需求 做一个类似于安卓的弹出消息框,如图.当用户点击下载或者选择时,能够从底部弹出一个提示框,用于提示用户. 二:Popup 类 不需要我们自己额外去写一个弹窗类,微软自己有一个Popup 弹窗类 ...

  10. Tinghua Data Mining 8

    聚类 Clustering 根据评论信息做一些聚类,挖掘关系. bug 期望最大法 peek高峰的个数与高斯函数的个数不一定相同 Z隐含参数 不需要求 每个点属于哪个簇 类似于辅助线 跳板 借力 模型 ...