spring源码加载bean定义信息 loadBeanDefinitions

最新推荐文章于 2024-07-29 12:53:48 发布
最新推荐文章于 2024-07-29 12:53:48 发布
阅读量451 收藏
点赞数 1
CC 4.0 BY-SA版权
分类专栏： spring 源码 文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/xiaomengxin521/article/details/123312096
本文深入探讨了Spring框架中bean定义信息的加载和解析过程，从配置文件加载到bean定义注册，详细解析了bean标签如何转化为bean定义信息，涉及BeanDefinition创建、属性解析、注册等多个步骤，揭示了Spring容器初始化bean定义的内部机制。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

上编文章咱们已经把工厂容器准备好了，那么既然是容器就会存放数据，它是怎么存放的呢？
上一篇传送门
咱们先看下bean定义信息的类关系
在这里插入图片描述

loadBeanDefinitions 目前咱们先看 普通 bean定义信息加载

这个方法调用比较深，过渡流程

  1. AbstractXmlApplicationContext.loadBeanDefinitions 创建bean定义信息的读取器
  2. AbstractXmlApplicationContext.loadBeanDefinitions(beanDefinitionReader)使用读取器进行加载bean的定义信息
  3. AbstractBeanDefinitionReader.loadBeanDefinitions 循环多个*.xml文件，进行加载
  4. AbstractBeanDefinitionReader.loadBeanDefinitions(location,)解析location，获取resources
  5. AbstractBeanDefinitionReader.loadBeanDefinitions(resources) 批量处理resources
  6. AbstractBeanDefinitionReader.loadBeanDefinitions(resource) 循环多个资源调用单个资源加载
  7. XmlBeanDefinitionReader.loadBeanDefinitions(EncodedResource) 读取文件流，进行加载
  8. XmlBeanDefinitionReader.doLoadBeanDefinitions(inputSource, encodedResource.getResource()) 把文件流解析成Document
  9. XmlBeanDefinitionReader.registerBeanDefinitions，创建文档读取器
  10. DefaultBeanDefinitionDocumentReader.registerBeanDefinitions(doc,XmlReaderContext) 使用默认的bean定义信息文档读取器来注册bean定义信息
  11. DefaultBeanDefinitionDocumentReader.doRegisterBeanDefinitions(element)
  12. DefaultBeanDefinitionDocumentReader.parseBeanDefinitions(element,delegate)真正开始解析xml标签了

DefaultBeanDefinitionDocumentReader.parseBeanDefinitions 解析xml文档

遍历xml文档中的节点，并进行解析
咱们这里先看普通的bean标签是如何解析成bean定义信息的，定制化在AOP时候再看是怎么执行的。

<bean id="myProperties" class="com.msgqu.debug.config.MyProperties">
	<property name="url" value="${msgqu.name}"></property>
</bean>

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;
				// 如果是 http://www.springframework.org/schema/beans ，那么则是默认的解析标签
				if (delegate.isDefaultNamespace(ele)) {
					parseDefaultElement(ele, delegate);
				}else {
					// 解析定制化标签
					delegate.parseCustomElement(ele);
				}
			}
		}
	}else {
		// 解析定制化标签
		delegate.parseCustomElement(root);
	}
}

DefaultBeanDefinitionDocumentReader.parseDefaultElement(ele, delegate) 解析默认标签

开始解析标签

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
	if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
		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)) {
		doRegisterBeanDefinitions(ele);
	}
}

DefaultBeanDefinitionDocumentReader.processBeanDefinition 开始解析bean标签

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
	//解析bean定义信息元素，并包装成BeanDefinitionHolder
	BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
	if (bdHolder != null) {
		bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
		try {
			// Register the final decorated instance.
			BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
		}catch (BeanDefinitionStoreException ex) {
			getReaderContext().error("Failed to register bean definition with name '" +bdHolder.getBeanName() + "'", ele, ex);
		}
		
		getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
	}
}
BeanDefinitionParserDelegate.parseBeanDefinitionElement(ele) 使用策略解析类对bean标签进行解析

BeanDefinitionParserDelegate是bean标签的解析类

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
	//获取到id属性
	String id = ele.getAttribute(ID_ATTRIBUTE);
	// name属性是全限定类名，方便后面实例化的时候使用，也会用于判断这个对象是否是class
	String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
	//注册别名，咱们知道，一个bean对象可以有多个别名
	List<String> aliases = new ArrayList<>();
	if (StringUtils.hasLength(nameAttr)) {
		String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
		aliases.addAll(Arrays.asList(nameArr));
	}
	String beanName = id;
	if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
		beanName = aliases.remove(0);
	}
	//检查bean的名称是必须的
	if (containingBean == null) {
		checkNameUniqueness(beanName, aliases, ele);
	}
	//创建beanDefinition，解析bean标签中的属性，并赋值给BeanDefinition
	AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
	if (beanDefinition != null) {
		//这里可以扩展bean名称生成器，有兴趣的可以了解哈
		if (!StringUtils.hasText(beanName)) {
			try {
				if (containingBean != null) {
					beanName = BeanDefinitionReaderUtils.generateBeanName(
							beanDefinition, this.readerContext.getRegistry(), true);
				}
				else {
					beanName = this.readerContext.generateBeanName(beanDefinition);
					String beanClassName = beanDefinition.getBeanClassName();
					if (beanClassName != null &&
							beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
							!this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
						aliases.add(beanClassName);
					}
				}
				if (logger.isTraceEnabled()) {
					logger.trace("Neither XML 'id' nor 'name' specified - " +
							"using generated bean name [" + beanName + "]");
				}
			}
			catch (Exception ex) {
				error(ex.getMessage(), ele);
				return null;
			}
		}
		String[] aliasesArray = StringUtils.toStringArray(aliases);
		// 返回bean定义信息的包装者
		return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
	}
	return null;
}
BeanDefinitionParserDelegate.parseBeanDefinitionElement 根据bean标签创建出bean定义信息

这里创建出的bean定义信息是GenericBeanDefinition

public AbstractBeanDefinition parseBeanDefinitionElement(
			Element ele, String beanName, @Nullable BeanDefinition containingBean) {
	//包装bean名称，放置到ArrayDeque中 类似标识递归中操作的过程一样 ，方便在解析过程中获取对应标签。
	this.parseState.push(new BeanEntry(beanName));
	//从bean标签中获取class 和 parent 属性值
	String className = null;
	if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
		className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
	}
	String parent = null;
	if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
		parent = ele.getAttribute(PARENT_ATTRIBUTE);
	}

	try {
		//创建bean定义信息
		AbstractBeanDefinition bd = createBeanDefinition(className, parent);
		//解析bean的其他属性 singleton、scope、abstract、lazy-init、autowire、autowire-candidate、primary、factory-method、factory-bean
		parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
		bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
		//解析子标签
		parseMetaElements(ele, bd);
		parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
		//方法替换
		parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
		//解析构造，为了方便实例化
		parseConstructorArgElements(ele, bd);
		//解析Property属性
		parsePropertyElements(ele, bd);
		parseQualifierElements(ele, bd);
		bd.setResource(this.readerContext.getResource());
		bd.setSource(extractSource(ele));
		//返回GenericBeanDefinition
		return bd;
	}catch (ClassNotFoundException ex) {
		error("Bean class [" + className + "] not found", ele, ex);
	}catch (NoClassDefFoundError err) {
		error("Class that bean class [" + className + "] depends on not found", ele, err);
	}catch (Throwable ex) {
		error("Unexpected failure during bean definition parsing", ele, ex);
	}finally {
		this.parseState.pop();
	}
	return null;
}
BeanDefinitionParserDelegate.parsePropertyElement 解析bean标签中的 标签
public void parsePropertyElement(Element ele, BeanDefinition bd) {
	String propertyName = ele.getAttribute(NAME_ATTRIBUTE);
	if (!StringUtils.hasLength(propertyName)) {
		error("Tag 'property' must have a 'name' attribute", ele);
		return;
	}
	this.parseState.push(new PropertyEntry(propertyName));
	try {
		if (bd.getPropertyValues().contains(propertyName)) {
			error("Multiple 'property' definitions for property '" + propertyName + "'", ele);
			return;
		}
		//解析Property的value值
		Object val = parsePropertyValue(ele, bd, propertyName);
		PropertyValue pv = new PropertyValue(propertyName, val);
		parseMetaElements(ele, pv);
		pv.setSource(extractSource(ele));
		bd.getPropertyValues().addPropertyValue(pv);
	}
	finally {
		this.parseState.pop();
	}
}
BeanDefinitionParserDelegate.parsePropertyValue 解析
public Object parsePropertyValue(Element ele, BeanDefinition bd, @Nullable String propertyName) {
	String elementName = (propertyName != null ?
			"<property> element for property '" + propertyName + "'" :
			"<constructor-arg> element");
	// Should only have one child element: ref, value, list, etc.
	NodeList nl = ele.getChildNodes();
	Element subElement = null;
	for (int i = 0; i < nl.getLength(); i++) {
		Node node = nl.item(i);
		if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT) &&
				!nodeNameEquals(node, META_ELEMENT)) {
			if (subElement != null) {
				error(elementName + " must not contain more than one sub-element", ele);
			}else {
				subElement = (Element) node;
			}
		}
	}
	//得到 ref 和 value 的值是否存在
	boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE);
	boolean hasValueAttribute = ele.hasAttribute(VALUE_ATTRIBUTE);
	if ((hasRefAttribute && hasValueAttribute) ||
			((hasRefAttribute || hasValueAttribute) && subElement != null)) {
		error(elementName +
				" is only allowed to contain either 'ref' attribute OR 'value' attribute OR sub-element", ele);
	}

	if (hasRefAttribute) {
		//如果是引用类型 ，进行包装成运行时bean引用 <property name="field" ref="beanName"></property>
		String refName = ele.getAttribute(REF_ATTRIBUTE);
		if (!StringUtils.hasText(refName)) {
			error(elementName + " contains empty 'ref' attribute", ele);
		}
		RuntimeBeanReference ref = new RuntimeBeanReference(refName);
		ref.setSource(extractSource(ele));
		return ref;
	}else if (hasValueAttribute) {
		//创建value值包装 （value值，及类型）<property name="url" value="${com.xxx}"/>
		TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));
		valueHolder.setSource(extractSource(ele));
		return valueHolder;
	}else if (subElement != null) {
		return parsePropertySubElement(subElement, bd);
	}else {
		// Neither child element nor "ref" or "value" attribute found.
		error(elementName + " must specify a ref or value", ele);
		return null;
	}
}

现在咱们已经获取到了BeanDefinition咱们再回到parseBeanDefinitionElement方法中

BeanDefinitionReaderUtils.registerBeanDefinition 注册bean的定义信息

看注册之前，咱们试想下，bean的定义信息会注册到哪里呢？

public static void registerBeanDefinition(
		BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
		throws BeanDefinitionStoreException {
	String beanName = definitionHolder.getBeanName();
	//注册bean定义信息   registry：DefaultListableBeanFactory
	registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
	// 这里设计的还是比较巧妙，Map中 key是别名，value是beanName
	String[] aliases = definitionHolder.getAliases();
	if (aliases != null) {
		for (String alias : aliases) {
			registry.registerAlias(beanName, alias);
		}
	}
}
DefaultListableBeanFactory.registerBeanDefinition 注册bean定义信息

注册之前咱们试想下，如果是自己的来存储的话，会使用什么样的数据结构？

public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
			throws BeanDefinitionStoreException {

	Assert.hasText(beanName, "Bean name must not be empty");
	Assert.notNull(beanDefinition, "BeanDefinition must not be null");

	if (beanDefinition instanceof AbstractBeanDefinition) {
		try {
			((AbstractBeanDefinition) beanDefinition).validate();
		}catch (BeanDefinitionValidationException ex) {
			throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,"Validation of bean definition failed", ex);
		}
	}

	BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
	if (existingDefinition != null) {
		//如果缓存中存在bean定义信息，那么要求是必要支持bean定义信息的覆盖
		//在这属性是在咱们创建完容器的时候设置的定制化属性，想不起来可以看下
		if (!isAllowBeanDefinitionOverriding()) {
			throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
		}
		//把解析出的bean定义信息注册到Map中
		this.beanDefinitionMap.put(beanName, beanDefinition);
	}else {
		if (hasBeanCreationStarted()) {
			//如果已经创建
			synchronized (this.beanDefinitionMap) {
				this.beanDefinitionMap.put(beanName, beanDefinition);
				List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
				updatedDefinitions.addAll(this.beanDefinitionNames);
				updatedDefinitions.add(beanName);
				this.beanDefinitionNames = updatedDefinitions;
				removeManualSingletonName(beanName);
			}
		}else {
			// 注册到beanDefinitionMap中
			this.beanDefinitionMap.put(beanName, beanDefinition);
			this.beanDefinitionNames.add(beanName);
			removeManualSingletonName(beanName);
		}
		this.frozenBeanDefinitionNames = null;
	}
	if (existingDefinition != null || containsSingleton(beanName)) {
		resetBeanDefinition(beanName);
	}else if (isConfigurationFrozen()) {
		clearByTypeCache();
	}
}

单个bean标签也注册完了，咱们梳理下流程

bean定义信息是为了创建bean对象的时候使用，除了特殊情况（FactoryBean等），基本上都会先创建bean定义信息，所以这块是比较周要的一环

  1. 加载配置文件locations
  2. 创建xml解析器
  3. 解析标签，并生成bean定义信息
  4. 解析标签内的属性
  5. 注册bean定义信息
spring源码解析之AnnotationConfigWebApplicationContext#loadBeanDefinitions()方法加载BeanDefinition过程
蛐蛐的博客
10-13 2060
1.简介 AnnotationConfigWebApplicationContext是常用的上下文容器类，在spring boot没有流行的时候，以前用tomcat在web.xml配置 spring容器时，如果使用Java注解的配置类，一般都会使用这个上下文类 顾名思义，AnnotationConfig代表注解配置，Web代表具有web功能，可以访问ServletContext。这是这个上下文的基本功能。 之前在spring源码解析之AbstractApplicationContext#..
Spring 源码之 BeanDefinition 加载分析
weixin_42118323的博客
04-29 253
BeanDefinition 直译就是 bean 定义信息，BeanDefinition 是 Spring 用来描述一个 bean 的配置元信息的表现形式，bean 的各种配置元信息最后都会被转换为 BeanDefinition，Spring 会根据 BeanDefinition 去对 bean 进行实例化、初始化，BeanDefinition 涉及到 Spring Bean 的整个生命周期。
Spring源码（六）loadBeanDefinitions方法
qq_40223516的博客
08-10 1573
Spring源码（六）loadBeanDefinitions方法
三、SpringIOC源码之XmlBeanFactory
【原】编程界的小学生
10-01 458
SpringIOC源码之XmlBeanFactory 一、概述 1、说明 XmlBeanFactory是实现ioc方式之一，是那种比较屌丝的，功能对比ApplicationContext来讲差太多了。SpringIOC主要是如下三步骤 定位：说白了就是找到我们传递进去的xml文件。 加载：找到我们的xml文件位置后，将其解析成BeanDefinition对象。 注册：将bean对象放到ioc的工...
spring配置文件加载 loadBeanDefinitions分析
蓝天的博客
03-31 570
下面来分析loadBeanDefinitions方法，如下图： loadBeanDefinitions(beanFactory);，这里的beanFactory是对象DefaultListableBeanFactory，这个对象是具体实际干活的类， 重点看loadBeanDefinitions方法， 这里比较关键的是判断是否是默认的命名空间，如果是默认的命名空间则调用parseDefaultElement...
loadBeanDefinitions
ray1205的专栏
09-21 1084
org.springframework.beans.factory.support.AbstractBeanDefinitionReader.loadBeanDefinitions(String) 从指定的resource location加载bean definitions，location可以为pattern。获取resourceLoader，如果为null抛出BeanDefinitio
spring源码----loadBeanDefinitions(DefaultListableBeanFactory)详解
Code-zyc的博客
03-30 1155
目录方法图片：new XmlBeanDefinitionReader接着往下执行这四个方法：loadBeanDefinitions(XmlBeanDefinitionReader）loadBeanDefinitions(String...)loadBeanDefinitions(String）loadBeanDefinitions(String,@Nullable Set《Resource》）loadBeanDefinitions(Resource...） 方法图片： 首先执行第一个方法： new Xml
spring源码解析-（1）关于Bean
qq_46020268的博客
06-08 776
以上代码可以有效的避免我们在开发中大量的if判断，同时可以让你的代码可阅读性更高。hutools和spring依赖中均有该类型的写法，可以参考一下。2、设计模式&接口&抽象类，帮助更好的处理一系列方法在面对一系列处理的时候，我们应该抽象出接口，并使用抽象类去约定模板方法，继而使用子类去实现，这种方式会节省我们大量重复的工作，而且所有的方法都有迹可循，在模板方法中定义流程，在子类中实现，能够有效的解耦流程和实现。这样我们就可以只关心子类的具体实现了。
Spring源码-xml配置文件如何加载解析默认标签变为BeanDefinition
最新发布
qq_37200262的博客
07-29 574
1.创建Environment 2.META-INF/spring.schemas文件加载 3.META-INF/spring.handlers加载 4.解析xml文件转为BeanDefinitionHolder
6-Spring架构源码分析-IoC 之加载 BeanDefinition
Java架狗师知识框架速查表
07-28 263
在IoC容器内部其实是将第二个过程解析得到的BeanDefinition注入到一个HashMap容器中，IoC容器就是通过这个HashMap来维护这些BeanDefinition的。BeanDefinitionReader读取、解析Resource资源，也就是将用户定义的Bean表示成IoC容器的内部数据结构BeanDefinition。这段代码是Spring中编程式使用IoC容器，通过这四段简单的代码，我们可以初步判断IoC容器的使用过程。...
Spring源码讲解之 loadBeanDefinitions 方法
misterhou的专栏
08-07 922
loadBeanDefinitions 方法在 org.springframework.context.support.AbstractRefreshableApplicationContext 类中被定义，用来将 bean 定义信息加载到 bean 工厂中，该方法会在 org.springframework.context.support.AbstractRefreshableApplicationContext.refreshBeanFactory() 方法中被调用，调用该方法需要传递一个 org.sp
从源码解析Spring IoC（一）：loadBeanDefinitions
G17093192114的博客
07-01 256
从源码解析Spring IoC（一）：loadBeanDefinitions 导语 上一篇用大白话讲述了Spring IoC的大致流程，并且用了一个比喻来协助理解。但是都比较粗略，所以这次用追踪源码的方式来体会更多的细节。 正文 本文基于SpringMVC最基础的Xml配置方式来进行源码追踪，和其他方式在流程上是一样的。 SpringMvC在初始化DispatcherServlet的时候会创建一个WebApplicationContext对象并调用**refresh()**方法。 refresh() @Ov
6.Spring源码解析-loadBeanDefinitions（String location）
大乐乐
11-24 763
上图131行判断是不是默认的命名空间即：http://www.springframework.org/schema/beans。xmlns属性就是xml规范定义的用来设置命名空间的。这样设置了之后其实里面的bean元素全名就相当于。解析beandefinitions和后处理xml后续继续说。委托给Document并加载Document类。获取资源组可能存在多个bean.xml。获取当前正在加载的资源发现是空。创建了一个字节输入流，继续解析。预处理xml，点进去发现是空。创建一个编码资源并解析。
Spring源码--03--加载bean的定义信息---Spring注解解析原理
时光里的博客
02-13 515
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前置知识---obtainFreshBeanFactory();createBeanFactory----创建bean工厂**==new 一个 DefaultListableBeanFactory==** ![在这里插入图片描述](https://img-blog.csdnimg.cn/20210505175837575.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5na
Spring IOC BeanDefinitions加载（一）
MX__LL的博客
08-28 298
Spring IOC BeanDefinitions加载（一）
【Spring源码】IOC容器实现(3)--BeanDefinition的载入和解析
yhl_jxy的博客
07-13 929
前言 Github：https://github.com/yihonglei/thinking-in-spring BeanDefinition的载入和解析 上文分析了BeanDefiniton的Resource定位过程： Spring源码--IOC容器实现(2)--BeanDefinition的Resource定位 这篇文章分析下BeanDefinition信息的载入过程。 载入过程...
Spring源码讲解之 XmlBeanDefinitionReader 中 loadBeanDefinitions 方法
misterhou的专栏
08-08 1182
XmlBeanDefinitionReader 中 loadBeanDefinitions 方法是在 org.springframework.beans.factory.support.BeanDefinitionReader 接口中被定义的，其作用是从资源文件中加载 bean 定义，该方法接收一个 org.springframework.core.io.Resource 类型的参数，返回值是 int 类型的，从资源文件中成功加载并注册成功的 bean 定义数量，当加载或解析 bean 定义时出现错误会抛出
循序渐进Srping源码-loadBeanDefinitions方法
oowgsoo的专栏
11-07 290
loadBeanDefinitions 这篇文章只讲一个方法： public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException { ResourceLoader resourceLoader = getResourceLoader(); if (resourceLoader == null) {
【Spring源码分析】二、解析及注册BeanDifinitions
chuxue1989的专栏
12-12 240
上一篇文章中，大致分析了，Spring BeanFactory的类结构图，本篇文章分析如何解析配置文件和注册Bean的配置 一、源码切入点 private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this); public XmlBeanFactory(Resource resource, BeanFa...
Spring框架源码解析：XML配置与Bean注册
`ClassPathResource`用于定位XML配置文件的位置，`reader.loadBeanDefinitions(resource)`则是启动Bean定义的加载过程，这个点是整个资源配置的关键入口。 `DefaultListableBeanFactory`作为Bean的注册中心，它会...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值