《Spring6核心技术》第10章:深度解析@Component注解(注解+案例+时序图+源码)

嘟嘟鱼啊鱼
发布于 2023-5-30 15:37
浏览
0收藏

作者:冰河星球:​​http://m6z.cn/6aeFbs​

博客:​​https://binghe.gitcode.host​

文章汇总:​​https://binghe.gitcode.host/md/all/all.html​

源码地址:https://github.com/binghe001/spring-annotation-book/tree/master/spring-annotation-chapter-10

沉淀,成长,突破,帮助他人,成就自我。

大家好,我是冰河~~


  • 本章难度:★★★★☆
  • 本章重点:进一步学习并掌握@Component注解向IOC容器中注入Bean的案例和流程,从源码级别彻底掌握@Component注解在Spring底层的执行流程。

本节目录如下所示:

  • 学习指引
  • 注解说明

    ○ 注解源码

    ○ 使用场景

  • 使用案例
  • 源码时序图
  • 源码解析
  • 总结
  • 思考

一、学习指引

​Spring中的@Component注解,你真的彻底了解过吗?​

@Component注解可以说是Spring中使用的比较频繁的一个注解了。在项目开发过程中,我们自己编写的类如果想注入到Spring中,由Spring来管理Bean的生命周期,就可以使用@Component注解将其注入到IOC容器中。

并且@Component注解还有三个衍生注解,那就是@Repository、@Service和@Controller注解,并且衍生出的注解通常会在使用MVC架构开发项目时,标注到MVC架构的分层类上。

比如:@Repository通常会被标注到表示dao层的类上,@Service注解通常会被标注到表示Service层的类上,而@Controller注解通常会被标注到表示Controller层的类上。

二、注解说明

​关于@Component注解的一点点说明~~​

使用Spring开发项目时,如果类上标注了@Component注解,当启动IOC容器时,Spring扫描到标注了@Component注解的单例Bean,就会创建对应的Bean对象并注入到IOC容器中。

2.1 注解源码

IOC容器在启动时,如果扫描到被标注了@Component注解的类,则会将这些类的类定义信息自动注入IOC容器,并创建这些类的对象。

@Component注解的源码详见:org.springframework.stereotype.Component。

/**
 *     @author Mark Fisher
 *     @since 2.5
 *     @see Repository
 *     @see Service
 *     @see Controller
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Indexed
public @interface Component {
 String value() default "";
}

从源码可以看出,@Component注解是从Spring2.5版本开始提供的注解,并且@Component注解只能标注到类上。其中只含有一个String类型的value属性,具体含义如下所示。

  • value:用于指定注入容器时Bean的id。如果没有指定Bean的id,默认值为当前类的名称。

@Component注解提供了三个衍生注解:分别是:@Repository、@Service和@Controller注解。

(1)@Repository注解

@Repository注解的源码详见:org.springframework.stereotype.Repository。

/**
 *     @author Rod Johnson
 *     @author Juergen Hoeller
 *     @since 2.0
 *     @see Component
 *     @see Service
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Repository {
 @AliasFor(annotation = Component.class)
 String value() default "";
}
(2)@Service注解

@Service注解的源码详见:org.springframework.stereotype.Service。

/**
 *     @author Juergen Hoeller
 *     @since 2.5
 *     @see Component
 *     @see Repository
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Service {
 @AliasFor(annotation = Component.class)
 String value() default "";

}
(3)@Controller注解

@Controller注解注解的源码详见:org.springframework.stereotype.Controller。

/**
 *     @author Arjen Poutsma
 *     @author Juergen Hoeller
 *     @since 2.5
 *     @see Component
 *     @see org.springframework.web.bind.annotation.RequestMapping
 *     @see org.springframework.context.annotation.ClassPathBeanDefinitionScanner
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Controller {
 @AliasFor(annotation = Component.class)
 String value() default "";
}

可以看到,@Repository、@Service和@Controller注解本质上还是@Component注解,这里不再赘述。

2.2 使用场景

在Spring开发项目的过程中,如果需要将自己创建的类注入到IOC容器中,就可以使用@Component注解,也可以使用@Repository、@Service和@Controller注解。

其中,@Component注解一般会被标注到非三层(非MVC架构)类上,而@Repository、@Service和@Controller注解通常会被标注到三层架构的类上。并且@Repository通常会被标注到表示dao层的类上,@Service注解通常会被标注到表示Service层的类上,而@Controller注解通常会被标注到表示Controller层的类上。

这里,需要注意的是,基于Spring的注解开发项目时,必须先将类对象交给Spring管理,然后Spring会处理类中的属性和方法。如果类没有被Spring接管,那么类里面的属性和方法上的注解都不会被解析。

三、使用案例

​@Component的实现案例,我们一起实现吧~~​

本节,就基于@Component注解、@Repository、@Service和@Controller注解实现简单的案例程序,观察被上述四个注解标注的类是否注入到IOC容器中。具体实现步骤如下所示。

(1)新建ComponentBean类

ComponentBean类的源码详见:spring-annotation-chapter-10工程下的io.binghe.spring.annotation.chapter10.component.ComponentBean。

@Component
public class ComponentBean {
}

可以看到,ComponentBean就是一个标注了@Component注解的普通类。

(2)新建RepositoryBean类

RepositoryBean类的源码详见:spring-annotation-chapter-10工程下的io.binghe.spring.annotation.chapter10.component.RepositoryBean。

@Repository
public class RepositoryBean {
}

可以看到,RepositoryBean类就是一个标注了@Repository注解的普通类。

(3)新建ServiceBean类

ServiceBean类的源码详见:spring-annotation-chapter-10工程下的io.binghe.spring.annotation.chapter10.component.ServiceBean。

@Service
public class ServiceBean {
}

可以看到,ServiceBean类就是一个标注了@Service注解的普通类。

(4)新建ControllerBean类

ControllerBean类的源码详见:spring-annotation-chapter-10工程下的io.binghe.spring.annotation.chapter10.component.ControllerBean。

@Controller
public class ControllerBean {
}

可以看到,ControllerBean类就是一个标注了@Controller注解的普通类。

(5)新建ComponentConfig类

ComponentConfig类的源码详见:spring-annotation-chapter-10工程下的io.binghe.spring.annotation.chapter10.config.ComponentConfig。

@Configuration
@ComponentScan(value = {"io.binghe.spring.annotation.chapter10"})
public class ComponentConfig {
}

可以看到,ComponentConfig类上标注了@Configuration,说明ComponentConfig类是一个Spring的配置类,并且使用@ComponentScan注解指定了扫描的包名是io.binghe.spring.annotation.chapter10。

(6)新建ComponentTest类

ComponentTest类的源码详见:spring-annotation-chapter-10工程下的io.binghe.spring.annotation.chapter10.ComponentTest。

public class ComponentTest {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ComponentConfig.class);
        String[] definitionNames = context.getBeanDefinitionNames();
        Arrays.stream(definitionNames).forEach((definitionName) -> System.out.println(definitionName));
    }
}

可以看到,在ComponentTest类的main()方法中打印了IOC容器中注入的Bean对象的名称。

(7)运行ComponentTest类

运行ComponentTest类的main()方法,输出的结果信息如下所示。

org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
componentConfig
componentBean
controllerBean
repositoryBean
serviceBean

从输出的结果信息可以看出,打印出了被@Component、@Repository、@Service和@Controller注解标注的Bean的名称。

说明:使用Spring开发项目时,如果Spring扫描到类上标注了@Component、@Repository、@Service和@Controller注解的单例Bean,就会创建对应的Bean对象并注入到IOC容器中。

四、源码时序图

​结合时序图理解源码会事半功倍,你觉得呢?​

本节,就以源码时序图的方式,直观的感受下@Component注解在Spring源码层面的执行流程。@Component注解在Spring源码层面执行的时序图如图10-1~10~3所示。

注意:@Repository、@Service和@Controller注解本质上还是@Component注解,这里就不再单独分析@Repository、@Service和@Controller注解的执行流程。

《Spring6核心技术》第10章:深度解析@Component注解(注解+案例+时序图+源码)-鸿蒙开发者社区

《Spring6核心技术》第10章:深度解析@Component注解(注解+案例+时序图+源码)-鸿蒙开发者社区

《Spring6核心技术》第10章:深度解析@Component注解(注解+案例+时序图+源码)-鸿蒙开发者社区

由图10-1~10-3可以看出,@Component注解在注册Bean的流程中涉及到ComponentTest类、AnnotationConfigApplicationContext类、AbstractApplicationContext类、PostProcessorRegistrationDelegate类、ConfigurationClassPostProcessor类、ConfigurationClassParser类、SourceClass类、ComponentScanAnnotationParser类、ClassPathBeanDefinitionScanner类、ClassPathScanningCandidateComponentProvider类、AnnotationConfigUtils类、BeanDefinitionReaderUtils类、和DefaultListableBeanFactory类。具体的源码执行细节参见源码解析部分。

五、源码解析

​源码时序图整清楚了,那就整源码解析呗!​

本节,主要分析@Component注解在Spring源码层面的执行流程,结合源码执行的时序图,会理解的更加深刻。

注意:本节的源码分析流程与第9章5.2小节的源码分析流程大体相同,只是多了一个更加细节的分析,这里,只对这些细节点进行详细的分析。所以,本节的源码分析可以结合第9章5.2小节的源码分析共同理解。

(1)解析ConfigurationClassParser类的doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass, Predicatefilter)方法

源码详见:org.springframework.context.annotation.ConfigurationClassParser#doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass, Predicatefilter)。

protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter) throws IOException {
    if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
        processMemberClasses(configClass, sourceClass, filter);
    }
    /**************省略其他代码****************/
    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) {
            Set<BeanDefinitionHolder> scannedBeanDefinitions = this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
            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());
                }
            }
        }
    }
 /**************省略其他代码****************/
    return null;
}

可以看到,在ConfigurationClassParser类的doProcessConfigurationClass()方法中,判断如果本质上是@Component注解(@Repository、@Service和@Controller注解),会调用processMemberClasses()方法处理内部类。

(2)解析ConfigurationClassParser类的processMemberClasses(ConfigurationClass configClass, SourceClass sourceClass,Predicatefilter)方法

源码详见:org.springframework.context.annotation.ConfigurationClassParser#processMemberClasses(ConfigurationClass configClass, SourceClass sourceClass,Predicatefilter)。

private void processMemberClasses(ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter) throws IOException {
    Collection<SourceClass> memberClasses = sourceClass.getMemberClasses();
    /*****************省略其他代码***************/
}

可以看到,在processMemberClasses()方法中,会调用sourceClass的getMemberClasses()方法获取SourceClass的集合。

(3)解析SourceClass类的getMemberClasses()方法

源码详见:org.springframework.context.annotation.ConfigurationClassParser.SourceClass#getMemberClasses()。

public Collection<SourceClass> getMemberClasses() throws IOException {
    Object sourceToProcess = this.source;
    if (sourceToProcess instanceof Class<?> sourceClass) {
        try {
            Class<?>[] declaredClasses = sourceClass.getDeclaredClasses();
            List<SourceClass> members = new ArrayList<>(declaredClasses.length);
            for (Class<?> declaredClass : declaredClasses) {
                members.add(asSourceClass(declaredClass, DEFAULT_EXCLUSION_FILTER));
            }
            return members;
        }
        catch (NoClassDefFoundError err) {
            sourceToProcess = metadataReaderFactory.getMetadataReader(sourceClass.getName());
        }
    }
    MetadataReader sourceReader = (MetadataReader) sourceToProcess;
    String[] memberClassNames = sourceReader.getClassMetadata().getMemberClassNames();
    List<SourceClass> members = new ArrayList<>(memberClassNames.length);
    for (String memberClassName : memberClassNames) {
        try {
            members.add(asSourceClass(memberClassName, DEFAULT_EXCLUSION_FILTER));
        }
        catch (IOException ex) {
            if (logger.isDebugEnabled()) {
                logger.debug("Failed to resolve member class [" + memberClassName + "] - not considering it as a configuration class candidate");
            }
        }
    }
    return members;
}

getMemberClasses()方法的主要作用就是处理标注了@Component、@Repository、@Service和@Controller注解的类的内部类,因为内部类也有可能会标注这些注解。在getMemberClasses()方法中,利用反射拿到类的内部类,将内部类封装成SourceClass,存放到members集合中并返回。

(4)返回ConfigurationClassParser类的processMemberClasses(ConfigurationClass configClass, SourceClass sourceClass,Predicatefilter)方法

此时重点关注如下代码。

private void processMemberClasses(ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter) throws IOException {
    /*******************省略其他代码*****************/
    if (!memberClasses.isEmpty()) {
        List<SourceClass> candidates = new ArrayList<>(memberClasses.size());
        for (SourceClass memberClass : memberClasses) {
            if (ConfigurationClassUtils.isConfigurationCandidate(memberClass.getMetadata()) && !memberClass.getMetadata().getClassName().equals(configClass.getMetadata().getClassName())) {
                candidates.add(memberClass);
            }
        }
      /*******************省略其他代码*****************/
    }
}

可以看到,在ConfigurationClassParser类的processMemberClasses()方法中,如果获取到的内部类集合memberClasses不为空,则遍历获取到的memberClasses集合,使用ConfigurationClassUtils类的isConfigurationCandidate()方法判断内部类上是否有需要处理的注解,如果有需要处理的注解,则将类添加到candidates集合中。

(5)解析ConfigurationClassUtils类的isConfigurationCandidate(AnnotationMetadata metadata)方法

源码详见:org.springframework.context.annotation.ConfigurationClassUtils#isConfigurationCandidate(AnnotationMetadata metadata)。

static boolean isConfigurationCandidate(AnnotationMetadata metadata) {
    if (metadata.isInterface()) {
        return false;
    }
    for (String indicator : candidateIndicators) {
        if (metadata.isAnnotated(indicator)) {
            return true;
        }
    }
    return hasBeanMethods(metadata);
}

isConfigurationCandidate()方法的作用主要是判断内部类上面是否有需要处理的注解,具体的判断逻辑是:如果是接口,则直接返回false,如果是@Component(含@Repository、@Service和@Controller)、@ComponentScan、@Import、@ImportResource等注解,则返回true。最后判断方法上是否标注了@Bean注解,如果标注了@Bean注解,则返回true。否则,返回false。

(6)返回ConfigurationClassParser类的processMemberClasses(ConfigurationClass configClass, SourceClass sourceClass,Predicatefilter)方法

此时重点关注如下代码。

private void processMemberClasses(ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter) throws IOException {
    /**********省略其他代码**************/
    if (!memberClasses.isEmpty()) {
        /**********省略其他代码**************/
        OrderComparator.sort(candidates);
        for (SourceClass candidate : candidates) {
            if (this.importStack.contains(configClass)) {
                this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
            }
            else {
                this.importStack.push(configClass);
                try {
                    processConfigurationClass(candidate.asConfigClass(configClass), filter);
                }
                finally {
                    this.importStack.pop();
                }
            }
        }
    }
}

在processMemberClasses()方法中,首先对获取到的内部类进行排序,随后遍历内部类集合,调用candidate的asConfigClass()方法将内部类封装成ConfigurationClass对象。并传入processConfigurationClass()方法中解析内部类的注解信息。

(7)返回ConfigurationClassParser类的doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass, Predicatefilter)方法。

继续分析如下代码片段。

Set<BeanDefinitionHolder> scannedBeanDefinitions = this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());

其他分析流程省略,直接来到ClassPathBeanDefinitionScanner类的doScan(String... basePackages)方法。

(8)解析ClassPathBeanDefinitionScanner类的doScan(String... basePackages)方法

源码详见:org.springframework.context.annotation.ClassPathBeanDefinitionScanner#doScan(String... basePackages)。

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);
        /***************省略其他代码*****************/
    }
    return beanDefinitions;
}

可以看到,在ClassPathBeanDefinitionScanner类的doScan()中,会遍历传入的扫描包路径数组,调用findCandidateComponents()方法加载符合一定条件的BeanDefinition。

(9)解析ClassPathScanningCandidateComponentProvider类的findCandidateComponents(String basePackage)方法

源码详见:org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#findCandidateComponents(String basePackage)

public Set<BeanDefinition> findCandidateComponents(String basePackage) {
    if (this.componentsIndex != null && indexSupportsIncludeFilters()) {
        return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);
    }
    else {
        return scanCandidateComponents(basePackage);
    }
}

在findCandidateComponents()方法中,会调用scanCandidateComponents()方法来扫描basePackage包下标注了注解的类。

(10)解析ClassPathScanningCandidateComponentProvider类的scanCandidateComponents(String basePackage)方法

源码详见:org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#scanCandidateComponents(String basePackage)。

private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
    Set<BeanDefinition> candidates = new LinkedHashSet<>();
    try {
        String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
            resolveBasePackage(basePackage) + '/' + this.resourcePattern;
        Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
        boolean traceEnabled = logger.isTraceEnabled();
        boolean debugEnabled = logger.isDebugEnabled();
        for (Resource resource : resources) {
            String filename = resource.getFilename();
            if (filename != null && filename.contains(ClassUtils.CGLIB_CLASS_SEPARATOR)) {
                continue;
            }
            if (traceEnabled) {
                logger.trace("Scanning " + resource);
            }
            try {
                MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
                if (isCandidateComponent(metadataReader)) {
                    ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
                    sbd.setSource(resource);
                    if (isCandidateComponent(sbd)) {
                        if (debugEnabled) {
                            logger.debug("Identified candidate component class: " + resource);
                        }
                        candidates.add(sbd);
                    }
                /***************省略其他代码*************/
            }
            catch (FileNotFoundException ex) {
                if (traceEnabled) {
                    logger.trace("Ignored non-readable " + resource + ": " + ex.getMessage());
                }
            }
            catch (Throwable ex) {
                throw new BeanDefinitionStoreException(
                    "Failed to read candidate component class: " + resource, ex);
            }
        }
    }
    catch (IOException ex) {
        throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
    }
    return candidates;
}

可以看到,在ClassPathScanningCandidateComponentProvider类的scanCandidateComponents()方法中,会加载basePackage包路径下的资源,将其封装成ScannedGenericBeanDefinition类的对象,并传入isCandidateComponent()方法中对类进行过滤。符合条件时,会将当前ScannedGenericBeanDefinition类的对象存入candidates集合中,最终返回candidates集合。

(11)解析ClassPathScanningCandidateComponentProvider类的isCandidateComponent(MetadataReader metadataReader)方法

源码详见:org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#isCandidateComponent(MetadataReader metadataReader)。

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;
}

可以看到,在isCandidateComponent()方法中,首先遍历excludeFilters规则列表,如果匹配到excludeFilters规则,则直接返回false。否则,遍历includeFilters规则,如果匹配到includeFilters规则,则调用isConditionMatch()方法来匹配@Conditional注解的规则。

这里,注意的是在IOC容器启动调用AnnotationConfigApplicationContext类的构造方法时,就会对includeFilters规则列表进行初始化。源码详见:org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#registerDefaultFilters()

protected void registerDefaultFilters() {
    this.includeFilters.add(new AnnotationTypeFilter(Component.class));
    ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
    try {
        this.includeFilters.add(new AnnotationTypeFilter(
            ((Class<? extends Annotation>) ClassUtils.forName("jakarta.annotation.ManagedBean", cl)), false));
        logger.trace("JSR-250 'jakarta.annotation.ManagedBean' found and supported for component scanning");
    }
    catch (ClassNotFoundException ex) {
        // JSR-250 1.1 API (as included in Jakarta EE) not available - simply skip.
    }
    try {
        this.includeFilters.add(new AnnotationTypeFilter(
            ((Class<? extends Annotation>) ClassUtils.forName("jakarta.inject.Named", cl)), false));
        logger.trace("JSR-330 'jakarta.inject.Named' annotation found and supported for component scanning");
    }
    catch (ClassNotFoundException ex) {
        // JSR-330 API not available - simply skip.
    }
}

可以看到,在registerDefaultFilters()方法中,默认会将@Component注解封装成AnnotationTypeFilter对象并存入includeFilters规则列表中。

(12)返回ClassPathBeanDefinitionScanner类的doScan(String... basePackages)方法

源码详见:org.springframework.context.annotation.ClassPathBeanDefinitionScanner#doScan(String... basePackages)。此时重点关注如下代码片段。

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) {
            /***********省略其他代码***********/
            if (candidate instanceof AnnotatedBeanDefinition) {
                AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
            }
            if (checkCandidate(beanName, candidate)) {
                BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
                definitionHolder =  AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
                beanDefinitions.add(definitionHolder);
                registerBeanDefinition(definitionHolder, this.registry);
            }
        }
    }
    return beanDefinitions;
}

后续解析AnnotationConfigUtils类的processCommonDefinitionAnnotations()方法和解析registerBeanDefinition()方法的流程与第9章5.2小节的源码分析流程一致,这里不再赘述。

至此,@Component注解在Spring源码层面的执行流程分析完毕。

六、总结

​@Component注解介绍完了,我们一起总结下吧!​

本章,首先介绍了@Component注解的源码和使用场景,随后介绍了@Component注解的使用案例。接下来,详细介绍了@Component在Spring中执行的源码时序图和源码流程。

七、思考

​既然学完了,就开始思考几个问题吧?​

关于@Component注解,通常会有如下几个经典面试题:

  • @Component注解的作用是什么?
  • @Component注解有哪些使用场景?
  • @Component注解是如何将Bean注入到IOC容器的?
  • @Component注解在Spring内部的执行流程?
  • 你在平时工作中,会在哪些场景下使用@Component注解?
  • 你从@Component注解的设计中得到了哪些启发?



文章转载自公众号:冰河技术

标签
已于2023-5-30 15:37:06修改
收藏
回复
举报
回复
    相关推荐