spring启动流程(二）：包的扫描流程

news2024/11/29 7:57:27

在applicationContext的创建中，我们分析了applicationContext的创建过程，在本文中，我们将分析spring是如何进行包扫描的。

依旧是AnnotationConfigApplicationContext的构造方法：

public AnnotationConfigApplicationContext(String... basePackages) {
    this();
    //对传入的包进行扫描，扫描完成后，会得到一个 BeanDefinition 的集合
    scan(basePackages);
    refresh();
}
复制代码

这次我们将目光放在scan(basePackages);上，进入该方法：

AnnotationConfigApplicationContext#scan

public void scan(String... basePackages) {
     Assert.notEmpty(basePackages, "At least one base package must be specified");
     // 这里的scanner对象就是在this()中创建的
     this.scanner.scan(basePackages);
}
复制代码

这个方法关键代码是this.scanner.scan(basePackages);，这个scanner就是在this()中创建的对象：

public AnnotationConfigApplicationContext() {
    this.reader = new AnnotatedBeanDefinitionReader(this);
    // scanner 就是在这里创建的
    this.scanner = new ClassPathBeanDefinitionScanner(this);
}
复制代码

继续追踪，这里我们对不重要的方法仅给出调用链，重点关注扫描包的过程：

AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(String...)
 |-AnnotationConfigApplicationContext#scan
  |-ClassPathBeanDefinitionScanner#scan
   |-ClassPathBeanDefinitionScanner#doScan
复制代码

ClassPathBeanDefinitionScanner#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) {
        //获取所有符合条件的BeanDefinition
        Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
        for (BeanDefinition candidate : candidates) {
            //绑定BeanDefinition与Scope
            ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
            candidate.setScope(scopeMetadata.getScopeName());
            //查看是否配置类是否指定bean的名称，如没指定则使用类名首字母小写
            String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
            //下面两个if是处理lazy、Autowire、DependencyOn、initMethod、enforceInitMethod、destroyMethod、
            // enforceDestroyMethod、Primary、Role、Description这些逻辑的
            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);
                //检查scope是否创建，如未创建则进行创建
                definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(
                        scopeMetadata, definitionHolder, this.registry);
                beanDefinitions.add(definitionHolder);
                //注册 beanDefinition
                registerBeanDefinition(definitionHolder, this.registry);
            }
        }
    }
    return beanDefinitions;
}

复制代码

这段代码完成的功能很明了，大体上做了以下几件事：

  1. 根据包路径，得到符合条件的 BeanDefinition
  2. 遍历 BeanDefinition，进一步丰富beanDefinition信息
  3. 将 BeanDefinition 添加到 beanFactory

BeanDefinition也是spring的重要组件之一，关于BeanDefinition的分析，可参考spring组件之BeanDefinition。

接下来我们主要分析这三个的操作。

1. 根据包路径得到 BeanDefinition

这一步主要发生在Set<BeanDefinition> candidates = findCandidateComponents(basePackage);，我们跟进去看看代码的执行，这里依旧对不重要代码给出调用链，该方法的调用如下：

AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(String...)
 |-AnnotationConfigApplicationContext#scan
  |-ClassPathBeanDefinitionScanner#scan
   |-ClassPathBeanDefinitionScanner#doScan
    |-ClassPathScanningCandidateComponentProvider#findCandidateComponents
     |-ClassPathScanningCandidateComponentProvider#scanCandidateComponents
复制代码

最终调用到了ClassPathScanningCandidateComponentProvider#scanCandidateComponents，代码如下(有删减)：

private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
    Set<BeanDefinition> candidates = new LinkedHashSet<>();
    //组装扫描路径（组装完成后是这种格式：classpath*:org/springframework/learn/demo01/**/*.class）
    String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
            resolveBasePackage(basePackage) + '/' + this.resourcePattern;
    //根据路径获取资源对象，即扫描出该路径下的的所有class文件，得到 Resource
    Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
    for (Resource resource : resources) {
        if (resource.isReadable()) {
            //根据资源对象获取资源对象的MetadataReader
            MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
            // 这里做了两件事：
            // 1. 是否需要初始化为spring bean，即是否有 @Component、@Service等注解
            // 2. 查看配置类是否有@Conditional一系列的注解，然后是否满足注册Bean的条件
            if (isCandidateComponent(metadataReader)) {
                ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
                sbd.setResource(resource);
                sbd.setSource(resource);
                if (isCandidateComponent(sbd)) {
                    candidates.add(sbd);
                }
            }
        }
    }
    return candidates;
}
复制代码

可以看到，以上代码做了三件事：

  1. 根据传入的basePackage得到扫描路径
  2. 根据扫描路径得到该路径下的所有class文件对应的Resource
  3. 将 Resource 转化为 beanDefinition

接下来我们就以上代码进行分析。

1.1 根据basePackage得到包扫描路径

这一步没啥好分析，就是一个字符串的拼接与替换，将传入的org.springframework.learn.demo01转换为classpath*:org/springframework/learn/demo01/**/*.class，相关代码就一行：

String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
        resolveBasePackage(basePackage) + '/' + this.resourcePattern;
复制代码

1.2 扫描包路径

得到包扫描路径后，接下来就是进行扫描了。spring在扫描时，会把扫描路径下的所有class文件扫描出来，然后封装成Resource，代码如下

Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
复制代码

跟进代码，同样地，我们对不重要的方法，依旧只给出方法调用：

AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(String...)
 |-AnnotationConfigApplicationContext#scan
  |-ClassPathBeanDefinitionScanner#scan
   |-ClassPathBeanDefinitionScanner#doScan
    |-ClassPathScanningCandidateComponentProvider#findCandidateComponents
     |-ClassPathScanningCandidateComponentProvider#scanCandidateComponents
      |- GenericApplicationContext#getResources
       |-AbstractApplicationContext#getResources
        |-PathMatchingResourcePatternResolver#getResources
         |-PathMatchingResourcePatternResolver#findPathMatchingResources
复制代码

我们将代码聚集于PathMatchingResourcePatternResolver#findPathMatchingResources:

protected Resource[] findPathMatchingResources(String locationPattern) throws IOException {
    // 传入的 locationPattern 是 classpath*:org/springframework/learn/demo01/**/*.class
    // rootDirPath 是 classpath*:org/springframework/learn/demo01/
    String rootDirPath = determineRootDir(locationPattern);

    // subPattern 是 **/*.class
    String subPattern = locationPattern.substring(rootDirPath.length());

    // 这里返回的 Resource 是 rootDirPath 的绝对路径(用url表示)
    // URL [file:/xxx/spring-learn/build/classes/java/main/org/springframework/learn/demo01/]
    Resource[] rootDirResources = getResources(rootDirPath);
    
    Set<Resource> result = new LinkedHashSet<>(16);
    for (Resource rootDirResource : rootDirResources) {
        rootDirResource = resolveRootDirResource(rootDirResource);
        URL rootDirUrl = rootDirResource.getURL();
        if (equinoxResolveMethod != null && rootDirUrl.getProtocol().startsWith("bundle")) {
            URL resolvedUrl = (URL) ReflectionUtils.invokeMethod(equinoxResolveMethod, null, rootDirUrl);
            if (resolvedUrl != null) {
                rootDirUrl = resolvedUrl;
            }
            rootDirResource = new UrlResource(rootDirUrl);
        }
        // 处理 vfs 资源查找
        if (rootDirUrl.getProtocol().startsWith(ResourceUtils.URL_PROTOCOL_VFS)) {
            result.addAll(VfsResourceMatchingDelegate
                    .findMatchingResources(rootDirUrl, subPattern, getPathMatcher()));
        }
        // 处理jar包文件查找
        else if (ResourceUtils.isJarURL(rootDirUrl) || isJarResource(rootDirResource)) {
            result.addAll(doFindPathMatchingJarResources(rootDirResource, rootDirUrl, subPattern));
        }
        // 处理文件路径下的文件查找
        else {
            result.addAll(doFindPathMatchingFileResources(rootDirResource, subPattern));
        }
    }
    return result.toArray(new Resource[0]);
}
复制代码

通过分析，发现该类的处理过程如下：

  1. 通过传入的 locationPattern 得到该pattern下的url绝对路径，封装为Resource
  2. 遍历返回的路径，查找class文件，封装为Resource

我们来看看spring是如何将pattrn转换为url路径的，我们跟进代码：

|-PathMatchingResourcePatternResolver#getResources
 |-PathMatchingResourcePatternResolver#findAllClassPathResources
  |-PathMatchingResourcePatternResolver#doFindAllClassPathResources
复制代码

最终代码到了PathMatchingResourcePatternResolver#doFindAllClassPathResources:

protected Set<Resource> doFindAllClassPathResources(String path) throws IOException {
    Set<Resource> result = new LinkedHashSet<>(16);
    ClassLoader cl = getClassLoader();
    // path对应的url
    Enumeration<URL> resourceUrls = (cl != null ? cl.getResources(path) : 
            ClassLoader.getSystemResources(path));
    while (resourceUrls.hasMoreElements()) {
        URL url = resourceUrls.nextElement();
        // 将url转换为Resource，并添加到结果中
        result.add(convertClassLoaderURL(url));
    }
    if ("".equals(path)) {
        addAllClassLoaderJarRoots(cl, result);
    }
    return result;
}

// 将url转换为Resource
protected Resource convertClassLoaderURL(URL url) {
    return new UrlResource(url);
}
复制代码

此时传入的path为org/springframework/learn/demo01/，从代码可知，最终调用了java的ClassLoader方法来获取path对应的url，然后将url转换为Resource添加到结果集中并返回。

拿到类的绝对路径之后，接下就是对路径进行遍历，拿到class文件了。让我们再回到PathMatchingResourcePatternResolver#findPathMatchingResources，spring扫描时，会根据传入的url类型，共扫描3个地方：

  1. vfs
  2. jar包
  3. 文件路径

vfs注释上说是"URL protocol for a general JBoss VFS resource"，即通用JBoss VFS资源的URL协议，这里不深究。如果项目中引入了jar包且需要扫描jar中的路径，就会使用jar包扫描方式进行class文件查找，由于调试时，demo01是使用文件方式扫描的，这里就重点分析文件扫描方式，至于jar是如何扫描的，有兴趣的小伙伴可自行研究下。

我们跟进findPathMatchingResources方法：

|-PathMatchingResourcePatternResolver#findPathMatchingResources
 |-PathMatchingResourcePatternResolver#doFindPathMatchingFileResources
  |-PathMatchingResourcePatternResolver#doFindMatchingFileSystemResources
复制代码
protected Set<Resource> doFindMatchingFileSystemResources(File rootDir, 
            String subPattern) throws IOException {
    // 这里进行文件查找
    Set<File> matchingFiles = retrieveMatchingFiles(rootDir, subPattern);
    Set<Resource> result = new LinkedHashSet<>(matchingFiles.size());
    for (File file : matchingFiles) {
        result.add(new FileSystemResource(file));
    }
    return result;
}
复制代码

在PathMatchingResourcePatternResolver#doFindMatchingFileSystemResources中，spring将扫描到的File转换为FileSystemResource保存，这是我们遇到的第二个Resource类型了(前面为UrlResource，这里为FileSystemResource).

接下我们重点关注Set<File> matchingFiles = retrieveMatchingFiles(rootDir, subPattern);，看看spring是如何完成文件查找的：

|-PathMatchingResourcePatternResolver#findPathMatchingResources
 |-PathMatchingResourcePatternResolver#doFindPathMatchingFileResources
  |-PathMatchingResourcePatternResolver#doFindMatchingFileSystemResources
   |-PathMatchingResourcePatternResolver#retrieveMatchingFiles
    |-PathMatchingResourcePatternResolver#doRetrieveMatchingFiles
复制代码
protected void doRetrieveMatchingFiles(String fullPattern, File dir, Set<File> result) 
        throws IOException {
    for (File content : listDirectory(dir)) {
        String currPath = StringUtils.replace(content.getAbsolutePath(), File.separator, "/");
        if (content.isDirectory() && getPathMatcher().matchStart(fullPattern, currPath + "/")) {
            if (!content.canRead()) {
            }
            else {
                // 如果是文件夹，递归调用
                doRetrieveMatchingFiles(fullPattern, content, result);
            }
        }
        // 如果是文件且文件路径
        if (getPathMatcher().match(fullPattern, currPath)) {
            result.add(content);
        }
    }
}
复制代码

以上代码比较简单，与我们平常遍历文件的方式是一样的。

值得一提的是，getPathMatcher().match(fullPattern, currPath)最终调用到的是AntPathMatcher#doMatch，这是一个ant风格的路径匹配验证，即路径中带有*，如传入的pattern是/xxx/spring-framework/spring-learn/build/classes/java/main/org/springframework/learn/demo01/**/*.class，表示匹配/xxx/spring-framework/spring-learn/build/classes/java/main/org/springframework/learn/demo01/及其子文件夹下所有以.class文件结尾的文件，当前传入的path是/xxx/spring-framework/spring-learn/build/classes/java/main/org/springframework/learn/demo01/BeanObj2.class，显然匹配。关于AntPathMatcher#doMatch方法是如何进行匹配的，这里就不进行展开了。

经过了以上步骤，我们终于得到了class文件对应的Resource了.

1.3 将 Resource 转化为 BeanDefinition

将 Resource 转化为 BeanDefinition，代码是

ClassPathScanningCandidateComponentProvider#scanCandidateComponents

// 从 resource 得到 MetadataReader
MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);

// 这里做了两件事：
// 1. 是否需要初始化为spring bean，即是否有 @Component、@Service等注解
// 2. 查看配置类是否有@Conditional一系列的注解，然后是否满足注册Bean的条件
if (isCandidateComponent(metadataReader)) {
    // 将 metadataReader 转换为 ScannedGenericBeanDefinition，这也是BeanDefinition家族中的一员
    ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
    ...
}
复制代码

1. 从 Resource 得到 MetadataReader

我们追踪下MetadataReader的获取：

|-ClassPathScanningCandidateComponentProvider#scanCandidateComponents
 |-CachingMetadataReaderFactory#getMetadataReader
  |-SimpleMetadataReaderFactory#getMetadataReader(Resource)
   |-SimpleMetadataReader#SimpleMetadataReader
复制代码

代码最终运行到了SimpleMetadataReader的构造方法:

SimpleMetadataReader(Resource resource, @Nullable ClassLoader classLoader) throws IOException {
    SimpleAnnotationMetadataReadingVisitor visitor 
        = new SimpleAnnotationMetadataReadingVisitor(classLoader);
    // 这里发生了class文件的读取与解析
    getClassReader(resource).accept(visitor, PARSING_OPTIONS);
    this.resource = resource;
    this.annotationMetadata = visitor.getMetadata();
}
复制代码

再进一步追踪，发现class文件的读取与解析发生在ClassReader类：

这个类使用asm来读取class文件，代码比较复杂，就不深究了。

一直以来，我都以为spring是通过反射来获取类信息的，到这里才知道，原来spring是通过asm直接读取class文件来获取类的信息的 。

最后我们来看下得到的MetadataReader的结果：

这里重点关注annotations属性，里面有一个annotations和mappings，annotations内容为@Service，mappings是一个数组，内容为

0-@Service
1-@Component
2-@Index
复制代码

annotations本人猜测是 BeanObj1上的注解：

至于mappings是啥，我不好猜测，不过也可以从注解中发现一些端倪：

@Service上有@Component注解，@Component上有@Indexed，而这三者都出现在了mappings中，这看着像是专门用来保存拿注解之上的注解的？不纠结这个了，暂且就当作是这功能吧！注意：mappings里面的内容很重要，后面会用来！

2. isCandidateComponent(MetadataReader)：判断是否需要实例化为spring bean

在上一步中，我们得到了basePackage下所有类的MetadataReader描述文件，注意这里是所有类，但这些类是不是都要转成spring bean，托管到spring容器呢？这就是isCandidateComponent(MetadataReader)的功能了。废话少说，上代码：

protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
    // 省略部分代码
    for (TypeFilter tf : this.includeFilters) {
        // 这里判断是否需要托管到spring容器
        if (tf.match(metadataReader, getMetadataReaderFactory())) {
            // 判断是否有@Conditional一系列的注解
            return isConditionMatch(metadataReader);
        }
    }
    return false;
}
复制代码

这段主要是做了两个判断：

  • 是否需要为spring bean
  • 是否有@Conditional等一系列的注解

这里我们先来看第一个判断。

在spring中，标明spring bean的注解有很多，像@Component、@Repository、@Service、@Controller、@Configuration，甚至是你自己写的注解类，只要上面标了这些注解，像

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
// 添加 @Component 或 @Service 或 @Repository 等其中之一
@Component
public @interface MySpringBean {
    ...
}
复制代码

都能被spring识别。如果是spring提供的注解（@Component、@Repository等），在判断是不是spring bean时，只需要做类似

if(annotation == Component.class || annotation == Repository.class) {
    ...
}
复制代码

的判断就行了。但对于自定义的注解@MySpringBean，spring是怎么知道这是spring bean呢？在我们定义@MySpringBean时，一定要在类上添加@Component 或 @Service 或 @Repository 等其中之一才能被spring识别，这其中有什么玄机呢？我们跟进代码AbstractTypeHierarchyTraversingFilter#match(MetadataReader, MetadataReaderFactory)，这里我们对不重要的代码依旧只给出调用链：

|-ClassPathScanningCandidateComponentProvider#isCandidateComponent(MetadataReader)
 |-AbstractTypeHierarchyTraversingFilter#match(MetadataReader, MetadataReaderFactory)
  |-AnnotationTypeFilter#matchSelf
复制代码

代码最终到了AnnotationTypeFilter#matchSelf:

@Override
protected boolean matchSelf(MetadataReader metadataReader) {
    AnnotationMetadata metadata = metadataReader.getAnnotationMetadata();
    // 这里的annotationType就是 @Component
    return metadata.hasAnnotation(this.annotationType.getName()) ||
        (this.considerMetaAnnotations && metadata.hasMetaAnnotation(this.annotationType.getName()));
}
复制代码

关键就在这了：

metadata.hasAnnotation(this.annotationType.getName())
与
this.considerMetaAnnotations && metadata.hasMetaAnnotation(this.annotationType.getName())
复制代码

我们先看metadata.hasAnnotation(this.annotationType.getName())的比较：

// AnnotationMetadata#hasAnnotation
default boolean hasAnnotation(String annotationName) {
    return getAnnotations().isDirectlyPresent(annotationName);
}
复制代码

这里的getAnnotations()得到的结果是

mappings里的内容是

0-@Service
1-@Component
2-@Index
复制代码

这其实就是我们前面得到的MetadataReader里的内容！

再追踪下去，发现isDirectlyPresent就是判断annotations与mappings里有没有出现@Component:

private boolean isPresent(Object requiredType, boolean directOnly) {
    // 判断 annotations 里有没有出现 @Component
    for (MergedAnnotation<?> annotation : this.annotations) {
        Class<? extends Annotation> type = annotation.getType();
        if (type == requiredType || type.getName().equals(requiredType)) {
            return true;
        }
    }
    if (!directOnly) {
        // 判断 mappings 里有没有出现 @Component
        for (AnnotationTypeMappings mappings : this.mappings) {
            for (int i = 1; i < mappings.size(); i++) {
                AnnotationTypeMapping mapping = mappings.get(i);
                if (isMappingForType(mapping, requiredType)) {
                    return true;
                }
            }
        }
    }
    return false;
}
复制代码

接着我们再来看this.considerMetaAnnotations && metadata.hasMetaAnnotation(this.annotationType.getName())，查看调用：

|-AnnotationTypeFilter#matchSelf
 |-AnnotationMetadata#hasMetaAnnotation
  |-MergedAnnotationsCollection#get(String, Predicate)
   |-MergedAnnotationsCollection#get(String, Predicate, MergedAnnotationSelector)
    |-MergedAnnotationsCollection#find
复制代码

最终的查找方法在MergedAnnotationsCollection#find:

private <A extends Annotation> MergedAnnotation<A> find(Object requiredType,
        @Nullable Predicate<? super MergedAnnotation<A>> predicate,
        @Nullable MergedAnnotationSelector<A> selector) {

    MergedAnnotation<A> result = null;
    for (int i = 0; i < this.annotations.length; i++) {
        MergedAnnotation<?> root = this.annotations[i];
        AnnotationTypeMappings mappings = this.mappings[i];
        // mappings 遍历 mappings
        for (int mappingIndex = 0; mappingIndex < mappings.size(); mappingIndex++) {
            AnnotationTypeMapping mapping = mappings.get(mappingIndex);
            if (!isMappingForType(mapping, requiredType)) {
                continue;
            }
            // 到这里，就是找到了 @Component 注解
            MergedAnnotation<A> candidate = (mappingIndex == 0
                ? (MergedAnnotation<A>) root
                : TypeMappedAnnotation.createIfPossible(mapping, root, IntrospectionFailureLogger.INFO));
            if (candidate != null && (predicate == null || predicate.test(candidate))) {
                if (selector.isBestCandidate(candidate)) {
                    return candidate;
                }
                result = (result != null ? selector.select(result, candidate) : candidate);
            }
        }
    }
    return result;
}
复制代码

可以看到，查找方式跟上面的metadata.hasAnnotation(this.annotationType.getName())高度相似。

以上就是spring用来判断是否包含@Service、@Component等注解的逻辑了。

在java中，注解是不能继承的，如

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Base {

}

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Child extends  Base {

}
复制代码

以上语法在java中不被允许的，spring 就是采用这解析注解的注解的方式，实现了类似于继承的功能。

接着我们再来看ClassPathScanningCandidateComponentProvider#isConditionMatch方法。实际上，这个方法是用来判断类是否含有@Conditional注解的，满足条件则会识别为spring bean，代码最终调用到了ConditionEvaluator#shouldSkip(AnnotatedTypeMetadata, ConfigurationCondition.ConfigurationPhase):

public boolean shouldSkip(@Nullable AnnotatedTypeMetadata metadata, @Nullable ConfigurationPhase phase) {
    // 省略了一些代码

    // 得到 condition 对象
    List<Condition> conditions = new ArrayList<>();
        for (String[] conditionClasses : getConditionClasses(metadata)) {
            for (String conditionClass : conditionClasses) {
                Condition condition = getCondition(conditionClass, this.context.getClassLoader());
                conditions.add(condition);
            }
        }
    }

    AnnotationAwareOrderComparator.sort(conditions);
    // 遍历，判断 condition 条件是否成立
    for (Condition condition : conditions) {
        ConfigurationPhase requiredPhase = null;
        if (condition instanceof ConfigurationCondition) {
            requiredPhase = ((ConfigurationCondition) condition).getConfigurationPhase();
        }
        if ((requiredPhase == null || requiredPhase == phase) 
                // 判断 condition 条件是否成立，一个条件满足就返回true
                && !condition.matches(this.context, metadata)) {
            return true;
        }
    }

    return false;
}

// 通过反射获取 Condition 对象
private Condition getCondition(String conditionClassName, @Nullable ClassLoader classloader) {
    Class<?> conditionClass = ClassUtils.resolveClassName(conditionClassName, classloader);
    return (Condition) BeanUtils.instantiateClass(conditionClass);
}
复制代码

这里做了两件事：

  1. 获取 condition 对象
  2. 遍历 condition对象，调用condition.matches()方法，判断条件是否成立

3. 从 MetadataReader 得到 ScannedGenericBeanDefinition

这里仅是做了一个简单的赋值，看下 ScannedGenericBeanDefinition 的构造方法就明白了：

ScannedGenericBeanDefinition#ScannedGenericBeanDefinition

public ScannedGenericBeanDefinition(MetadataReader metadataReader) {
    Assert.notNull(metadataReader, "MetadataReader must not be null");
    this.metadata = metadataReader.getAnnotationMetadata();
    setBeanClassName(this.metadata.getClassName());
}
复制代码

代码比较简单，就不多做分析了。

2. 丰富beanDefinition信息

历经千难万险，终于得到了beanDefinition，但此时beanDefinition并不丰富，接下来就是进一步扩展 beanDefinition的信息了。这些信息包括bean的名称、bean的作用域、@Lazy 注解、@Primary注解、@DependsOn注解等，代码如下：

public abstract class AnnotationConfigUtils {

    ...

    /**
     * 进一步丰富 BeanDefinition
     */
    static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd, 
            AnnotatedTypeMetadata metadata) {
        // 处理 @Lazy
        AnnotationAttributes lazy = attributesFor(metadata, Lazy.class);
        if (lazy != null) {
            abd.setLazyInit(lazy.getBoolean("value"));
        }
        else if (abd.getMetadata() != metadata) {
            lazy = attributesFor(abd.getMetadata(), Lazy.class);
            if (lazy != null) {
                abd.setLazyInit(lazy.getBoolean("value"));
            }
        }
        // 处理 @Primary
        if (metadata.isAnnotated(Primary.class.getName())) {
            abd.setPrimary(true);
        }
        // 处理 @DependsOn
        AnnotationAttributes dependsOn = attributesFor(metadata, DependsOn.class);
        if (dependsOn != null) {
            abd.setDependsOn(dependsOn.getStringArray("value"));
        }
        // 处理 @Role
        AnnotationAttributes role = attributesFor(metadata, Role.class);
        if (role != null) {
            abd.setRole(role.getNumber("value").intValue());
        }
        // 处理 @Description
        AnnotationAttributes description = attributesFor(metadata, Description.class);
        if (description != null) {
            abd.setDescription(description.getString("value"));
        }
    }
}
复制代码

3. registerBeanDefinition(definitionHolder, this.registry): 添加 BeanDefinition 到 beanFactory

将BeanDefinition 到 beanFactory的操作比较简单，关键的代码如下：

|-ClassPathBeanDefinitionScanner#registerBeanDefinition
 |-BeanDefinitionReaderUtils#registerBeanDefinition
  |-GenericApplicationContext#registerBeanDefinition
   |-DefaultListableBeanFactory#registerBeanDefinition
复制代码

DefaultListableBeanFactory#registerBeanDefinition

this.beanDefinitionMap.put(beanName, beanDefinition);
复制代码

从ClassPathBeanDefinitionScanner#registerBeanDefinition到DefaultListableBeanFactory#registerBeanDefinition，这其中虽然经历了一些弯弯绕绕，但依旧不妨碍我们找到关键的代码。

到此，磁盘上的class文件，经过spring扫描，终于变成了BeanDefinition，保存在BeanFactory中了。

4. 总结

本文比较长，主要分析了spring 扫描包路径得到beanDefinition的过程，主要流程如下：

  1. 根据包名得到路径Resource；
  2. 根据路径Resouce得到该路径下所有class文件的Resouce；
  3. 根据class文件的Resouce通过asm解析得到MetadataReader，注意：这里的MetadataReader还是所有class文件的MetadataReader；
  4. 从MetadataReader中找到需要spring托管的MetadataReader，将其转化为ScannedGenericBeanDefinition，ScannedGenericBeanDefinition为BeanDefinition的子类；
  5. 进一步丰富 ScannedGenericBeanDefinition 的信息；
  6. 将上面得到的BeanDefinition添加到BeanFactory中

至此，包名转换为BeanDefinition完成。

本文还有两个值得注意的地方：

  1. spring 在获取类上的注解时，不是通过反射，而是使用asm直接解析class文件，然后再获取类上的注解的
  2. 在处理注解时，spring通过解析“注解的注解”实现了一套类似于注解继承的方式，这也是spring能识别@Component、@Service甚至是开发者自定义注解的原因。

得到了BeanDefinition后，接着就是spring容器的初始化了，我们下篇文章再见。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/3414.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

自底向上语法分析（bottom-up parsing）

自底向上语法分析（bottom-up parsing）

自底向上语法分析&#xff08;bottom-up parsing&#xff09;自底向上分析概述LR分析概述LR(0)分析增广文法点标记项目LR(0)分析表CLOSURE函数GOTO函数LR(0)自动机的状态集LR(0)分析表构造算法LR(0)自动机的形式化定义LR(0)分析的冲突问题SLR分析SLR算法的关键SLR分析的冲突问题…
阅读更多...
U3D热更新技术

U3D热更新技术

作者 : SYFStrive 博客首页 : HomePage &#x1f4cc;&#xff1a;个人社区&#xff08;欢迎大佬们加入&#xff09; &#x1f449;&#xff1a;社区链接&#x1f517; &#x1f937;‍♀️&#xff1a;创作不易转发需经作者同意&#x1f608; &#x1f483;&#xff1a;程…
阅读更多...
适用于 Windows 的企业级 Subversion 服务器

适用于 Windows 的企业级 Subversion 服务器

适用于 Windows 的企业级 Subversion 服务器。 Subversion 的 Windows 身份验证 Windows 身份验证是 VisualSVN 服务器的一个关键特性。此功能专为 Active Directory 域环境设计&#xff0c;允许用户使用其 Windows 凭据访问 VisualSVN 服务器。 VisualSVN Server 支持两种不同…
阅读更多...
【Linux】基础IO ——中

【Linux】基础IO ——中

&#x1f387;Linux&#xff1a;基础IO 博客主页&#xff1a;一起去看日落吗分享博主的在Linux中学习到的知识和遇到的问题博主的能力有限&#xff0c;出现错误希望大家不吝赐教分享给大家一句我很喜欢的话&#xff1a; 看似不起波澜的日复一日&#xff0c;一定会在某一天让你看…
阅读更多...
这些Java基础知识，诸佬们都还记得嘛(学习，复习，面试都可)

这些Java基础知识，诸佬们都还记得嘛(学习，复习，面试都可)

前言&#xff1a;大家好&#xff0c;我是小威&#xff0c;24届毕业生&#xff0c;在一家满意的公司实习。本篇将记录几次面试中经常被问到的知识点以及对学习的知识点总结和面试题的复盘。 本篇文章记录的基础知识&#xff0c;适合在学Java的小白&#xff0c;也适合复习中&…
阅读更多...
趣说 Mysql内存篇 Buffer Pool

趣说 Mysql内存篇 Buffer Pool

讲解顺序 先说 Mysql InnoDB 内存结构 Buffer PoolPage 管理机制Change BufferLog Buffer Buffer Pool 接上回 说到了 LRU 算法对内存的数据 进行淘汰 LRU 算法本身是 最近最少使用的&#xff0c;但是这样就会出现 分不清楚 哪些是真正多次使用的数据 LRU缺点&#xff1a…
阅读更多...
软考重点10 知识产权

软考重点10 知识产权

软考重点10 知识产权一、著作权1. 著作权的理解&#xff08;1&#xff09;版权&#xff1a;&#xff08;2&#xff09;人身权与财产权2. 知识产权的归属判定3. 知识产权的归属判定&#xff08;1&#xff09;委托创作&#xff08;2&#xff09;合作开发4. 著作权保护对象及范围5…
阅读更多...
为什么要有包装类，顺便说一说基本数据类型、包装类、String类该如何转换？

为什么要有包装类，顺便说一说基本数据类型、包装类、String类该如何转换？

一、前言 开门见山&#xff0c;首先看看八种基本数据类型对应的包装类&#xff1a; 基本数据类型包装类charCharacterbyteByteshortShortintIntegerlongLongfloatFloatdoubleDoublebooleanBoolean 其中Character 、Boolean的父类是Object&#xff0c;其余的父类是Number 二、装…
阅读更多...
【软件测试】毕业打工两年，辞职一年后转行月薪18K，软件测试让我发起了第一春......

【软件测试】毕业打工两年，辞职一年后转行月薪18K，软件测试让我发起了第一春......

目录&#xff1a;导读前言一、Python编程入门到精通二、接口自动化项目实战三、Web自动化项目实战四、App自动化项目实战五、一线大厂简历六、测试开发DevOps体系七、常用自动化测试工具八、JMeter性能测试九、总结&#xff08;尾部小惊喜&#xff09;前言 小徐&#xff1a; 毕…
阅读更多...
C++ 类和对象 日期类的实现

C++ 类和对象 日期类的实现

作者&#xff1a;小萌新 专栏&#xff1a;初阶C 作者简介&#xff1a;大二学生 希望能和大家一起进步 本篇博客目标&#xff1a; 完成Date类的实现 梳理剩下两个默认函数 好困 跑个步去 睡醒啦&#xff01; 继续肝 日期类的实现本章目标一. 日期类的实现1.1 Getmonthday的实现…
阅读更多...
CNN的实现与可视化

CNN的实现与可视化

CNN的实现 我们已经实现了卷积层和池化层&#xff0c;现在来组合这些层&#xff0c;搭建进行手写数字识别的CNN。如下图所示&#xff0c;网络的构成是“Convolution - ReLU - Pooling -Affine - ReLU - Affine - Softmax”&#xff0c;我们将它实现为名为SimpleConvNet的类。 …
阅读更多...
R语言—向量

R语言—向量

向量&#xff08;vector&#xff09; R 语言最基本的数据结构是向量。类似于数学上的集合的概念&#xff0c;由一个或多个元素构成。向量其实是用于存储数值型、字符型、或逻辑型数据的一维数组。 创建向量 c()函数 > a <- 1 #给a赋值1 > a #显示a的值 [1] 1 …
阅读更多...
【C++初阶】类和对象终极篇

【C++初阶】类和对象终极篇

文章目录一.加const修饰this指针二.cout<<自定义类型的对象的实现1.深入理解cout和<<2流插入和流提取3.友元函数的来源a.作为ostream成员函数b.作为全局函数c.作为Date类的成员函数d.作为Date类的友元函数三.再谈构造函数之初始化列表四.隐式类型转换&explicit…
阅读更多...
Linux命令从入门到实战----文件目录类

Linux命令从入门到实战----文件目录类

文章目录pwd显示当前工作路径的绝对路径ls列出目录的内容cd切换目录mkdir 创建一个新的目录删除一个空的目录touch创建新文件cp复制文件或目rm删除文件或目录mv移动文件与目录&#xff0c;重命名文件cat查看文件内容&#xff0c;创建新文件more文件内容分屏查看less分屏显示文件…
阅读更多...
【C语言】字符串、字符数组

【C语言】字符串、字符数组

目录 写在开头 正文 一、字符串的本质 二、输入函数scanf和gets 三、输出函数printf和puts 四、字符串的长度——strlen 五、字符串的复制——strcpy 六、字符串的比较函数 七、实战练习 八、二维字符数组——字符串数组 写在最后 写在开头 看了标题&#xff0c;是…
阅读更多...
Kotlin编程实战——类与对象(05)

Kotlin编程实战——类与对象(05)

一 概述 类与继承属性和字段接口(interface )函数式&#xff08;SAM&#xff09;接口可见性修饰符扩展数据类(data class)密封类泛型嵌套类与内部类枚举类对象表达式与对象声明类型别名内联类(inline class)委托委托属性 二 类与继承 类继承(open override )抽象类(abstract)…
阅读更多...
MySQL去重中 distinct 和 group by 的区别

MySQL去重中 distinct 和 group by 的区别

今天在写业务需要对数据库重复字段进行去重时&#xff0c;因为是去重&#xff0c;首先想到的是distinct关键字。于是一小时过去了。。。。&#xff08;菜鸟一个&#xff0c;大家轻点骂&#xff09; 我把问题的过程用sql语句演示给大家演示一下 首先我使用的是mybatis-plus&am…
阅读更多...
数据结构之哈希表

数据结构之哈希表

文章目录 一、概念二、哈希冲突三、如何解决哈希冲突&#xff1f; 1.哈希函数设计2.负载因子调节3.闭散列4.开散列&#xff08;哈希桶&#xff09;四、模拟实现哈希桶总结一、概念 顺序结构以及平衡树中&#xff0c;元素与其存储位置之间没有对应的关系&#xff0c;因此在查找一…
阅读更多...
C++多态学习笔记

C++多态学习笔记

C多态学习笔记一、多态概述二、多态的作用三、多态发生的三个条件四、多态实现的原理五、接口的定义六、模板方法模式七、虚析构函数和纯虚析构函数7.1 虚析构函数7.2 纯虚析构函数八、重写重载重定义九、父类引用子类对象一、多态概述 同一个操作作用于不同的对象&#xff0c;…
阅读更多...
2014年848数据结构真题复习

2014年848数据结构真题复习

求k频度K0; for&#xff08;i1;i<n;i&#xff09; 假如是1——8&#xff0c;执行了9次&#xff0c;8次有效&#xff0c;最后一次无效for&#xff08;ji;j<n;j&#xff09;k 我的理解&#xff1a;假设n为8我们看k频度实际上就是看内圈for的有效循环次数第一轮是1——8 八次…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023