devbox
小小林熬夜学编程
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

spring源码分析系列-spring启动流程(包含bean的生命周期)上_startupstep beancreation

作者：小小林熬夜学编程 | 2024-05-22 18:03:00

赞

踩

startupstep beancreation

目录

1. 基本环境：

2. 进入源码

2.1 分析this()方法

2. register方法

        真是万事开头难，一点不假。计划着写一个spring源码分析的系列文章，但是每每提笔又不知道该用什么样的开场白比较合适，很是无奈。实话讲，阅读源码的过程很漫长甚至有点痛苦，但是每次学到些什么又会有莫名的满足，从这篇文章开始，我们一点点一步步来揭开spring源码的神秘面纱，我们切勿急躁，怀着一颗虔诚的心踏踏实实的学，就像是流水不争先只争个滔滔不绝。

        闲言少叙，言归正传。spring启动流程我准备分为上中下三篇，本篇重点内容包括配置类转beanDefinition并注册到spring容器的过程，ConfigurationClassPostProcessor这个最重要的后置处理器的注册过程。注意哦，本篇内容只会介绍它的注册过程具体解析过程在下一篇。

1. 基本环境：

(1) 通过包扫描交给spring托管的IndexDao类：

  1. @Component
  2. public class IndexDao {
  3. 	public void query(){
  4. 		System.out.println("indexDao query...");
  5. 	}
  6. }

(2) 通过@Import交给spring托管的IndexDao2类： 

  1. public class IndexDao2 {
  2. 	public void query(){
  3. 		System.out.println("indexDao2 query...");
  4. 	}
  5. }

(3) 核心配置类IocConfig：

  1. @Configuration
  2. @ComponentScan("com.zlb.ioc")
  3. @Import(MySelector.class)
  4. public class IocConfig {
  5.  
  6. }

(4) MySelector类,重写方法返回的正式IndexDao2的全限定名：

  1. public class MySelector implements ImportSelector {
  2. 	@Override
  3. 	public String[] selectImports(AnnotationMetadata importingClassMetadata) {
  4. 		return new String[]{IndexDao2.class.getName()};
  5. 	}
  6. }

(5) 最后，主测试类：

  1. public class Demo {
  2. 	public static void main(String[] args) {
  3. 		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(IocConfig.class);
  4. 		IndexDao dao = context.getBean(IndexDao.class);
  5. 		IndexDao2 dao2 = context.getBean(IndexDao2.class);
  6. 		dao.query();
  7. 		dao2.query();
  8. 	}
  9. }

2. 进入源码

进入到创建上下文对象的构造方法中：

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(IocConfig.class);
  1. public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
  2. 		this();
  3. 		register(componentClasses);
  4. 		refresh();
  5. }

2.1 分析this()方法

这里我们要注意一下，在执行this方法之前java会首先执行父类的无参构造，就是

GenericApplicationContext的GenericApplicationContext()方法：
  1. public GenericApplicationContext() {
  2. 		this.beanFactory = new DefaultListableBeanFactory();
  3. }

注：我们常说的bean工厂正是上边这个货DefaultListableBeanFactory，它也是我们spring上下文对象的一个属性。

接下来我们再进入到this方法：

  1. public AnnotationConfigApplicationContext() {
  2. 		StartupStep createAnnotatedBeanDefReader = this.getApplicationStartup().start("spring.context.annotated-bean-reader.create");
  3. 		//这个构造函数主要做了两件事
  4. 		//  1.AnnotatedBeanDefinitionReader的registry赋值
  5. 		//  2.向beanFactory中注册ConfigurationClassPostProcessor
  6.         // 进到这行
  7. 		this.reader = new AnnotatedBeanDefinitionReader(this);
  8. 		createAnnotatedBeanDefReader.end();
  9. 		this.scanner = new ClassPathBeanDefinitionScanner(this);
  10. }
  1. public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
  2. 	//进到这行	
  3.     this(registry, getOrCreateEnvironment(registry));
  4. }
  1. public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
  2. 		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
  3. 		Assert.notNull(environment, "Environment must not be null");
  4. 		//给registry属性赋值 后边注册自定义Config类的时候会用到
  5. 		this.registry = registry;
  6. 		this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
  7. 		//向beanFactory中注册ConfigurationClassPostProcessor 进入这个方法
  8. 		AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
  9. }
  1. public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {
  2. 	//进到这个方法	
  3.     registerAnnotationConfigProcessors(registry, null);
  4. }
  1. public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
  2. 			BeanDefinitionRegistry registry, @Nullable Object source) {
  3.  
  4. 		//从registry(上下文)中获取beanFactory
  5. 		DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
  6. 		//给beanFactory设置两个属性 暂时不用管
  7. 		if (beanFactory != null) {
  8. 			if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
  9. 				beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
  10. 			}
  11. 			if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
  12. 				beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
  13. 			}
  14. 		}
  15.  
  16. 		Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
  17.  
  18. 		//向beanFactory中注册ConfigurationClassPostProcessor
  19. 		//这个if块最重要其他不用管
  20. 		if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
  21. 			//将ConfigurationClassPostProcessor转换成beanDefinition
  22. 			RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
  23. 			def.setSource(source);
  24. 			//registerPostProcessor()这个方法中注册ConfigurationClassPostProcessor
  25. 			//进到registerPostProcessor这个方法
  26. 			beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
  27. 		}
  28.  
  29. 		if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
  30. 			RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
  31. 			def.setSource(source);
  32. 			beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
  33. 		}
  34.  
  35. 		// Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
  36. 		if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
  37. 			RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
  38. 			def.setSource(source);
  39. 			beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
  40. 		}
  41.  
  42. 		// Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
  43. 		if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
  44. 			RootBeanDefinition def = new RootBeanDefinition();
  45. 			try {
  46. 				def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
  47. 						AnnotationConfigUtils.class.getClassLoader()));
  48. 			}
  49. 			catch (ClassNotFoundException ex) {
  50. 				throw new IllegalStateException(
  51. 						"Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
  52. 			}
  53. 			def.setSource(source);
  54. 			beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
  55. 		}
  56.  
  57. 		if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
  58. 			RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
  59. 			def.setSource(source);
  60. 			beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
  61. 		}
  62.  
  63. 		if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
  64. 			RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
  65. 			def.setSource(source);
  66. 			beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
  67. 		}
  68.  
  69. 		return beanDefs;
  70. 	}
  1. private static BeanDefinitionHolder registerPostProcessor(
  2. 			BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName) {
  3.  
  4. 		definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
  5. 		// 这个方法就是在注册了  
  6. 		// registry就是我们的bean工厂DefaultListableBeanFactory
  7. 		// beanName就是org.springframework.context.annotation.internalConfigurationAnnotationProcessor
  8. 		// definition就是根据ConfigurationClassPostProcessor转换来的beanDefinition
  9. 		// 那到底注册是干啥呢 我们继续
  10. 		registry.registerBeanDefinition(beanName, definition);
  11. 		return new BeanDefinitionHolder(definition, beanName);
  12. }

注：注意哦，registry默认实现是DefaultListableBeanFactory，我们要进入到这个实现类的registerBeanDefinition()方法。

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

那么行棋至此，this方法的主要逻辑我们已经看完了，小小总结一下this()方法究竟干了些啥呢？其实非常简单就干了两件事：

        1. new了一个bean工厂的默认实现DefaultListableBeanFactory并赋值给了spring上下文的成员变量。

        2. new了一个AnnotatedBeanDefinitionReader对象也赋值给了spring上下文的成员变量。但是这个不太重要。

        3. 在new AnnotatedBeanDefinitionReader对象过程中向bean工厂中注册了一个特别重要的类ConfigurationClassPostProcessor，这个类极其极其重要！具体作用我们后面会说到，先请大家牢记此类。

2. register方法

接下来我们分析register()方法。这个方法很简单只做了一件事，那就是把我们的配置类注册给spring。

  1. public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
  2. 		this();
  3.         //进到这个方法
  4. 		register(componentClasses);
  5. 		refresh();
  6. }
  1. @Override
  2. 	public void register(Class<?>... componentClasses) {
  3. 		Assert.notEmpty(componentClasses, "At least one component class must be specified");
  4. 		StartupStep registerComponentClass = this.getApplicationStartup().start("spring.context.component-classes.register")
  5. 				.tag("classes", () -> Arrays.toString(componentClasses));
  6. 		//参数componentClasses其实就是我们的配置类
  7. 		//进到这行
  8. 		this.reader.register(componentClasses);
  9. 		registerComponentClass.end();
  10. }
  1. public void register(Class<?>... componentClasses) {
  2. 		for (Class<?> componentClass : componentClasses) {
  3. 			//配置类可以传多个 但是我们只有一个 go on
  4. 			registerBean(componentClass);
  5. 		}
  6. }
  1. public void registerBean(Class<?> beanClass) {
  2. 		//继续
  3. 		doRegisterBean(beanClass, null, null, null, null);
  4. 	}
  1. private <T> void doRegisterBean(Class<T> beanClass, @Nullable String name,
  2. 			@Nullable Class<? extends Annotation>[] qualifiers, @Nullable Supplier<T> supplier,
  3. 			@Nullable BeanDefinitionCustomizer[] customizers) {
  4. 		//把我们的配置类转成beanDefinition
  5. 		AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);
  6. 		if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
  7. 			return;
  8. 		}
  9.  
  10. 		abd.setInstanceSupplier(supplier);
  11. 		ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
  12. 		abd.setScope(scopeMetadata.getScopeName());
  13. 		String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
  14.  
  15. 		AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
  16. 		if (qualifiers != null) {
  17. 			for (Class<? extends Annotation> qualifier : qualifiers) {
  18. 				if (Primary.class == qualifier) {
  19. 					abd.setPrimary(true);
  20. 				}
  21. 				else if (Lazy.class == qualifier) {
  22. 					abd.setLazyInit(true);
  23. 				}
  24. 				else {
  25. 					abd.addQualifier(new AutowireCandidateQualifier(qualifier));
  26. 				}
  27. 			}
  28. 		}
  29. 		if (customizers != null) {
  30. 			for (BeanDefinitionCustomizer customizer : customizers) {
  31. 				customizer.customize(abd);
  32. 			}
  33. 		}
  34. 		//对beanDefinition和beanName再做一次封装 包装成一个holder
  35. 		BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
  36. 		definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
  37. 		//注册beanDefinition正是在这儿完成的 进去这行代码
  38. 		BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
  39. 	}
  1. public static void registerBeanDefinition(
  2. 			BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
  3. 			throws BeanDefinitionStoreException {
  4.  
  5. 		// Register bean definition under primary name.
  6. 		String beanName = definitionHolder.getBeanName();
  7. 		//注册beanDefinition在这儿
  8. 		//registry默认实现是DefaultListableBeanFactory
  9. 		registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
  10.  
  11. 		// Register aliases for bean name, if any.
  12. 		String[] aliases = definitionHolder.getAliases();
  13. 		if (aliases != null) {
  14. 			for (String alias : aliases) {
  15. 				registry.registerAlias(beanName, alias);
  16. 			}
  17. 		}
  18. 	}
  1. @Override
  2. 	public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
  3. 			throws BeanDefinitionStoreException {
  4.  
  5. 		Assert.hasText(beanName, "Bean name must not be empty");
  6. 		Assert.notNull(beanDefinition, "BeanDefinition must not be null");
  7.  
  8. 		//校验 不用管
  9. 		if (beanDefinition instanceof AbstractBeanDefinition) {
  10. 			try {
  11. 				((AbstractBeanDefinition) beanDefinition).validate();
  12. 			}
  13. 			catch (BeanDefinitionValidationException ex) {
  14. 				throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
  15. 						"Validation of bean definition failed", ex);
  16. 			}
  17. 		}
  18.  
  19. 		BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
  20. 		//existingDefinition = null  不会进这个if
  21. 		if (existingDefinition != null) {
  22. 			if (!isAllowBeanDefinitionOverriding()) {
  23. 				throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
  24. 			}
  25. 			else if (existingDefinition.getRole() < beanDefinition.getRole()) {
  26. 				// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
  27. 				if (logger.isInfoEnabled()) {
  28. 					logger.info("Overriding user-defined bean definition for bean '" + beanName +
  29. 							"' with a framework-generated bean definition: replacing [" +
  30. 							existingDefinition + "] with [" + beanDefinition + "]");
  31. 				}
  32. 			}
  33. 			else if (!beanDefinition.equals(existingDefinition)) {
  34. 				if (logger.isDebugEnabled()) {
  35. 					logger.debug("Overriding bean definition for bean '" + beanName +
  36. 							"' with a different definition: replacing [" + existingDefinition +
  37. 							"] with [" + beanDefinition + "]");
  38. 				}
  39. 			}
  40. 			else {
  41. 				if (logger.isTraceEnabled()) {
  42. 					logger.trace("Overriding bean definition for bean '" + beanName +
  43. 							"' with an equivalent definition: replacing [" + existingDefinition +
  44. 							"] with [" + beanDefinition + "]");
  45. 				}
  46. 			}
  47. 			this.beanDefinitionMap.put(beanName, beanDefinition);
  48. 		}
  49. 		else {
  50. 			//不会进这个if
  51. 			if (hasBeanCreationStarted()) {
  52. 				// Cannot modify startup-time collection elements anymore (for stable iteration)
  53. 				synchronized (this.beanDefinitionMap) {
  54. 					this.beanDefinitionMap.put(beanName, beanDefinition);
  55. 					List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
  56. 					updatedDefinitions.addAll(this.beanDefinitionNames);
  57. 					updatedDefinitions.add(beanName);
  58. 					this.beanDefinitionNames = updatedDefinitions;
  59. 					removeManualSingletonName(beanName);
  60. 				}
  61. 			}
  62. 			else {
  63. 				// Still in startup registration phase
  64. 				//核心部分：注册beanDefinition
  65. 				//其实就是向bean工厂的beanDefinitionMap中put个beanDefinition
  66. 				//还有就是向bean工厂的beanDefinitionNames集合中添加一个名字而已
  67. 				this.beanDefinitionMap.put(beanName, beanDefinition);
  68. 				this.beanDefinitionNames.add(beanName);
  69. 				removeManualSingletonName(beanName);
  70. 			}
  71. 			this.frozenBeanDefinitionNames = null;
  72. 		}
  73.  
  74. 		if (existingDefinition != null || containsSingleton(beanName)) {
  75. 			resetBeanDefinition(beanName);
  76. 		}
  77. 		else if (isConfigurationFrozen()) {
  78. 			clearByTypeCache();
  79. 		}
  80. 	}

截止到这里，我们已经把配置类转换成了beanDefinition并且注册给了spring容器。再强调一次，所谓注册通俗点说就是把我们的类转换成beanDefinition然后放到beanFactory的集合里边，也就是这个：

this.beanDefinitionMap.put(beanName, beanDefinition);
this.beanDefinitionNames.add(beanName);

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小小林熬夜学编程/article/detail/609329
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号