Spring源码-Springboot加载配置类beanDefinition

系列文章目录

1、spring源码-Springboot加载配置类beanDefinition

2、spring源码-Springboot解析配置类时，解析配置类的内部类

3、spring源码-Springboot解析配置类时，解析配置类的@Import注解

4、spring源码-springboot中各种Conditional注解之ConditionalOnJava分析

5、Spring源码-springboot中注入filter

6、Spring源码-Springboot使用内置tomcat配置DispatcherServlet

7、Spring源码-Springboot不使用默认的tomcat，使用外部tomcat原理

---

---

前言

旨在梳理springboot从主入口类开始运行流程
1、解析主入口类(类上的注解)并生成beanDefinition注册到beanFactory
2、解析主入口类上的注解
3、根据主入口类@ComponentScan注解扫描定义路径下的bean并生成对应的beanDefinition注册到beanFactory，递归调用2的解析注解的方法
4、生成这些解析过的类含有@Bean注解、@Import、@ImportResource注解方法的beanDefinition注册到beanFactory
5、根据这些beanDefinition生成相应的bean实例

---

一、加载beanDefinition

1.1、加载beanDefinition时序图

1.2、加载主入口类beanDefinition

@SpringBootApplication
public class XXXApplication{
 	 public static void main(String[] args) {
        SpringApplication.run(XXXApplication.class,args);
    }
}

SpringApplication

public ConfigurableApplicationContext run(String... args) {
	    // ...
        // 1、在META-INF/spring.factories中获取配置的监听器
		SpringApplicationRunListeners listeners = getRunListeners(args);
		listeners.starting();
		try {
		    // ...
			// 2、发布ApplicationEnvironmentPreparedEvent，用于加载配置文件
			ConfigurableEnvironment environment = prepareEnvironment(listeners,
					applicationArguments);
		
			// ...
		    // 3、创建上下文AnnotationConfigServletWebServerApplicationContext实例
			context = createApplicationContext();
		     
		    // ...
		    // 4、生成XXXApplication对应的beanDefinition，并添加到beanFactory
			prepareContext(context, environment, listeners, applicationArguments,
					printedBanner);		
			// 5、调用AbstractApplicationContext的refresh()方法
			refreshContext(context);
			
			// ...
		}
		catch (Throwable ex) {
			// ...
		}
	    // ...
		return context;
	}

在第四步内解析加载主入口类beanDefinition,如下

private void prepareContext(ConfigurableApplicationContext context,
			ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
			ApplicationArguments applicationArguments, Banner printedBanner) {
		// ...
		// 获取入口类
		Set<Object> sources = getAllSources();
		Assert.notEmpty(sources, "Sources must not be empty");
        // 此处解析加载主入口类beanDefinition
		load(context, sources.toArray(new Object[0]));
		// ...
	}

protected void load(ApplicationContext context, Object[] sources) {
		//...
		BeanDefinitionLoader loader = createBeanDefinitionLoader(
				getBeanDefinitionRegistry(context), sources);
		// ...
		loader.load();
  }

最终调用BeanDefinitionLoader的如下方法，然后调用AnnotatedBeanDefinitionReader的register方法将主入口类的beanDefinition注册到beanFactory

private int load(Class<?> source) {
		// ...
		// 是否具有@Component注解，主入口类是有的
		if (isComponent(source)) {
			this.annotatedReader.register(source);
			return 1;
		}
		return 0;
	}

1.3、加载@Configuration注解类beanDefinition

因为@Configuration注解上具有@Component注解，等同于@Component，所以一同处理。

ConfigurationClassPostProcessor

public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		int factoryId = System.identityHashCode(beanFactory);
		if (this.factoriesPostProcessed.contains(factoryId)) {
			throw new IllegalStateException(
					"postProcessBeanFactory already called on this post-processor against " + beanFactory);
		}
		this.factoriesPostProcessed.add(factoryId);
		if (!this.registriesPostProcessed.contains(factoryId)) {
			// BeanDefinitionRegistryPostProcessor hook apparently not supported...
			// Simply call processConfigurationClasses lazily at this point then.
			// 这一步开始进行解析
			processConfigBeanDefinitions((BeanDefinitionRegistry) beanFactory);
		}

		enhanceConfigurationClasses(beanFactory);
		beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory));
	}

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
	    List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
		// 获取spring中所有beanName
		String[] candidateNames = registry.getBeanDefinitionNames();
	
		for (String beanName : candidateNames) {
			BeanDefinition beanDef = registry.getBeanDefinition(beanName);
			if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||
					ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {
				if (logger.isDebugEnabled()) {
					logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
				}
			}
			// 1、是否具有@Component、@ComponentScan、@Import、@ImportResource、@Bean注解
			// 刚开始只有主入口类满足条件
			else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
				configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
			}
		}

		// Return immediately if no @Configuration classes were found
		if (configCandidates.isEmpty()) {
			return;
		}
        // ...
		// Parse each @Configuration class
		ConfigurationClassParser parser = new ConfigurationClassParser(
				this.metadataReaderFactory, this.problemReporter, this.environment,
				this.resourceLoader, this.componentScanBeanNameGenerator, registry);

		Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
		Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
		do {
		    // 2、刚开始只有主入口类满足条件
		    // 开始解析具有@Component、@ComponentScan、@Import、@ImportResource、@Bean注解的beanDefinition
			parser.parse(candidates);
			parser.validate();

			Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
			configClasses.removeAll(alreadyParsed);

			// Read the model and create bean definitions based on its content
			if (this.reader == null) {
				this.reader = new ConfigurationClassBeanDefinitionReader(
						registry, this.sourceExtractor, this.resourceLoader, this.environment,
						this.importBeanNameGenerator, parser.getImportRegistry());
			}
			// 3、生成这些解析过的类含有@Bean注解、@Import、@ImportResource注解方法的beanDefinition注册到beanFactory
			// 例如:beanFactory.registerBeanDefinition("getMybatisPlusInterceptor",beanDefinition);
			// 如果@Bean内容为空，那么beanName为方法名
			this.reader.loadBeanDefinitions(configClasses);
			alreadyParsed.addAll(configClasses);
			// 在while循环中，每次解析完配置类并注册BeanDefinition到spring中时，
			// 先清空已经解析的配置类
			candidates.clear();
			// 如果spring中最新的beanDefinition数量大于之前解析的数量，那么重新从spring中获取所有
			// beanName
			if (registry.getBeanDefinitionCount() > candidateNames.length) {
				String[] newCandidateNames = registry.getBeanDefinitionNames();
				Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
				// 将已经解析过的配置类的className放到set里
				Set<String> alreadyParsedClasses = new HashSet<>();
				for (ConfigurationClass configurationClass : alreadyParsed) {
					alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
				}
				for (String candidateName : newCandidateNames) {
				    // 从spring中获取的最新的beanName不在已经解析过的配置类名里
					if (!oldCandidateNames.contains(candidateName)) {
						BeanDefinition bd = registry.getBeanDefinition(candidateName);
						// 没有被解析过的配置类放到candidates中循环重新进行解析
						if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
								!alreadyParsedClasses.contains(bd.getBeanClassName())) {
							candidates.add(new BeanDefinitionHolder(bd, candidateName));
						}
					}
				}
				candidateNames = newCandidateNames;
			}
		}
		while (!candidates.isEmpty());
      // ...
	}

ConfigurationClassParser

public void parse(Set<BeanDefinitionHolder> configCandidates) {
		for (BeanDefinitionHolder holder : configCandidates) {
			BeanDefinition bd = holder.getBeanDefinition();
			try {
				if (bd instanceof AnnotatedBeanDefinition) {
					parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
				}
				else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
					parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
				}
				else {
					parse(bd.getBeanClassName(), holder.getBeanName());
				}
			}
			catch (BeanDefinitionStoreException ex) {
				throw ex;
			}
			catch (Throwable ex) {
				throw new BeanDefinitionStoreException(
						"Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
			}
		}

		this.deferredImportSelectorHandler.process();
	}




protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {
		processConfigurationClass(new ConfigurationClass(metadata, beanName), DEFAULT_EXCLUSION_FILTER);
	}

protected void processConfigurationClass(ConfigurationClass configClass, Predicate<String> filter) throws IOException {
        // 获取当前被解析配置类的所有Conditional注解的value属性集合，
        // 如果有一个condition不匹配就不解析当前配置类
		if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
			return;
		}

		ConfigurationClass existingClass = this.configurationClasses.get(configClass);
		if (existingClass != null) {
			if (configClass.isImported()) {
				if (existingClass.isImported()) {
					existingClass.mergeImportedBy(configClass);
				}
				// Otherwise ignore new imported config class; existing non-imported class overrides it.
				return;
			}
			else {
				// Explicit bean definition found, probably replacing an import.
				// Let's remove the old one and go with the new one.
				this.configurationClasses.remove(configClass);
				this.knownSuperclasses.values().removeIf(configClass::equals);
			}
		}

		// Recursively process the configuration class and its superclass hierarchy.
		SourceClass sourceClass = asSourceClass(configClass, filter);
		do {
			sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);
		}
		while (sourceClass != null);
		
		this.configurationClasses.put(configClass, configClass);
	}

protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
			throws IOException {
        if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
			// 解析内部类，递归调用processConfigurationClass解析每一个内部类
			processMemberClasses(configClass, sourceClass, filter);
		}
		// ...
		// 1、处理 @PropertySource  注解
		for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
				sourceClass.getMetadata(), PropertySources.class,
				org.springframework.context.annotation.PropertySource.class)) {
			if (this.environment instanceof ConfigurableEnvironment) {
				processPropertySource(propertySource);
			}
			else {
				logger.warn("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
						"]. Reason: Environment must implement ConfigurableEnvironment");
			}
		}

		// 2、处理 @ComponentScan 注解
		Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
				sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
		if (!componentScans.isEmpty() &&
				!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
			for (AnnotationAttributes componentScan : componentScans) {
				// 3、根据componentScan 的basePackages扫描路径下的bean,如果没有配置则为入口类所在包路径，并生成对应的beanDefinition注册到beanFactory
				Set<BeanDefinitionHolder> scannedBeanDefinitions =
						this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
				// Check the set of scanned definitions for any further config classes and parse recursively if needed
				for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
					BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
					if (bdCand == null) {
						bdCand = holder.getBeanDefinition();
					}
					// 4、是否具有@Component、@ComponentScan、@Import、@ImportResource、@Bean注解，有则递归执行解析注解方法
					if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
						parse(bdCand.getBeanClassName(), holder.getBeanName());
					}
				}
			}
		}

		// 5、处理 @Import 注解
		// getImports方法获取当前配置类的所有@Import注解的value属性值
		// (也就是我们@Import引入的类)Set集合
		processImports(configClass, sourceClass, getImports(sourceClass), true);

		// 6、处理 @ImportResource 注解
		AnnotationAttributes importResource =
				AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
		if (importResource != null) {
			String[] resources = importResource.getStringArray("locations");
			Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
			for (String resource : resources) {
				String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
				configClass.addImportedResource(resolvedResource, readerClass);
			}
		}

		// 7、处理 @Bean 注解
		Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
		for (MethodMetadata methodMetadata : beanMethods) {
			configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
		}

		// 8、处理实现的接口中的@Bean修饰的方法
		processInterfaces(configClass, sourceClass);

		// 9、如果有父类继续解析父类上面的注解
		if (sourceClass.getMetadata().hasSuperClass()) {
			String superclass = sourceClass.getMetadata().getSuperClassName();
			if (superclass != null && !superclass.startsWith("java") &&
					!this.knownSuperclasses.containsKey(superclass)) {
				this.knownSuperclasses.put(superclass, configClass);
				// Superclass found, return its annotation metadata and recurse
				return sourceClass.getSuperClass();
			}
		}

		// 10、没有父类则当前配置类解析完毕
		return null;
	}

总结

在实例化AnnotationConfigServletWebServerApplicationContext后，调用其抽象父类AbstractApplicationContext的refresh方法，其中invokeBeanFactoryPostProcessors开始调用工厂后置处理器类的方法，即开始执行上面的1.3