前言
接上篇 Spring 5 启动性能优化之 @Indexed，上篇提到 Spring 可以在编译时生成索引文件，在应用上下文启动时可以通过索引文件查找所需要的注册的 Bean，如果不存在索引文件或者配置了不处理索引文件的参数，则不会从索引文件获取元数据。这时，Spring 便需要从指定的包中扫描 bean。
要获取类的信息，我们第一反应一般是通过反射获取，因为类加载器将类加载到虚拟机中，会读取 class 文件，而 class 文件中包含着完整的类的信息。那么 Spring 是怎么做的呢？是否还有其他更高效的方式？跟随源码，让我们一探究竟。
Spring Bean 扫描分析
要想成为 Spring 的 bean，我们通常会在类上添加注解 @Component、@Controller、@Service、@Repository 等注解。并且 Spring 从 4.x 版本开始 Spring 开始支持条件注解 @Conditional，满足条件的类才会注册为 Spring 的 bean 。因此在分析源码之前，我们可以大概猜到具有这么一个流程。首先 Spring 从类路径中读取到所有的类的元数据，然后选择存在特定注解的类，最后如果存在条件注解还需要满足条件才能注册为 bean。实际上是不是这样呢？
扫描流程概览
我们仍将 AnnotationConfigApplicationContext 应用上下文的扫描方法作为入口进行分析。源码如下：
public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry { // 用来注册 bean private final AnnotatedBeanDefinitionReader reader; // 用来扫描并注册 bean private final ClassPathBeanDefinitionScanner scanner; public AnnotationConfigApplicationContext() { this.reader = new AnnotatedBeanDefinitionReader(this); this.scanner = new ClassPathBeanDefinitionScanner(this); } //从给定的包中扫描 @Override public void scan(String... basePackages) { Assert.notEmpty(basePackages, "At least one base package must be specified"); this.scanner.scan(basePackages); } }
scan 是扫描包的方法，实现异常简单，其委托给 ClassPathBeanDefinitionScanner 进行扫描，这是 Spring 内部实现经常用的一个组合模式，使类的职责更为清晰。查看 ClassPathBeanDefinitionScanner 扫描的源码如下：
public class ClassPathBeanDefinitionScanner extends ClassPathScanningCandidateComponentProvider { public int scan(String... basePackages) { int beanCountAtScanStart = this.registry.getBeanDefinitionCount(); // 扫描并注册 bean doScan(basePackages); // 如果有必要的话，注册处理注解的 BeanFactoryPostProcessor if (this.includeAnnotationConfig) { AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry); } return (this.registry.getBeanDefinitionCount() - beanCountAtScanStart); } }
这里扫描分成了两个步骤，一个是扫描，另一个是注册处理注解配置的处理器 BeanFactoryPostProcessor ，应用上下文在其生命周期中会调用
BeanFactoryPostProcessor 的方法，这给予对 bean 进行额外处理的机会，如将 @Configuration 标注的类中标注 @Bean 注解的方法的返回对象注册为 Spring 中的 bean 。 注册的处理器及其实现在后面进行探讨，这里让我们把重点放到扫描过程。 跟踪 doScan 方法的源码如下：
protected Set<BeanDefinitionHolder> doScan(String... basePackages) { Assert.notEmpty(basePackages, "At least one base package must be specified"); Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>(); for (String basePackage : basePackages) { // 循环从包中查找候选组件 Set<BeanDefinition> candidates = findCandidateComponents(basePackage); for (BeanDefinition candidate : candidates) { ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate); candidate.setScope(scopeMetadata.getScopeName()); // 获取或生成 bean 的名称 String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry); // 对候选组件进行再处理，设置必要的信息 if (candidate instanceof AbstractBeanDefinition) { postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName); } if (candidate instanceof AnnotatedBeanDefinition) { AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate); } // 检查候选组件是否与现有 bean冲突或需要注册 if (checkCandidate(beanName, candidate)) { BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName); definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry); beanDefinitions.add(definitionHolder); // 注册 bean registerBeanDefinition(definitionHolder, this.registry); } } } return beanDefinitions; }
Spring 的方法一般不会太长，结构也较为清晰，这里我们可以看到，Spring 先查找候选组件，然后对候选组件设置必要的属性，最后检查候选组件与现存的 bean 定义如果无冲突，则进行注册，注册则是使用一个 map 来保存 bean 定义，后面再分析。跟踪其查找候选组件的方法 findCandidateComponents，源码如下：
public Set<BeanDefinition> findCandidateComponents(String basePackage) { if (this.componentsIndex != null && indexSupportsIncludeFilters()) { return addCandidateComponentsFromIndex(this.componentsIndex, basePackage); } else { return scanCandidateComponents(basePackage); } }
查找候选组件根据是否存在索引文件进行了不同的处理，参见前文 Spring 5 启动性能优化之 @Indexed 查看索引文件的处理过程，这里把重点放到候选组件的扫描过程。跟踪 scanCandidateComponents 方法源码如下,其中省略了不重要的代码：
private Set<BeanDefinition> scanCandidateComponents(String basePackage) { Set<BeanDefinition> candidates = new LinkedHashSet<>(); // 先将包名转换为 Resource String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + resolveBasePackage(basePackage) + '/' + this.resourcePattern; Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath); for (Resource resource : resources) { // 然后获取元数据读取器 MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource); // 如果读取到的类为候选组件则添加到候选组件列表 if (isCandidateComponent(metadataReader)) { ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader); sbd.setSource(resource); if (isCandidateComponent(sbd)) { candidates.add(sbd); } } } return candidates; }
这里先将包名转换为 Resource，Resource 是 Spring 对资源的统一抽象，然后对 Resource 进行读取，转换为 MetadataReader ，MetadataReader 是元数据的读取器，可以读取到类的元信息，然后判断元信息对应的类为候选组件则添加到候选组件列表。后面我们关注两件事情，第一是 Resource 如何转换为 MetadataReader ，第二是如何判断类是否符合候选组件要求。
Resource 如何转换为 MetadataReader？
上述方法中先调用了 getMetadataReaderFactory() 获取 MetadataReaderFactory，然后使用 MetadataReaderFactory 获取 MetadataReader，那么我们就来看这几个类到底是做什么用的，包含了哪些信息。
查看 MetadataReaderFactory 源码如下：
public interface MetadataReaderFactory { // 根据类名获取 MetadataReader MetadataReader getMetadataReader(String className) throws IOException; // 根据 Resource 获取 MetadataReader MetadataReader getMetadataReader(Resource resource) throws IOException; }
MetadataReaderFactory 是一个接口，其内部有两个工厂方法都是用来获取 MetadataReader ，再看什么是 MedataReader，源码如下:
public interface MetadataReader { // 获取 Resource Resource getResource(); // 获取类的元数据 ClassMetadata getClassMetadata(); // 获取注解的元数据 AnnotationMetadata getAnnotationMetadata(); }
MetadataReader 提供了获取 ClassMetadata 和 AnnotationMetadata 对象的方法，那么这两个类都是做什么用的呢？继续跟踪源码。ClassMetadata 源码如下：
public interface ClassMetadata { // 获取类名 String getClassName(); // 当前类是否为接口 boolean isInterface(); // 当前类是否表示注解 boolean isAnnotation(); // 当前类是否是抽象的 boolean isAbstract(); // 当前类是否可以创建 default boolean isConcrete() { return !(isInterface() || isAbstract()); } // 当前类是否标记为 final boolean isFinal(); // 当前类是否是独立的，即为最顶部的类或为静态内部类 boolean isIndependent(); // 当前类是否定义在外部类中 default boolean hasEnclosingClass() { return (getEnclosingClassName() != null); } // 获取外部类的名称 @Nullable String getEnclosingClassName(); // 当前类是否具有父类 default boolean hasSuperClass() { return (getSuperClassName() != null); } // 获取当前类的父类的名称 @Nullable String getSuperClassName(); // 获取当前类实现的接口名称 String[] getInterfaceNames(); // 获取当前类的成员内部类名称 String[] getMemberClassNames(); }
可以看到，ClassMetadata 是获取类的元数据的一个接口，其上面的信息也可以通过反射获取。再看 AnnotationMetadata ，源码如下：
public interface AnnotationMetadata extends ClassMetadata, AnnotatedTypeMetadata { // 获取注解上的元注解类型名称 default Set<String> getMetaAnnotationTypes(String annotationName) { ...省略部分代码 } // 给定的注解是否存在于类上 default boolean hasAnnotation(String annotationName) { ...省略部分代码 } // 给定的元注解是否存在于类上 default boolean hasMetaAnnotation(String metaAnnotationName) { ...省略部分代码 } // 给定的注解是否存在于类上方法上 default boolean hasAnnotatedMethods(String annotationName) { ...省略部分代码 } // 获取所有被给定注解或元注解标注的方法元数据 Set<MethodMetadata> getAnnotatedMethods(String annotationName); // 使用反射创建给定类的注解元数据 static AnnotationMetadata introspect(Class<?> type) { return StandardAnnotationMetadata.from(type); }
可以看到，AnnotationMetadata 继承了 ClassMetadata ，并且包含一些有关注解的元数据。既然 MetadataReader 是使用 MetadataReaderFactory 获取到的，那么跟踪 getMetadataReaderFactory() 方法查看如何获取 MetadataReaderFactory 的实现。源码如下：
public final MetadataReaderFactory getMetadataReaderFactory() { if (this.metadataReaderFactory == null) { this.metadataReaderFactory = new CachingMetadataReaderFactory(); } return this.metadataReaderFactory; }
这里获取到的是 CachingMetadataReaderFactory 的实例，它会调用父类 SimpleMetadataReaderFactory 的 getMetadataReader 方法，然后把获取到的 MetaReader 缓存，再跟踪 SimpleMetadataReaderFactory 的 getMetadataReader 方法的实现，源码如下：
@Override public MetadataReader getMetadataReader(Resource resource) throws IOException { return new SimpleMetadataReader(resource, this.resourceLoader.getClassLoader()); }
这里看到实际上就是 new 了一个 SimpleMetadataReader，查看其构造方法源码如下：
SimpleMetadataReader(Resource resource, @Nullable ClassLoader classLoader) throws IOException { SimpleAnnotationMetadataReadingVisitor visitor = new SimpleAnnotationMetadataReadingVisitor(classLoader); getClassReader(resource).accept(visitor, PARSING_OPTIONS); this.resource = resource; this.annotationMetadata = visitor.getMetadata(); } @Override public ClassMetadata getClassMetadata() { return this.annotationMetadata; } @Override public AnnotationMetadata getAnnotationMetadata() { return this.annotationMetadata; }
这里看到 SimpleMetadataReader 使用了 asm 框架中的 ClassReader 读取类的信息，将 SimpleAnnotationMetadataReadingVisitor 作为访问者，接收 asm 访问到的类元信息，然后再转换为 AnnotationMetadata 保存，这样就获取到了 MetadataReader 中保存的元数据。通过上面的流程我们发现，Spring 实际并没有使用反射，因此不要进行类加载，使用 asm 框架直接读取 class 信息，大大提高了性能。
如何判断一个类是否满足组件要求
读取到类的元数据后就需要判断类是否满足组件的要求，跟踪 ClassPathBeanDefinitionScanner 的 isCandidateComponent 方法，其方法为父类 ClassPathScanningCandidateComponentProvider 的方法，源码如下：
protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException { for (TypeFilter tf : this.excludeFilters) { if (tf.match(metadataReader, getMetadataReaderFactory())) { return false; } } for (TypeFilter tf : this.includeFilters) { if (tf.match(metadataReader, getMetadataReaderFactory())) { return isConditionMatch(metadataReader); } } return false; }
这里先使用 excludeFilters 排序满足条件的类，默认情况下 excludeFilters 为空，不会对扫描到的类进行排除。
排除不需要的类后就需要判断扫描的类是否满足条件。先使用 includeFilters 进行判断，满足条件的类有可能成为 Spring 的 bean。默认的 includeFilter 在 ClassPathBeanDefinitionScanner 实例化时注册，源码如下：
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters, Environment environment, @Nullable ResourceLoader resourceLoader) { Assert.notNull(registry, "BeanDefinitionRegistry must not be null"); this.registry = registry; if (useDefaultFilters) { // 注册默认的过滤器 registerDefaultFilters(); } setEnvironment(environment); setResourceLoader(resourceLoader); } protected void registerDefaultFilters() { ...省略部分代码 this.includeFilters.add(new AnnotationTypeFilter(Component.class)); ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader(); this.includeFilters.add(new AnnotationTypeFilter( ((Class<? extends Annotation>) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false)); this.includeFilters.add(new AnnotationTypeFilter( ((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Named", cl)), false)); }
可以看到，默认注册了支持 @Component、@ManagedBean、@Named 注解的 TypeFilter，只有类上存在这三个注解中的一个才可能成为候选组件。在 Spring 4.x 版本中，Spring 添加了条件注解，这里进行了支持。满足 includeFilter 后还使用 isConditionMatch 判断了条件是否满足，继续跟踪源码：
private boolean isConditionMatch(MetadataReader metadataReader) { if (this.conditionEvaluator == null) { this.conditionEvaluator = new ConditionEvaluator(getRegistry(), this.environment, this.resourcePatternResolver); } return !this.conditionEvaluator.shouldSkip(metadataReader.getAnnotationMetadata()); }
这里使用 ConditionEvaluator 对注解 @Conditional 进行处理，不满足则会跳过后面的处理。后续会专门对 @Conditional 进行分析。isConditionMatch 还具有另外一个重载的方法，只有两个条件都满足才会真正成为 Spring 的bean。这两个方法调用都在 ClassPathScanningCandidateComponentProvider#scanCandidateComponents ，相关源码前面已经进行了分析，这里再贴一次避免嵌套过深大家找不到。isConditionMatch 重载方法的源码如下：
protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) { AnnotationMetadata metadata = beanDefinition.getMetadata(); return (metadata.isIndependent() && (metadata.isConcrete() || (metadata.isAbstract() && metadata.hasAnnotatedMethods(Lookup.class.getName())))); }
这里类成为 Spring 的 bean，还需要保证是独立能创建的。
整理流程如下：Spring 拿到扫描到的类的元信息，判断类上是否存在支持的注解，如果存在继续判断是否满足 @Conditional 注解，最后还要保证类是能够创建的，这样的一个类才完全的满足 Spring 组件的要求，成为 Spring 的 bean。
总结
本篇首先引出 Spring 在类路径下扫描 bean 的过程。通过分析，我们发现 Spring 使用 asm 框架直接对类的信息进行读取，并将读取到的信息映射为 Spring 中表示元数据的 ClassMetadata 及 AnnotationMetadata 。拿到所有给定包名下的类的元信息后，通过检查类上是否存在支持的注解，如 Component，然后继续判断类上是否存在 @Conditional 注解及是否满足条件，最后还要保证类能够创建才能成为 Spring 中组件的候选对象。至此，Spring 的 bean 扫描完成。
