【Springboot】@Import 注解的使用

作用

@Import 可以基于 Java 注解配置是Spring ，提供了类似 @Bean 注解的功能，通过@Import直接将指定类作为组件给容器注入

1.配置类里面使用@Bean标注在方法上，给容器注册组件，默认也是单实例的
2.配置类本身也是组件
3.proxyBeanMethods: 代理bean的方法
Full(proxyBeanMethods = true) 默认，调用多次方法，只产生一个对象
Lite(proxyBeanMethods = false) 每次调用这些方法，都会产生一个新的对象
4.@Import({})
给容器中自动创建出这两个类型的组件，组件名字默认是全类名

编码实现

config.MyConfig

MyConfig.java

package com.zwy.boot.config;

import ch.qos.logback.core.db.DBHelper;
import com.zwy.boot.bean.Pet;
import com.zwy.boot.bean.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

/**
 * 1.配置类里面使用@Bean标注在方法上，给容器注册组件，默认也是单实例的
 * 2.配置类本身也是组件
 * 3.proxyBeanMethods: 代理bean的方法
 *         Full(proxyBeanMethods = true)  默认，调用多次方法，只产生一个对象
 *         Lite(proxyBeanMethods = false)  每次调用这些方法，都会产生一个新的对象
 * 4.@Import({})
 *         给容器中自动创建出这两个类型的组件，组件名字默认是全类名
 * @author zwy
 */
@Import({User.class, DBHelper.class})
@Configuration(proxyBeanMethods = true)
public class MyConfig {

    /**
     * @Bean 给容器中添加组件，以方法名作为组件的名字。
     * 返回类型就是组件的类型，返回的值，就是组件在容器中的实例
     * 外部无论对配置类中这个组件注册方法调用多少次，获取的都是之前注册容器中的单实例对象
     * @return User
     */
    @Bean
    public User user01() {
        User zhangsan = new User("zhangsan", 18);
        // User组件依赖了Pet组件
        zhangsan.setPet(tomcatPet());
        return zhangsan;
    }

    // 自定义组件名字"tom"
    @Bean("tom")
    public Pet tomcatPet() {
        return new Pet("tomcat");
    }
}

MainApplication

MainApplication.java

package com.zwy.boot;

import ch.qos.logback.core.db.DBHelper;
import com.zwy.boot.bean.Pet;
import com.zwy.boot.bean.User;
import com.zwy.boot.config.MyConfig;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

/**
 * 主程序类; 主配置类
 * 注解@SpringBootApplication：这是一个springboot应用
 * @author zwy
 */
@SpringBootApplication
public class MainApplication {

    public static void main(String[] args) {
        // 1.返回IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);

        // 2.查看容器里面的组件
        String[] names = run.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }

        System.out.println("======================");

        // 3.从容器中获取组件，注册
        Pet pet1 = run.getBean("tom", Pet.class);
        Pet pet2 = run.getBean("tom", Pet.class);
        System.out.println("组件：" + (pet1 == pet2));

        MyConfig bean = run.getBean(MyConfig.class);
        System.out.println(bean);

        User user1 = bean.user01();
        User user2 = bean.user01();
        System.out.println(user1 == user2);

        // 4.验证proxyBeanMethods=false时，用户的宠物是不是容器中的宠物？
        User user01 = run.getBean("user01", User.class);
        Pet tom = run.getBean("tom", Pet.class);
        System.out.println("用户的宠物：" + (user01.getPet() == tom));

        // 5.获取组件
        String[] beanNamesForType = run.getBeanNamesForType(User.class);
        System.out.println("=====================");
        for (String s : beanNamesForType) {
            System.out.println(s);
        }
        DBHelper bean1 = run.getBean(DBHelper.class);
        System.out.println(bean1);
    }
}

另外有：

bean.Pet

Pet.java

package com.zwy.boot.bean;

/**
 * 宠物
 * @author zwy
 */
public class Pet {

    private String name;

    public Pet() {
    }

    public Pet(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Pet{" +
                "name='" + name + '\'' +
                '}';
    }
}

bean.User

User.java

package com.zwy.boot.bean;

/**
 * 用户
 * @author zwy
 */
public class User {

    private String name;

    private Integer age;

    private Pet pet;

    public User() {
    }

    public User(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Pet getPet() {
        return pet;
    }

    public void setPet(Pet pet) {
        this.pet = pet;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", pet=" + pet +
                '}';
    }
}

文件结构

实验项目的文件结构如下：

运行

则运行结果有：

总结

在Spring Boot中，@Import注解用于导入其他配置类或组件类，使得它们的Bean定义和配置信息能够被当前的应用上下文所识别和使用。@Import注解功能：

1. 导入配置类：
   当你在某个类或者配置类上使用@Import注解时，你可以指定一个或多个需要导入的类。这些类可以是其他的@Configuration配置类，也可以是普通的Java类。
2. 注入Bean定义：
   通过@Import注解导入的类中的@Bean方法或者通过@ComponentScan扫描到的@Component、@Service、@Repository、@Controller等注解标记的类，其定义的Bean会被自动注册到Spring容器中。
3. 组合配置：
   @Import注解提供了一种将多个相关配置类组合在一起的方式，这样可以更好地组织和管理你的应用程序配置。
4. 自定义导入类：
   除了直接导入具体的类，你还可以使用ImportSelector或ImportBeanDefinitionRegistrar接口来自定义导入逻辑。这两个接口允许你在运行时动态决定需要导入哪些类或Bean。
5. 导入选择器（ImportSelector）：
   实现ImportSelector接口的类可以在运行时根据某种逻辑选择要导入的类。ImportSelector接口提供了selectImports()方法，该方法返回一个字符串数组，每个字符串代表一个要导入的类的全限定名。
6. 注册器（ImportBeanDefinitionRegistrar）：
   实现ImportBeanDefinitionRegistrar接口的类可以在运行时直接操作BeanDefinitionRegistry，动态注册Bean定义。这个接口提供了registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry)方法，可以在其中自定义注册Bean的逻辑。
7. 作用域：
   @Import注解通常在@Configuration类上使用，但也可以在@Component或任何其他受Spring管理的类上使用。

总的来说，@Import注解在Spring Boot中提供了一种灵活的方式来组织和组合配置类，以及动态地引入和注册Bean定义，使得应用程序的配置更加模块化和可维护。

参考

https://blog.csdn.net/tuoni123/article/details/80213050