Spring Boot 原理解析—启动类包扫描原理

为了何更好的理解该篇内容，请先阅读Spring Boot 原理解析—入口SpringApplication。

我们知道在使用Spring Boot时，Spring会自动加载Spring Boot中启动类包下以及其子包下的带注解的类，本篇不会讲述是如何加载注解类的，因为这是属于Spring的内容，我们只讲述为什么会根据启动类加载子包下的带注解的类。在讲解Spring Boot源码之前我们先看一下Spring中包的扫描方式一种是@ComponentScan("cn.org.microservice.spring.ioc.annotation")注解，另一种则是以XML的方式配置：

<context:component-scan base-package="cn.org.microservice.spring.ioc.annotation"/>

如果我们不使用XMl而使用@ComponentScan，但是在注解中不配置然任何包,也就是说直接在@Configuration注解的泪伤注解@ComponentScan，代码如下所示：

package cn.org.microservice.spring.ioc.annotation;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@Configuration
@ComponentScan
public class ConfigrationBean {
}

然后在其子包下创建几个Bean，如下所示，我们在其子包下创建了三个Bean类，为了方便我们只创建类，没有创建接口。

package cn.org.microservice.spring.ioc.annotation.bean.service;
import org.springframework.stereotype.Service;
@Service
public class ServiceBean {
}
package cn.org.microservice.spring.ioc.annotation.bean;
import org.springframework.stereotype.Component;
@Component
public class BeanA {
}
package cn.org.microservice.spring.ioc.annotation.bean1;
import org.springframework.stereotype.Component;
@Component
public class Bean2 {
}

然后我们使用测试类测试，然后输出容器中注册的Bean的名称。

public class AnnotationTest {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(ConfigrationBean.class);
	for(String beanName : applicationContext.getBeanDefinitionNames()) {
	System.out.println(beanName);
	}
    }
}
//一下为输出内容
org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalRequiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
configrationBean
beanA
serviceBean
bean2

通过输出我们看到容器中居然注册其子包下的注解类，但是实际上上我们并没有告诉容器去注册cn.org.microservice.spring.ioc.annotation子包，但是Spring还是扫描了cn.org.microservice.spring.ioc.annotation子包。SpringBoot用的就是这个原理。通过Spring Boot 原理解析—入口SpringApplication一篇我们知道Spring Boot启动类上包含Configuration注解和@ComponentScan，我们运行main方法的时候只需要将主类注册到Spring容器中，后续就会扫描主类包下的子包。下面我们就来看看其中的源码解析，先看Spring Boot注册主类的逻辑是在run方法中调用的prepareContext方法：

prepareContext(context, environment, listeners, applicationArguments,printedBanner);

然后我们进入prepareContext方法内部：

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");
    //加载资源 sources.toArray(new Object[0])就是主类的Class实例
    load(context, sources.toArray(new Object[0]));
    listeners.contextLoaded(context);
}
//接着我们再看load方法
protected void load(ApplicationContext context, Object[] sources) {
		...
    //创建BeanDefinitionLoader实例，由BeanDefinitionLoader 加载资源
    BeanDefinitionLoader loader = createBeanDefinitionLoader(getBeanDefinitionRegistry(context), sources);
    ......
    //BeanDefinitionLoader 实例加载资源
    loader.load();
}

然后我们只需要关注BeanDefinitionLoader的load方法即可：

public int load() {
    int count = 0;
	//这里我们传入的sources为主类的Class实例：Application.class
    for (Object source : this.sources) {
	count += load(source);
    }
    return count;
}
private int load(Object source) {
    Assert.notNull(source, "Source must not be null");
    //我们传入的是Class类型的实例，因此走该分支
    if (source instanceof Class<?>) {
		return load((Class<?>) source);
    }
    //下面是其他分支，不作介绍
    ......
    throw new IllegalArgumentException("Invalid source type " + source.getClass());
}
private int load(Class<?> source) {
    if (isGroovyPresent()&& GroovyBeanDefinitionSource.class.isAssignableFrom(source)) {
        //非Groovy不作介绍
	....
    }
    //我们知道@Configuration的元注解@Component，因此走该分支
    if (isComponent(source)) {
        //使用BeanDefinitionRegistry实例注册Bean
	this.annotatedReader.register(source);
	return 1;
    }
    return 0;
}

下面我们看将主类注册到Spring容器中的逻辑：

public void register(Class<?>... annotatedClasses) {
    for (Class<?> annotatedClass : annotatedClasses) {
	//调用registerBean
	registerBean(annotatedClass);
    }
}
public void registerBean(Class<?> annotatedClass) {
    //doRegisterBean才是注册Bean的逻辑
    doRegisterBean(annotatedClass, null, null, null);
}
<T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,@Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {
    AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
    if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
	return;
    }
    //一下为对BeanDefinition实例的处理
    ......
    //创建BeanDefinitionHolder实例
    BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
    definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
    //将BeanDefinition注册到容器，调用完该方法 Spring Boot的主类已经被注册到Spring 容器中了。
    //registerBeanDefinition方法就是将BeanDefinition注册到Spring 容器中，这里不在展示
    BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}

至此，我们已经将主类注册到Spring 容器中了，接着就是Spring 如何根据注册到Spring中的主类扫描主类下以及其子包下的注解的类，即如何将其他Bean注册到Spring容器中。同样我们在Spring Boot 原理解析—从入口SpringApplication说起一篇中说过Bean的注册最终是调用最终调用AbstractApplicationContext的refresh()方法。我们就看该方法中的内容，其中调用方法invokeBeanFactoryPostProcessors处理已经注册到Spring容器中的Bean，也就是我们刚开始时注入到Spring中的主类。

public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
	ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
	try {
	    // Invoke factory processors registered as beans in the context.
	    //调用工厂处理已经注册到容器中的Bean
	    invokeBeanFactoryPostProcessors(beanFactory);
        }
			......
    }
}

然后我们只需要关注invokeBeanFactoryPostProcessors即可，如下代码为其调用流程：

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
    ......
}
public static void invokeBeanFactoryPostProcessors( ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
    ......
    //该方法处理已经注册到容器中的Bean
    invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
    .....
}
private static void invokeBeanFactoryPostProcessors( Collection<? extends BeanFactoryPostProcessor> postProcessors, ConfigurableListableBeanFactory beanFactory) {
    //下面将逻辑交给BeanFactoryPostProcessor实现ConfigurationClassPostProcessor处理
    for (BeanFactoryPostProcessor postProcessor : postProcessors) {
        postProcessor.postProcessBeanFactory(beanFactory);
    }
}
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
    ......
    //处理配置Bean定义
    processConfigBeanDefinitions(registry);
}
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
    List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
    //获取已经注册到Spring容器中的Bean的名称
    String[] candidateNames = registry.getBeanDefinitionNames();
    //下面的逻辑是将@Configuration注解的类加入到configCandidates中
    // ConfigurationClassParser解析每一个 @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 {
	//解析@Configuration注解的类
        parser.parse(candidates);
	}
		.....
}

真正解析@Configuration注解是ConfigurationClassParser类的parse方法，下面我们查看parse方法代码：

public void parse(Set<BeanDefinitionHolder> configCandidates) {
    this.deferredImportSelectors = new LinkedList<>();
    for (BeanDefinitionHolder holder : configCandidates) {
	BeanDefinition bd = holder.getBeanDefinition();
	try {
	    //我们前面注入的主类是属于AnnotatedBeanDefinition，走该分支，其他的代码省略
	    if (bd instanceof AnnotatedBeanDefinition) {
                //这里继续调用了parse的重载方法
	        parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
	    }
            //下面的其他分支我们不关注
            ......
	}
	......
    }
}
protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {
    //调用processConfigurationClass解析配置类
    //将Bean名称和AnnotationMetadata 注解数据封装为ConfigurationClass
    processConfigurationClass(new ConfigurationClass(metadata, beanName));
}
	
protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
    //其他逻辑
    .....
    SourceClass sourceClass = asSourceClass(configClass);
    do {
        //解析@Configuration注解的类，doProcessConfigurationClass才真正解析@Configuration类
	sourceClass = doProcessConfigurationClass(configClass, sourceClass);
        }
    ......
}

上面的方法中doProcessConfigurationClass才解析@Configuration注解的类，我们查看doProcessConfigurationClass方法源码：

protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)throws IOException {
    //是否拥有@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) {
	    // 配置类上有 @ComponentScan 注解 我们的主类上是有该注解的。
	    Set<BeanDefinitionHolder> scannedBeanDefinitions =this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
				.......
	}
    }
    ......
}

doProcessConfigurationClass源码中会判断@Configuration注解的类上是否包含@ComponentScan注解，如果包含则处理该注解，这个配置的就是要扫描的包的名称：@ComponentScan是由ComponentScanAnnotationParser实例进行解析，我们继续查看的ComponentScanAnnotationParser的parse方法：

public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) {
    ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry,componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader);
    //获取@ComponentScan配置的包
    Set<String> basePackages = new LinkedHashSet<>();
    String[] basePackagesArray = componentScan.getStringArray("basePackages");
    for (String pkg : basePackagesArray) {
        String[] tokenized = StringUtils.tokenizeToStringArray(this.environment.resolvePlaceholders(pkg),
ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
    Collections.addAll(basePackages, tokenized);
    }
    for (Class<?> clazz : componentScan.getClassArray("basePackageClasses")) {
        basePackages.add(ClassUtils.getPackageName(clazz));
    }
    //如果@ComponentScan注解配置的包为空，则使用@Configuration注解的类的包作为扫描包
    if (basePackages.isEmpty()) {
			basePackages.add(ClassUtils.getPackageName(declaringClass));
    }
    //接下李就是扫描宝，然后将包内的Bean注册到Spring容器中，下面的逻辑就不看了，
    return scanner.doScan(StringUtils.toStringArray(basePackages));
}

ComponentScanAnnotationParser的parse方法的逻辑主要是获取@ComponentScan注解中配置的包，然后交给ClassPathBeanDefinitionScanner扫描包，如果@ComponentScan没有配置包，使用basePackages.add(ClassUtils.getPackageName(declaringClass))将@Configuration注解的类的包设置为要扫描的包。

总结：

上面走了那么多的代码，其实主要做了两件事，1.将@SpringBootApplication注解的类注册到Spring容器，2.调用Spring容器的refresh()方法注册Bean时，将要扫描的包配置为@SpringBootApplication注解的类的包。其实我们使用new AnnotationConfigApplicationContext(ConfigrationBean.class)也是一样的道理，我们可以看下该构造方法：

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
    this();
    //第一步：注册@Configuration注解类到Spring容器
    register(annotatedClasses);
    //调用refresh注册其他Bean。
    //如果@Configuration注解的类上有@ComponentScan注解
    //解析时根据@ComponentScan扫描包
    //如果@ComponentScan配置了包，则使用@ComponentScan配置的包
    //如果@ComponentScan没有配置包，则扫描其注解的类的包
    refresh();
}