Sring源码解析(一)Spring是怎么读取配置Xml文件的

本文涉及的产品
全局流量管理 GTM,标准版 1个月
公共DNS(含HTTPDNS解析),每月1000万次HTTP解析
云解析 DNS,旗舰版 1个月
简介: 1#Spring读取配置文件 ##Document在XmlBeanDefinitionReader.doLoadBeanDefinitions(InputSource inputSource, Resource resource)方法中将Xml文件转换成Document对象;Document doc = doLoadDocument(inputSource, resource);

作者石臻臻, CSDN博客之星Top5Kafka Contributornacos Contributor华为云 MVP ,腾讯云TVP, 滴滴Kafka技术专家KnowStreaming, 《Kafka运维与实战宝典》电子书作者。 领取《Kafka运维与实战宝典》PDF请联系石臻臻


KnowStreaming  是滴滴开源的Kafka运维管控平台, 有兴趣一起参与参与开发的同学,但是怕自己能力不够的同学,可以联系我,当你导师带你参与开源!

1#Spring读取配置文件 ##Document

XmlBeanDefinitionReader.doLoadBeanDefinitions(InputSource inputSource, Resource resource)方法中将Xml文件转换成Document对象;Document doc = doLoadDocument(inputSource, resource);20180428164047190.png

2Element


org.w3c.dom.Element 是一个接口 public interface Element extends NodeSpring中DefaultBeanDefinitionDocumentReader

@Override
 public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
  this.readerContext = readerContext;
  logger.debug("Loading bean definitions");
  // 从Document中获取Element
  Element root = doc.getDocumentElement();
  //注册BeanDefinitions
  doRegisterBeanDefinitions(root);
 }

DefaultBeanDefinitionDocumentReader.doRegisterBeanDefinitions(Element root)

protected void doRegisterBeanDefinitions(Element root) {
  BeanDefinitionParserDelegate parent = this.delegate;
  /**
  1.根据Element root创建**BeanDefinitionParserDelegate**对象
  2.解析Xml文件头中的一些属性配置到 BeanDefinitionParserDelegate属性(DocumentDefaultsDefinition)defaults;
  **/
  this.delegate = createDelegate(getReaderContext(), root, parent);
  //根据root查询 xml文件的命名空间是不是public static final String BEANS_NAMESPACE_URI = "http://www.springframework.org/schema/beans";
  if (this.delegate.isDefaultNamespace(root)) {
   //省略.....
  }
  //默认空实现 子类可以重写这个方法来处理自定义xml文件
  preProcessXml(root);
  parseBeanDefinitions(root, this.delegate);
  //默认空实现 子类可以重写这个方法来处理自定义xml文件
  postProcessXml(root);
  this.delegate = parent;
 }

this.delegate = createDelegate(getReaderContext(), root, parent);里面调用 BeanDefinitionParserDelegate.initDefaults方法 1.初始化属性值private final DocumentDefaultsDefinition defaults = new DocumentDefaultsDefinition(); 2. TODO..

public void initDefaults(Element root, BeanDefinitionParserDelegate parent) {
  // this.defaults 是一个DocumentDefaultsDefinition对象;
  populateDefaults(this.defaults, (parent != null ? parent.defaults : null), root);
  this.readerContext.fireDefaultsRegistered(this.defaults);
 }

BeanDefinitionParserDelegate.populateDefaults方法主要是讲xml文件中的一些命名空间的基本配置转换成DocumentDefaultsDefinition 对象; 例如

<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
 http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd"
 default-autowire="byName" default-lazy-init="false" default-dependency-check="all" >

//parentDefaults是父类的DocumentDefaultsDefinition对象
protected void populateDefaults(DocumentDefaultsDefinition defaults, DocumentDefaultsDefinition parentDefaults, Element root) {
  //查看xml文件中默认的default-lazy-init 值;(如果xml没有显示配置 则它的值为 default)懒加载的默认值
  String lazyInit = root.getAttribute(DEFAULT_LAZY_INIT_ATTRIBUTE);
  if (DEFAULT_VALUE.equals(lazyInit)) {
   //如果有父类,则以父类的为准,否则将返回false。
   lazyInit = (parentDefaults != null ? parentDefaults.getLazyInit() : FALSE_VALUE);
  }
  defaults.setLazyInit(lazyInit);
  //default-autowire-candidates
  String merge = root.getAttribute(DEFAULT_MERGE_ATTRIBUTE);
  if (DEFAULT_VALUE.equals(merge)) {
   // Potentially inherited from outer <beans> sections, otherwise falling back to false.
   merge = (parentDefaults != null ? parentDefaults.getMerge() : FALSE_VALUE);
  }
  defaults.setMerge(merge);
  //default-autowire
  String autowire = root.getAttribute(DEFAULT_AUTOWIRE_ATTRIBUTE);
  if (DEFAULT_VALUE.equals(autowire)) {
   // Potentially inherited from outer <beans> sections, otherwise falling back to 'no'.
   autowire = (parentDefaults != null ? parentDefaults.getAutowire() : AUTOWIRE_NO_VALUE);
  }
  defaults.setAutowire(autowire);
  // Don't fall back to parentDefaults for dependency-check as it's no longer supported in
  // <beans> as of 3.0. Therefore, no nested <beans> would ever need to fall back to it.
  defaults.setDependencyCheck(root.getAttribute(DEFAULT_DEPENDENCY_CHECK_ATTRIBUTE));
  if (root.hasAttribute(DEFAULT_AUTOWIRE_CANDIDATES_ATTRIBUTE)) {
   defaults.setAutowireCandidates(root.getAttribute(DEFAULT_AUTOWIRE_CANDIDATES_ATTRIBUTE));
  }
  else if (parentDefaults != null) {
   defaults.setAutowireCandidates(parentDefaults.getAutowireCandidates());
  }
  if (root.hasAttribute(DEFAULT_INIT_METHOD_ATTRIBUTE)) {
   defaults.setInitMethod(root.getAttribute(DEFAULT_INIT_METHOD_ATTRIBUTE));
  }
  else if (parentDefaults != null) {
   defaults.setInitMethod(parentDefaults.getInitMethod());
  }
  if (root.hasAttribute(DEFAULT_DESTROY_METHOD_ATTRIBUTE)) {
   defaults.setDestroyMethod(root.getAttribute(DEFAULT_DESTROY_METHOD_ATTRIBUTE));
  }
  else if (parentDefaults != null) {
   defaults.setDestroyMethod(parentDefaults.getDestroyMethod());
  }
  //这里是???
  defaults.setSource(this.readerContext.extractSource(root));
 }

3##DocumentDefaultsDefinition

DocumentDefaultsDefinition(文档的默认值定义)保存了 标准的Spring Xml文件中的 {@code beans}  层级的属性,这些属性是当前Xml配置中的默认全局属性值,例如  { @code default-lazy-init },{ @code default-autowire },等等。

例如:

<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
 http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd"
 default-autowire="byName" default-lazy-init="false" default-dependency-check="all" >

4###DefaultsDefinition

默认定义的标记接口,没有任何定义 ,只是单纯的标记一下;继承BeanMetadataElement类;通常具体的实现(例如DocumentDefaultsDefinition)是基于文档的默认值,例如在一个XML文档根标记级别来进行设置默认值

###BeanMetadataElement

需要被实现的元数据接口,这个接口定义了Object getSource()方法,返回一个配置源对象

public class DocumentDefaultsDefinition implements DefaultsDefinition {
 //初始化懒加载
 private String lazyInit;
 //
 private String merge;
 // 自动装载的类型 
 private String autowire;
 //
 private String dependencyCheck;
 private String autowireCandidates;
 //初始化方法
 private String initMethod;
 //销毁方法
 private String destroyMethod;
 //返回配置源对象
 private Object source;
 //省略 get set ......
}

default-autowire和autowire的可选值

可选值 功能说明
no 默认不使用autowiring。 必须显示的使用”“标签明确地指定bean。
byName 根据属性名自动装配。此选项将检查容器并根据名字查找与属性完全一致的bean,并将其与属性自动装配。
byType 如果容器中存在一个与指定属性类型相同的bean,那么将与该属性自动装配。如果存在多个该类型的bean,那么将会抛出异常,并指出不能使用byType方式进行自动装配。若没有找到相匹配的bean,则什么事都不发生,属性也不会被设置。如果你不希望这样,那么可以通过设置 dependency-check=”objects”让Spring抛出异常。
constructor 与byType的方式类似,不同之处在于它应用于构造器参数。如果在容器中没有找到与构造器参数类型一致的bean,那么将会抛出异常。
autodetect 通过bean类的自省机制(introspection)来决定是使用constructor还是byType方式进行自动装配。如果发现默认的构造器,那么将使用byType方式。

解析完了一些xml中Element的默认属性,接下来就是解析Element中的子属性了 DefaultBeanDefinitionDocumentReader.parseBeanDefinitions(root, this.delegate);这个方法里我们主要看 delegate.parseCustomElement(ele);

 

public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd) {
  //获取命名空间
  String namespaceUri = getNamespaceURI(ele);
  //根据命名空间得到命名空间的处理类handler  如果是dubbo的uri 则返回的就是DubboNamespaceHandler
  //他们都继承自NamespaceHandlerSupport implements NamespaceHandler 
  //里面有调用了hander的init()...
  NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
  if (handler == null) {
   error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
   return null;
  }
  //1.根据Element的getLocalName()得到Element的name,然后根据这个name去NamespaceHandlerSupport中的一个属性为private final Map<String, BeanDefinitionParser> parsers ;中查找对应的解析器;这个解析器是什么时候被放到这个map里面的呢?TODO...
  //2.根据对应的解析器调用  .parse(element,parserContext)进行解析 
  return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
 }

5让我们来单独解析一下NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri)首先了解一下 this.readerContext是BeanDefinitionParserDelegate中的一个属性private final XmlReaderContext readerContext;##XmlReaderContext

继承了ReaderContext类,并且提供了 对XmlBeanDefinitionReaderNamespaceHandlerResolver的访问权限;

public class XmlReaderContext extends ReaderContext {
 //可以看到 方法权限是private 的
 private final XmlBeanDefinitionReader reader;
 private final NamespaceHandlerResolver namespaceHandlerResolver;
 public XmlReaderContext(
   Resource resource, ProblemReporter problemReporter,
   ReaderEventListener eventListener, SourceExtractor sourceExtractor,
   XmlBeanDefinitionReader reader, NamespaceHandlerResolver namespaceHandlerResolver) {
  super(resource, problemReporter, eventListener, sourceExtractor);
  this.reader = reader;
  this.namespaceHandlerResolver = namespaceHandlerResolver;
 }
 //但是提供了一些访问的方法
 public final XmlBeanDefinitionReader getReader() {
  return this.reader;
 }
 public final BeanDefinitionRegistry getRegistry() {
  return this.reader.getRegistry();
 }
 public final ResourceLoader getResourceLoader() {
  return this.reader.getResourceLoader();
 }
 public final ClassLoader getBeanClassLoader() {
  return this.reader.getBeanClassLoader();
 }
 public final Environment getEnvironment() {
  return this.reader.getEnvironment();
 }
 public final NamespaceHandlerResolver getNamespaceHandlerResolver() {
  return this.namespaceHandlerResolver;
 }
  public String generateBeanName(BeanDefinition beanDefinition) {
  return this.reader.getBeanNameGenerator().generateBeanName(beanDefinition, getRegistry());
 }
 public String registerWithGeneratedName(BeanDefinition beanDefinition) {
  String generatedName = generateBeanName(beanDefinition);
  getRegistry().registerBeanDefinition(generatedName, beanDefinition);
  return generatedName;
 }
 public Document readDocumentFromString(String documentContent) {
  InputSource is = new InputSource(new StringReader(documentContent));
  try {
   return this.reader.doLoadDocument(is, getResource());
  }
  catch (Exception ex) {
   throw new BeanDefinitionStoreException("Failed to read XML document", ex);
  }
 }

1.那XmlReaderContext是什么时候被赋值的呢?我们顺着XmlReaderContext了解一下 ①. XmlBeanDefinitionReader.registerBeanDefinitions中被创建

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
  BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
  int countBefore = getRegistry().getBeanDefinitionCount();
  //创建XmlReaderContext,然后赋值给BeanDefinitionDocumentReader中readerContext属性中
  documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
  return getRegistry().getBeanDefinitionCount() - countBefore;
 }
public XmlReaderContext createReaderContext(Resource resource) {
  //this 最后就是 XmlReaderContext中的XmlBeanDefinitionReader属性
  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;
 }
 /**
 *如果没有具体的实现类,则创建 默认的实现类返回
 * 默认的实现类DefaultNamespaceHandlerResolver中的handlerMappingsLocation属性(Resource location to search for)=META-INF/spring.handlers
 */
 protected NamespaceHandlerResolver createDefaultNamespaceHandlerResolver() {
  return new DefaultNamespaceHandlerResolver(getResourceLoader().getClassLoader());
 }

②.创建后的XmlReaderContext被当做 BeanDefinitionParserDelegate 构造函数的参数来创建BeanDefinitionParserDelegate对象

protected void doRegisterBeanDefinitions(Element root) {
  BeanDefinitionParserDelegate parent = this.delegate;
  this.delegate = createDelegate(getReaderContext(), root, parent); 
  //省略.....
  }
相关文章
|
12天前
|
XML Java 开发者
Spring底层架构核心概念解析
理解 Spring 框架的核心概念对于开发和维护 Spring 应用程序至关重要。IOC 和 AOP 是其两个关键特性,通过依赖注入和面向切面编程实现了高效的模块化和松耦合设计。Spring 容器管理着 Beans 的生命周期和配置,而核心模块为各种应用场景提供了丰富的功能支持。通过全面掌握这些核心概念,开发者可以更加高效地利用 Spring 框架开发企业级应用。
56 18
|
2月前
|
人工智能 自然语言处理 Java
FastExcel:开源的 JAVA 解析 Excel 工具,集成 AI 通过自然语言处理 Excel 文件,完全兼容 EasyExcel
FastExcel 是一款基于 Java 的高性能 Excel 处理工具,专注于优化大规模数据处理,提供简洁易用的 API 和流式操作能力,支持从 EasyExcel 无缝迁移。
172 9
FastExcel:开源的 JAVA 解析 Excel 工具,集成 AI 通过自然语言处理 Excel 文件,完全兼容 EasyExcel
|
1月前
|
Serverless 对象存储 人工智能
智能文件解析:体验阿里云多模态信息提取解决方案
在当今数据驱动的时代,信息的获取和处理效率直接影响着企业决策的速度和质量。然而,面对日益多样化的文件格式(文本、图像、音频、视频),传统的处理方法显然已经无法满足需求。
84 4
智能文件解析:体验阿里云多模态信息提取解决方案
|
1天前
|
传感器 监控 安全
智慧工地云平台的技术架构解析:微服务+Spring Cloud如何支撑海量数据?
慧工地解决方案依托AI、物联网和BIM技术,实现对施工现场的全方位、立体化管理。通过规范施工、减少安全隐患、节省人力、降低运营成本,提升工地管理的安全性、效率和精益度。该方案适用于大型建筑、基础设施、房地产开发等场景,具备微服务架构、大数据与AI分析、物联网设备联网、多端协同等创新点,推动建筑行业向数字化、智能化转型。未来将融合5G、区块链等技术,助力智慧城市建设。
|
2月前
|
设计模式 XML Java
【23种设计模式·全精解析 | 自定义Spring框架篇】Spring核心源码分析+自定义Spring的IOC功能,依赖注入功能
本文详细介绍了Spring框架的核心功能,并通过手写自定义Spring框架的方式,深入理解了Spring的IOC(控制反转)和DI(依赖注入)功能,并且学会实际运用设计模式到真实开发中。
【23种设计模式·全精解析 | 自定义Spring框架篇】Spring核心源码分析+自定义Spring的IOC功能,依赖注入功能
|
1月前
|
监控 JavaScript 数据可视化
建筑施工一体化信息管理平台源码,支持微服务架构,采用Java、Spring Cloud、Vue等技术开发。
智慧工地云平台是专为建筑施工领域打造的一体化信息管理平台,利用大数据、云计算、物联网等技术,实现施工区域各系统数据汇总与可视化管理。平台涵盖人员、设备、物料、环境等关键因素的实时监控与数据分析,提供远程指挥、决策支持等功能,提升工作效率,促进产业信息化发展。系统由PC端、APP移动端及项目、监管、数据屏三大平台组成,支持微服务架构,采用Java、Spring Cloud、Vue等技术开发。
|
2月前
|
Java Spring
【Spring配置】创建yml文件和properties或yml文件没有绿叶
本文主要针对,一个项目中怎么创建yml和properties两种不同文件,进行配置,和启动类没有绿叶标识进行解决。
|
2月前
|
存储 缓存 Java
Spring面试必问:手写Spring IoC 循环依赖底层源码剖析
在Spring框架中,IoC(Inversion of Control,控制反转)是一个核心概念,它允许容器管理对象的生命周期和依赖关系。然而,在实际应用中,我们可能会遇到对象间的循环依赖问题。本文将深入探讨Spring如何解决IoC中的循环依赖问题,并通过手写源码的方式,让你对其底层原理有一个全新的认识。
69 2
|
3月前
|
前端开发 Java 开发者
Spring MVC中的请求映射:@RequestMapping注解深度解析
在Spring MVC框架中,`@RequestMapping`注解是实现请求映射的关键,它将HTTP请求映射到相应的处理器方法上。本文将深入探讨`@RequestMapping`注解的工作原理、使用方法以及最佳实践,为开发者提供一份详尽的技术干货。
217 2
|
3月前
|
前端开发 Java Spring
探索Spring MVC:@Controller注解的全面解析
在Spring MVC框架中,`@Controller`注解是构建Web应用程序的基石之一。它不仅简化了控制器的定义,还提供了一种优雅的方式来处理HTTP请求。本文将全面解析`@Controller`注解,包括其定义、用法、以及在Spring MVC中的作用。
81 2

推荐镜像

更多