经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » Java相关 » Spring » 查看文章
Java Springboot自动装配原理详解
来源：jb51　　时间：2021/10/8 17:42:36　　对本文有异议

Debug路线图

说多都是泪，大家看图。

在这里插入图片描述

让我们从run说起

用了这么多年的的Springboot，这个 run() 方法到底做了些什么事呢？

  1. @SpringBootApplication
  2. public class SpringbootDemoApplication {
  3.     public static void main(String[] args) {
  4.         SpringApplication.run(SpringbootDemoApplication.class, args);
  5.     }
  6. }

归属

run() 方法归属于 SpringApplication.class 对象，所以在调用run() 方法前，需要先实例化 SpringApplication.class 对象：

  1. 	public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
  2. 		return new SpringApplication(primarySources).run(args);
  3. 	}

SpringApplication.class 对象实例化时，都做了些什么事呢？

这里主要看需要注意两个方法：①getSpringFactoriesInstances() 和 ②deduceMainApplicationClass()

  1. /**
  2.  * 实例化时，实际调用的构造方法
  3.  */
  4. public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
  5. 		this.resourceLoader = resourceLoader;
  6. 		Assert.notNull(primarySources, "PrimarySources must not be null");
  7. 		this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
  8. 		// 这里将spring.
  9. 		this.webApplicationType = WebApplicationType.deduceFromClasspath();
  10. 		this.bootstrapRegistryInitializers = getBootstrapRegistryInitializersFromSpringFactories();
  11. 		// 设置初始化器
  12. 		setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
  13. 		// 设置监听器
  14. 		setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
  15. 		this.mainApplicationClass = deduceMainApplicationClass();
  16. 	}

①getSpringFactoriesInstances()方法主要加载整个应用程序中的 spring.factories 文件，将文件的内容放到缓存对象中，方便后续获取使用。

  1. private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
  2. 		// 初次加载，cache中获取不到数据，所以为null
  3. 		Map<String, List<String>> result = cache.get(classLoader);
  4. 		if (result != null) {
  5. 			return result;
  6. 		}
  7. 		result = new HashMap<>();
  8. 		try {
  9. 			// FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories"，这个配置类眼熟吧
  10. 			// 加载配置类
  11. 			Enumeration<URL> urls = classLoader.getResources(FACTORIES_RESOURCE_LOCATION);
  12. 			while (urls.hasMoreElements()) {
  13. 				URL url = urls.nextElement();
  14. 				UrlResource resource = new UrlResource(url);
  15. 				// 这里加载资源
  16. 				Properties properties = PropertiesLoaderUtils.loadProperties(resource);
  17. 				for (Map.Entry<?, ?> entry : properties.entrySet()) {
  18. 					String factoryTypeName = ((String) entry.getKey()).trim();
  19. 					String[] factoryImplementationNames =
  20. 							StringUtils.commaDelimitedListToStringArray((String) entry.getValue());
  21. 					for (String factoryImplementationName : factoryImplementationNames) {
  22. 						result.computeIfAbsent(factoryTypeName, key -> new ArrayList<>())
  23. 								.add(factoryImplementationName.trim());
  24. 					}
  25. 				}
  26. 			}
  27. 			// Replace all lists with unmodifiable lists containing unique elements
  28. 			result.replaceAll((factoryType, implementations) -> implementations.stream().distinct()
  29. 					.collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList)));
  30. 			// 这里将获取到资源放入cache中
  31. 			cache.put(classLoader, result);
  32. 		}
  33. 		catch (IOException ex) {
  34. 			throw new IllegalArgumentException("Unable to load factories from location [" +
  35. 					FACTORIES_RESOURCE_LOCATION + "]", ex);
  36. 		}
  37. 		return result;
  38. 	}

②deduceMainApplicationClass() 方法返回了启动类的类信息：

在这里插入图片描述

小结

实例化SpringApplication.class 对象完成了两件事：

1.加载整个应用程序中的 spring.factories 文件，将文件的内容放到缓存对象中，方便后续获取使用。

2.返回了启动类的类信息。

run

有了SpringApplication.class 对象实例对象，接下来就可以调用run() 方法。

在run() 方法中，我们主要关注两个方法prepareContext() 和 refreshContext()

  1. public ConfigurableApplicationContext run(String... args) {
  2. // 省略部分代码
  3. 	try {
  4. 		prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
  5. 		refreshContext(context);
  6. 	}
  7. // 省略部分代码

prepareContext()方法准备上下文环境，通过调用load()方法加载启动类，为获取启动类上的注解做准备；

  1. private void load(Class<?> source) {
  2. 		if (isGroovyPresent() && GroovyBeanDefinitionSource.class.isAssignableFrom(source)) {
  3. 			// Any GroovyLoaders added in beans{} DSL can contribute beans here
  4. 			GroovyBeanDefinitionSource loader = BeanUtils.instantiateClass(source, GroovyBeanDefinitionSource.class);
  5. 			((GroovyBeanDefinitionReader) this.groovyReader).beans(loader.getBeans());
  6. 		}
  7. 		// 这里会判断启动类不是一个groovy闭包也不是一个匿名类
  8. 		if (isEligible(source)) {
  9. 			// 注册读取启动类的注解信息
  10. 			// 注意，这里将启动类型注册为AnnotatedBeanDefinition类型，后面parse()解析时会用到。
  11. 			this.annotatedReader.register(source);
  12. 		}
  13. 	}

refreshContext() 方法最终调用了AbstractApplicationContext.class 类的 refresh()，这里相信看过spring源码的小伙伴都很熟悉 refresh() 这个方法。

自动装配操作的主战场主要是在 ①invokeBeanFactoryPostProcessors() 方法，①调用了②invokeBeanDefinitionRegistryPostProcessors() 方法，②调用了ConfigurationClassPostProcessor.class 的③postProcessBeanDefinitionRegistry()方法，③调用了 ④processConfigBeanDefinitions() 方法；

④ processConfigBeanDefinitions() 方法中：

  1. public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
  2. 		List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
  3. 		String[] candidateNames = registry.getBeanDefinitionNames();
  4. 		// 这里会循环匹配到启动类，并且添加到上面的configCandidates集合中。
  5. 		for (String beanName : candidateNames) {
  6. 			BeanDefinition beanDef = registry.getBeanDefinition(beanName);
  7. 			if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
  8. 				if (logger.isDebugEnabled()) {
  9. 					logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
  10. 				}
  11. 			}
  12. 			else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
  13. 				configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
  14. 			}
  15. 		}
  16. 		
  17. 		// ...
  18. 		
  19. 		// 解析每一个标注了@Configuration注解的类，启动类上的@SpringBootApplication就包含了@Configuration注解
  20. 		ConfigurationClassParser parser = new ConfigurationClassParser(
  21. 				this.metadataReaderFactory, this.problemReporter, this.environment,
  22. 				this.resourceLoader, this.componentScanBeanNameGenerator, registry);
  23. 				Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
  24. 		Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
  25. 		do {
  26. 			StartupStep processConfig = this.applicationStartup.start("spring.context.config-classes.parse");
  27. 			// 开始解析
  28. 			parser.parse(candidates);
  29. 			parser.validate();
  30. 	}
  31. 		// ============ 分割线 =================
  32. /**
  33.  * 为了方便阅读，这里将parse()方法接入
  34.  */
  35. public void parse(Set<BeanDefinitionHolder> configCandidates) {
  36. 		for (BeanDefinitionHolder holder : configCandidates) {
  37. 			BeanDefinition bd = holder.getBeanDefinition();
  38. 			try {
  39. 				// 在前面prepareContext()方法中的load()方法中已经说过，所以这会进入这个判断解析
  40. 				if (bd instanceof AnnotatedBeanDefinition) {
  41. 					parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
  42. 				}	
  43. 		// ...
  44. 		}
  45. 		// 注意！！这里，parse()解析完成后，会回到这里执行process()方法；
  46. 		this.deferredImportSelectorHandler.process();
  47. 	}

进入判断后parse()方法会接着调用 ①processConfigurationClass()方法，①调用②doProcessConfigurationClass()方法；

②doProcessConfigurationClass()中又开始对注解进行进一步的解析，包括@PropertySource、@ComponentScan、@Import（咱们看这个）、@ImportResource、@Bean，解析之前，会通过getImports()方法调用collectImports()方法，统计出被@Import标注的类型信息；

  1. 	protected final SourceClass doProcessConfigurationClass(
  2. 			ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
  3. 			throws IOException {
  4. 		// ...
  5. 		// Process any @Import annotations
  6. 		processImports(configClass, sourceClass, getImports(sourceClass), filter, true);
  7. 		// ...
  8. // ============ 分割线 =================
  9. private Set<SourceClass> getImports(SourceClass sourceClass) throws IOException {
  10. 		Set<SourceClass> imports = new LinkedHashSet<>();
  11. 		Set<SourceClass> visited = new LinkedHashSet<>();
  12. 		collectImports(sourceClass, imports, visited);
  13. 		return imports;
  14. 	}
  15. private void collectImports(SourceClass sourceClass, Set<SourceClass> imports, Set<SourceClass> visited)
  16. 			throws IOException {
  17.  
  18. 		if (visited.add(sourceClass)) {
  19. 			for (SourceClass annotation : sourceClass.getAnnotations()) {
  20. 				String annName = annotation.getMetadata().getClassName();
  21. 				if (!annName.equals(Import.class.getName())) {
  22. 					// 注意看这里，自调用递归查询
  23. 					collectImports(annotation, imports, visited);
  24. 				}
  25. 			}
  26. 			imports.addAll(sourceClass.getAnnotationAttributes(Import.class.getName(), "value"));
  27. 		}
  28. 	}
  29. }

getImports() 方法查询结果展示：

在这里插入图片描述

当parse()方法解析完成 @Import 注解后（这里忘记的小伙伴，可看看上面的parse()方法，我有代码注释），接着开始调用①process()方法，①中调用②processGroupImports()方法，②中接着调用 ③grouping.getImports()方法，③调用DeferredImportSelector.Group 接口的 ④process()方法，这里我们看它的实现类 AutoConfigurationImportSelector.class 实现的 ④process()方法（这里需要留意一下，一会还会回来用到），④调用了 ⑤getAutoConfigurationEntry()，⑤中调用了⑥getCandidateConfigurations() 方法；

重点来了：经过上面的一系列方法调用，终于来到这个方法，相信大家在许多博客里都又看到过 ⑥getCandidateConfigurations() 这个方法，但又没有说清楚具体是怎么调用到这个方法的，只是说了这个类会得到待配置的class的类名集合等等；

在⑥这个方法中，显示通过 ⑦getSpringFactoriesLoaderFactoryClass() 这个方法返回了一个EnableAutoConfiguration.class 注解对象，然后又通过调用 ⑧loadFactoryNames()，⑧又调用了 ⑨loadSpringFactories()；

⑧⑨方法看着是不是比较眼熟？ 是的，我们在初始化SpringApplication对象时，曾调用过这两个方法，在调用⑨时，将 spring.factories 文件的内容放到cache缓存对象中。

  1. @Override
  2. protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
  3. 		// getSpringFactoriesLoaderFactoryClass()这个方法返回了一个EnableAutoConfiguration.class注解对象
  4. 		List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
  5. 				getBeanClassLoader());
  6. 		Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you "
  7. 				+ "are using a custom packaging, make sure that file is correct.");
  8. 		return configurations;
  9. }
  10.  
  11. protected Class<?> getSpringFactoriesLoaderFactoryClass() {
  12. 		return EnableAutoConfiguration.class;
  13. }
  14. // ===========================分割线===========================
  15. private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
  16. 		Map<String, List<String>> result = cache.get(classLoader);
  17. 		if (result != null) {
  18. 			return result;
  19. 		}
  20. 	// ...

此时的cache对象中存在EnableAutoConfiguration对象，size=131个：

在这里插入图片描述

这131个就是 spring.factories 文件中的自动装配配置项：

在这里插入图片描述

当然，这里面有许多我们没有用到类信息也被装配了进来，这里不要着急接着往下看，装配完成后回到了⑤getAutoConfigurationEntry()方法中，且返回了一个List< String>的一个配置类信息集合，接着又做了些什么事？

在这里插入图片描述

从上图可以看出，131个配置信息，经过过滤移除后，最终变成13个需要使用的，拿到最终配置信息，（愣着干嘛，赶紧撒花呀！），到这里自动装配过程基本上就结束了。

这里的结束是指自动装配过程结束，也就是我们 refresh()中的invokeBeanFactoryPostProcessors() 方法执行结束，当然这个方法还做很多别的事，但是本文只关注自动装配相关，完成此方法后并不表示类就已经实例化完成，这里只是将类信息装配到了spring容器中，后续会有别的方法完成类的实例化。（实例化看它：finishBeanFactoryInitialization()）

在这里插入图片描述

再说说注解

@SpringBootApplication 是的没错，这个注解大家都熟悉，springboot 项目启动类上都有：

在这里插入图片描述

@SpringBootApplication 中包含了两个注解：

  • @EnableAutoConfiguration（重点）：启用 SpringBoot 的自动配置机制；
  • @ComponentScan： 扫描被@Component (@Service,@Controller)注解的 bean，注解默认会扫描该类所在的包下所有的类；
  • @SpringBootConfiguration：允许在上下文中注册额外的 bean 或导入其他配置类；

三个注解中，自动装配的核心 @EnableAutoConfiguration 就是这个注解：

在这里插入图片描述

@EnableAutoConfiguration 注解通过 Spring 提供的 @Import 注解导入了 AutoConfigurationImportSelector.class类（@Import 注解可以导入配置类或者 Bean 到当前类中），这个类的作用在上也说过（获取spring.factories文件中待配置的class的类名集合）。

总结

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注w3xue的更多内容！

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

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号