温馨提示×

温馨提示×

您好,登录后才能下订单哦!

密码登录×
登录注册×
其他方式登录
点击 登录注册 即表示同意《亿速云用户服务条款》

如何进行的加载及配置文件的解析

发布时间:2021-11-09 17:13:13 来源:亿速云 阅读:117 作者:柒染 栏目:大数据

如何进行的加载及配置文件的解析,针对这个问题,这篇文章详细介绍了相对应的分析和解答,希望可以帮助更多想解决这个问题的小伙伴找到更简单易行的方法。

bean的加载-配置文件的解析

spring是个包含很多个模块的框架。其中核心部分有四个,bean,core,context和Expresion Language.

core和bean是spring的基础模块。提供Ioc(控制反转)和依赖注入特性,这些的基础概念是BeanFactory。即bean工厂,一个可以创建各种bean的工厂。我们使用spring来过将项目的时候,都离不开bean,Bean模块包含访问配置文件,创建和管理bean以及进行Ioc和DI操作相关的所有类。

既然bean这么重要,那么就来分析一下bean的加载过程就顺理成章了。只分析比较核心的,能够根据这些方法想起其中细节的一些方法,所以有些地方不会太深入,适合对spring有一定了解的读者,深究就留给自己去研究吧。

<bean id="xxx" class="com.xx.xx.Person"/>

如上,bean的定义是如此简单,但是加载过程是怎样的呢?为了简便起见,这里还是会使用已经过时的DefaultListableBeanFactory的子类XmlBeanFactory来做分析,源码使用的是spring 5.1.5.RELEASE。这里是学习工程

核心类

DefaultListableBeanFacory

如何进行的加载及配置文件的解析

先给一个类图,了解一下,有个印象,后续会逐步熟悉的。

AliasRegistry: 定义对alias的简答年增删改等操作;
SimpleAliasRegistry: 主要是用map作为alias的缓存,并对接口AliasRegistry进行实现;
SingletonBeanRegistry: 定义对单例的注册及获取;
BeanFactory: 定义获取bean及bean的各种属性;
DefaultSingletonBeanRegistry: 对接口SingletonBeanRegistry各函数的实现;
hierarchicalBeanFactory: 继承BeanFactory,也就是在beanFactory定义的功能的基础上增加了对ParrentFactory的支持;
BeanDefintionRegistry: 定义对BeanDefinition的各种增删改操作;
FactoryBeanRegistrySupport: 在DefaultSingletonBeanRegistry基础上增加了对FactoryBean的特殊处理功能;
ConfigurableBeanFactory: 提供配置Factory的各种方法;
ListableBeanFactory: 根据各种条件获取备案的配置清单;
AbstractBeanFactory: 综合FactoryBeanRegistrySupport和ConfigurableBeanFactory的功能。
AutowireCapableBeanFacotry: 提供创建bean、自动注入、初始化以及应用bean的后置处理器;
AbstractAutowireCapableBeanFactory: 综合AbstractBeanFactory并对接口AutowireCapableBeanFactory进行实现;
ConfigurableListableBeanFactory: BeanFactory配置清单,指定胡烈类型及接口等;
DefaultListableBeanFactory: 综合上面内所有功能,主要是对Bean注册后的处理;

XmlBeanFactory是DefaultListableBeanFactory的子类,标记为已经过时,里面增加了XmlBeanDefinitionReader类型的reader属性。虽然已经标记为过时,但是即使是DefaultListableBeanFactory,最终在spring初始化的过程中,也是使用的XmlBeanDefinitionReader来读取的配置文件。因此不影响我们对代码的分析。

XmlBeanDefinitionReader

spring的配置文件是实现bean配置的最常用方式(这里不讨论springboot),而读取xml配置文件的就是XmlBeanDefinitionReader。先来看一下会使用到的一些类的功能。

ResourceLoader: 定义资源加载器,主要应用于根据给定的资源文件地址返回对应你的Resource;
BeanDefinitionReader: 主要定义资源文件读取并转换为BeanDefinition的各个功能;
EnvironmentCapable: 定义获取Environment方法;
DocumentLoader: 定义从资源文件加载到转换为Document的功能;
AbstractBeanDefinitionReader: 对EnvironmentCapable、BeanDefinitionReader类定义的功能进行实现;
BeanDefinitionDocumentReader: 定义读取Document并注册BeanDefinition功能;
BeanDefinitionParserDelegate: 定义解析Element的各种方法;

XmlBeanDefinitionReader通过继承AbstractBeanDefinitionReader中的方法,来使用ResourseLoader将资源文件路径转换为对应的Resource文件;通过DocumentLoader对Resource文件进行转换,将Resource文件转换为Document文件;通过实现接口BeanDefinitionDocumentReader的DefaultBeanDefinitionDocumentReader类对Document进行解析,并使用BeanDefinitionParserDelegate对Element进行解析。

xml文件读取

public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
	super(parentBeanFactory);
    // 开始加载并读取xml文件
	this.reader.loadBeanDefinitions(resource);
}

构造方法中super调用了父类,一直跟到底,会在AbstractAutowireCapableBeanFactory中发现以下代码:

public AbstractAutowireCapableBeanFactory() {
	super();
    // 忽略指定接口的自动装配功能
	ignoreDependencyInterface(BeanNameAware.class);
	ignoreDependencyInterface(BeanFactoryAware.class);
	ignoreDependencyInterface(BeanClassLoaderAware.class);
}

回到构造函数的this.reader.loadBeanDefinitions(resource);

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

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
	//...
	// 检查当前线程正正在加载的resource
	Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
	if (currentResources == null) {
		currentResources = new HashSet<>(4);
		this.resourcesCurrentlyBeingLoaded.set(currentResources);
	}
    //如果当前准备解析的encodeResource正在加载,则抛出异常
	if (!currentResources.add(encodedResource)) {
		throw new BeanDefinitionStoreException(
				"Detected cyclic loading of " + encodedResource + " - check your import definitions!");
	}
	try {
		//获取resource的inputStream
		InputStream inputStream = encodedResource.getResource().getInputStream();
		try {
			//包装成inputSource
			InputSource inputSource = new InputSource(inputStream);
			if (encodedResource.getEncoding() != null) {
				inputSource.setEncoding(encodedResource.getEncoding());
			}
			//开始加载
			return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
		}
		finally {
			inputStream.close();
		}
	}
	//...
}

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
		throws BeanDefinitionStoreException {
	try {
        //将resource转成document,这里头会去验证xml文件,DTD或者XSD,不同的类型会用不用的解析方式,喜欢的自己去看吧
		Document doc = doLoadDocument(inputSource, resource);
        //解析document并注册bean
		int count = registerBeanDefinitions(doc, resource);
		//...
        //返回加载的bean的数量
		return count;
	}
}

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
    //创建document解析器
	BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
	int countBefore = getRegistry().getBeanDefinitionCount();
    //使用document解析器解析document
    //这里createReaderContext()创建的是XmlReaderContext
	documentReader.registerBeanDefinitions(doc, createReaderContext(resource));//***①
	return getRegistry().getBeanDefinitionCount() - countBefore;
}

public XmlReaderContext createReaderContext(Resource resource) {
	return new XmlReaderContext(resource, this.problemReporter, this.eventListener,
			this.sourceExtractor, this, getNamespaceHandlerResolver());
}

public NamespaceHandlerResolver getNamespaceHandlerResolver() {
	if (this.namespaceHandlerResolver == null) {
		this.namespaceHandlerResolver = createDefaultNamespaceHandlerResolver();
	}
	return this.namespaceHandlerResolver;
}

protected NamespaceHandlerResolver createDefaultNamespaceHandlerResolver() {
	ClassLoader cl = (getResourceLoader() != null ? getResourceLoader().getClassLoader() : getBeanClassLoader());
    //返回默认的命名空间解析器,这个东西会用来获取解析标签的NamespaceHandler
	return new DefaultNamespaceHandlerResolver(cl);
}

看方法***①:

//DefaultBeanDefinitionDocumentReader.java
public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
	this.readerContext = readerContext;
    //解析document
	doRegisterBeanDefinitions(doc.getDocumentElement());
}

protected void doRegisterBeanDefinitions(Element root) {
    BeanDefinitionParserDelegate parent = this.delegate;
    //创建默认的BeanDefinitionParserDelegate,用来解析自定义标签
	this.delegate = createDelegate(getReaderContext(), root, parent);
    //...profile的处理,如果在web.xml中定义了profile,则只解析相应的文件
    if (this.delegate.isDefaultNamespace(root)) {
		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);
}

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);
	}
}

解析默认标签

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
	if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
        //解析import标签,如果有import标签,其实就会递归解析了
		importBeanDefinitionResource(ele);
	}
	else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
        //解析别名标签
		processAliasRegistration(ele);
	}
	else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
        //解析bean标签
		processBeanDefinition(ele, delegate);
	}
	else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
		// 解析beans标签,其实就是把当前节点继续丢去解析而已,产生了递归
		doRegisterBeanDefinitions(ele);
	}
}

对默认标签的解析就不多写了,无非不过就是怎么去读取文件,怎么解决文件中的各种数据,喜欢的就自己深究下去吧,再细下去就太多了,为了给自己一个印象,我这里不会深究下去。

解析自定义标签

先看个demo吧。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:myname="http://www.wt.com/schema/user"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
	   http://www.wt.com/schema/user http://www.wt.com/schema/user.xsd">

    <myname:user id="user" name="wt" age="23" email="taow"/>
</beans>

指定命名空间myname="http://www.wt.com.schema/user",看下面META-INF/Spring.handlers配置定义了当前命名空间所使用的解析器;schemaLocation中的http://www.wt.com/schema/user.xsd指定文件所在目录,看下面META-INF/Spring.schemas的配置,指定了xsd的文件所在目录。

# META-INF/Spring.handlers
# 定义指定namespace解析器,格式namespace = NamespaceHandler
http\://www.wt.com/schema/user=com.wt.test.customtag.MyNamespaceHandler
# META-INF/Spring.schemas
# 定义xml约束文档xsd所在目录
http\://www.wt.com/schema/user.xsd=META-INF/user.xsd
<!-- META-INF/user.xsd -->
<?xml version="1.0" encoding="UTF-8"?>
<schema xmlns="http://www.w3.org/2001/XMLSchema"
        targetNamespace="http://www.wt.com/schema/user"
        elementFormDefault="qualified">

    <element name="user">
        <complexType>
            <attribute name="id" type="string" />
            <attribute name="email" type="string" />
            <attribute name="name" type="string" />
            <attribute name="age" type="int" />
        </complexType>
    </element>
</schema>
//注册自定义的命名空间解析器
public class MyNamespaceHandler extends NamespaceHandlerSupport {
	public void init() {
        //注册解析器
		registerBeanDefinitionParser("user", new UserBeanDefinitionParser());
	}
}

//该方法在父类NamespaceHandlerSupport中,父类实现了NamespaceHandler
public BeanDefinition parse(Element element, ParserContext parserContext) {
	BeanDefinitionParser parser = findParserForElement(element, parserContext);
	return (parser != null ? parser.parse(element, parserContext) : null);
}
//标签解析器
public class UserBeanDefinitionParser extends AbstractSingleBeanDefinitionParser {

	@Override
	protected Class<?> getBeanClass(Element element) {
		return User.class;
	}

	@Override
	protected void doParse(Element element, BeanDefinitionBuilder bean) {
		String name = element.getAttribute("name");
		String age = element.getAttribute("age");
		String email = element.getAttribute("email");
		if (StringUtils.hasText(name)) {
			bean.addPropertyValue("name", name);
		}
		if (StringUtils.hasText(age)) {
			bean.addPropertyValue("age", age);
		}
		if (StringUtils.hasText(email)) {
			bean.addPropertyValue("email", email);
		}
	}
}

以上就是所有的自定义标签的配置。实现NamespaceHandler,在init方法中注册我们自定义的解析器。其实逻辑只是我们调用namespaceHandler的parse方法来解析自定义标签。但真正的解析肯定就是在parse方法中调用我们自己的解析器来解析而已。

现在开始分析,自定义标签是通过delegate.parseCustomElement(ele)来解析的。dalegate就是注释中提到的创建的默认的BeanDefinitionParserDelegate。

//BeanDefinitionParserDelegate.java
public BeanDefinition parseCustomElement(Element ele) {
	return parseCustomElement(ele, null);
}

public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
	//获取namespaceURI,也就是我们定义的命名空间http://www.wt.com/schema/user
    String namespaceUri = getNamespaceURI(ele);
	if (namespaceUri == null) {
		return null;
	}
    //使用nameSpaceHandlerResolver,根据namespaceUri获取自定义的标签解析器NamespaceHandler,
	NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
	if (handler == null) {
		error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
		return null;
	}
    //解析自定义标签
	return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
}

我们自定义的MyNamespaceHandler是就是通过NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);这一行来获取的。直接跟进去,进入resolve方法。至于getNamespaceHandlerResolver()在哪里创建的之前提到过,这里就不继续说了,是默认的。

//DefaultNamespaceHandlerResolver.java
public NamespaceHandler resolve(String namespaceUri) {
	//获取所有的命名空间->命名空间解析器的映射,就是Spring.handlers中的映射
	Map<String, Object> handlerMappings = getHandlerMappings();
	Object handlerOrClassName = handlerMappings.get(namespaceUri);
	if (handlerOrClassName == null) {
		return null;
	}
	//第一次加载的时候是String->String,但是如果已经获取过,就会实例化而变成String->NamespaceHandler并加入缓存,
	//所以这里先判断是不是已经初始化过,如果是就不用再初始化了
	else if (handlerOrClassName instanceof NamespaceHandler) {
		return (NamespaceHandler) handlerOrClassName;
	}
	else {
		//第一次加载,根据全限定类名初始化
		String className = (String) handlerOrClassName;
		try {
			Class<?> handlerClass = ClassUtils.forName(className, this.classLoader);
			//...
			NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass);
            //执行init方法,我们自定义的namespaceHandler在这个方法中注册了我们自己的解析器
			namespaceHandler.init();
			//加入当前实例,避免下次进入再次实例化
			handlerMappings.put(namespaceUri, namespaceHandler);
			return namespaceHandler;
		}
		//...
	}
}

private Map<String, Object> getHandlerMappings() {
	Map<String, Object> handlerMappings = this.handlerMappings;
	if (handlerMappings == null) {
		synchronized (this) {
			handlerMappings = this.handlerMappings;
			if (handlerMappings == null) {
				//...
				try {
					//从文件中获取映射关系
					Properties mappings =
						PropertiesLoaderUtils.loadAllProperties(this.handlerMappingsLocation, this.classLoader);
					//...
					handlerMappings = new ConcurrentHashMap<>(mappings.size());
					CollectionUtils.mergePropertiesIntoMap(mappings, handlerMappings);
					this.handlerMappings = handlerMappings;
				}
				//...
			}
		}
	}
	return handlerMappings;
}

public static final String DEFAULT_HANDLER_MAPPINGS_LOCATION = "META-INF/spring.handlers";

public DefaultNamespaceHandlerResolver() {
	this(null, DEFAULT_HANDLER_MAPPINGS_LOCATION);
}

在getHandlerMappings()方法中,我们注意看这行代码Properties mappings = PropertiesLoaderUtils.loadAllProperties(this.handlerMappingsLocation, this.classLoader);这样代码就是从Spring.handlers文件中获取所有的映射关系。在上面的代码最后面,贴上了默认的地址,也就是META-INF/Spring.handlers。

这样就拿到了我们自定义的NamespaceHandler,接下来就是调用我们的MyNameSpaceHandler的parse方法来解析咯(实际上在这里头会调用我们自己的解析器UserBeanDefinitionParser哦,比较简单,自己看咯)。

我们熟悉的spring-aop就是通过自定义标签来实现的哦,使用的是AopNamespaceHandler哦。
还有springmvc的<annotation-driven/>也是哦,使用的是MvcNamespaceHandler哦。

xml的解析内容比较少,但是如果不熟悉spring的话看起来还是有一定难度的。这里重在给自己勾勒初一个大致的轮廓,在这其中可以回忆起其中的细节。

关于如何进行的加载及配置文件的解析问题的解答就分享到这里了,希望以上内容可以对大家有一定的帮助,如果你还有很多疑惑没有解开,可以关注亿速云行业资讯频道了解更多相关知识。

向AI问一下细节

免责声明:本站发布的内容(图片、视频和文字)以原创、转载和分享为主,文章观点不代表本网站立场,如果涉及侵权请联系站长邮箱:is@yisu.com进行举报,并提供相关证据,一经查实,将立刻删除涉嫌侵权内容。

AI