Spring注解之@Import注解怎么使用

其他教程   发布日期:2025年03月18日   浏览次数:227

本篇内容介绍了“Spring注解之@Import注解怎么使用”的有关知识,在实际案例的操作过程中,不少人都会遇到这样的困境,接下来就让小编带领大家学习一下如何处理这些情况吧!希望大家仔细阅读,能够学有所成!

    介绍

    在Spring中@Import使用得比较频繁,它得作用是导入bean,具体的导入方式有多种,特别在SpringBoot项目中,很多地方都使用到了@Import注解,特别对于一些和SpringBoot整合的组件,其实现都大量使用了@Import,例如使用Feign集成SpringBoot时会加上注解@EnableFeignClients,使用Dubbo时会使用@EnableDubbo等,这些注解里面都使用了@Import注解来注册一些bean。

    @Import导入bean的三种方式

    @Import导入bean有三种方式,分别是导入

    1. 普通类
    ,实现
    1. ImportSelector
    接口的类,实现
    1. ImportBeanDefinitionRegistrar
    接口的类。

    普通类

    在开放过程中,尽量保持类不要太过于庞大,类过于庞大的话会变得臃肿复杂,不好维护,一个配置类中需要配置很多bean,且逻辑实现也比较复杂,代码量大,如果全部都放在同一个配置类中,这显然不太理智,这时候我们可以将每个bean单独拿出来放到一个类里面,然后使用@Import注解导入,如下代码所示。

    • 定义一个bean

    1. @Data
    2. public class UserBean {
    3. private String username;
    4. private String sex;
    5. }
    • 导入bean

    1. @Configuration
    2. @Import(value = {UserBean.class}) //注入普通Bean
    3. public class ImportConfiguration {
    4. }

    从上面可以看出只需要在配置类上面使用@Import注解导入对应Java Bean,然后这个bean就能注册进IOC容器中。

    ImportSelector接口

    ImportSelector是一个接口,可以通过实现它来完成bean的注册,它只有一个

    1. selectImports()
    方法,它会返回一个bean的名称数组,这个数组中的bean名称就会被注册进IOC容器中。
    1. public class MyImportSelector implements ImportSelector {
    2. @Override
    3. public String[] selectImports(AnnotationMetadata importingClassMetadata) {
    4. return new String[]{UserBean.class.getName()};
    5. }
    6. }

    ImportBeanDefinitionRegistrar接口

    使用ImportBeanDefinitionRegistrar也可以注册bean,它会传入BeanDefinitionRegistry接口,然后进可以注册bean,这里注册的是bean的元信息BeanDefinition。

    1. public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    2. @Override
    3. public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    4. String name = UserBean.class.getName();
    5. BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition(UserBean.class);
    6. builder.addPropertyValue("sex","男");
    7. AbstractBeanDefinition beanDefinition = builder.getBeanDefinition();
    8. registry.registerBeanDefinition(name, beanDefinition);
    9. }
    10. }

    源码解析

    spring容器启动后,会在

    1. ConfigurationClassParser
    解析类中解析@Import注解,解析出需要注册的bean,下面就是最关键的代码,通过调用processImports方法,然后解析出对应的bean,可以看出有几个判断,分别判断是否是ImportSelector类型,ImportBeanDefinitionRegistrar类型,如果都不是,则证明是直接导入普通java类,如果是普通java类和ImportSelector类型,那么就会将要注册的bean加入一个Map集合configurationClasses中,后续会将它进行注册,如果是ImportBeanDefinitionRegistrar类型,那么会将其加入一个Map集合importBeanDefinitionRegistrars中,后续在扩展点会对它进行再次处理。
    1. private void processImports(ConfigurationClass configClass, ConfigurationClassParser.SourceClass currentSourceClass,
    2. Collection<ConfigurationClassParser.SourceClass> importCandidates, Predicate<String> exclusionFilter,
    3. boolean checkForCircularImports) {
    4. if (candidate.isAssignable(ImportSelector.class)) {
    5. Class<?> candidateClass = candidate.loadClass();
    6. ImportSelector selector = ParserStrategyUtils.instantiateClass(candidateClass, ImportSelector.class,
    7. this.environment, this.resourceLoader, this.registry);
    8. Predicate<String> selectorFilter = selector.getExclusionFilter();
    9. if (selectorFilter != null) {
    10. exclusionFilter = exclusionFilter.or(selectorFilter);
    11. }
    12. if (selector instanceof DeferredImportSelector deferredImportSelector) {
    13. this.deferredImportSelectorHandler.handle(configClass, deferredImportSelector);
    14. } else {
    15. String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
    16. Collection<ConfigurationClassParser.SourceClass> importSourceClasses = asSourceClasses(importClassNames, exclusionFilter);
    17. processImports(configClass, currentSourceClass, importSourceClasses, exclusionFilter, false);
    18. }
    19. } else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
    20. Class<?> candidateClass = candidate.loadClass();
    21. ImportBeanDefinitionRegistrar registrar =
    22. ParserStrategyUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class,
    23. this.environment, this.resourceLoader, this.registry);
    24. configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
    25. } else {
    26. this.importStack.registerImport(
    27. currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
    28. processConfigurationClass(candidate.asConfigClass(configClass), exclusionFilter);
    29. }
    30. }

    经过上面解析后,Spring会注册Bean的元信息,会通过

    1. configClass.isImported()
    判断bean是否是通过@Import方式导入的普通bean或者ImportSelector类型的导入的bean,如果是,则执行
    1. registerBeanDefinitionForImportedConfigurationClass
    ,里面主要就是组装成BeanDefinition,然后注册进BeanFactory。
    1. private void loadBeanDefinitionsForConfigurationClass(ConfigurationClass configClass, ConfigurationClassBeanDefinitionReader.TrackedConditionEvaluator trackedConditionEvaluator) {
    2. if (trackedConditionEvaluator.shouldSkip(configClass)) {
    3. String beanName = configClass.getBeanName();
    4. if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {
    5. this.registry.removeBeanDefinition(beanName);
    6. }
    7. this.importRegistry.removeImportingClass(configClass.getMetadata().getClassName());
    8. return;
    9. }
    10. if (configClass.isImported()) {
    11. registerBeanDefinitionForImportedConfigurationClass(configClass);
    12. }
    13. for (BeanMethod beanMethod : configClass.getBeanMethods()) {
    14. loadBeanDefinitionsForBeanMethod(beanMethod);
    15. }
    16. loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
    17. loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
    18. }

    如果是通过ImportBeanDefinitionRegistrar方式,则会调用loadBeanDefinitionsFromRegistrars,里面会循环去执行我们自定义的ImportBeanDefinitionRegistrar,然后进行bean的元信息注册。

    1. private void loadBeanDefinitionsFromRegistrars(Map<ImportBeanDefinitionRegistrar, AnnotationMetadata> registrars) {
    2. registrars.forEach((registrar, metadata) ->
    3. registrar.registerBeanDefinitions(metadata, this.registry, this.importBeanNameGenerator));
    4. }

    从上面的源码解析中,我们看出通过@Import直接导入普通的java类和导入实现了ImportSelector接口的类是直接注册进BeanFactory,这两者本质是一样的,而通过实现ImportBeanDefinitionRegistrar接口方式的类则需要去实现我们自定义的注册bean元信息的逻辑。

    以上就是Spring注解之@Import注解怎么使用的详细内容,更多关于Spring注解之@Import注解怎么使用的资料请关注九品源码其它相关文章!