如何进行的加载及配置文件的解析,针对这个问题,这篇文章详细介绍了相对应的分析和解答,希望可以帮助更多想解决这个问题的小伙伴找到更简单易行的方法。
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。这里是学习工程
先给一个类图,了解一下,有个印象,后续会逐步熟悉的。
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来读取的配置文件。因此不影响我们对代码的分析。
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进行解析。
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的话看起来还是有一定难度的。这里重在给自己勾勒初一个大致的轮廓,在这其中可以回忆起其中的细节。
关于如何进行的加载及配置文件的解析问题的解答就分享到这里了,希望以上内容可以对大家有一定的帮助,如果你还有很多疑惑没有解开,可以关注亿速云行业资讯频道了解更多相关知识。
免责声明:本站发布的内容(图片、视频和文字)以原创、转载和分享为主,文章观点不代表本网站立场,如果涉及侵权请联系站长邮箱:is@yisu.com进行举报,并提供相关证据,一经查实,将立刻删除涉嫌侵权内容。