HelloWorld
登录

Spring系列(五) 容器初始化过程源码

Easter79

2021-10-12

1330 0 0

IoC/DI 的概念

容器是Spring的核心之一(另一个核心是AOP). 有了容器, IOC才可能实现.

  • 什么使IoC? IoC就是将类自身管理的与其由依赖关系的对象的创建/关联和管理交予容器实现, 容器按照配置(比如xml文件)来组织应用对象的创建和关联.

  • 什么使DI? DI是IoC的实现方式, 由容器在程序初始化的时候将类的依赖对象注入进去.

  • IoC和DI的关系? IoC(Inversion of Control)是一种设计原则, 可以减少代码的耦合度, DI(Dependency Injection)是IOC的具体实现方式, 还有其他的实现方式如 DL(Dependency Lookup).

Spring 容器

ClassPathXmlApplicationContext类应该都比较熟悉, 从熟悉的事物开始寻找线索.

下载Spring源码后用idea打开, 找到类ClassPathXmlApplicationContext, idea可以使用 ctrl+N 输入类名搜索, 打开源文件, 按 ctrl+Alt+U 可以生成类图.

BeanFactory和ResourceLoader是两个顶层接口. BeanFactory是Bean的工厂,定义了IoC基本的功能. ResourceLoader是资源加载的策略接口,定义了加载资源的基本规范, ApplicationContext需要此接口的功能.

BeanFactory提供了容器最基本的功能, 其中定义的方法会频繁使用, 接口定义如下:

1public interface BeanFactory {
2    // 一个标记, 带有此标记开头的类不是bean, 而是工厂本身
3	String FACTORY_BEAN_PREFIX = "&";
4	// 下面几个方法是各种获取bean的方式
5	Object getBean(String name) throws BeansException;
6	<T> T getBean(String name, @Nullable Class<T> requiredType) throws BeansException;
7	Object getBean(String name, Object... args) throws BeansException;
8	<T> T getBean(Class<T> requiredType) throws BeansException;
9	<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
10	// 判断bean是否存在
11	boolean containsBean(String name);
12	// bean作用域是否单例
13	boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
14	// bean作用域是否原型
15	boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
16	// bean是否与给定解析类型匹配
17	boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
18	boolean isTypeMatch(String name, @Nullable Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
19	// 获取bean类型
20	@Nullable
21	Class<?> getType(String name) throws NoSuchBeanDefinitionException;
22	//获取bean别名数组
23	String[] getAliases(String name);
24
25}

ApplicationContext 扩展了BeanFactory的功能, 除了作为工厂外, 它还提供了消息国际化(MessageSource), 获取环境bean(EnvironmentCapable), 容器消息发布(ApplicationEventPublisher)等功能. 因为它包含了容器以外的这些功能, 所以对了解容器来说多少会产生干扰. 事实上, 查看BeanFactory的子类(在类图上选中类,或者在源代码视图中按Ctrl+Alt+B)能从它的实现中找到DefaultListableBeanFactory, 从名称上二者在继承该关系上应该比较近, 功能也比较纯粹, 没有类似ApplicationContext的其他干扰.

DefaultListableBeanFactory 类是最基本的容器实现类, 它的继承关系如下图. 作为bean的工厂, 它的职责就是生产bean, 基本功能正是顶级接口BeanFactory定义的那些方法. 它上级的接口扩展了自动装配的能力(AutowireCapableBeanFactory), 注册和获取等操作BeanDefinition实例的能力(BeanDefinitionRegistry).

BeanDefinition

BeanDefinition 用来抽象bean定义在spring中的抽象, 最终spring将外部配置的bean转化为BeanDefinition的实例存储.

容器初始化过程

容器初始化过程分为三步, 资源Resource定位, 解析加载, 注册.

DefaultListableBeanFactory是工厂, 继承它的子类只有一个XmlBeanFactory, 它被标注为@Deprecated.所以不应该在应用中使用该类, 但它可以作为了解源码的入口. 它有个XmlBeanDefinitionReader的私有变量直接new初始化, 参数this将工厂实例传给这个对象, 这样它就有了工厂的引用, 方便内部处理.

1public class XmlBeanFactory extends DefaultListableBeanFactory {
2
3	private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);
4
5
6	public XmlBeanFactory(Resource resource) throws BeansException {
7		this(resource, null);
8	}
9
10	public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
11		super(parentBeanFactory);
12		// 这个是调用实际加载资源的方法
13		this.reader.loadBeanDefinitions(resource);
14	}

大概串一下初始化的执行流程:

  1. 获得一个Resource实例resource, 其实就是xml文件生成的输入流
  2. 实例化DefaultListableBeanFactory工厂beanFactory, 将resource作为构造参数传入
  3. beanFactory实例化, 生成XmlBeanDefinitionReader的实例reader, 并将beanFactory的引用传递给他
  4. 在beanFactory构造函数中调用reader的方法加载resource, 解析生成一系列BeanDefinition的实例, 因为readere有工厂的实例, 所以这些实例可以注册到工厂中

加载XML Bean的关键代码

下面按照调用关系跟踪代码, 忽略其他的xml元素, 最终目标是找到加载注册bean的机制.

XmlBeanDefinitionReader --> loadBeanDefinitions --> doLoadBeanDefinitions --> registerBeanDefinitions DefaultBeanDefinitionDocumentReader: BeanDefinitionDocumentReader --> registerBeanDefinitions --> doRegisterBeanDefinitions --> parseBeanDefinitions --> parseDefaultElement / processBeanDefinition BeanDefinitionParserDelegate --> parseBeanDefinitionElement BeanDefinitionReaderUtils --> registerBeanDefinition DetaultListableBeanFactory --> registerBeanDefinition

一. XmlBeanDefinitionReader.loadBeanDefinitions(EncodedResource encodedResource) 生成InputSource对象(用来初始化XML Dom对象)

1InputStream inputStream = encodedResource.getResource().getInputStream();
2try {
3	// 生成实例, 后面用来加载dom
4	InputSource inputSource = new InputSource(inputStream);
5	if (encodedResource.getEncoding() != null) {
6		inputSource.setEncoding(encodedResource.getEncoding());
7	}
8	// 生成InputSource后,调用这个方法
9	return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
10}
11finally {
12	inputStream.close();
13}

二. XmlBeanDefinitionReader.doLoadBeanDefinitions(InputSource inputSource, Resource resource) 加载生成Xml Document对象

1// 生成doc实例
2Document doc = doLoadDocument(inputSource, resource);
3return registerBeanDefinitions(doc, resource);

三. XmlBeanDefinitionReader.registerBeanDefinitions(Document doc, Resource resource)

1// 生成BeanDefinitionDocumentReader的实例, 默认实现为生成DefaultBeanDefinitionDocumentReader类的实例, 通过BeanUtil工具的实例化方法生成
2BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
3int countBefore = getRegistry().getBeanDefinitionCount();
4// 传入doc和资源的上下文对象, 注册bean
5documentReader.registerBeanDefinitions(doc, createReaderContext(resource));

四. registerBeanDefinitions(Document doc, XmlReaderContext readerContext) BeanDefinitionDocumentReader是接口, 实现类为DefaultBeanDefinitionDocumentReader

1@Override
2public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
3	this.readerContext = readerContext;
4	logger.debug("Loading bean definitions");
5	// 获取根节点
6	Element root = doc.getDocumentElement();
7	// 从根节点开始, 调用的这个方法会递归子节点
8	doRegisterBeanDefinitions(root);
9}

五. doRegisterBeanDefinitions(Element root) 类为DefaultBeanDefinitionDocumentReader

1protected void doRegisterBeanDefinitions(Element root) {
2	//任何嵌套的<beans>元素都将导致此方法的递归。为了正确传播和保留<beans> default- *属性，请跟踪当前（父）委托，该委托可以为null。创建新的（子）委托，引用父项以进行回退，然后最终将this.delegate重置为其原始（父）引用。此行为模拟了一堆代理，而实际上并不需要一个代理。
3	BeanDefinitionParserDelegate parent = this.delegate;
4	this.delegate = createDelegate(getReaderContext(), root, parent);
5
6	if (this.delegate.isDefaultNamespace(root)) {
7		// 下面这一块代码主要是做profile检查, 没有启用profile的bean不加载, 将直接return
8		String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
9		if (StringUtils.hasText(profileSpec)) {
10			String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
11					profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
12			if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
13				if (logger.isInfoEnabled()) {
14					logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec +
15							"] not matching: " + getReaderContext().getResource());
16				}
17				return;
18			}
19		}
20	}
21
22	preProcessXml(root);
23	// 具体解析的方法, pre和post的在这个类中为空方法
24	parseBeanDefinitions(root, this.delegate);
25	postProcessXml(root);
26
27	this.delegate = parent;
28}

六. parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) 类为DefaultBeanDefinitionDocumentReader

1/**
2* 解析文档中的根节点
3* "import", "alias", "bean".
4*/
5protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
6	// 是根节点,就获取子节点, 遍历,如果是根"import", "alias", "bean", 就调用parseDefaultElement, 否则parseCustomElement
7	if (delegate.isDefaultNamespace(root)) {
8		NodeList nl = root.getChildNodes();
9		for (int i = 0; i < nl.getLength(); i++) {
10			Node node = nl.item(i);
11			if (node instanceof Element) {
12				Element ele = (Element) node;
13				if (delegate.isDefaultNamespace(ele)) {
14					parseDefaultElement(ele, delegate);
15				}
16				else {
17					delegate.parseCustomElement(ele);
18				}
19			}
20		}
21	}
22	else {
23		delegate.parseCustomElement(root);
24	}
25}

七. parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) 类为DefaultBeanDefinitionDocumentReader

1private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
2		if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
3			// 解析"import"元素, 这个方法会定位import的资源位置并重复第一步开始的步骤
4			importBeanDefinitionResource(ele);
5		}
6		else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
7			// 别名"alias"注册
8			processAliasRegistration(ele);
9		}
10		else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
11			// 前方高能... 处理bean元素
12			processBeanDefinition(ele, delegate);
13		}
14		else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
15			// 递归"beans"
16			doRegisterBeanDefinitions(ele);
17		}
18	}

八. processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) 类为DefaultBeanDefinitionDocumentReader

1/**
2*  处理bean元素的定义, 并且注册
3*/
4protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
5	// 获取bean的包装对象,代码见第九步
6	BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
7	if (bdHolder != null) {
8		bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
9		try {
10			// 注册最终的bean装饰对象
11			BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
12		}
13		catch (BeanDefinitionStoreException ex) {
14			getReaderContext().error("Failed to register bean definition with name '" +
15					bdHolder.getBeanName() + "'", ele, ex);
16		}
17		// Send registration event.
18		getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
19	}
20}

九. parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) 类为 BeanDefinitionParserDelegate 关注两个实例化过程,一个是BeanDefinition, 一个是其装饰对象BeanDefinitionHolder的实例

1/**
2* 解析bean元素, 可能会返回null, 如果有错误则报告给
3* {@link org.springframework.beans.factory.parsing.ProblemReporter}.
4*/
5@Nullable
6public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
7	String id = ele.getAttribute(ID_ATTRIBUTE);
8	String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
9
10	List<String> aliases = new ArrayList<>();
11	if (StringUtils.hasLength(nameAttr)) {
12		String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
13		aliases.addAll(Arrays.asList(nameArr));
14	}
15
16	String beanName = id;
17	if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
18		beanName = aliases.remove(0);
19		if (logger.isDebugEnabled()) {
20			logger.debug("No XML 'id' specified - using '" + beanName +
21					"' as bean name and " + aliases + " as aliases");
22		}
23	}
24
25	if (containingBean == null) {
26		checkNameUniqueness(beanName, aliases, ele);
27	}
28	// 实例化一个 BeanDefination 实例
29	AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
30	if (beanDefinition != null) {
31		if (!StringUtils.hasText(beanName)) {
32			try {
33				if (containingBean != null) {
34					beanName = BeanDefinitionReaderUtils.generateBeanName(
35							beanDefinition, this.readerContext.getRegistry(), true);
36				}
37				else {
38					beanName = this.readerContext.generateBeanName(beanDefinition);
39					String beanClassName = beanDefinition.getBeanClassName();
40					if (beanClassName != null &&
41							beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
42							!this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
43						aliases.add(beanClassName);
44					}
45				}
46				if (logger.isDebugEnabled()) {
47					logger.debug("Neither XML 'id' nor 'name' specified - " +
48							"using generated bean name [" + beanName + "]");
49				}
50			}
51			catch (Exception ex) {
52				error(ex.getMessage(), ele);
53				return null;
54			}
55		}
56		String[] aliasesArray = StringUtils.toStringArray(aliases);
57		return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
58	}
59
60	return null;
61}

十. registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) 是类的静态方法BeanDefinitionReaderUtils ;给registry对象调用

1// 注册bean的最终方法
2public static void registerBeanDefinition( BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) throws BeanDefinitionStoreException {
3
4	// 使用首要名称注册bean
5	String beanName = definitionHolder.getBeanName();
6	// 注册bean, 具体实现在类DetaultListableBeanFactory中
7	registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
8
9	// 注册bean的别名
10	String[] aliases = definitionHolder.getAliases();
11	if (aliases != null) {
12		for (String alias : aliases) {
13			registry.registerAlias(beanName, alias);
14		}
15	}
16}

十一. registerBeanDefinition(String beanName, BeanDefinition beanDefinition) 在类DetaultListableBeanFactory

1@Override
2public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
3		throws BeanDefinitionStoreException {
4	....
5
6	BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
7	if (existingDefinition != null) {
8		....
9		// 存到map里面
10		this.beanDefinitionMap.put(beanName, beanDefinition);
11	}
12	else {
13		if (hasBeanCreationStarted()) {
14			// Cannot modify startup-time collection elements anymore (for stable iteration)
15			synchronized (this.beanDefinitionMap) {
16				this.beanDefinitionMap.put(beanName, beanDefinition);
17				List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
18				updatedDefinitions.addAll(this.beanDefinitionNames);
19				updatedDefinitions.add(beanName);
20				this.beanDefinitionNames = updatedDefinitions;
21				if (this.manualSingletonNames.contains(beanName)) {
22					Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
23					updatedSingletons.remove(beanName);
24					this.manualSingletonNames = updatedSingletons;
25				}
26			}
27		}
28		else {
29			// Still in startup registration phase
30			this.beanDefinitionMap.put(beanName, beanDefinition);
31			this.beanDefinitionNames.add(beanName);
32			this.manualSingletonNames.remove(beanName);
33		}
34		this.frozenBeanDefinitionNames = null;
35	}
36
37	if (existingDefinition != null || containsSingleton(beanName)) {
38		resetBeanDefinition(beanName);
39	}
40}

到目前为止, bean就注册到工厂里面去了, 实际上工厂里面保存了BeanDefinition的一个映射Map, 这样有助于Spring做一些验证, 当获取bean的时候也可以方便实现懒加载.

点赞
收藏

评论区

加载中...

相关推荐

MySQL:[Err] 1292 - Incorrect datetime value: ‘0000-00-00 00:00:00‘ for column ‘CREATE_TIME‘ at row 1

文章目录问题用navicat导入数据时，报错：原因这是因为当前的MySQL不支持datetime为0的情况。解决修改sql\mode:sql\mode:SQLMode定义了MySQL应支持的SQL语法、数据校验等，这样可以更容易地在不同的环境中使用MySQL。全局s

Oracle 分组与拼接字符串同时使用

SELECTT.,ROWNUMIDFROM(SELECTT.EMPLID,T.NAME,T.BU,T.REALDEPART,T.FORMATDATE,SUM(T.S0)S0,MAX(UPDATETIME)CREATETIME,LISTAGG(TOCHAR(

手写Java HashMap源码

HashMap的使用教程HashMap的使用教程HashMap的使用教程HashMap的使用教程HashMap的使用教程22

SSM的基本知识点

\SpringSpring框架是一个容器，它的主要作用是创建和管理对象。Spring框架实现了解耦。Spring框架通过DI实现了IoC。关于Spring框架，必须掌握和理解的：1. Spring的基本概念与特性；2. 常用的注解：通用的4个注解，自动装配的注解；3.

spring源码

SpringIOC容器源码解析系列，建议大家按顺序阅读，欢迎讨论(_spring源码均为4.1.6.RELEASE版本_)1.Spring源码IOC容器(一)构建简单IOC容器(https://my.oschina.net/u/2377110/blog/902073)2.Spring源码IOC容器(二)Bean的定位解析注

SpringIOC官方文档解读

IoC容器本章介绍了Spring的控制反转（IoC）容器。1.1。SpringIoC容器和Bean简介本章介绍了反转控制（IoC）原则的Spring框架实现。IoC也称为依赖注入（DI）。在此过程中，对象可以通过①构造函数参数（），②工厂方法的参数③或在构造或从工厂方法返回后在对象实例上设置的属性来定义其依