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：
然后，创建一个实现了 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类创建的应用上下文中，通过这种方式，可以轻松地将多个配置类组合在一起，从而构建更复杂的配置层次结构。
- 发表于:
- 原文链接：https://page.om.qq.com/page/OttZDR5m69-_oLUoKlvpldWQ0
- 腾讯「腾讯云开发者社区」是腾讯内容开放平台帐号（企鹅号）传播渠道之一，根据《腾讯内容开放平台服务协议》转载发布内容。
- 如有侵权，请联系 cloudcommunity@tencent.com 删除。
相关快讯
扫码
添加站长 进交流群
领取专属 10元无门槛券
私享最新 技术干货
腾讯云开发者
