经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » Java相关 » Spring » 查看文章
Spring 源码阅读（二）IoC 容器初始化以及 BeanFactory 创建和 BeanDefinition 加载过程
来源：cnblogs　　作者：LinweiWang　　时间：2024/4/23 10:05:36　　对本文有异议

相关代码提交记录：https://github.com/linweiwang/spring-framework-5.3.33

IoC 容器三种启动方式

XML

JavaSE：

  1. ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml")
  2. ApplicationContext context = new FileSystemXmlApplicationContext("C:/beans.xml")

JavaWeb

  1. 通过 web.xml 配置 ContextLoaderListener，指定 Spring 配置文件。

XML+注解

因为有 XML ，所以和纯 XML 启动方式一样

注解

JavaSE

  1. ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class)

JavaWeb

  1. 通过 web.xml 配置 ContextLoaderListener，指定 Spring 配置文件。

BeanFactory 是 Spring 框架中 IoC 容器的顶层接?,它只是?来定义?些基础功能,定义?些基础规范,? ApplicationContext 是它的?个?接?，所以 ApplicationContext 是具备 BeanFactory 提供的全部功能力的。
通常，我们称 BeanFactory 为 SpringIOC 的基础容器，ApplicationContext 是容器的?级接?，?
BeanFactory 要拥有更多的功能，?如说国际化?持和资源访问（XML、Java 配置类）等等。

image

下面以纯 XML 依赖原有 spring-research 来跟踪源码。

IoC 容器初始化主体流程

分析 new ClassPathXmlApplicationContext("spring-config.xml");

ClassPathXmlApplicationContext.java

  1.     // 创建 ClassPathXmlApplicationContext，加载 XML 中的定义信息，并且自动 refresh 容器（Context）
  2. 	public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
  3. 		// 调用重载方法
  4. 		this(new String[] {configLocation}, true, null);
  5. 	}
  7. 	public ClassPathXmlApplicationContext(
  8. 			String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
  9. 			throws BeansException {
  11. 		// 初始化父类
  12. 		super(parent);
  13. 		// 设置配置文件
  14. 		setConfigLocations(configLocations);
  15. 		// refresh context
  16. 		if (refresh) {
  17. 			refresh();
  18. 		}
  19. 	}

进入 refresh() 方法，在父类 AbstractApplicationContext 中

  1. 	@Override
  2. 	public void refresh() throws BeansException, IllegalStateException {
  3. 		// 对象锁
  4. 		synchronized (this.startupShutdownMonitor) {
  5. 			StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
  7. 			// 刷新前的预处理
  8. 			// Prepare this context for refreshing.
  9. 			prepareRefresh();
  11. 			// 获取 BeanFactory: 默认实现是 DefaultListableBeanFactory
  12. 			// 加载 BeanDefinition 并注册到 BeanDefinitionRegistry
  13. 			// Tell the subclass to refresh the internal bean factory.
  14. 			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
  16. 			// BeanFactory 预准备工作
  17. 			// Prepare the bean factory for use in this context.
  18. 			prepareBeanFactory(beanFactory);
  20. 			try {
  21. 				// BeanFactory 准备工作完成后的后置处理，留给子类实现
  22. 				// Allows post-processing of the bean factory in context subclasses.
  23. 				postProcessBeanFactory(beanFactory);
  25. 				StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
  26. 				// 实例化实现了 BeanFactoryPostProcessor 接口的 Bean，并调用该接口方法
  27. 				// Invoke factory processors registered as beans in the context.
  28. 				invokeBeanFactoryPostProcessors(beanFactory);
  29. 				// 注册 BeanPostProcessor （Bean 的后置处理器），在创建 Bean 的前后执行
  30. 				// Register bean processors that intercept bean creation.
  31. 				registerBeanPostProcessors(beanFactory);
  32. 				beanPostProcess.end();
  34. 				// 初始化 MessageSource 组件：国际化、消息绑定、消息解析等
  35. 				// Initialize message source for this context.
  36. 				initMessageSource();
  38. 				// 初始化事件派发器
  39. 				// Initialize event multicaster for this context.
  40. 				initApplicationEventMulticaster();
  42. 				// 初始化其他特殊的 Bean，在容器刷新的时候子类自定义实现：如创建 Tomcat、Jetty 等 Web 服务器
  43. 				// Initialize other special beans in specific context subclasses.
  44. 				onRefresh();
  46. 				// 注册应用监听器（即实现了 ApplicationListener 接口的 Bean）
  47. 				// Check for listener beans and register them.
  48. 				registerListeners();
  50. 				// 初始化创建非懒加载的单例 Bean、填充属性、调用初始化方法（ afterPropertiesSet，init-method 等）、调用 BeanPostProcessor 后置处理器
  51. 				// Instantiate all remaining (non-lazy-init) singletons.
  52. 				finishBeanFactoryInitialization(beanFactory);
  54. 				// 完成 context 刷新，调用 LifecycleProcessor 的 onRefresh 方法并发布 ContextRefreshedEvent
  55. 				// Last step: publish corresponding event.
  56. 				finishRefresh();
  57. 			}
  59. 			catch (BeansException ex) {
  60. 				if (logger.isWarnEnabled()) {
  61. 					logger.warn("Exception encountered during context initialization - " +
  62. 							"cancelling refresh attempt: " + ex);
  63. 				}
  65. 				// Destroy already created singletons to avoid dangling resources.
  66. 				destroyBeans();
  68. 				// Reset 'active' flag.
  69. 				cancelRefresh(ex);
  71. 				// Propagate exception to caller.
  72. 				throw ex;
  73. 			}
  75. 			finally {
  76. 				// Reset common introspection caches in Spring's core, since we
  77. 				// might not ever need metadata for singleton beans anymore...
  78. 				resetCommonCaches();
  79. 				contextRefresh.end();
  80. 			}
  81. 		}
  82. 	}

整体流程如下：

1 刷新前的预处理： prepareRefresh();
 主要是一些准备工作设置其启动日期和活动标志以及执行一些属性的初始化。
 
 2 初始化 BeanFactory： obtainFreshBeanFactory()；

  • 如果有旧的 BeanFactory 就删除并创建新的 BeanFactory
  • 解析所有的 Spring 配置文件，将配置文件中定义的 bean 封装成 BeanDefinition，加载到BeanFactory 中（这里只注册，不会进行 Bean 的实例化）

3 BeanFactory 预准备工作：prepareBeanFactory(beanFactory);
配置 BeanFactory 的标准上下文特征，例如上下文的 ClassLoader、后置处理器等。

4 BeanFactory 准备工作完成后的后置处理，留给子类实现：postProcessBeanFactory(beanFactory);
空方法，如果子类需要，自己去实现

5 调用 Bean 工厂后置处理器：invokeBeanFactoryPostProcessors(beanFactory);

实例化和调用所有BeanFactoryPostProcessor，完成类的扫描、解析和注册。
BeanFactoryPostProcessor 接口是 Spring 初始化 BeanFactory 时对外暴露的扩展点，Spring IoC 容器允许 BeanFactoryPostProcessor 在容器实例化任何 bean 之前读取 bean 的定义，并可以修改它。

6 注册 BeanPostProcesso：registerBeanPostProcessors(beanFactory);
所有实现了 BeanPostProcessor 接口的类注册到 BeanFactory 中。

7 初始化 MessageSource 组件：initMessageSource();
初始化MessageSource组件（做国际化功能；消息绑定，消息解析）

8 初始化事件派发器：initApplicationEventMulticaster();
初始化应用的事件派发/广播器 ApplicationEventMulticaster。

9 初始化其他特殊的 Bean：onRefresh();
空方法，模板设计模式;子类重写该方法并在容器刷新的时候自定义逻辑。
例：SpringBoot 在 onRefresh() 完成内置 Tomcat 的创建及启动

10 注册应用监听器：registerListeners();
向事件分发器注册硬编码设置的 ApplicationListener，向事件分发器注册一个 IoC 中的事件监听器（并不实例化）

11 初始化创建非懒加载的单例 Bean：finishBeanFactoryInitialization(beanFactory);
初始化创建非懒加载的单例 Bean、填充属性、调用初始化方法（ afterPropertiesSet，init-method 等）、调用 BeanPostProcessor 后置处理器，是整个 Spring IoC 核心中的核心。

12 完成 context 刷新：finishRefresh();
完成 context 刷新，调用 LifecycleProcessor 的 onRefresh 方法并发布 ContextRefreshedEvent

获取 BeanFactory 子流程

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

AbstractApplicationContext.java

  1. 	protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
  2. 		// 对 BeanFactory 进行刷新操作，默认实现 AbstractRefreshableApplicationContext#refreshBeanFactory
  3. 		refreshBeanFactory();
  4. 		// 返回上一步 beanFactory，默认实现 AbstractRefreshableApplicationContext#getBeanFactory
  5. 		return getBeanFactory();
  6. 	}

AbstractRefreshableApplicationContext

  1. 	@Override
  2. 	protected final void refreshBeanFactory() throws BeansException {
  3. 		// 判断是否已有 BeanFactory
  4. 		if (hasBeanFactory()) {
  5. 			// 销毁 Bean
  6. 			destroyBeans();
  7. 			// 关闭 BeanFactory
  8. 			closeBeanFactory();
  9. 		}
  10. 		try {
  11. 			// 实例化 DefaultListableBeanFactory
  12. 			DefaultListableBeanFactory beanFactory = createBeanFactory();
  13. 			// 设置序列化 ID
  14. 			beanFactory.setSerializationId(getId());
  15. 			// 自定义 BeanFactory 的一些属性：allowBeanDefinitionOverriding、allowCircularReferences
  16. 			//   allowBeanDefinitionOverriding 是否允许覆盖
  17. 			//   allowCircularReferences  是否允许循环依赖
  18. 			customizeBeanFactory(beanFactory);
  19. 			// 加载应用中的 BeanFactory
  20. 			loadBeanDefinitions(beanFactory);
  21. 			// 赋值给当前 beanFactory 属性
  22. 			this.beanFactory = beanFactory;
  23. 		}
  24. 		catch (IOException ex) {
  25. 			throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
  26. 		}
  27. 	}
  29. 	@Override
  30. 	public final ConfigurableListableBeanFactory getBeanFactory() {
  31. 		DefaultListableBeanFactory beanFactory = this.beanFactory;
  32. 		if (beanFactory == null) {
  33. 			throw new IllegalStateException("BeanFactory not initialized or already closed - " +
  34. 					"call 'refresh' before accessing beans via the ApplicationContext");
  35. 		}
  36. 		return beanFactory;
  37. 	}

image

BeanDefinition 加载解析及注册子流程

继续分析 AbstractRefreshableApplicationContext#refreshBeanFactory 中的 loadBeanDefinitions 的实现方法在 AbstractXmlApplicationContext#loadBeanDefinitions 中（若是注解在 AnnotationConfigWebApplicationContext）

AbstractXmlApplicationContext

  1. 	@Override
  2. 	protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
  3. 		// 给指定的 BeanFactory 创建一个 XmlBeanDefinitionReader 进行读取和解析 XML
  4. 		// Create a new XmlBeanDefinitionReader for the given BeanFactory.
  5. 		XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
  7. 		// 给 XmlBeanDefinitionReader 设置上下文信息
  8. 		// Configure the bean definition reader with this context's
  9. 		// resource loading environment.
  10. 		beanDefinitionReader.setEnvironment(getEnvironment());
  11. 		beanDefinitionReader.setResourceLoader(this);
  12. 		beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
  14. 		// 提供给子类上西安的模板方法：自定义初始化策略
  15. 		// Allow a subclass to provide custom initialization of the reader,
  16. 		// then proceed with actually loading the bean definitions.
  17. 		initBeanDefinitionReader(beanDefinitionReader);
  18. 		// 真正的去加载 BeanDefinitions
  19. 		loadBeanDefinitions(beanDefinitionReader);
  20. 	}
  22. 	protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
  23. 		// 从 Resource 资源对象加载 BeanDefinitions
  24. 		Resource[] configResources = getConfigResources();
  25. 		if (configResources != null) {
  26. 			reader.loadBeanDefinitions(configResources);
  27. 		}
  28. 		// 从 XML 配置文件加载 BeanDefinition 对象
  29. 		String[] configLocations = getConfigLocations();
  30. 		if (configLocations != null) {
  31. 			reader.loadBeanDefinitions(configLocations);
  32. 		}
  33. 	}

reader.loadBeanDefinitions(configLocations); 中调用了 AbstractBeanDefinitionReader#loadBeanDefinitions

  1. 	@Override
  2. 	public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {
  3. 		Assert.notNull(locations, "Location array must not be null");
  4. 		int count = 0;
  5. 		// 如果有多个配置文件，循环读取加载，并统计数量
  6. 		for (String location : locations) {
  7. 			count += loadBeanDefinitions(location);
  8. 		}
  9. 		return count;
  10. 	}
  12. 	@Override
  13. 	public int loadBeanDefinitions(String location) throws BeanDefinitionStoreException {
  14. 		return loadBeanDefinitions(location, null);
  15. 	}
  17. 	public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException {
  18. 		// 获取上下文的 ResourceLoader （资源加载器）
  19. 		ResourceLoader resourceLoader = getResourceLoader();
  20. 		if (resourceLoader == null) {
  21. 			throw new BeanDefinitionStoreException(
  22. 					"Cannot load bean definitions from location [" + location + "]: no ResourceLoader available");
  23. 		}
  25. 		// 判断资源加载器是否为 ResourcePatternResolver 类型
  26. 		if (resourceLoader instanceof ResourcePatternResolver) {
  27. 			// Resource pattern matching available.
  28. 			try {
  29. 				// 统一加载转换为 Resource 对象
  30. 				Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
  31. 				// 通过 Resource 对象加载 BeanDefinitions
  32. 				int count = loadBeanDefinitions(resources);
  33. 				if (actualResources != null) {
  34. 					Collections.addAll(actualResources, resources);
  35. 				}
  36. 				if (logger.isTraceEnabled()) {
  37. 					logger.trace("Loaded " + count + " bean definitions from location pattern [" + location + "]");
  38. 				}
  39. 				return count;
  40. 			}
  41. 			catch (IOException ex) {
  42. 				throw new BeanDefinitionStoreException(
  43. 						"Could not resolve bean definition resource pattern [" + location + "]", ex);
  44. 			}
  45. 		}
  46. 		else {
  47.     		// 否则以绝对路径转换为 Resource 对象
  48. 			// Can only load single resources by absolute URL.
  49. 			Resource resource = resourceLoader.getResource(location);
  50. 			int count = loadBeanDefinitions(resource);
  51. 			if (actualResources != null) {
  52. 				actualResources.add(resource);
  53. 			}
  54. 			if (logger.isTraceEnabled()) {
  55. 				logger.trace("Loaded " + count + " bean definitions from location [" + location + "]");
  56. 			}
  57. 			return count;
  58. 		}
  59. 	}
  61. 	@Override
  62. 	public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {
  63. 		Assert.notNull(resources, "Resource array must not be null");
  64. 		int count = 0;
  65. 		for (Resource resource : resources) {
  66. 			count += loadBeanDefinitions(resource);
  67. 		}
  68. 		return count;
  69. 	}
  71. 	@Override
  72. 	public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {
  73. 		Assert.notNull(resources, "Resource array must not be null");
  74. 		int count = 0;
  75. 		for (Resource resource : resources) {
  76. 			// 加载
  77. 			count += loadBeanDefinitions(resource);
  78. 		}
  79. 		return count;
  80. 	}

loadBeanDefinitions(resource); 调用了 XmlBeanDefinitionReader#loadBeanDefinitions 方法

  1. 	@Override
  2. 	public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
  3. 		return loadBeanDefinitions(new EncodedResource(resource));
  4. 	}
  6. 	public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
  7. 		Assert.notNull(encodedResource, "EncodedResource must not be null");
  8. 		if (logger.isTraceEnabled()) {
  9. 			logger.trace("Loading XML bean definitions from " + encodedResource);
  10. 		}
  12. 		Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
  14. 		if (!currentResources.add(encodedResource)) {
  15. 			throw new BeanDefinitionStoreException(
  16. 					"Detected cyclic loading of " + encodedResource + " - check your import definitions!");
  17. 		}
  19. 		try (InputStream inputStream = encodedResource.getResource().getInputStream()) {
  20. 			// 把 XML 文件流封装为 InputSource 对象
  21. 			InputSource inputSource = new InputSource(inputStream);
  22. 			if (encodedResource.getEncoding() != null) {
  23. 				inputSource.setEncoding(encodedResource.getEncoding());
  24. 			}
  25. 			// 执行加载逻辑
  26. 			return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
  27. 		}
  28. 		catch (IOException ex) {
  29. 			throw new BeanDefinitionStoreException(
  30. 					"IOException parsing XML document from " + encodedResource.getResource(), ex);
  31. 		}
  32. 		finally {
  33. 			currentResources.remove(encodedResource);
  34. 			if (currentResources.isEmpty()) {
  35. 				this.resourcesCurrentlyBeingLoaded.remove();
  36. 			}
  37. 		}
  38. 	}
  40. 	protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
  41. 			throws BeanDefinitionStoreException {
  43. 		try {
  44. 			// 读取 XML 信息，将 XML 中信息保存到 Document 对象中
  45. 			Document doc = doLoadDocument(inputSource, resource);
  46. 			// 再解析 Document 对象，封装为 BeanDefinition 对象进行注册
  47. 			int count = registerBeanDefinitions(doc, resource);
  48. 			if (logger.isDebugEnabled()) {
  49. 				logger.debug("Loaded " + count + " bean definitions from " + resource);
  50. 			}
  51. 			return count;
  52. 		}
  53. 		catch (BeanDefinitionStoreException ex) {
  54. 			throw ex;
  55. 		}
  56. 		catch (SAXParseException ex) {
  57. 			throw new XmlBeanDefinitionStoreException(resource.getDescription(),
  58. 					"Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);
  59. 		}
  60. 		catch (SAXException ex) {
  61. 			throw new XmlBeanDefinitionStoreException(resource.getDescription(),
  62. 					"XML document from " + resource + " is invalid", ex);
  63. 		}
  64. 		catch (ParserConfigurationException ex) {
  65. 			throw new BeanDefinitionStoreException(resource.getDescription(),
  66. 					"Parser configuration exception parsing XML from " + resource, ex);
  67. 		}
  68. 		catch (IOException ex) {
  69. 			throw new BeanDefinitionStoreException(resource.getDescription(),
  70. 					"IOException parsing XML document from " + resource, ex);
  71. 		}
  72. 		catch (Throwable ex) {
  73. 			throw new BeanDefinitionStoreException(resource.getDescription(),
  74. 					"Unexpected exception parsing XML document from " + resource, ex);
  75. 		}
  76. 	}
  78. 	public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
  79. 		BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
  80. 		// 获取已有 BeanDefinition 的数量
  81. 		int countBefore = getRegistry().getBeanDefinitionCount();
  82. 		// 注册 BeanDefinition
  83. 		documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
  84. 		// 计算出新注册的 BeanDefinition 数量
  85. 		return getRegistry().getBeanDefinitionCount() - countBefore;
  86. 	}

documentReader.registerBeanDefinitions(doc, createReaderContext(resource)); 会进入 DefaultBeanDefinitionDocumentReader#registerBeanDefinitions

  1. 	@Override
  2. 	public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
  3. 		this.readerContext = readerContext;
  4. 		doRegisterBeanDefinitions(doc.getDocumentElement());
  5. 	}
  7. 	protected void doRegisterBeanDefinitions(Element root) {
  8. 		// Any nested <beans> elements will cause recursion in this method. In
  9. 		// order to propagate and preserve <beans> default-* attributes correctly,
  10. 		// keep track of the current (parent) delegate, which may be null. Create
  11. 		// the new (child) delegate with a reference to the parent for fallback purposes,
  12. 		// then ultimately reset this.delegate back to its original (parent) reference.
  13. 		// this behavior emulates a stack of delegates without actually necessitating one.
  14. 		BeanDefinitionParserDelegate parent = this.delegate;
  15. 		this.delegate = createDelegate(getReaderContext(), root, parent);
  17. 		if (this.delegate.isDefaultNamespace(root)) {
  18. 			String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
  19. 			if (StringUtils.hasText(profileSpec)) {
  20. 				String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
  21. 						profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
  22. 				// We cannot use Profiles.of(...) since profile expressions are not supported
  23. 				// in XML config. See SPR-12458 for details.
  24. 				if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
  25. 					if (logger.isDebugEnabled()) {
  26. 						logger.debug("Skipped XML bean definition file due to specified profiles [" + profileSpec +
  27. 								"] not matching: " + getReaderContext().getResource());
  28. 					}
  29. 					return;
  30. 				}
  31. 			}
  32. 		}
  34. 		preProcessXml(root);
  35. 		// 真正解析 XML
  36. 		parseBeanDefinitions(root, this.delegate);
  37. 		postProcessXml(root);
  39. 		this.delegate = parent;
  40. 	}
  42. 	protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
  43. 		if (delegate.isDefaultNamespace(root)) {
  44. 			NodeList nl = root.getChildNodes();
  45. 			for (int i = 0; i < nl.getLength(); i++) {
  46. 				Node node = nl.item(i);
  47. 				if (node instanceof Element) {
  48. 					Element ele = (Element) node;
  49. 					if (delegate.isDefaultNamespace(ele)) {
  50. 						// 解析默认标签元素："import", "alias", "bean"
  51. 						parseDefaultElement(ele, delegate);
  52. 					}
  53. 					else {
  54. 						// 解析自定义标签
  55. 						delegate.parseCustomElement(ele);
  56. 					}
  57. 				}
  58. 			}
  59. 		}
  60. 		else {
  61. 			// 解析自定义标签
  62. 			delegate.parseCustomElement(root);
  63. 		}
  64. 	}
  66. 	private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
  67. 		// import 标签
  68. 		if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
  69. 			importBeanDefinitionResource(ele);
  70. 		}
  71. 		// alias 标签
  72. 		else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
  73. 			processAliasRegistration(ele);
  74. 		}
  75. 		// bean 标签：着重分析
  76. 		else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
  77. 			processBeanDefinition(ele, delegate);
  78. 		}
  79. 		// 嵌套 bean 标签
  80. 		else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
  81. 			// recurse
  82. 			doRegisterBeanDefinitions(ele);
  83. 		}
  84. 	}
  86. 	protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
  87. 		// 解析 bean 标签为 BeanDefinitionHolder 里面持有 BeanDefinition
  88. 		BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
  89. 		if (bdHolder != null) {
  90. 			// 若有必要装饰 bdHolder （bean 标签内有自定义标签的情况下）
  91. 			bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
  92. 			try {
  93. 				// 完成 BeanDefinition 的注册
  94. 				// Register the final decorated instance.
  95. 				BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
  96. 			}
  97. 			catch (BeanDefinitionStoreException ex) {
  98. 				getReaderContext().error("Failed to register bean definition with name '" +
  99. 						bdHolder.getBeanName() + "'", ele, ex);
  100. 			}
  101. 			// Send registration event.
  102. 			getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
  103. 		}
  104. 	}

BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry()); 调用了 BeanDefinitionReaderUtils#registerBeanDefinition

  1. 	public static void registerBeanDefinition(
  2. 			BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
  3. 			throws BeanDefinitionStoreException {
  5.         // 注册
  6. 		// Register bean definition under primary name.
  7. 		String beanName = definitionHolder.getBeanName();
  8. 		registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
  10. 		// Register aliases for bean name, if any.
  11. 		String[] aliases = definitionHolder.getAliases();
  12. 		if (aliases != null) {
  13. 			for (String alias : aliases) {
  14. 				registry.registerAlias(beanName, alias);
  15. 			}
  16. 		}
  17. 	}

registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition()); 调用了 DefaultListableBeanFactory#registerBeanDefinition

  1. 	@Override
  2. 	public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
  3. 			throws BeanDefinitionStoreException {
  5. 		Assert.hasText(beanName, "Bean name must not be empty");
  6. 		Assert.notNull(beanDefinition, "BeanDefinition must not be null");
  8. 		if (beanDefinition instanceof AbstractBeanDefinition) {
  9. 			try {
  10. 				((AbstractBeanDefinition) beanDefinition).validate();
  11. 			}
  12. 			catch (BeanDefinitionValidationException ex) {
  13. 				throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
  14. 						"Validation of bean definition failed", ex);
  15. 			}
  16. 		}
  18. 		BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
  19. 		if (existingDefinition != null) {
  20. 			if (!isAllowBeanDefinitionOverriding()) {
  21. 				throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
  22. 			}
  23. 			else if (existingDefinition.getRole() < beanDefinition.getRole()) {
  24. 				// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
  25. 				if (logger.isInfoEnabled()) {
  26. 					logger.info("Overriding user-defined bean definition for bean '" + beanName +
  27. 							"' with a framework-generated bean definition: replacing [" +
  28. 							existingDefinition + "] with [" + beanDefinition + "]");
  29. 				}
  30. 			}
  31. 			else if (!beanDefinition.equals(existingDefinition)) {
  32. 				if (logger.isDebugEnabled()) {
  33. 					logger.debug("Overriding bean definition for bean '" + beanName +
  34. 							"' with a different definition: replacing [" + existingDefinition +
  35. 							"] with [" + beanDefinition + "]");
  36. 				}
  37. 			}
  38. 			else {
  39. 				if (logger.isTraceEnabled()) {
  40. 					logger.trace("Overriding bean definition for bean '" + beanName +
  41. 							"' with an equivalent definition: replacing [" + existingDefinition +
  42. 							"] with [" + beanDefinition + "]");
  43. 				}
  44. 			}
  45. 			this.beanDefinitionMap.put(beanName, beanDefinition);
  46. 		}
  47. 		else {
  48. 			// 注册逻辑
  49. 			if (hasBeanCreationStarted()) {
  50. 				// Cannot modify startup-time collection elements anymore (for stable iteration)
  51. 				synchronized (this.beanDefinitionMap) {
  52. 					this.beanDefinitionMap.put(beanName, beanDefinition);
  53. 					List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
  54. 					updatedDefinitions.addAll(this.beanDefinitionNames);
  55. 					updatedDefinitions.add(beanName);
  56. 					this.beanDefinitionNames = updatedDefinitions;
  57. 					removeManualSingletonName(beanName);
  58. 				}
  59. 			}
  60. 			else {
  61. 				// Still in startup registration phase
  62. 				this.beanDefinitionMap.put(beanName, beanDefinition);
  63. 				this.beanDefinitionNames.add(beanName);
  64. 				removeManualSingletonName(beanName);
  65. 			}
  66. 			this.frozenBeanDefinitionNames = null;
  67. 		}
  69. 		if (existingDefinition != null || containsSingleton(beanName)) {
  70. 			resetBeanDefinition(beanName);
  71. 		}
  72. 		else if (isConfigurationFrozen()) {
  73. 			clearByTypeCache();
  74. 		}
  75. 	}

整体调用链如下

  1. AbstractRefreshableApplicationContext#refreshBeanFactory
  2.     AbstractXmlApplicationContext#loadBeanDefinitions
  3.         AbstractBeanDefinitionReader#loadBeanDefinitions // 加载 BeanDefinition
  4.             XmlBeanDefinitionReader#loadBeanDefinitions
  5.                 XmlBeanDefinitionReader#doLoadBeanDefinitions // 读取 XML 为 Document
  6.                     XmlBeanDefinitionReader#registerBeanDefinitions // 真正开始注册
  7.                         DefaultBeanDefinitionDocumentReader#registerBeanDefinitions
  8.                             DefaultBeanDefinitionDocumentReader#doRegisterBeanDefinitions
  9.                                 DefaultBeanDefinitionDocumentReader#parseBeanDefinitions
  10.                                     DefaultBeanDefinitionDocumentReader#parseDefaultElement
  11.                                         DefaultBeanDefinitionDocumentReader#processBeanDefinition
  12.                                             BeanDefinitionReaderUtils#registerBeanDefinition
  13.                                                 DefaultListableBeanFactory#registerBeanDefinition

image

原文链接：https://www.cnblogs.com/linweiwang/p/18151805

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Spring热门文章

  • 解决springboot+activemq启动报注解错误的问题
  • Springboot整合Rabbitmq之Confirm和Return机制
  • SpringBoot SpringEL表达式的使用
  • SpringBoot自动配置原理,你真的懂吗?(简单易懂)
  • Spring源码：Bean生命周期（终章）
  • Springboot-Management的项目实践
  • 解决springboot 启动找不到主类的问题
  • Spring5路径匹配器PathPattern解析
  • SpringAOP如何获取方法参数上的注解
  • java与es8实战之五：SpringBoot应用中操作es8(带安全检查：https、账号密码、API Key)

    • Spring推荐文章

  • SpringBoot Session共享，配置不生效问题排查 → 你竟然在代码里下毒！
  • 【Spring源码分析】Spring Scope功能中的动态代理 - Scoped Proxy
  • Spring AOP概念及原理
  • SpringBoot2.7还是任性的，就是不支持Logback1.3，你能奈他何
  • SpringBoot+ Sharding Sphere 轻松实现数据库字段加解密
  • Spring MVC 中视图的实现原理，在Spring MVC 中实现重定向和转发，以及访问静态资源 - Rainbow-Sea
  • Spring MVC 中 HttpMessageConverter 转换器 - Rainbow-Sea
  • SpringBoot+mail 轻松实现各类邮件自动推送
  • Spring MVC 获取三个域(request请求域，session 会话域，application 应用域)对象的方式 - Rainbow-Sea
  • SpringBoot3整合SpringDoc实现在线接口文档

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号