Spring容器启动之扫描加载类实现原理

最新推荐文章于 2022-08-03 14:53:53 发布
最新推荐文章于 2022-08-03 14:53:53 发布
阅读量397 收藏
点赞数 1
分类专栏： spring源码 java技术
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43817989/article/details/110533383
版权

Spring容器启动之扫描加载类实现原理

整理代码过程中极为痛苦，我要坚持。

你的坚持，终将美好

spring容器启动会执行AbstractApplicationContext#refresh()方法，该方法是spring启动核心方法，下面主要整理下spring容器在启动时，是如何将项目里面的类，扫描到并注册到spring容器中。
先看下refresh()方法概要时序图
在这里插入图片描述
本章主要讲述的是1.2步骤中，扫描并注册Bean的过程，先看下1.2源码

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
		/**
		 * 注意下面这个方法，该方法就是扫描项目中的Bean，并将Bean注入到BeanDefinition中。
		 */
		refreshBeanFactory();
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		return beanFactory;
	}

接下来进入refreshBeanFactory方法源码

@Override
	protected final void refreshBeanFactory() throws BeansException {
		/**
		 * 查看是否启动的临时容器，存在就销毁关闭容器。为下面创建容器做准备。
		 */
		if (hasBeanFactory()) {
			destroyBeans();
			closeBeanFactory();
		}
		try {
			//创建容器并设置容器标示
			DefaultListableBeanFactory beanFactory = createBeanFactory();
			beanFactory.setSerializationId(getId());
			/**
			 * 定制容器，里面是设置是否允许BeanDefinition重写和循环引用。默认false
			 */
			customizeBeanFactory(beanFactory);
			/**
			 * 创建一个容器后，通过容器去加载BeanDefinition
			 */
			loadBeanDefinitions(beanFactory);
			this.beanFactory = beanFactory;
		}
	}

进入loadBeanDefinitions(beanFactory) 源码

@Override
	protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
		//为BeanFactory创建一个XmlBeanDefinitionReader实例，
		XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
		//设置BeanDifinitionReader环境遍历、加载资源器、资源解析器。
		beanDefinitionReader.setEnvironment(this.getEnvironment());
		beanDefinitionReader.setResourceLoader(this);
		beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
		/**
		 *初始化Reader，校验模式，自动校验or不校验。为后续的解析docment做初始化，配置文件xml是按照DTD还是XSD方式解析。默认spring按照XSD配置文件，
  		 * XSD与DTO区别：DTD ：xml文件会有一行以<!DOCTYPE 开头的标示 eg：<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN" "https://www.springframework.org/dtd/spring-beans-2.0.dtd">
  		 * 	XSD的xml文件是没有那个标示。
		 */
		
		initBeanDefinitionReader(beanDefinitionReader);
		/**
		 * 通过BeanDefinitionReader去加载bean定义。开始读取配置文件循环的获取配置文件里面的信息
		 */
		loadBeanDefinitions(beanDefinitionReader);
	}
	/**
	 * 通过XmlBeanDefinitionReader加载BeanDefinition
	 * 
	 */
	protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
		Resource[] configResources = getConfigResources();
		if (configResources != null) {
			reader.loadBeanDefinitions(configResources);
		}
		String[] configLocations = getConfigLocations();
		if (configLocations != null) {
			reader.loadBeanDefinitions(configLocations);
		}
	}
	
	@Override
	public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {
		Assert.notNull(locations, "Location array must not be null");
		int counter = 0;
		for (String location : locations) {
			counter += loadBeanDefinitions(location);
		}
		return counter;
	}

上述方法中：getConfigResource()是从ClassPathXmlApplicationContext构造器传入的指定配置文件位置，进而将配置文件读取到Resource中。
getConfigLocations() 是从AbstractRefreshableConfigApplicationContext构造器传入指定配置文件，如果没有设置文件路径，默认取 /WEB-INF/applicationContext.xml
之后将配置源循环调用

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);
				int loadCount = loadBeanDefinitions(resources);
				if (actualResources != null) {
					for (Resource resource : resources) {
						actualResources.add(resource);
					}
				}
				return loadCount;
			}
			catch (IOException ex) {
				throw new BeanDefinitionStoreException(
						"Could not resolve bean definition resource pattern [" + location + "]", ex);
			}
		}
		else {
			// Can only load single resources by absolute URL.
			Resource resource = resourceLoader.getResource(location);
			int loadCount = loadBeanDefinitions(resource);
			if (actualResources != null) {
				actualResources.add(resource);
			}
			return loadCount;
		}
	}

真正的开始读取文件文件源码

	public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
		Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
		if (currentResources == null) {
			currentResources = new HashSet<>(4);
			this.resourcesCurrentlyBeingLoaded.set(currentResources);
		}
		if (!currentResources.add(encodedResource)) {
			throw new BeanDefinitionStoreException(
					"Detected cyclic loading of " + encodedResource + " - check your import definitions!");
		}
		try {
			InputStream inputStream = encodedResource.getResource().getInputStream();
			try {
				InputSource inputSource = new InputSource(inputStream);
				if (encodedResource.getEncoding() != null) {
					inputSource.setEncoding(encodedResource.getEncoding());
				}
				return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
			}
			finally {
				inputStream.close();
			}
		}
		catch (IOException ex) {
			throw new BeanDefinitionStoreException(
					"IOException parsing XML document from " + encodedResource.getResource(), ex);
		}
		finally {
			currentResources.remove(encodedResource);
			if (currentResources.isEmpty()) {
				this.resourcesCurrentlyBeingLoaded.remove();
			}
		}
	}

注意try/catch里面的这个方法doLoadBeanDefinitions();Spring源码方法已do开始就代表真正去做某些事情，在这里就是真正的加载BeanDefinitions。

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
			throws BeanDefinitionStoreException {
		try {
			Document doc = doLoadDocument(inputSource, resource);
			return registerBeanDefinitions(doc, resource);
		}
		//删除了解析失败捕捉异常的catch
	}

上述方法通过文件流以及xml类型去获取document（xml中的文本内容），registerBeanDefinitions() 方法就开始注册document中定义的属性内容

	public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
		BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
		int countBefore = getRegistry().getBeanDefinitionCount();
		//注册文档中属性
		documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
		//记录本次注册bean的个数
		return getRegistry().getBeanDefinitionCount() - countBefore;
	}
	@Override
	public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
		this.readerContext = readerContext;
		logger.debug("Loading bean definitions");
		Element root = doc.getDocumentElement();
		doRegisterBeanDefinitions(root);
	}

终于到了解析标签的阶段了。doRegisterBeanDefinitions()

protected void doRegisterBeanDefinitions(Element root) {
		//下面两段代码是创建BeanDefinition解析代表，并且解析初始化<beans>标签
		//例如 获取beans标签中default-lazy-init、default-init-method等等属性，如果没有设置，spring会将这些属性设置默认值。具体默认属性请看BeanDefinitionParserDelegate类中的常量
		BeanDefinitionParserDelegate parent = this.delegate;
		this.delegate = createDelegate(getReaderContext(), root, parent);
		//判断xml文件是否是默认的spring文件类型。即beans 为http://www.springframework.org/schema/beans
		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);
				if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
					return;
				}
			}
		}
		//前置处理方法，空方法，为子类提供前置方法。
		preProcessXml(root);
		//解析<beans>标签里面的标签
		parseBeanDefinitions(root, this.delegate);
		//后置处理方法，空方法，为子类提供后置方法。
		postProcessXml(root);

		this.delegate = parent;
	}

接下来是开始解析beans标签中的属性方法源码

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
		/**
		 * 检查xml文件root节点，是否是默认解析方式。
		 * 默认 http://www.springframework.org/schema/beans。
		 */
		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)) {
						/**
						 * spring默认的几个标签。import/alias/bean/beans
						 * 只有上述的几个标签是走默认的解析方式。
						 */
						parseDefaultElement(ele, delegate);
					}
					else {
						/**
						 * 定制标签解析方式。
						 */
						delegate.parseCustomElement(ele);
					}
				}
			}
		}
		else {
			delegate.parseCustomElement(root);
		}
	}

解析spring默认标签元素 parseDefaultElement()

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
		if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
			//解析<import>标签
			importBeanDefinitionResource(ele);
		}
		else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
			//解析<alias>标签
			processAliasRegistration(ele);
		}
		else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
			//解析<bean>标签
			processBeanDefinition(ele, delegate);
		}
		else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
			//解析<beans>标签
			doRegisterBeanDefinitions(ele);
		}
	}

从上述源码中可以看出spring支持四个默认标签import/alias/bean/beans。
接下来分别看下上述解析4个标签的源代码 ，先看下解析import都做了什么事情？

/**
	 * Parse an "import" element and load the bean definitions
	 * from the given resource into the bean factory.
	 */
	protected void importBeanDefinitionResource(Element ele) {
		//<import resource="classpath*:spring/spring-core.xml"/>
		//获取import标签上的resource属性，如果为空，跳过。
		String location = ele.getAttribute(RESOURCE_ATTRIBUTE);
		if (!StringUtils.hasText(location)) {
			getReaderContext().error("Resource location must not be empty", ele);
			return;
		}
		// Resolve system properties: e.g. "${user.dir}"
		//解析resource属性上的表达式。
		location = getReaderContext().getEnvironment().resolveRequiredPlaceholders(location);

		Set<Resource> actualResources = new LinkedHashSet<>(4);

		// Discover whether the location is an absolute or relative URI
		//默认加载路径方式为相对路径。
		boolean absoluteLocation = false;
		try {
			//判断得出import标签引用的路径是绝对路径还是相对路径
			absoluteLocation = ResourcePatternUtils.isUrl(location) || ResourceUtils.toURI(location).isAbsolute();
		}

		// Absolute or relative?
		if (absoluteLocation) {
		// 绝对路径加载配置文件的方式。
			try {
				int importCount = getReaderContext().getReader().loadBeanDefinitions(location, actualResources);
			}
			
		}
		else {
			// No URL -> considering resource location as relative to the current file.
			//相对路径加载方式。
			try {
				int importCount;
				Resource relativeResource = getReaderContext().getResource().createRelative(location);
				if (relativeResource.exists()) {
					importCount = getReaderContext().getReader().loadBeanDefinitions(relativeResource);
					actualResources.add(relativeResource);
				}
				else {
					String baseLocation = getReaderContext().getResource().getURL().toString();
					importCount = getReaderContext().getReader().loadBeanDefinitions(
							StringUtils.applyRelativePath(baseLocation, location), actualResources);
				}
			}
			
		}
		Resource[] actResArray = actualResources.toArray(new Resource[0]);
		getReaderContext().fireImportProcessed(location, actResArray, extractSource(ele));
	}

先会判断是否为标签，importBeanDefinitionResource()方法主要负责将引入的配置文件再次通过XmlBeanDefinitionReader#loadBeanDefinitions()方法将这些配置文件再次加载进来，源码中会根据import标签中的路径是绝对路径还是相对路径分别走不同的加载文件方式。最后都会重新用相应reader#loadBeanDefinitions()方法去加载配置文件，达到加载import配置文件里面的Bean类定义以及相关信息。

Soulful_Liu
关注
专栏目录
Spring5.0源码学习系列之浅谈懒加载机制原理（七）
Nicky's blog
11-12 3692
懒加载（Lazy-initialized beans）：懒加载模式是bean在第一次调用时候被实例，而不是spring容器启动时候，默认是不开启的，（ A lazy-initialized bean tells the IoC container to create a bean instance when it is first requested, rather than at startup.），通过改配置lazy-init="true"
Spring Boot（四）：Spring Boot启动原理分析
最新发布
Lansonli（蓝深李）的博客
02-05 1万+
将配置类@SpringBootApplication标注的类所在包及下面所有子包里的所有组件扫描到spring容器。点击@SpringBootApplication，再点击@EnableAutoConfiguration进入类文件。这些自动配置类给我们当前项目的场景提供了一些组件和配置，有了自动配置就免除类手动编写配置文件，注入等等功能。这里管理着springboot中所有依赖的版本，是一个版本控制中心，导入依赖如果不写版本就用这里的版本。该jar包提供一系列的配置类，替换掉了我们的XML配置信息。
JVM学习--(六)类加载器原理
weixin_30463341的博客
03-13 351
我们知道我们编写的java代码，会经过编译器编译成字节码文件（class文件），再把字节码文件装载到JVM中，映射到各个内存区域中，我们的程序就可以在内存中运行了。那么字节码文件是怎样装载到JVM中的呢？中间经过了哪些步骤？常说的双亲委派模式又是怎么回事？本文主要搞清楚这些问题。 类装载流程 1、加载 加载是类装载的第一步，首先通过class文件的路径读取到二进制流，并解析二进制...
Spring 容器加载相关类图
bob于的专栏
02-22 2446
我们知道使用XmlBeanFactory来实现Spring IOC容器。而XmlBeanFactory有两个最核心的类： 1： DefaultListableBeanFactory(是Spring注册及加载Bean的默认实现) 2： XmlBeanDefinationReader(是XML文件的读取和注册也就是：资源文件的读取、解析和注册) 对于DefaultListableBeanFact
Spring 配置加载原理
csywxr的博客
08-03 560
Spring 配置加载
【类加载器】类加载器的原理及其使用方式
04-19 427
类加载器：❶Java虚拟机中可以安装多个类加载器，系统默认三个主要类加载器。 每个类负责加载特定位置的类： █BootStrap, █ExtClassLoader, █AppClassLoader ❷类加载器也是Java类，因为其他是java类的类加载器本身也要被类加载器加载，显然必须有第一个类加载器不是java类，这正是BootStrap（由C语言写的，没有开源）。
spring启动componentscan类扫描加载过程
11-25
2. **读取配置元数据**：Spring容器会解析包含`@ComponentScan`注解的配置类，获取到扫描的包名。这通常发生在`ClassPathBeanDefinitionScanner`的初始化阶段。 3. **类路径扫描**：`...
spring boot容器启动流程
08-28
@ComponentScan 注解是 Spring 的自动扫描注解，可定义扫描范围，加载到 IOC 容器。 2.2 EnableAutoConfiguration 注解 @EnableAutoConfiguration 注解是 Spring Boot 的核心注解之一。它的源码如下： ``` @...
基于配置类的Spring容器启动流程
qq_39804316的博客
04-16 500
下面将运行一个最基本的Demo，从容器获取C对象，直接Debug源码看看做了什么 AnnotationConfigApplicationContext类图，主要做了3件事情 查看父类GenericApplicationContext的构造方法，发现创建了一个DefaultListableBeanFactory， public GenericApplicationContext() { this.beanFactory = new DefaultListableBeanFactory(); }
14、加载spring启动首先进入的类方法注解1
08-08
在Spring框架中，当应用程序启动时，Spring容器会负责初始化并管理所有的Bean。在这个过程中，我们有时需要在Bean被创建后立即执行某些操作，或者在Bean销毁前进行清理工作。Spring提供了多种方式来指定这些初始化和...
Spring类加载器的选择逻辑
Big-wang的专栏
12-24 1296
public static ClassLoader getDefaultClassLoader() { ClassLoader cl = null; try { cl = Thread.currentThread().getContextClassLoader(); } catch (Throwable ex)
(十九)Core Java 加载器及Spring底层AOP原理实现 (117)
modaiairen524的博客
04-01 357
 目录 :        1 ) .  类加载器及其委托机制的深入分析2 ) .  自定义加载器的编写原理分析3 ) .  编写对class文件进行加密的工具类4 ) .  编写和测试自己编写的解密类加载器5 ) .  类加载器的一个高级问题的实验分析6 ) .  分析代理类的作用与原理和AOP概念7 ) .   创建动态类及查看其方法列表信息8 ) . 创建动态类的实例对象及调用其方法9 ). ...
java 类加载器，SPI机制，spring factories的原理
只有不断地学习，不断地进步，才能感受到生活的快乐，意义。。。。
06-11 1510
java的SPI机制打破双亲委派进行加载类。 约定条件如下： 1、当一个服务提供者提供了一个接口的具体实现后，在该服务打的jar包里的META-INFO/services目录下创建一个以接口全限名为命令的文件，文件里的内容为接口的实现类。 2、将这个jar包放入到主程序的classPath中。 ...
springboot中SPI机制
信马堂
06-11 4100
一、从java类加载机制说起 java中的类加载器负载加载来自文件系统、网络或者其他来源的类文件。jvm的类加载器默认使用的是双亲委派模式。三种默认的类加载器Bootstrap ClassLoader、Extension ClassLoader和System ClassLoader（Application ClassLoader）每一个中类加载器都确定了从哪一些位置加载文件。于此同时我们也可以通...
Spring容器启动加载配置类扫描Bean源码流程解析
wdg2333的博客
08-03 594
Spring容器启动加载配置类扫描Bean源码流程解析代码启动类配置类先看AnnotationConfigApplicationContext 类图invokeBeanFactoryPostProcessors( ConfigurableListableBeanFactory beanFactory, List beanFactoryPostProcessors)方法invokeBeanDefinitionRegistryPostProcessorspostProcessBeanDefinitionRegi
手写框架-Spring容器类加载流程
qq_27242695的博客
11-12 452
手写框架-Spring容器类加载刘恒 本文章主要介绍Spring容器加载Bean的流程。从xml文件上的标签是如何注入到.java文件并实例化的流程。 1 源码简介 1.1 源码程序入口 AbstractApplicationContext的refresh()方法 AbstractApplicationContext applicationContext = new ClassPathXmlApplicationContext(); applicationContext.refresh();
Java和Spring扫描加载 配置文件
.
08-12 1521
在项目中有些参数经常需要修改，或者后期可能会有改动时，那我们最好把这些参数放到properties文件中，在源代码中读取properties里面的配置，这样后期只需要改动properties文件即可，不需要修改源码。 一、java加载配置文件 package readProperties; import java.io.InputStream; import java.io.Buffer...
Spring import注解加载机制
不甘平庸的人
03-14 419
org.springframework.context.annotation.ConfigurationClassParser#parse(java.util.Set<org.springframework.beans.factory.config.BeanDefinitionHolder>) 在初始化类组装器组装BeanDefinition时。会对BeanDefinition进行判断，如果是注解性的BeanDefinition，则需要获取注解的元信息，即该类的所有注解内容。 or.
Spring基于XML扫描到创建BeanDefinition的原理
Hj95815的博客
05-20 380
说明 本文以SpringMVC容器为例，来看看容器创建和扫描的过程，这里我们只主要介绍基于xml的父容器的扫描实现，如有不正确的地方欢迎指教。 前提知识 sevlet容器的启动原理 基于web.xml的启动方式，servlet容器在启动的时候会解析WEB-INF/web.xml文件 父子容器的创建。其中父容器创建是根据ContextLoaderListener的监听机制去实现的 具体容器依赖关系图 具体容器的类型 具体的创建流程 调用org.springframework.web.context.C
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值