Spring中@import注解终极揭秘！

Spring中@import注解终极揭秘 - 程序员古德

技术概念

它能干啥

@Import注解在Spring框架中主要用于解决模块化和配置管理方面的技术问题，它可以帮助开发者实现以下几个目标：

模块化配置：在大型项目中，通常需要将配置信息分散到多个配置类中，以便更好地组织和管理，@Import注解允许开发者在一个主配置类中导入其他配置类，从而实现配置的模块化。
第三方库或组件的集成：当项目中需要集成第三方库或组件时，这些库或组件可能会提供自己的配置类，通过@Import注解，开发者可以轻松地将这些第三方配置类集成到项目的总体配置中。
条件化配置：@Import还可以与条件注解（如@Conditional）结合使用，以实现基于特定条件的配置加载，因此在不同的环境或情境下，可以加载不同的配置类，从而实现更加灵活和动态的配置管理。
扩展Spring功能：通过导入实现了特定接口的类，开发者可以扩展Spring框架的功能，比如，可以导入自定义的BeanFactoryPostProcessor或BeanDefinitionRegistrar来修改或添加bean定义。
解决循环依赖问题：在某些情况下，使用@Import注解可以解决因循环依赖而导致的配置问题，通过将相互依赖的配置类分解并使用@Import进行导入，可以打破循环依赖的链条。

它有哪些特性

在Spring框架中，@Import注解可以用来引入一个或多个组件，这些组件通常是通过@Bean注解定义的，当使用@Import注解时，实际上是在告诉Spring：“除了当前配置类中的bean定义外，还想包含另一个配置类（或多个配置类）中定义的bean。”

@Import注解可以用来引入：

带有@Bean方法的配置类：这是最常见的情况，可以在一个配置类中定义bean，并使用@Import将其引入到其他配置类中。
ImportSelector实现：这是一个更高级的特性，允许根据某些条件或运行时环境动态地选择要导入的配置类。
ImportBeanDefinitionRegistrar实现：这是一个更底层的机制，允许在运行时手动注册bean定义。
使用@Import来组合多个配置类，从而构建复杂的配置层次结构。

使用@Import注解引入一个类

下面是一个简单的Java代码示例，演示了如何使用@Import注解来导入一个配置类。

首先，定义一个简单的服务接口GreetingService和其实现类GreetingServiceImpl：

// GreetingService.java  
public interface GreetingService {  
    String sayGreeting();  
}  
  
// GreetingServiceImpl.java  
public class GreetingServiceImpl implements GreetingService {  
    @Override  
    public String sayGreeting() {  
        return "Hello, World!";  
    }  
}

接着，创建一个配置类GreetingConfig，该类使用@Bean注解来定义GreetingService的bean：

// GreetingConfig.java  
import org.springframework.context.annotation.Bean;  
import org.springframework.context.annotation.Configuration;  
  
@Configuration  
public class GreetingConfig {  
  
    @Bean  
    public GreetingService greetingService() {  
        return new GreetingServiceImpl();  
    }  
}

接着，创建一个主配置类AppConfig，并使用@Import注解来导入GreetingConfig类：

// AppConfig.java  
import org.springframework.context.annotation.Configuration;  
import org.springframework.context.annotation.Import;  
  
@Configuration  
@Import(GreetingConfig.class) // 导入GreetingConfig配置类  
public class AppConfig {  
    // 其他bean定义可以在这里添加  
}

最后，编写客户端代码来使用这个bean：

// Application.java  
import org.springframework.context.ApplicationContext;  
import org.springframework.context.annotation.AnnotationConfigApplicationContext;  
  
public class Application {  
  
    public static void main(String[] args) {  
        // 创建应用上下文，指定主配置类  
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);  
  
        // 从应用上下文中获取GreetingService bean  
        GreetingService greetingService = context.getBean(GreetingService.class);  
  
        // 调用bean的方法并打印结果  
        System.out.println(greetingService.sayGreeting());  
  
        // 关闭应用上下文（虽然在这个简单示例中不是必需的）  
        ((AnnotationConfigApplicationContext) context).close();  
    }  
}

运行上面代码，将会有如下输出：

Hello, World!

和ImportBeanDefinitionRegistrar接口一起使用

ImportBeanDefinitionRegistrar是一个Spring接口，它允许在运行时以编程方式注册额外的bean定义，当需要在Spring容器刷新过程中动态添加bean定义时，可以实现这个接口，ImportBeanDefinitionRegistrar通常与@Import注解结合使用，以便在Spring容器启动时执行自定义的bean注册逻辑。

下面是一个简单的案例，演示了如何使用ImportBeanDefinitionRegistrar来动态注册bean定义。

首先，创建一个简单的服务类MyDynamicService：

public class MyDynamicService {  
    public void performTask() {  
        System.out.println("MyDynamicService is performing a task.");  
    }  
}

然后，创建一个实现了 ImportBeanDefinitionRegistrar 接口的类 MyBeanDefinitionRegistrar：

import org.springframework.beans.factory.support.BeanDefinitionRegistry;  
import org.springframework.beans.factory.support.GenericBeanDefinition;  
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;  
import org.springframework.core.type.AnnotationMetadata;  
  
public class MyBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {  
  
    @Override  
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {  
        // 创建 GenericBeanDefinition 实例  
        GenericBeanDefinition beanDefinition = new GenericBeanDefinition();  
        // 设置 bean 类  
        beanDefinition.setBeanClassName(MyDynamicService.class.getName());  
        // 注册 bean 定义到容器中，指定 bean 的名称  
        registry.registerBeanDefinition("myDynamicService", beanDefinition);  
    }  
}

记着，需要一个配置类来触发 MyBeanDefinitionRegistrar 的注册：

import org.springframework.context.annotation.Configuration;  
import org.springframework.context.annotation.Import;  
  
@Configuration  
@Import(MyBeanDefinitionRegistrar.class)  
public class MyAppConfig {  
    // 其他配置...  
}

最后，在应用程序中使用 AnnotationConfigApplicationContext 来加载 MyAppConfig 并获取 MyDynamicService 的实例：

import org.springframework.context.ApplicationContext;  
import org.springframework.context.annotation.AnnotationConfigApplicationContext;  
  
public class Application {  
    public static void main(String[] args) {  
        ApplicationContext context = new AnnotationConfigApplicationContext(MyAppConfig.class);  
        MyDynamicService myDynamicService = context.getBean(MyDynamicService.class);  
        myDynamicService.performTask(); // 输出："MyDynamicService is performing a task."  
    }  
}

在这个例子中，当Spring容器启动时，它会处理@Import注解并调用MyBeanDefinitionRegistrar的registerBeanDefinitions方法。

这个方法会在容器中动态地注册MyDynamicService的bean定义，随后，可以像获取其他Springbean一样获取并使用MyDynamicService的实例。

和ImportSelector接口一起使用

ImportSelector是Spring框架提供的一个接口，它允许开发者在运行时根据某些条件或逻辑选择要导入的配置类，ImportSelector接口定义了一个方法selectImports，该方法返回一个字符串数组，表示要导入的配置类的全限定名。

以下是一个简单的示例，展示了如何使用ImportSelector来动态选择要导入的配置类：

首先，定义两个简单的配置类ConfigA和ConfigB，每个配置类都有一个Bean定义：

// ConfigA.java  
@Configuration  
public class ConfigA {  
    @Bean  
    public String configABean() {  
        return "Bean from ConfigA";  
    }  
}  
  
// ConfigB.java  
@Configuration  
public class ConfigB {  
    @Bean  
    public String configBBean() {  
        return "Bean from ConfigB";  
    }  
}

接下来，创建一个实现 ImportSelector 接口的类 MyImportSelector，它根据某个条件（例如系统属性）来决定导入哪个配置类：

// MyImportSelector.java  
import org.springframework.context.annotation.ImportSelector;  
import org.springframework.core.type.AnnotationMetadata;  
  
import java.util.Arrays;  
  
public class MyImportSelector implements ImportSelector {  
  
    @Override  
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {  
        // 根据某个条件决定导入哪个配置类  
        if (System.getProperty("config.selector") != null && "configA".equals(System.getProperty("config.selector"))) {  
            return new String[]{ConfigA.class.getName()};  
        } else {  
            return new String[]{ConfigB.class.getName()};  
        }  
    }  
}

在上面的 MyImportSelector 类中，selectImports 方法检查系统属性 config.selector 的值，并根据该值返回相应的配置类全限定名。

最后，创建一个主配置类 MainConfig，并使用 @Import 注解引入 MyImportSelector：

// MainConfig.java  
import org.springframework.context.annotation.Configuration;  
import org.springframework.context.annotation.Import;  
  
@Configuration  
@Import(MyImportSelector.class)  
public class MainConfig {  
    // 其他配置...  
}

现在，在应用程序中，可以根据系统属性 config.selector 的值来动态选择要加载的配置类：

// Application.java  
import org.springframework.context.ApplicationContext;  
import org.springframework.context.annotation.AnnotationConfigApplicationContext;  
  
public class Application {  
    public static void main(String[] args) {  
        // 设置系统属性以决定要导入的配置类  
        System.setProperty("config.selector", "configA"); // 设置为 "configA" 或 "configB"  
  
        ApplicationContext context = new AnnotationConfigApplicationContext(MainConfig.class);  
  
        // 根据系统属性的设置，以下将打印出不同的结果  
        String bean = context.getBean(String.class);  
        System.out.println(bean);  
    }  
}

运行上述 Application 类的 main 方法，并根据需要设置系统属性 config.selector 的值，将看到根据该值动态加载了不同的配置类中的 Bean。如果设置为 “configA”，则输出将是 “Bean from ConfigA”；如果设置为其他值或未设置，则输出将是 “Bean from ConfigB”。

使用@Import注解引入多个类

当使用@Import注解来组合多个配置类时，可以在一个主配置类上使用@Import注解，并指定要导入的其他配置类的类名。这样做可以让Spring框架在创建应用上下文时，加载并处理这些配置类中定义的bean。

以下是一个简单的代码案例，展示了如何使用@Import来组合多个配置类：

首先，定义两个简单的配置类，每个配置类都使用@Bean注解来定义一个不同的bean：

// FirstConfig.java  
@Configuration  
public class FirstConfig {  
  
    @Bean  
    public String firstBean() {  
        return "First Bean";  
    }  
}  
  
// SecondConfig.java  
@Configuration  
public class SecondConfig {  
  
    @Bean  
    public String secondBean() {  
        return "Second Bean";  
    }  
}

记着，创建一个主配置类，并使用@Import注解来导入上面定义的两个配置类：

// MainConfig.java  
@Configuration  
@Import({FirstConfig.class, SecondConfig.class})  
public class MainConfig {  
    // 这里不需要定义任何bean，因为只是组合其他配置类  
}

最后，编写一个客户端类来演示如何从应用上下文中获取这些bean：

// Application.java  
public class Application {  
  
    public static void main(String[] args) {  
        // 创建应用上下文，并指定主配置类  
        ApplicationContext context = new AnnotationConfigApplicationContext(MainConfig.class);  
  
        // 从应用上下文中获取FirstConfig中定义的bean  
        String firstBean = context.getBean("firstBean", String.class);  
        System.out.println("First Bean: " + firstBean);  
  
        // 从应用上下文中获取SecondConfig中定义的bean  
        String secondBean = context.getBean("secondBean", String.class);  
        System.out.println("Second Bean: " + secondBean);  
  
        // 关闭应用上下文（虽然不是必需的，但在实际应用程序中应该这样做）  
        ((ConfigurableApplicationContext) context).close();  
    }  
}

当运行Application类的main方法时，输出将会是：

First Bean: First Bean  
Second Bean: Second Bean

这证明了Spring成功地加载了FirstConfig和SecondConfig中定义的bean，并将它们组合到了由MainConfig类创建的应用上下文中，通过这种方式，可以轻松地将多个配置类组合在一起，从而构建更复杂的配置层次结构。

关注我，每天学习互联网编程技术 - 程序员古德

END!
END!
END!

往期回顾

精品文章

Java并发基础：concurrent Flow API全面解析

Java并发基础：CopyOnWriteArraySet全面解析

Java并发基础：ConcurrentSkipListMap全面解析

Java并发基础：ConcurrentSkipListSet全面解析！

Java并发基础：SynchronousQueue全面解析！