Bean定义解析注册流程总结

已于 2022-06-16 15:56:50 修改
阅读量291 收藏
点赞数
文章标签： spring java 后端
于 2022-06-16 15:53:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011523825/article/details/125314674
版权

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

前言

对Spring IOC主流程中Bean定义解析注册流程分支的总结
这个分支的主要工作内容有两个
1 将xml中的配置信息解析成bean定义信息（BeannDefinition）对象
2 将BeanDefinition对象注册到工厂中，为后续实例化bean对象做准备

public abstract class AbstractXmlApplicationContext extends AbstractRefreshableConfigApplicationContext {
	protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
			// Create a new XmlBeanDefinitionReader for the given BeanFactory.
			XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
	
			// Configure the bean definition reader with this context's
			// resource loading environment.
			beanDefinitionReader.setEnvironment(this.getEnvironment());
			beanDefinitionReader.setResourceLoader(this);
			beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
	
			// Allow a subclass to provide custom initialization of the reader,
			// then proceed with actually loading the bean definitions.
			initBeanDefinitionReader(beanDefinitionReader);
			loadBeanDefinitions(beanDefinitionReader);
		}
	
	protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
			Resource[] configResources = getConfigResources();
			if (configResources != null) {
				reader.loadBeanDefinitions(configResources);
			}
			//容器初始化时设置了这个参数 他是xml配置文件的路径
			String[] configLocations = getConfigLocations();
			if (configLocations != null) {
				reader.loadBeanDefinitions(configLocations);
			}
		}
}

在继续跟方法之前，先介绍下DefinitionReader家族，防止后边跟晕了

一、DefinitionReader家族以及分工

在这里插入图片描述
DefinitionReader是家族的顶级接口,方法定义中可以看出主要就是用来加载bean定义信息的。其中loadBeanDefinitions有四个重载方法。画红框的三个重载方法统一由AbstractBeanDefinitionReader做了实现，唯一的一个框外的loadBeanDefinitions方法由其三个子类分别实现。

在这里插入图片描述
AbstractBeanDefinitionReader的主要目的就是将入参的字符串统一转化为Resource对象，便于子类处理。

1.1 继续跟踪代码reader.loadBeanDefinitions()

了解了BeafinitionReader家族的使命,接着跟踪加载方法。会跟踪到AbstractBeanDefinitionReader类中

public abstract class AbstractBeanDefinitionReader implements BeanDefinitionReader, EnvironmentCapable {
    //实现顶级接口中loadBeanDefinitions的方法之一
    @Override
	public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {
		Assert.notNull(locations, "Location array must not be null");
		int count = 0;
		for (String location : locations) {
			count += loadBeanDefinitions(location);
		}
		return count;
	}

    //实现顶级接口中loadBeanDefinitions的方法之二
    @Override
	public int loadBeanDefinitions(String location) throws BeanDefinitionStoreException {
		return loadBeanDefinitions(location, null);
	}
	
	//这个方法完成了AbstractBeanDefinitionReader的主要使命，就是将入参统一成Resource对象
	public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException {
		//获取资源加载器 其实就是容器
		ResourceLoader resourceLoader = getResourceLoader();
		。。省略代码
		if (resourceLoader instanceof ResourcePatternResolver) {
			// Resource pattern matching available.
			try {
				//通过资源解析器获取资源
				Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
				//执行加载bean定义
				int count = loadBeanDefinitions(resources);
				。。省略代码
				return count;
			}
			catch (IOException ex) {
				。。省略代码
			}
		}
		else {
			// Can only load single resources by absolute URL.
			Resource resource = resourceLoader.getResource(location);
			//执行加载bean定义
			int count = loadBeanDefinitions(resource);
			。。省略代码
			return count;
		}
	}
	 //实现顶级接口中loadBeanDefinitions的方法之三
	@Override
	public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {
		Assert.notNull(resources, "Resource array must not be null");
		int count = 0;
		for (Resource resource : resources) {
		    //最后交给子类来实现
			count += loadBeanDefinitions(resource);
		}
		return count;
	}
}

1.2 继续跟踪代码reader.loadBeanDefinitions()

继续跟踪会跟踪到具体的子类XmlBeanDefinitionReader中

public class XmlBeanDefinitionReader extends AbstractBeanDefinitionReader {
    //实现顶级接口中loadBeanDefinitions的方法之四
	@Override
	public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
		return loadBeanDefinitions(new EncodedResource(resource));
	}
	
	//加载处理
	public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
			。。。省略代码
			try (InputStream inputStream = encodedResource.getResource().getInputStream()) {
				InputSource inputSource = new InputSource(inputStream);
				。。。省略代码
				//真正的执行加载
				return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
			}
			catch (IOException ex) {
				。。。省略代码
			}
			finally {
		     	。。。省略代码
			}
		}
    //真正加载处理
    protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
			throws BeanDefinitionStoreException {
		try {
		    //将资源加载成Document对象 到这里加载结束了 剩下的是注册环节
			Document doc = doLoadDocument(inputSource, resource);
			//执行注册
			int count = registerBeanDefinitions(doc, resource);
			。。。省略代码
			return count;
		}
			。。。省略代码
	}
	//注册bean定义信息
    public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
		BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
		int countBefore = getRegistry().getBeanDefinitionCount();
		//委托给BeanDefinitionDocumentReader类完成后续的注册流程
		documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
		return getRegistry().getBeanDefinitionCount() - countBefore;
	}

}

二、BeanDefinitionDocumentReader

继续跟踪documentReader.registerBeanDefinitions方法，会从BeanDefinitionReader家族来到BeanDefinitionDocumentReader家族。虽然名字很像但是他们没有血缘关系
在这里插入图片描述
这个家族的使命就是注册bean，并且只有DefaultBeanDefinitionDocumentReader一个实现类

public class DefaultBeanDefinitionDocumentReader implements BeanDefinitionDocumentReader {
    //注册bean定义
	@Override
	public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
		this.readerContext = readerContext;
		//真正执行bean定义注册
		doRegisterBeanDefinitions(doc.getDocumentElement());
	}

    protected void doRegisterBeanDefinitions(Element root) {
		。。。省略注释
		BeanDefinitionParserDelegate parent = this.delegate;
		//委托给BeanDefinitionParserDelegate来执行解析
		this.delegate = createDelegate(getReaderContext(), root, parent);
		。。。省略代码
		preProcessXml(root);
		//解析bean定义信息 在这里
		parseBeanDefinitions(root, this.delegate);
		postProcessXml(root);
		this.delegate = parent;
	}
	//解析的目的是将Element元素解析成BeanDefinition对象最终注入到工厂中
    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)) {
					    //解析默认标签（bean标签在这里 所以继续跟这个方法）
						parseDefaultElement(ele, delegate);
					}
					else {
					    //解析自定义标签（aop mvc 都是自定义标签） 后续总结aop时在跟这里
						delegate.parseCustomElement(ele);
					}
				}
			}
		}
		else {
		    //解析自定义标签（aop mvc 都是自定义标签） 后续总结aop时在跟这里
			delegate.parseCustomElement(root);
		}
	}
    //解析默认标签
    protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
        //这里完成了解析 BeanDefinitionHolder内部封装了bean定义信息
		BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
		if (bdHolder != null) {
			bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
			try {
				//将bean定义信息注册到工作
				BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
			}
			catch (BeanDefinitionStoreException ex) {
				getReaderContext().error("Failed to register bean definition with name '" +
						bdHolder.getBeanName() + "'", ele, ex);
			}
			// Send registration event.
			getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
		}
	}
}

三、BeanDefinitionParserDelegate

这个类是解析注册流程中最后的一个委托了,最后在大致跟以下delegate.parseBeanDefinitionElement(ele)方法

public class BeanDefinitionParserDelegate {
	@Nullable
	public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
	    //继续跟这里
		return parseBeanDefinitionElement(ele, null);
	}
	
	public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
	    //解析出标签中的id
		String id = ele.getAttribute(ID_ATTRIBUTE);
		//解析出标签中的name
		String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

		List<String> aliases = new ArrayList<>();
		if (StringUtils.hasLength(nameAttr)) {
			String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
			aliases.addAll(Arrays.asList(nameArr));
		}
		//默认bean名称是id
		String beanName = id;
		//如果没定义id 但是有name 那么就用name
		if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
			beanName = aliases.remove(0);
			if (logger.isTraceEnabled()) {
				logger.trace("No XML 'id' specified - using '" + beanName +
						"' as bean name and " + aliases + " as aliases");
			}
		}
		。。。省略代码
		//获取bean定义
		AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
		if (beanDefinition != null) {
			。。。省略代码
			String[] aliasesArray = StringUtils.toStringArray(aliases);
			//将bean定义信息封装到BeanDefinitionHolder对象中
			return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
		}
		return null;
	}
	
	@Nullable
	public AbstractBeanDefinition parseBeanDefinitionElement(
			Element ele, String beanName, @Nullable BeanDefinition containingBean) {

		this.parseState.push(new BeanEntry(beanName));
		//获取类全路径名称
		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);
			//解析流程继续跟这里
			parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
			bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
           ...省略代码
			return bd;
		}
		...省略代码
	}
	//最终的解析流程
    public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,
			@Nullable BeanDefinition containingBean, AbstractBeanDefinition bd) {
		//解析作用域 scope
		if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {
			error("Old 1.x 'singleton' attribute in use - upgrade to 'scope' declaration", ele);
		}
		else if (ele.hasAttribute(SCOPE_ATTRIBUTE)) {
			bd.setScope(ele.getAttribute(SCOPE_ATTRIBUTE));
		}
		else if (containingBean != null) {
			// Take default from containing bean in case of an inner bean definition.
			bd.setScope(containingBean.getScope());
		}
		//解析是否是抽象的
		if (ele.hasAttribute(ABSTRACT_ATTRIBUTE)) {
			bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(ABSTRACT_ATTRIBUTE)));
		}
		//解析是否懒加载
		String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE);
		if (isDefaultValue(lazyInit)) {
			lazyInit = this.defaults.getLazyInit();
		}
		bd.setLazyInit(TRUE_VALUE.equals(lazyInit));
		...后边还有很多 可以自己看源码
		return bd;
	}

}

总结

1 容器将解析和加载bean定义信息的任务委托给了BeanDefinitionReader来处理
2 BeanDefinitionReader的子类AbstractBeanDefinitionReader将加载的入参从字符串统一封装成了Resource对象交给子类继续处理
3 其中的一个子类XMLBeanDefinitionReader将Resource封装成了Document对象并委托BeanDefinitionDocumentReader完成后续的解析和注册
4 BeanDefinitionDocumentReader的唯一实现类DefaultBeanDefinitionDocumentReader委托BeanDefinitionParserDelegate将Document对象解析成BeanDefinition对象最终将其注册到BeanFactory工厂中

吉星23526
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring多种加载Bean方式解析
08-30
主要的流程是找到定义Bean的方式，然后生成BeanDefinition后注册到Spring上下文中，由Spring自动创建Bean的实例。 BeanDefinition BeanDefinition是一个接口，用来描述一个Bean实例，例如是SINGLETON还是PROTOTYPE...
SpringBean生成流程详解 —— 由浅入深(附超精细流程图)
热门推荐
战斧的博客
03-09 1万+
（全网最细，原创）硬核解释SpringBean生成的流程，同时分析网上一些常见错误结论
springBoot中bean的注册方式
XBBHBDM的博客
08-01 3835
springboot加载bean的5种方式
Spring 中 Bean 的创建流程
qq_53195681的博客
12-24 571
Spring 中 Bean 的创建流程
Spring源码之bean的注册流程
李远亮的专栏
11-14 646
为了更好的理解Spring中bean的注册原理，我们通过一个示例进行分析，代码如下： public static void main(String[] args) { BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("spring-bean-test.xml")); MyBean bean = (MyBean) beanFactory.getBean("myBean"); System.out.println("My
Spring源码分析——Bean的注册
Hopefully Sky的博客
05-12 590
背景 Spring版本：5.1.14.RELEASE 仔细阅读依赖注入(Dependency Injection)框架是如何实现的这篇博文后，我们大致知道了一个DI容器是如何创建bean的。总体来，bean的创建流程分为如下三步： 定义化：从xml文件中解析bean的定义(获得BeanDefinition实例)，之后创建bean都是通过bean的定义去创建。 实例化：实例化的过程是一个创建Bean的过程，即调用Bean的构造函数，单例的Bean放入单例池中。 初始化：初始化的过程是一个赋值的过程，即调用B
Spring Bean实例化实现过程解析
08-25
Spring Bean 实例化实现过程解析 Spring Bean 实例化是 Spring 框架中一个非常重要的概念，它直接关系到 Bean 的生命周期和管理。在 Spring 框架中，Bean 的实例化是通过容器来管理的，容器会根据配置文件中的信息...
通过实例解析spring bean之间的关系
08-25
总结，Spring Bean之间的关系是构建模块化和可扩展应用程序的关键。通过Bean的继承，我们可以复用和定制配置；依赖注入则让我们能够灵活地管理对象间的依赖，提高代码的灵活性和可维护性。在实际项目中，理解并熟练...
Spring bean生命周期配置过程解析
08-24
当Spring容器（ApplicationContext或BeanFactory）加载Bean定义时，会调用`AbstractAutowireCapableBeanFactory`类的`createBeanInstance()`方法来创建Bean实例。这个阶段通常涉及到构造函数的选择和调用，以及依赖...
SPRING FRAMEWORK BEAN作用域和生命周期原理解析
08-25
SPRING FRAMEWORK BEAN作用域和生命周期原理解析 Spring Framework 是一个流行的 Java Web 应用程序框架，它提供了一个强大的依赖注入机制，称为 Bean 容器。Bean 容器管理着应用程序中的所有对象，并提供了一些...
【Spring】Bean注册和注入
m0_56975154的博客
10-22 1537
这几个注解在 IOC 场景下，没有区别，都是将类注册进 Spring 库，但在其他场景一般这样用。当使用以下方法注入时，会注入进 NULL 值，而非对象，原因已在下面代码的注释中写出。使用注解注册 Bean 是注册进 Spring 提供的库，就不需要自建库了。使用 @Bean 修饰方法，@Configuration 修饰类。使用注解注册简而言之就是使用某个注解修饰类或方法，对其进行注册。使用工厂方法注册就是调用静态工厂方法注册 Bean。此方法注册就相当于 XML 中的工厂方法注册。
Spring注解式开发: Bean的注册
m0_55435847的博客
04-26 2280
Spring中的Bean的注册有很多种方式，但大多区别不大,首先启动spring这个IOC容器的方式就有两种分别是古老的用*.xml文件来启动还有现在主流用注解式@Configuration声明一个为配置类来启动Spring容器。 首先说明:得先大概会用Spring和SpringBoot(要不然可能会懵，只是可能会懵而已不用在意),因为SprinBoot里面就都是注解式开发 方式一（不推荐方式）: 用xml文件里面的<Bean>标签声明注册 (用*.xml文件启动Spring) x...
Spring创建Bean的顺序
baidu_39476610的博客
05-27 1892
一直对Spring创建bean的顺序很好奇，现在总算有时间写个代码测试一下。不想看过程的小伙伴可以直接看结论 目录结构： 其中：bean4、bean5包下的class没有注解@Component，测试过程中，这两个包的class会直接通过的方式创建。bean1、bean2、bean3包下的class注解了@Component，以便component-scan扫描。另外，bean创建之间没有依赖关...
spring注册bean方式总结
weixin_43241706的博客
05-16 1882
spring注册bean的方式
SpringBoot原理篇(注册bean的方式和注解，配置参数，自动装配的原理，案例自定义启动器)【详解】
最新发布
qq_1424674116的博客
03-23 1653
Scope：加在bean对象上，用于设置bean对象的作用域如果一个bean对象上没有加此注解：Spring默认以单例模式维护bean对象从容器里获取这个bean对象，无论获取几次，得到的都是同一个对象如果想要修改bean的作用域，可以给bean对象加注解@Scope("singleton")：单例的。默认就是单例的@Scope("prototype")：多例的。
Spring注册Bean(提供Bean)--方法大全
IT利刃出鞘的博客
05-13 1402
本文用示例介绍SpringBoot如何向容器注册bean（即：将对象加入容器）。
Spring中注册Bean的方式有哪些？
weixiaohuai的博客
03-01 7673
目录 一、概述 二、第一种方式： XML配置方式 三、第二种方式： 使用@Component注解 + @ComponentScan包扫描方式 四、第三种方式：@Configuration + @Bean方式 五、第四种方式：FactoryBean方式 六、第五种方式：@Import方式 七、第六种方式：@Import + ImportSelector方式 八、第七种方式：@Import + ImportBeanDefinitionRegistrar方式 九、第八种方式：BeanDefi
Spring Bean 注册顺序优先级总结
gzt19881123的专栏
02-07 9290
Spring Bean 注册顺序注册优先级，以及初始化顺序相关总结
Spring注册Bean的几种方式
qq_19286785的博客
03-09 2856
Spring中常用的几种注册Bean的方式
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值