Spring源码分析--IOC容器篇

最新推荐文章于 2022-10-25 20:32:03 发布
最新推荐文章于 2022-10-25 20:32:03 发布
阅读量256 收藏
点赞数 1
分类专栏： Spring 文章标签： spring xml ioc java spring源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42224683/article/details/116071315
版权

一、环境准备

我们以xml配置文件示例

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <beans>
        <bean id="luoluo" class="com.luo.pojo.Goods">
            <property name="name" value="hehe"/>
        </bean>
    </beans>
</beans>

spring的启动类

public class SpringRun {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
        Object luo = applicationContext.getBean("luoluo");
    }
}

二、知识初探

IOC中设计到的几个很重要的类，如下

接口、类含义
BeanFactory创建bean的顶级接口
BeanDefinitionxml中的bean信息最终会被解析成为一个个BeanDefinition
BeanDefinitionMap<k,v>键值对，key是bean的名称，v 是对应的BeanDefinition

在这里插入图片描述

二、开始走进源码

  1. 先看第一句代码
ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("application.xml");

进入该方法

public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
		this(new String[] {configLocation}, true, null);
}
	
public ClassPathXmlApplicationContext(
			String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
			throws BeansException {
		super(parent);
		setConfigLocations(configLocations); //把配置文件路径设置到上下文中，方便下文解析
		if (refresh) {
			refresh(); //这里是最重要的方法
	}
}

setConfigLocations(configLocations);

把配置文件加载进容器中，那么是怎么加载进容器的呢？在这之前我们先了解下资源加载器 ResourceLoader和资源模式解析器 ResourcePatternResolver，用于从类路径下或者文件系统中加载并识别资源。常见的资源模式如下

  • classpath:
  • classpath*:
  • /WEB-INF/*-context.xml
  • /beans.xml

既然能够加载文件系统中的资源，比如C：\Users\luo20\Desktop\dubbo.xml，那么我们操作系统的环境信息应该在加载配置文件之前就设置进上下文中，这个也有对应的实现

protected String resolvePath(String path) {
		return getEnvironment().resolveRequiredPlaceholders(path);
	}

现在系统的信息也有了，配置文件资源也有了，接下来开始最最最重要的方法

refresh()

这个方法是IOC的核心

@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			//记录上下文的启动时间和当前的状态等信息
			prepareRefresh();

			// 将配置文件中的信息提取出来并创建对象，封装为BeanDefinition，然后添加到BeanDefinitionMap
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// 配置beanFactory相关信息
			prepareBeanFactory(beanFactory);

			try {
				// 对BeanFactory进行后置处理
				postProcessBeanFactory(beanFactory);

				// 实例化并调用所有的BeanFactoryPostProcessor
				invokeBeanFactoryPostProcessors(beanFactory);

				// 实例化并注册BeanPostProcessor
				registerBeanPostProcessors(beanFactory);

				// 处理国际化
				initMessageSource();

				// 初始化事件多播器
				initApplicationEventMulticaster();

				//  模板方法，它可以被重写，用于上下文的刷新工作
				onRefresh();

				//  注册事件监听器，监听器需要实现 ApplicationListener 接口
				registerListeners();

				// 创建并初始化所有剩余的(非lazy-init)单例
				finishBeanFactoryInitialization(beanFactory);

				//广播事件，ApplicationContext 初始化完成
				finishRefresh();
			}
			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}
				destroyBeans();
				cancelRefresh(ex);
				throw ex;
			}
			finally {
				resetCommonCaches();
			}
		}
	}

下面我将一个一个方法进行深入解析

方法一：prepareRefresh();

protected void prepareRefresh() {
		// 设置容器的启动时间、激活状态
		this.startupDate = System.currentTimeMillis(); 
		this.closed.set(false);
		this.active.set(true); 

		// 这是一个空方法
		initPropertySources();
		// 校验需要的配置文件是否可以解析
		getEnvironment().validateRequiredProperties();

		// Store pre-refresh ApplicationListeners...
		if (this.earlyApplicationListeners == null) {
			this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
		}
		else {
			// Reset local application listeners to pre-refresh state.
			this.applicationListeners.clear();
			this.applicationListeners.addAll(this.earlyApplicationListeners);
		}

		// Allow for the collection of early ApplicationEvents,
		// to be published once the multicaster is available...
		this.earlyApplicationEvents = new LinkedHashSet<>();
	}

方法二：ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
		refreshBeanFactory();
		return getBeanFactory();
	}
@Override
	protected final void refreshBeanFactory() throws BeansException {
		//之前如果有bean工厂，清理掉
		if (hasBeanFactory()) {
			destroyBeans();
			closeBeanFactory();
		}
		try {
			//新建一个beanFactory 
			DefaultListableBeanFactory beanFactory = createBeanFactory();
			beanFactory.setSerializationId(getId());
			//对beanFactory进行一些定制化
			customizeBeanFactory(beanFactory);
			//从配置文件中加载对象信息，包装为BeanDefinition
			loadBeanDefinitions(beanFactory);
			synchronized (this.beanFactoryMonitor) {
				this.beanFactory = beanFactory;
			}
		}
		catch (IOException ex) {
			throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
		}
	}

重点在怎么把xml变为BeanDefinition，进入loadBeanDefinitions(beanFactory);

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
		// Create a new XmlBeanDefinitionReader for the given BeanFactory.
		XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
		// 设置需要的环境
		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);
		}
		//获取配置文件，在之前已经把配置文件设置进了上下文，所以很容易获取
		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 count = 0;
		for (String location : locations) {
			//还没有开始处理，进入
			count += loadBeanDefinitions(location);
		}
		//返回配置文件的数量
		return count;
	}

经过一系列的loadBeanDefinitions，最终到了这个方法

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
		Assert.notNull(encodedResource, "EncodedResource must not be null");
		if (logger.isTraceEnabled()) {
			logger.trace("Loading XML bean definitions from " + encodedResource);
		}

		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()) {
			InputSource inputSource = new InputSource(inputStream);
			if (encodedResource.getEncoding() != null) {
				inputSource.setEncoding(encodedResource.getEncoding());
			}
			//这里我们看到doLoadBeanDefinitions，而不是LoadBeanDefinitions，太好啦
			return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
		}
		catch (IOException ex) {
			throw new BeanDefinitionStoreException(
					"IOException parsing XML document from " + encodedResource.getResource(), ex);
		}
		finally {
			currentResources.remove(encodedResource);
			if (currentResources.isEmpty()) {
				this.resourcesCurrentlyBeingLoaded.remove();
			}
		}
	}

进入doLoadBeanDefinitions(inputSource, encodedResource.getResource());

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
			throws BeanDefinitionStoreException {

		try {
			//把xml解析成为文档对象，可以进行调试看看doc结果
			Document doc = doLoadDocument(inputSource, resource);
			//生成并注册BeanDefinition
			int count = registerBeanDefinitions(doc, resource);
			if (logger.isDebugEnabled()) {
				logger.debug("Loaded " + count + " bean definitions from " + resource);
			}
			return count;
		}

进入registerBeanDefinitions(doc, resource);

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
		BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
		//获取之前的BeanDefinition数量
		int countBefore = getRegistry().getBeanDefinitionCount();
		//这里不是真正处理的地方，进入
		documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
		return getRegistry().getBeanDefinitionCount() - countBefore;
	}

进入registerBeanDefinitions(doc, createReaderContext(resource))

@Override
	public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
		this.readerContext = readerContext;
		//又是do，开始真正的处理
		doRegisterBeanDefinitions(doc.getDocumentElement());
	}

进入

protected void doRegisterBeanDefinitions(Element root) {
		BeanDefinitionParserDelegate parent = this.delegate;
		this.delegate = createDelegate(getReaderContext(), root, parent);

		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);

		this.delegate = parent;
	}

进入parseBeanDefinitions(root, this.delegate);

//在文档的根级别解析"import", "alias", "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;
					//是否有默认的命名空间
					if (delegate.isDefaultNamespace(ele)) {
						//有，进入这个方法
						parseDefaultElement(ele, delegate);
					}
					else {
						delegate.parseCustomElement(ele);
					}
				}
			}
		}
		else {
			delegate.parseCustomElement(root);
		}
	}

我们的bean是有默认的命名空间的，所以进入

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)) {
			// recurse
			doRegisterBeanDefinitions(ele);
		}
	}

进入processBeanDefinition(ele, delegate);

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
		//把bean元素解析为BeanDefinition
		BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
		if (bdHolder != null) {
			bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
			try {
				// 把BeanDefinition放入到BeanDefinitionMap
				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));
		}
	}

当把我们配置文件中的bean标签解析为BeanDefinition，并添加到BeanDefinitionMap中，obtainFreshBeanFactory()方法完成

  • 篇幅太长，每天更新一个方法，哈哈
罗罗的1024
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Spring源码阅读-IOC 容器解析
Java架构师之路的博客
07-27 245
在Spring框架中最重要的是Spring IoC容器，它是Spring框架的核心。本文将从更高的角度来解析Sping IoC容器，了解其是如何设计的。了解一样东西最好的办法是从其核心本质出发，只要把握住了这样一个核心，其他的一些东西也迎刃而解了。这是一个很好的开端，我们一起开始吧... Spring IoC容器 org.springframework.context.ApplicationC...
SpringIOC 源码解析
暴躁兔子的记录
04-10 469
SpringIOC 源码解析 本篇主要和大家一起来看看spring中ioc的源码，从bean的定义到初始化、实例化的过程。我们都说spring其实就是个HashMap，那么到底底层是怎么管理beans的呢，还有我们想知道为什么使用了注解[@Component]之后，spring就会自动将这个类加入到容器。在这篇文章我尽量去解答这个疑问，有错漏的请大家指正。 前言 工欲善其事必先利其器，如今做ja...
Spring - 手把手分析 IoC 容器创建过程
业精于勤荒于嬉
10-25 2599
Spring - 手把手分析 IoC 容器创建过程
一 spring源码分析--- IOC容器
yamorn的专栏
03-04 873
前言 在分析spring源码之前，推荐Spring作者 Rod Johnson的两本书： Expert One-on-One J2EE Design and DevelopmentExpert One-on-One J2EE Development without EJB 这两本书是spring 作者多年的J2EE工作中总结的思想和经验，spring框架就是在这些思想上开发出来的
Spring源码学习---IOC容器
weixin_34319111的博客
06-05 295
前言 在之前的5个文章中我们已经对 IOC, DI, AOP 和配置相关进行了一些了解，相信在此基础上可以帮助大家更好地去阅读 Spring 的源码 源码学习-IOC容器 ① 注意事项 1.这里的源码版本号为 version 5.1.3.RELEASE 2.源码获取地址 github.com/spring-proj… 3.jdk要在1.8以上，spring5中大量使用了lambda表达式，而la...
【框架源码篇 01】Spring源码-手写IOC
最新发布
10-21
在本系列的第一篇【框架源码篇 01】中，我们将深入探讨Spring框架的核心组件——控制反转（Inversion of Control，简称IOC）。IOC是一种设计模式，它将对象的创建和管理职责从应用代码中解耦出来，转交给一个外部...
coco-spring-ioc
04-16
《简易Spring-ioc详解》 在Java开发领域，Spring框架以其强大的功能和广泛的应用而备受开发者喜爱。...此外，掌握这些核心概念后，无论是使用Spring框架还是其他类似的IoC容器，都将更加得心应手。
spring源码spring-framework-4.2.5.RELEASE
12-04
深入理解Spring源码需要对Java反射、动态代理、设计模式等有扎实的基础。建议从以下几个步骤入手： 1. 了解基本架构和模块划分。 2. 分析核心类如ApplicationContext、BeanFactory和DispatcherServlet的实现。 3. ...
spring-framework-5.3.29.tar.gz
08-31
三、源码分析 深入Spring Framework 5.3.29的源码，我们可以看到它采用模块化设计，每个组件都有清晰的职责划分。例如，`org.springframework.beans`包主要处理Bean的创建和管理，`org.springframework.context`包...
什么是AOP切面编程
罗罗的1024
09-05 1846
AOP（Aspect Oriented Programming）称为面向切面编程，它利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其名为“Aspect”，即方面。所谓“方面”，简单地说，就是将那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。AOP代表的是一个横向的关系，在程序开发中主要用来解决一些系统层面上的问题，比如日志，事务，权限，安全控制，等待，性能统计
spring的自动装配
罗罗的1024
08-31 1454
基于XML的自动装配Autowire default/no：不自动装配 byName: 根据名字进行装配，以属性名作为id，在容器中查找这个组件进行赋值 byType：根据类型进行装配 constructor: 使用构造器* byName <bean id="person" class="com.luo.spring.bean.Person" autowire="byName"/> bean id="car" class="com.luo.spring.bean.Car">
来了解下spring的FactoryBean工厂模式
罗罗的1024
08-30 1025
说到工厂模式，相信大家都很熟悉，我简单的帮回顾回顾吧 看图，哈哈~~ 要在spring中实现工厂模式，由很多方式，下面我列举几种 静态工厂 直接通过工厂获取实例。 public class CarStaticFactory { private static Car getCar(String name){ Car car = new Car(); car.setName(name); return car; } } <!--facto
spring框架中Test单元测试的使用
罗罗的1024
09-10 891
import com.luo.spring.service.MyService; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.co
Spring注册Bean的几种方式
罗罗的1024
09-16 773
方式一：基于XML <bean id="service" class="com.luo.service.ServiceImpl"></bean> 方式二：基于@Configuration、@Bean @Configuration public class AppConfig { @Bean("student") public Student student(){ Student student = new Student(); s
spring的简单介绍
罗罗的1024
08-29 743
spring简介 Spring是一个开源框架，使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。 Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。 下面是spring的框架结构 根据这个框架结构图，可以明显的看到，核心容器是spring框架的基础，所有的Spring模块都是在核心容器之上构建的。 spring的优势 1、非侵入式设计 Sp
FactoryBean和BeanFactory的区别
罗罗的1024
09-16 679
FactoryBean ：是一个工厂Bean，可以生成某一个类型Bean实例，它最大的一个作用是：可以让我们自定义Bean的创建过程。 BeanFactory ：是Spring容器中的一个基类，也是很重要的一个类，在BeanFactory中可以创建和管理Spring容器中的Bean，它对于Bean的创建有一个统一的流程。 FactoryBean 看看源码是怎么说的 package org.springframework.beans.factory; import org.springframework.l
手写模仿Spring容器
罗罗的1024
09-15 517
DAO层 public interface Dao { public void dao(); } public class DaoImpl implements Dao { @Override public void dao() { System.out.println("dao"); } } Service 层 public interface Service { public void service(); } public class Se
超详细的Spring使用
罗罗的1024
08-29 291
加载IOC容器的配置文件 一般我们都是用的ClassPathXmlApplicationContext，见名知意，加载在类路径下的配置文件，此外，我们还可以使用FileSystemXmlApplicationContext，来加载磁盘中的配置文件。 使用，在配置文件中注册bean <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans"
spring基础(一)
罗罗的1024
08-30 272
引用类型的赋值操作 如果想对一个引用类型赋值为null，怎么办呢？ 是这样操作吗 public class Person { public String name; private Integer age; private Car car; } -------------------------------- <bean class="com.luo.spring.bean.Person"> <property name="age" value="
Spring IOC容器源码分析与实现原理
Spring源码分析 Spring框架是Java开发中最流行的框架之一，其核心组件是IoC（Inversion of Control，控制反转）容器。IoC容器是Spring框架的核心组件之一，负责管理和提供Bean实例。下面将对Spring源码中的IoC容器...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

罗罗的1024

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值