spring IOC根据xml文件获取Document对象分析

最新推荐文章于 2022-04-13 17:09:09 发布
最新推荐文章于 2022-04-13 17:09:09 发布
阅读量250 收藏
点赞数
分类专栏： spring 文章标签： java spring 5
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wang0907/article/details/114027286
版权

写在前面

本文在这篇文章的基础上继续分析，这篇文章分析了如何获取验证模式，获取完验证模式之后就是将xml文件生成对应的文档对象了。

1：作用

用来从中解析用户配置的bean等信息为BeanDefinition数据结构。

2：测试代码

为了方便调试再贴下测试代码：

@Test
public void testBeanDefinitionLoad() {
    // 定义资源
    ClassPathResource classPathResource = new ClassPathResource("testbeandefinition.xml");
    // 定义IOC容器
    DefaultListableBeanFactory defaultListableBeanFactory = new DefaultListableBeanFactory();
    // 定义bean定义读取器
    XmlBeanDefinitionReader xmlBeanDefinitionReader = new XmlBeanDefinitionReader(defaultListableBeanFactory);
    // 通过bean定义读取器从资源中读取bean定义
    int i = xmlBeanDefinitionReader.loadBeanDefinitions(classPathResource);
    System.out.println("bean定义的个数是：" + i);
}

xml:

<?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="testBeanDefinitionBean"
          class="yudaosourcecode.spring.TestBeanDefinitionBean"></bean>

    <bean id="testBeanDefinitionBean1"
          class="yudaosourcecode.spring.TestBeanDefinitionBean"></bean>
    <!-- 这里引入自己的话会发生org.springframework.beans.factory.BeanDefinitionStoreException异常 -->
    <!--<import resource="testbeandefinition.xml"/>-->
</beans>

最终调用到代码：

org.springframework.beans.factory.xml.XmlBeanDefinitionReader#doLoadDocument
protected Document doLoadDocument(InputSource inputSource, Resource resource) throws Exception {
	return this.documentLoader.loadDocument(inputSource, getEntityResolver(), this.errorHandler,
			getValidationModeForResource(resource), isNamespaceAware());
}

其中获取验证模式的代码getValidationModeForResource(resource),我们已经再这篇文章中进行了分析。我们分析的入口方法是this.documentLoader.loadDocument。我们先来分析this.documentLoader。

3：DocumentLoader

DocumentLoader全类名为org.springframework.beans.factory.xml.DocumentLoader，是一个顶层接口。定义了从资源文件转换为Document文档对象的功能，只有一个方法如下：

org.springframework.beans.factory.xml.DocumentLoader
public interface DocumentLoader {
	Document loadDocument(
			InputSource inputSource, EntityResolver entityResolver,
			ErrorHandler errorHandler, int validationMode, boolean namespaceAware)
			throws Exception;
}

看下其中的参数：

inputSource：待解析的资源
entityResolver：解析文件的解析器
errorHandler：处理解析文件过程中发生的错误
validationMode：xml文件验证模式DTD(Document Type Definition) OR XSD(Xml Schema Definition)
namesapceAware：xml命名空间支持，true为支持，false为不支持

我们来debug看下这些参数：
在这里插入图片描述
该接口只有一个实现类org.springframework.beans.factory.xml.DefaultDocumentLoader，其实现的加载方法loadDocument我们单起一部分讲解。

3.1：loadDocument

源码如下：

org.springframework.beans.factory.xml.DefaultDocumentLoader#loadDocument
@Override
public Document loadDocument(InputSource inputSource, EntityResolver entityResolver,
		ErrorHandler errorHandler, int validationMode, boolean namespaceAware) throws Exception {
	// <2021-02-26 17:25> 创建文档构造器工厂
	DocumentBuilderFactory factory = createDocumentBuilderFactory(validationMode, namespaceAware);
	if (logger.isTraceEnabled()) {
		logger.trace("Using JAXP provider [" + factory.getClass().getName() + "]");
	}
	// <2021-02-26 17:26>通过文档构造器工厂创建文档构造器
	DocumentBuilder builder = createDocumentBuilder(factory, entityResolver, errorHandler);
	return builder.parse(inputSource);
}

<2021-02-26 17:25>处代码创建文档构造器工厂，其源码如下：

org.springframework.beans.factory.xml.DefaultDocumentLoader#createDocumentBuilderFactory
protected DocumentBuilderFactory createDocumentBuilderFactory(int validationMode, boolean namespaceAware)
			throws ParserConfigurationException {
	// 注意这里的类是jdk的rt.jar中的类，而非spring的了
	// 创建实例对象
	DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
	// 设置命名空间支持
	factory.setNamespaceAware(namespaceAware);
	// 如果有验证模式，目前一般都是xsd VALIDATION_XSD
	if (validationMode != XmlValidationModeDetector.VALIDATION_NONE) {
		// 开启验证
		factory.setValidating(true);
		// 如果是xsd强制开启命名空间支持
		if (validationMode == XmlValidationModeDetector.VALIDATION_XSD) {
			// Enforce namespace aware for XSD...
			factory.setNamespaceAware(true);
			try {
				// 设置SCHEMA_LANGUAGE_ATTRIBUTE属性
				factory.setAttribute(SCHEMA_LANGUAGE_ATTRIBUTE, XSD_SCHEMA_LANGUAGE);
			}
			catch (IllegalArgumentException ex) {
				ParserConfigurationException pcex = new ParserConfigurationException(
						"Unable to validate using XSD: Your JAXP provider [" + factory +
						"] does not support XML Schema. Are you running on Java 1.4 with Apache Crimson? " +
						"Upgrade to Apache Xerces (or Java 1.5) for full XSD support.");
				// <2021-02-26 18:38>
				pcex.initCause(ex);
				throw pcex;
			}
		}
	}

	return factory;
}

<2021-02-26 18:38>代码是设置引起异常，关于方法initCause可以参考这里。
<2021-02-26 17:26>处代码通过文档构造器工厂创建文档构造器
，其源码如下：

org.springframework.beans.factory.xml.DefaultDocumentLoader#createDocumentBuilder
protected DocumentBuilder createDocumentBuilder(DocumentBuilderFactory factory,
			@Nullable EntityResolver entityResolver, @Nullable ErrorHandler errorHandler)
			throws ParserConfigurationException {
	// 通过工厂创建文件构造器
	DocumentBuilder docBuilder = factory.newDocumentBuilder();
	// <2021-02-26 18:50>
	// 如果解析文件的解析器不为空，则设置
	if (entityResolver != null) {
		docBuilder.setEntityResolver(entityResolver);
	}
	// 如果错误处理handler不为空，则设置
	if (errorHandler != null) {
		docBuilder.setErrorHandler(errorHandler);
	}
	// 返回工厂构造器
	return docBuilder;
}

<2021-02-26 18:50>处代码是设置实体解析器，作用是查找约束文件，DTD类型就是对应的.dtd文件，XSD类型就是对应的.xsd文件，对应的接口是org.xml.sax.EntityResolver是在jdk的rt.jar中，并不是spring自己提供的功能，源码如下：

org.xml.sax.EntityResolver#resolveEntity
public interface EntityResolver {

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

}

可以看到只有一个方法resolveEntity,其中有两个参数，第一个是publicId，第二个是systemId，其中第二个参数systemId代表的是约束文件的地址，本例中的参数值如下图：
在这里插入图片描述
参数entityResolver的获取是在方法调用org.springframework.beans.factory.xml.DocumentLoader#loadDocument中通过org.springframework.beans.factory.xml.XmlBeanDefinitionReader#getEntityResolver方法获取的，该方法如下：

org.springframework.beans.factory.xml.XmlBeanDefinitionReader#getEntityResolver
protected EntityResolver getEntityResolver() {
	// 为null才进入，可以认为就是null
	if (this.entityResolver == null) {
		// <2021-02-28 09:32>
		// 获取资源加载器
		ResourceLoader resourceLoader = getResourceLoader();
		// 如果资源加载器不为空则直接new一个ResourceEntityResolver，这里执行最终返回的就是这个对象
		if (resourceLoader != null) {
			this.entityResolver = new ResourceEntityResolver(resourceLoader);
		}
		// 否则返回DelegatingEntityResolver对象
		else {
			this.entityResolver = new DelegatingEntityResolver(getBeanClassLoader());
		}
	}
	// 返回最终的实体解析器
	return this.entityResolver;
}

<2021-02-28 09:32>处代码是获取资源加载器，关于资源加载器可以参考这里，如果有资源加载器，则创建一个资源实体解析器ResourceEntityResolver，该类定义如下：

public class ResourceEntityResolver extends DelegatingEntityResolver {}

其中DelegatingEntityResolver定义如下：

public class DelegatingEntityResolver implements EntityResolver {}

接下来我们看下EntityResolver的的具体子类实现查找约束文件的逻辑。

4：EntityResolver

4.1：DelegatingEntityResolver

这是spring实现EntityResolver的直接子类，该类是一个代理类，根据具体的验证模式是调用具体的子类进行验证，代理源码如下：

org.springframework.beans.factory.xml.DelegatingEntityResolver
public class DelegatingEntityResolver implements EntityResolver {

	/** Suffix for DTD files. */
	public static final String DTD_SUFFIX = ".dtd";

	/** Suffix for schema definition files. */
	public static final String XSD_SUFFIX = ".xsd";
	// dtd验证模式的实体解析器
	private final EntityResolver dtdResolver;
	// xsd验证模式的实体解析器
	private final EntityResolver schemaResolver;

	@Override
	@Nullable
	public InputSource resolveEntity(@Nullable String publicId, @Nullable String systemId)
			throws SAXException, IOException {
		// 有systemId才处理，systemId标记的是验证文件信息
		if (systemId != null) {
			// 如果是dtd则使用this.dtdResolver
			if (systemId.endsWith(DTD_SUFFIX)) {
				return this.dtdResolver.resolveEntity(publicId, systemId);
			}
			// 如果是xsd则使用this.schemaResolver
			else if (systemId.endsWith(XSD_SUFFIX)) {
				return this.schemaResolver.resolveEntity(publicId, systemId);
			}
		}

		// 都不符合，返回null，则后续使用默认的网络下载方式获取
		return null;
	}
}

4.2：BeansDtdResolver

该类源码如下：

org.springframework.beans.factory.xml.BeansDtdResolver
public class BeansDtdResolver implements EntityResolver {
	// 约束文件扩展名常量
	private static final String DTD_EXTENSION = ".dtd";
	// 约束文件的名称常量
	private static final String DTD_NAME = "spring-beans";

	private static final Log logger = LogFactory.getLog(BeansDtdResolver.class);


	@Override
	@Nullable
	public InputSource resolveEntity(@Nullable 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 + "]");
		}
		// 地址信息以dtd结尾
		if (systemId != null && systemId.endsWith(DTD_EXTENSION)) {
			// 获取最后一个/的位置
			int lastPathSeparator = systemId.lastIndexOf('/');
			// 获取文件名地址
			int dtdNameStart = systemId.indexOf(DTD_NAME, lastPathSeparator);
			// 存在文件名
			if (dtdNameStart != -1) {
				// 拼接生成dtd文件名
				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
					InputSource source = new InputSource(resource.getInputStream());
					// 设置publicId
					source.setPublicId(publicId);
					// 设置systemId
					source.setSystemId(systemId);
					if (logger.isTraceEnabled()) {
						logger.trace("Found beans DTD [" + systemId + "] in classpath: " + dtdFile);
					}
					// 返回
					return source;
				}
				catch (FileNotFoundException ex) {
					if (logger.isDebugEnabled()) {
						logger.debug("Could not resolve beans DTD [" + systemId + "]: not found in classpath", ex);
					}
				}
			}
		}

		// 返回null，使用网络下载默认行为
		return null;
	}
}

4.3：PluggableSchemaResolver

该类有一个重要的属性DEFAULT_SCHEMA_MAPPINGS_LOCATION,如下：

public static final String DEFAULT_SCHEMA_MAPPINGS_LOCATION = "META-INF/spring.schemas";

该文件定义如下：
在这里插入图片描述
定义的是xsd的网络地址对应的jar包物理地址信息，最终会加载到变量private volatile Map<String, String> schemaMappings;其中加载代码如下：

Properties mappings = PropertiesLoaderUtils.loadAllProperties(this.schemaMappingsLocation, this.classLoader);
schemaMappings = new ConcurrentHashMap<>(mappings.size());
CollectionUtils.mergePropertiesIntoMap(mappings, schemaMappings);
this.schemaMappings = schemaMappings;

加载完毕后如下图：
在这里插入图片描述
接下来看下获取资源方法：

org.springframework.beans.factory.xml.PluggableSchemaResolver#resolveEntity
public InputSource resolveEntity(@Nullable 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 + "]");
	}
	// 如果systemId不为空
	if (systemId != null) {
		// <2021-02-28 11:26>，从映射map中获取资源jar包中的地址
		String resourceLocation = getSchemaMappings().get(systemId);
		// 如果是没有获取到地址，则尝试使用http协议开头的网络地址获取
		if (resourceLocation == null && systemId.startsWith("https:")) {
			// Retrieve canonical http schema mapping even for https declaration
			resourceLocation = getSchemaMappings().get("http:" + systemId.substring(6));
		}
		// 如果是不为空，则创建ClassPathResource并返回
		if (resourceLocation != null) {
			Resource resource = new ClassPathResource(resourceLocation, this.classLoader);
			try {
				InputSource source = new InputSource(resource.getInputStream());
				// 设置publicId，systemId
				source.setPublicId(publicId);
				source.setSystemId(systemId);
				if (logger.isTraceEnabled()) {
					logger.trace("Found XML schema [" + systemId + "] in classpath: " + resourceLocation);
				}
				// 返回
				return source;
			}
			catch (FileNotFoundException ex) {
				if (logger.isDebugEnabled()) {
					logger.debug("Could not find XML schema [" + systemId + "]: " + resource, ex);
				}
			}
		}
	}

	// Fall back to the parser's default behavior.
	return null;
}

<2021-02-28 11:26>处代码是从META-INF/spring.schema文件中加载约束文件url地址和jar包中地址的映射关系，源码如下：

org.springframework.beans.factory.xml.PluggableSchemaResolver#getSchemaMappings
private Map<String, String> getSchemaMappings() {
		Map<String, String> schemaMappings = this.schemaMappings;
	if (schemaMappings == null) {
		synchronized (this) {
			schemaMappings = this.schemaMappings;
			if (schemaMappings == null) {
				if (logger.isTraceEnabled()) {
					logger.trace("Loading schema mappings from [" + this.schemaMappingsLocation + "]");
				}
				try {
					// 从spring.schema文件中加载验证文件URL和jar包地址映射关系
					Properties mappings =
							PropertiesLoaderUtils.loadAllProperties(this.schemaMappingsLocation, this.classLoader);
					if (logger.isTraceEnabled()) {
						logger.trace("Loaded schema mappings: " + mappings);
					}
					schemaMappings = new ConcurrentHashMap<>(mappings.size());
					CollectionUtils.mergePropertiesIntoMap(mappings, schemaMappings);
					this.schemaMappings = schemaMappings;
				}
				catch (IOException ex) {
					throw new IllegalStateException(
							"Unable to load schema mappings from location [" + this.schemaMappingsLocation + "]", ex);
				}
			}
		}
	}
	// 返回模式映射字典
	return schemaMappings;
}

4.4：ResourceEntityResolver

源码：

org.springframework.beans.factory.xml.ResourceEntityResolver#resolveEntity
public InputSource resolveEntity(@Nullable String publicId, @Nullable String systemId)
			throws SAXException, IOException {
	// <2021-02-28 12:40>，直接调用父类方法获取
	InputSource source = super.resolveEntity(publicId, systemId);
	// 如果是没有获取到，并且systemId不为null
	if (source == null && systemId != null) {
		String resourcePath = null;
		try {
			// 使用u8编码
			String decodedSystemId = URLDecoder.decode(systemId, "UTF-8");
			String givenUrl = new URL(decodedSystemId).toString();
			// <2021-02-28 12:41>
			// 获取file://协议的项目所在地址
			String systemRootUrl = new File("").toURI().toURL().toString();
			// Try relative to resource base if currently in system root.
			if (givenUrl.startsWith(systemRootUrl)) {
				resourcePath = givenUrl.substring(systemRootUrl.length());
			}
		}
		catch (Exception ex) {
			// Typically a MalformedURLException or AccessControlException.
			if (logger.isDebugEnabled()) {
				logger.debug("Could not resolve XML entity [" + systemId + "] against system root URL", ex);
			}
			// No URL (or no resolvable URL) -> try relative to resource base.
			resourcePath = systemId;
		}
		if (resourcePath != null) {
			if (logger.isTraceEnabled()) {
				logger.trace("Trying to locate XML entity [" + systemId + "] as resource [" + resourcePath + "]");
			}
			Resource resource = this.resourceLoader.getResource(resourcePath);
			source = new InputSource(resource.getInputStream());
			source.setPublicId(publicId);
			source.setSystemId(systemId);
			if (logger.isDebugEnabled()) {
				logger.debug("Found XML entity [" + systemId + "]: " + resource);
			}
		}
		else if (systemId.endsWith(DTD_SUFFIX) || systemId.endsWith(XSD_SUFFIX)) {
			// External dtd/xsd lookup via https even for canonical http declaration
			String url = systemId;
			if (url.startsWith("http:")) {
				url = "https:" + url.substring(5);
			}
			try {
				// 创建InputSource并设置publicId，sysetemId信息
				source = new InputSource(new URL(url).openStream());
				source.setPublicId(publicId);
				source.setSystemId(systemId);
			}
			catch (IOException ex) {
				if (logger.isDebugEnabled()) {
					logger.debug("Could not resolve XML entity [" + systemId + "] through URL [" + url + "]", ex);
				}
				// Fall back to the parser's default behavior.
				source = null;
			}
		}
	}

	return source;
}

<2021-02-28 12:40>，这里调用的方法就是org.springframework.beans.factory.xml.DelegatingEntityResolver#resolveEntity已经在前面分析过。<2021-02-28 12:41>处代码是获取file://协议的项目根路径地址，如file:/Users/xb/Desktop/D/dongsir-dev/java-life-current/java-life/是我本地的结果值,用于从系统根路径查找约束文件，换句话说就是处理约束文件在系统根路径内的情况。

5：获取Document

最终调用方法org.springframework.beans.factory.xml.DefaultDocumentLoader#loadDocument获取文档对象，代码如下：

org.springframework.beans.factory.xml.DefaultDocumentLoader#loadDocument
@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);
}

到这里已经成功过去了xml文件对应的Document，接下来就是分析如何解析为BeanDefinition了，详细参考这里。

一户董
关注
专栏目录
一步一步手绘Spring IOC运行时序图二（基于XML的IOC容器初始化）
Jarvis.y的博客
10-05 439
前言 1、博客内容均出自于咕泡学院架构师第三期 2、本章内容共分为三部分 第一部分：一步一步手绘Spring IOC运行时序图一（Spring 核心容器 IOC初始化过程） 第二部分：一步一步手绘Spring IOC运行时序图二（基于XML的IOC容器初始化） 第三部分：一步一步手绘Spring IOC运行时序图三（基于Annotation的IOC容器初始化） 基于 Xml 的 IOC 容器的初始化 IOC 容器的初始化包括 BeanDefinition 的 Resource 定位、加载和注册这三个基
Spring IOC源码解析(一)---读取Xml文件生成Dom对象
qq_43459448的博客
08-18 156
源码解析（一）
spring IOC容器依赖注入XML配置
02-05
spring IOC容器依赖注入XML配置详解 运行环境：eclipse 构建工具：maven 不提供maven构建，maven用来解决jar包的依赖
#学习笔记#使用dom4j读取xml文件得到document对象
热门推荐
AHua~
05-25 2万+
介绍如何用don4j读取到xml文件中的document对象
将XML文件转换成document文件 XmlUtil --readXmlByPath
qq_40597050的博客
06-26 1426
import org.w3c.dom.Document; import org.w3c.dom.Node; import org.xml.sax.SAXException; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import javax.xml.parse...
xml方式简单实现springIOC
武腾坤的博客
05-23 364
目录结构： 项目是用maven管理，所使用jar <!-- 引入Spring-AOP等相关Jar --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifac...
使用Spring的Ioc用xml配置文件的方式获取第一个对象
wdx0000的博客
09-23 195
一、创建一个Web项目，导入jar包到lib目录下 （1）导包 ： 4个核心（beans、core、context、expression） + 1个依赖（commons-loggins.jar） （2）编写配置文件： applicationContext.xml 放在src资源目录下 <beans xmlns="http://www.springframework.org/schema/...
Spring IoC加载流程讲解
01-12
在 XmlBeanDefinitionReader 中，我们首先将 Xml 资源文件采用 DOM 解析的方式解析为一个可操作的 Document 对象，然后依赖一个 BeanDefinitionDocumentReader 对象对解析得到的 Document 对象进行处理。 7. 注册 ...
Spring IOC源码分析
路漫漫兮
02-01 438
IOC容器设计与实现 重点知识 BeanFactory定义了IOC基本功能，这也就是面向接口编程，对于对IOC功能的增强，是通过集成BeanFacroty的拓展接口来实现的。 这里的整体设计可以借鉴的，这就是典型的面向接口编程和装饰者模式。 在Spring中所有的bean都是由BeanFactory进行管理的，FactoryBean是产生或者粉饰对象生成的的工厂bean BeanFactory路线 BeanFactory是实现IOC的基本形式，也就是最原始的IOC规范。Applicat
Spring IOC初始化流程
Leo专题
03-02 618
文章目录1、Spring IOC初始化整体流程1.1 Spring IOC的容器体系介绍1.2 编写测试代码1.3 初始化整体流程源码剖析1.4 初始化整体流程与时序图2、Spring BeanFactory创建流程2.1 BeanFactory创建与BeanDefinition加载流程源码2.2 BeanFactory创建与BeanDefinition加载注册时序图2.3 BeanDefinition加载及注册源码剖析2.4 BeanDefinition加载于注册时序图 1、Spring IOC初始化整体
XML及使用dom4j解析XML
m0_63647215的博客
04-13 819
常见XML解析方法有两种 1.DOM：要求解析器将整个XML文件全部加载到内存中，生成一个Document对象 优点：元素和元素之间的结构，关系，可以针对元素进行增删查改操作 缺点：如果XML文件过大，可能会导致内存溢出 2.SAX：是一种速度更快，更加高效的解析方式，她是逐行扫描，边扫描边解析，并且以事件驱动的方式来进行具体的解析，每解析一行，都会出发一个事件。 优点：不会出现内存溢出，可以处理大文件 确定：只能读，不能写 解析器就是根据不同的解析方式提供具体的实现，为了方便开发人员来解
java读取文件 classpath_如何真正从Java的classpath中读取文本文件
weixin_36161279的博客
02-26 659
通过类path中的目录，从同一个类加载器加载的类中，您应该可以使用以下任一项：// From ClassLoader, all paths are "absolute" already - there's no context // from which they could be relative. Therefore you don't need a leading slash. InputS...
怎么将XML字符串转换为XmlDocument，并获取部分节点值
weixin_30521649的博客
05-18 248
我们的目标：解析XML字符串，并获取节点：z:row下的属性：ows_LinkFilename的值集合？？？ XML字符串数据结构如下： <listitems xmlns:s='uuid:BDC6E3F0-6DA3-11d1-A2A3-00AA00C14882' xmlns:dt='uuid:C2F41010-65B3-11d1-A29F-00AA00C14882' xmlns...
FAQ（37）： org.springframework.beans.factory.xml.XmlBeanDefinitionStoreException: Line 2 in XML docume
Diligence is the mother of success.
12-30 666
FAQ（37）： org.springframework.beans.factory.xml.XmlBeanDefinitionStoreException: Line 2 in XML docume
Dom4j+Java反射+工厂模式 模拟Spring实现从xml配置文件获取对象实例
AsajuHuishi的博客
05-07 568
文章目录1.Dom4j 解析2.Java反射3.工厂模式 刚刚开始学习Spring，我了解到bean的生命周期。一般来讲，首先执行无参构造，然后执行set方法设置bean的属性，然后执行xxxAware接口的setxxx方法，然后执行BeanPostProcessor的PostProcessBeforeInitialization方法，然后执行PostConstruct注解标注的方法，然后执行InitializingBean接口的AfterPropertiesSet方法，然后执行配置的init-metho
如何获取jar包中的文件路径，并取出。
carrypeng的博客
01-07 2807
word文件做成代码：其中包含表格，图片，埋点文字等 ExportWordByTempUtils exportWordByTempUtils = new ExportWordByTempUtils(); String filePath = exportWordByTempUtils.getFilePath("template/project.docx"); String resFilePath = StringUtils.substringBeforeLast(fi.
spring中读取xml配置文件、获取bean的几种方式
wangzhuoyan的专栏
05-31 1万+
获取Spring框架管理的类实例的方法有多种,如下： 方法一：在初始化时保存ApplicationContext对象 代码： ApplicationContext ac = new FileSystemXmlApplicationContext("applicationContext.xml"); ac.getBean("beanId"); 说明： 这种方式适用于采用Spring框架的独立应用程序
XML解析为Document对象
a5799的博客
04-13 1318
XML解析为Document对象 我们在上一篇Spring源码分析中有提到，Spring是将xml文件的InputStream转换为DOM树，然后在将DOM树解析转换为BeanDefinition从而注册bean，那么这一篇，我们就来介绍一些Spring如何将xml文件转换为Document 首选DOM解析XML文件的官方标准，DOM解析就是将整个XML文件转换为一个DOM节点树，然后通过遍历和查找节点来读取XML文件中定义的数据。 源码分析 Document doc = doLoadDocument(i
Spring源码之容器的基本实现：通过Xml配置装载Bean
u013998466的博客
07-13 391
Spring通过Xml配置来装载Bean的的流程： 读取xml配置文件 》解析Xml并找到对应类的配置 》实例化对象 环境准备 这是一个简单的bean public class User { private String name; public String getName() { return name; } public void setName(String name) { this.name = name; } } 这是一个简单的bean配置(web.xml) &lt.
实现基础Spring IOC框架的反射机制详解
- 加载配置文件：在程序中加载XML配置文件，并获取其document对象。 - 解析配置文件：利用DOM解析器或其他解析技术来解析XML文件，获取所有的bean定义信息。 - 创建Bean实例：通过反射机制，根据bean的全限定名...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值