SpringBoot源码学习——BeanDefinition注册以及@Configuration的解析
介绍
在理解Bean的注册以及配置类是如何解析之前，有几个贯穿容器整个IOC特性的工具类需要先了解一下
1.BeanDefinition——spring bean的建模对象
那么什么是spring bean的建模对象呢？一言概之就是把一个bean实例化出来的模型对象？有人会问把一个bean实例化出来有Class就行了啊，Class也就是我们通常说的类对象，就是一个普通对象的建模对象，那么为什么spring不能用Class来建立bean呢?很简单，因为Class无法完成bean的抽象，比如bean的作用域，bean的注入模型，bean是否是懒加载等等信息，Class是无法抽象出来的，故而需要一个BeanDefinition类来抽象这些信息，以便于spring能够完美的实例化一个bean
上述文字可以简单理解spring当中的BeanDefinition就是java当中的Class
Class可以用来描述一个类的属性和方法等等其他信息
BeanDefintion可以描述springbean当中的scope、lazy，以及属性和方法等等其他信息
2.BeanDefinitionHolder
该类本质上还是一个BeanDefinition，然而它会比我们的BeanDefinition多一个beanName和alias属性,因为一个类注册到容器中首先这个类会被解析成BeanDefinition，然后会被put到一个beanDefinitionMap中，其中的key就是beanName，也就是在容器中对这个类的唯一标识名。
注意，BeanDefinition本身并不直接携带beanName，通常它的beanName由一个内置的BeanName生成器产生，所以如果我们需要依赖于beanName操作，那么我们需要在获取BeanDefinition时将其封装成BeanDefinitionHolder对象
public class BeanDefinitionHolder implements BeanMetadataElement {
private final BeanDefinition beanDefinition;
private final String beanName;
@Nullable
private final String[] aliases;
...
}
3.BeanDefinitionReaderUtils
该类只有一个作用，那就是将一个BeanDefinitionHolder实例注册到容器中，也就是put到容器的beanDefinitionMap中
public abstract class BeanDefinitionReaderUtils {
...
public static void registerBeanDefinition(
BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
throws BeanDefinitionStoreException {
// Register bean definition under primary name.
String beanName = definitionHolder.getBeanName();
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
// Register aliases for bean name, if any.
String[] aliases = definitionHolder.getAliases();
if (aliases != null) {
for (String alias : aliases) {
registry.registerAlias(beanName, alias);
}
}
}
...
4.AnnotatedBeanDefinitionReader
根据官方文档来看，这个类属于 ClassPathBeanDefinitionScanner的替代品， ClassPathBeanDefinitionScanner可以对目标路径下所有类进行批量加载注册，而AnnotatedBeanDefinitionReader则可以对一些单独的特别的被注解的类进行加载注册（某些类是动态生成的或是第三方交互时获得的，因此在扫描期间它们并不存在，需要手动进行读取）
该类依赖于前面提到的BeanDefinitionReaderUtils，同时依赖于ConditionEvaluator，后者是一个判断目标注解类是否符合自身标注的Conditional条件来决定是否跳过该类的注册和加载
public class AnnotatedBeanDefinitionReader {
private final BeanDefinitionRegistry registry;
private BeanNameGenerator beanNameGenerator = AnnotationBeanNameGenerator.INSTANCE;
private ScopeMetadataResolver scopeMetadataResolver = new AnnotationScopeMetadataResolver();
private ConditionEvaluator conditionEvaluator;
...
private <T> void doRegisterBean(Class<T> beanClass, @Nullable String name,
@Nullable Class<? extends Annotation>[] qualifiers, @Nullable Supplier<T> supplier,
@Nullable BeanDefinitionCustomizer[] customizers) {
AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);
//判断该类是否符合注解条件
if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
return;
}
abd.setInstanceSupplier(supplier);
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
abd.setScope(scopeMetadata.getScopeName());
//生成beanName
String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
...
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
//注册bean
BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}
}
5.BeanDefinitionLoader
前面提到的类都是关于类的注册，但是在注册之前，首先需要获取到类信息。因此该类的作用就是通过不同的数据源获取BeanDefinition实例，然后交由前面的AnnotatedBeanDefinitionReader完成注册
通过下面直接管关联的成员来看，BeanDefinitionLoader可以对注解类进行读取、对xml文件进行读取，对Resouce对象进行读取，同时还能够通过ClassPathBeanDefinitionScanner进行扫描读取，然后完成注册
class BeanDefinitionLoader {
private final Object[] sources;
private final AnnotatedBeanDefinitionReader annotatedReader;
private final XmlBeanDefinitionReader xmlReader;
private BeanDefinitionReader groovyReader;
private final ClassPathBeanDefinitionScanner scanner;
private ResourceLoader resourceLoader;
...
private int load(Object source) {
Assert.notNull(source, "Source must not be null");
if (source instanceof Class<?>) {
return load((Class<?>) source);
}
if (source instanceof Resource) {
return load((Resource) source);
}
if (source instanceof Package) {
return load((Package) source);
}
if (source instanceof CharSequence) {
return load((CharSequence) source);
}
throw new IllegalArgumentException("Invalid source type " + source.getClass());
}
private int load(Class<?> source) {
if (isGroovyPresent() && GroovyBeanDefinitionSource.class.isAssignableFrom(source)) {
// Any GroovyLoaders added in beans{} DSL can contribute beans here
GroovyBeanDefinitionSource loader = BeanUtils.instantiateClass(source, GroovyBeanDefinitionSource.class);
load(loader);
}
if (isEligible(source)) {
this.annotatedReader.register(source);
return 1;
}
return 0;
}
....
}
6. ConfigurationClassParser
通过前面的几个类我们可以将配置源转化成BeanDefinition对象并完成注册，但这个时候，这些配置类中还隐藏着许多的注解类需要进行进一步的解析
ConfigurationClassParser是用来处理配置类的类，它将配置类中的各个注解成分解析出来，用一个ConfigurationClass封装，如果说BeanDefinition是对容器中的普通bean类进行的封装，那么ConfigurationClass就是专门对配置类的信息封装，通过这个类我们可以得到配置类中的所有标注了@Bean的方法集合以及其他实现了BeanDefinitionReader和ImportBeanDefinitionRegistrar等的类集合。这样我们就能够很容易的完成bean的注册
class ConfigurationClassParser {
...
protected final SourceClass doProcessConfigurationClass(
ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
throws IOException {
//处理标注了Component的类
if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
processMemberClasses(configClass, sourceClass, filter);
}
// 处理@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.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
"]. Reason: Environment must implement ConfigurableEnvironment");
}
}
//处理@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) {
// The config class is annotated with @ComponentScan -> perform the scan immediately
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();
}
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
parse(bdCand.getBeanClassName(), holder.getBeanName());
}
}
}
}
// 处理@Import注解
processImports(configClass, sourceClass, getImports(sourceClass), filter, true);
// 处理@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);
}
}
// 处理@Bean方法
Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
for (MethodMetadata methodMetadata : beanMethods) {
configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
}
// Process default methods on interfaces
processInterfaces(configClass, sourceClass);
// Process superclass, if any
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();
}
}
// No superclass -> processing is complete
return null;
}
...
}
7.ConfigurationClassBeanDefinitionReader
该类可以对解析好的ConfigurationClass对象进行处理，将其中需要注册到容器中的Bean注册到容器中
class ConfigurationClassBeanDefinitionReader {
...
private void loadBeanDefinitionsForConfigurationClass(
ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {
if (trackedConditionEvaluator.shouldSkip(configClass)) {
String beanName = configClass.getBeanName();
if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {
this.registry.removeBeanDefinition(beanName);
}
this.importRegistry.removeImportingClass(configClass.getMetadata().getClassName());
return;
}
if (configClass.isImported()) {
registerBeanDefinitionForImportedConfigurationClass(configClass);
}
for (BeanMethod beanMethod : configClass.getBeanMethods()) {
loadBeanDefinitionsForBeanMethod(beanMethod);
}
loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
}
...
}
8.ConfigurationClassPostProcessor
ConfigurationClassPostProcessor实现了BeanDefinitionRegistryPostProcessor，因此会在工厂后置处理器调用时执行，该类主要依赖于ConfigurationClassParser和ConfigurationClassBeanDefinitionReader，前者完成配置解析，后置完成Bean的注册
public class ConfigurationClassPostProcessor implements BeanDefinitionRegistryPostProcessor,
PriorityOrdered, ResourceLoaderAware, BeanClassLoaderAware, EnvironmentAware {
...
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
...
for (String beanName : candidateNames) {
...
// 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 {
parser.parse(candidates);
...
this.reader.loadBeanDefinitions(configClasses);
alreadyParsed.addAll(configClasses);
...
}
while (!candidates.isEmpty());
...
}
配置类注册解析的流程
先附带一张流程图
(1) 在实例化容器时容器同时实例化了AnnotationBeanDefinitionReader和ClassPathBeanDefinitionScanner
public class AnnotationConfigServletWebServerApplicationContext extends ServletWebServerApplicationContext{
...
public AnnotationConfigServletWebServerApplicationContext() {
this.reader = new AnnotatedBeanDefinitionReader(this);
this.scanner = new ClassPathBeanDefinitionScanner(this);
}
...
}
(2) 在构造AnnotatedBeanDefinitionReader时，该类又通过AnnotationConfigUtils向容器中注册了一个ConfigurationClassPostProcessor工厂后置处理器
public class AnnotatedBeanDefinitionReader {
...
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
...
AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}
...
}
public abstract class AnnotationConfigUtils {
...
public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
BeanDefinitionRegistry registry, @Nullable Object source) {
...
if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
}
...
}
...
}
(3)完成容器实例化后，在SpringApplication的prepareContext方法中，SpringApplication将我们在一开始传入的配置类也就是@SpringBootApplication注解类注册到容器中
public class SpringApplication {
...
private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment,
SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {
...
load(context, sources.toArray(new Object[0]));
listeners.contextLoaded(context);
}
...
}
(4)容器准备完成后，会在refresh方法中调用工厂后置处理器对容器完成初始化，其中ConfigurationClassPostProcessor在调用时，会对容器的配置类进行解析，并将解析出的Bean对象著猜测到容器中
源码在上面ConfigurationClassPostProcessor的说明中