当前位置： 代码网 > it编程>编程语言>Java > SpringBoot自动装配Import示例详解

SpringBoot自动装配Import示例详解

2024年09月17日 • Java •我要评论
一、前言@import导入的类会被spring加载到ioc容器中。而@import提供4中用法：导入bean导入配置类导入 importselector 实现类。一般用于加载配置文件中的类导入 imp

一、前言

@import导入的类会被spring加载到ioc容器中。而@import提供4中用法：

导入bean

导入配置类

导入 importselector 实现类。一般用于加载配置文件中的类

导入 importbeandefinitionregistrar 实现类。

二、 定义

@import注解定义如下，其内部只有一个参数为class对象数组

@target(elementtype.type)
@retention(retentionpolicy.runtime)
@documented
public @interface import {
  class<?>[] value();
}

三、使用说明

通过一个简单的小例子测试一下@import是不是真的能实现bean的注入

3.1 创建项目

3.1.1 导入依赖

这里我们除了springboot依赖，再添加个lombok依赖

<?xml version="1.0" encoding="utf-8"?>
<project xmlns="http://maven.apache.org/pom/4.0.0" xmlns:xsi="http://www.w3.org/2001/xmlschema-instance"
         xsi:schemalocation="http://maven.apache.org/pom/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelversion>4.0.0</modelversion>
    <parent>
        <groupid>org.springframework.boot</groupid>
        <artifactid>spring-boot-starter-parent</artifactid>
        <version>2.5.3</version>
        <relativepath/> <!-- lookup parent from repository -->
    </parent>
    <groupid>com.ldx</groupid>
    <artifactid>import-annotation</artifactid>
    <version>0.0.1-snapshot</version>
    <name>import-annotation</name>
    <description>demo project for spring boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter</artifactid>
        </dependency>
        <dependency>
            <groupid>org.projectlombok</groupid>
            <artifactid>lombok</artifactid>
            <optional>true</optional>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupid>org.springframework.boot</groupid>
                <artifactid>spring-boot-maven-plugin</artifactid>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupid>org.projectlombok</groupid>
                            <artifactid>lombok</artifactid>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

3.1.2 创建user类

package com.ldx.importannotation;
import lombok.allargsconstructor;
import lombok.data;
/**
 * 用户信息实体
 * @author ludangxin
 * @date 2021/8/1
 */
@data
@allargsconstructor
public class user {
   public user() {
      this.name = "李四";
      this.age = 13;
   }
   private string name;
   private integer age;
}

3.2 测试导入bean

3.2.1 修改启动类

import lombok.extern.slf4j.slf4j;
import org.springframework.boot.springapplication;
import org.springframework.boot.autoconfigure.springbootapplication;
import org.springframework.context.configurableapplicationcontext;
import org.springframework.context.annotation.import;
@slf4j
// 注入userbean
@import(value = user.class)
@springbootapplication
public class importannotationapplication {
   public static void main(string[] args) {
      configurableapplicationcontext applicationcontext = springapplication.run(importannotationapplication.class, args);
      user user = applicationcontext.getbean(user.class);
      log.info("user info ==={}",user);
   }
}

3.3 测试导入配置类

3.3.1 创建userconfig类

import org.springframework.context.annotation.bean;
/**
 * 用户配置类
 * @author ludangxin
 * @date 2021/8/1
 */
public class userconfig {
   @bean
   public user getuser(){
      return new user();
   }
}

3.3.2 修改启动类

将启动类上的@import的value指向userconfig类

@import(value = userconfig.class)

userbean注入成功。

3.4 测试导入importselector

3.4.1 创建useimportselector类

import org.springframework.context.annotation.importselector;
import org.springframework.core.type.annotationmetadata;
/**
 * 用户bean选择器配置类
 * @author ludangxin
 * @date 2021/8/1
 */
public class useimportselector implements importselector {
   @override
   public string[] selectimports(annotationmetadata importingclassmetadata) {
      // 指定user类的全限类名
      return new string[]{"com.ldx.importannotation.user"};
   }
}

3.4.2 修改启动类

将启动类上的@import的value指向useimportselector类

@import(value = useimportselector.class)

3.4.3 启动测试

userbean注入成功。

3.5 测试导入importbeandefinitionregistrar类

3.5.1 创建userimportbeandefinitionregistrar

package com.ldx.importannotation;
import org.springframework.beans.factory.config.beandefinition;
import org.springframework.beans.factory.support.beandefinitionbuilder;
import org.springframework.beans.factory.support.beandefinitionregistry;
import org.springframework.context.annotation.importbeandefinitionregistrar;
import org.springframework.core.type.annotationmetadata;
/**
 * 用户bean定义注册配置类
 * @author ludangxin
 * @date 2021/8/1
 */
public class userimportbeandefinitionregistrar implements importbeandefinitionregistrar {
   @override
   public void registerbeandefinitions(annotationmetadata importingclassmetadata, beandefinitionregistry registry) {
      // 创建user类型的bean的定义
      beandefinition beandefinition = beandefinitionbuilder.rootbeandefinition(user.class).getbeandefinition();
      // 将创建的userbean定义注册到springregistry中，其名称为user
      registry.registerbeandefinition("user", beandefinition);
   }
}

3.5.2 修改启动类

将启动类上的@import的value指向userimportbeandefinitionregistrar类

@import(value = userimportbeandefinitionregistrar.class)

3.6 小结

简介中介绍的四种方式都可以注入userbean。

好处：

  • 导入指定的bean或配置类。例如：由于业务需要将包路径或者需要加载的bean类不在@componentscan的扫描范围内，这时候我们就可以通过@import来实现bean的注入。
  • importselector方式是制定需要加载类的全限类名。这时候我们就可以将我们的需要装载的类写到配置文件中，比如某个txt中，然后项目启动的时候读取txt中的全限类名，实现bean的装载。springboot就是使用这种方式实现的自动装配。

四、 改进

上面的例子通过使用@import注解实现了spring bean的自动注入。但是装载bean每次都得指定bean的类或者配置类，在生产环境中我们在使用第三方jar的时候根本不知道应该使用哪个配置文件或者压根就不知道配置文件的名称。这时我们其实可以扩展一个注解来优化这个问题。

4.1 创建注解

package com.ldx.importannotation;
import org.springframework.context.annotation.import;
import java.lang.annotation.*;
/**
 * 启用user配置信息注解
 * @author ludangxin
 * @date 2021/8/1
 */
@target(elementtype.type)
@retention(retentionpolicy.runtime)
@documented
// 指定需要导入的userbean的配置类
@import(useimportselector.class)
public @interface enableuser {}

4.2 修改启动类

注掉之前的@import，使用刚创建的@enableuser注解

import lombok.extern.slf4j.slf4j;
import org.springframework.boot.springapplication;
import org.springframework.boot.autoconfigure.springbootapplication;
import org.springframework.context.configurableapplicationcontext;
import org.springframework.context.annotation.import;
@slf4j
//@import(value = userimportbeandefinitionregistrar.class)
@enableuser
@springbootapplication
public class importannotationapplication {
   public static void main(string[] args) {
      configurableapplicationcontext applicationcontext = springapplication.run(importannotationapplication.class, args);
      user user = applicationcontext.getbean(user.class);
      log.info("user info ==={}",user);
   }
}

userbean注入成功。

思考🤔
springboot项目中能不能直接获取或者使用jar包中的bean呢？

五、 验证

5.1 创建项目

user模块为bean的提供者，book-manage通过引入user模块jar，来验证项目中能不能直接使用jar中的bean

5.2 创建user模块

5.2.1 导入依赖

没啥特别的依赖

<?xml version="1.0" encoding="utf-8"?>
<project xmlns="http://maven.apache.org/pom/4.0.0" xmlns:xsi="http://www.w3.org/2001/xmlschema-instance"
   xsi:schemalocation="http://maven.apache.org/pom/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelversion>4.0.0</modelversion>
   <parent>
      <groupid>org.springframework.boot</groupid>
      <artifactid>spring-boot-starter-parent</artifactid>
      <version>2.5.3</version>
      <relativepath/> <!-- lookup parent from repository -->
   </parent>
   <groupid>com.ldx</groupid>
   <artifactid>user</artifactid>
   <version>0.0.1-snapshot</version>
   <name>user</name>
   <description>demo project for spring boot</description>
   <properties>
      <java.version>1.8</java.version>
   </properties>
   <dependencies>
      <dependency>
         <groupid>org.springframework.boot</groupid>
         <artifactid>spring-boot-starter</artifactid>
      </dependency>
      <dependency>
         <groupid>org.projectlombok</groupid>
         <artifactid>lombok</artifactid>
         <optional>true</optional>
      </dependency>
   </dependencies>
   <build>
      <plugins>
         <plugin>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-maven-plugin</artifactid>
            <configuration>
               <excludes>
                  <exclude>
                     <groupid>org.projectlombok</groupid>
                     <artifactid>lombok</artifactid>
                  </exclude>
               </excludes>
            </configuration>
         </plugin>
      </plugins>
   </build>
</project>

5.2.2 创建user类

package com.ldx.user;
import lombok.allargsconstructor;
import lombok.data;
import lombok.noargsconstructor;
import java.util.arraylist;
import java.util.list;
/**
 * 用户信息类
 * @author ludangxin
 * @date 2021/8/1
 */
@data
@noargsconstructor
@allargsconstructor
public class user {
   private integer id;
   private string name;
   /**
    * 角色状态吗 1.管理员 2.老师 3.学生
    */
   private character role;
   private integer age;
   public user getuserinfo() {
      return new user(66, "张三", '3', 21);
   }
   /**
    * 获取其任课老师信息
    */
   public list<user> getteachers() {
      list<user> users = new arraylist<>();
      user user = new user();
      user.setid(2);
      user.setname("王麻子");
      user.setage(45);
      user.setrole('2');
      user user1 = new user();
      user1.setid(3);
      user1.setname("李四");
      user1.setage(35);
      user1.setrole('2');
      users.add(user);
      users.add(user1);
      return users;
   }
}

5.2.3 修改启动类

import lombok.extern.slf4j.slf4j;
import org.springframework.boot.springapplication;
import org.springframework.boot.autoconfigure.springbootapplication;
import org.springframework.context.configurableapplicationcontext;
import org.springframework.context.annotation.bean;
@slf4j
@springbootapplication
public class userapplication {
  public static void main(string[] args) {
    configurableapplicationcontext applicationcontext = springapplication.run(userapplication.class, args);
    user user = applicationcontext.getbean(user.class);
    user.getteachers().foreach(obj ->
      log.info("user teacher info ==={} ", obj)
    );
  }
  @bean
  public user getuser() {
    return new user();
  }
}

5.3 创建book-manage模块

5.3.1 导入依赖

<?xml version="1.0" encoding="utf-8"?>
<project xmlns="http://maven.apache.org/pom/4.0.0" xmlns:xsi="http://www.w3.org/2001/xmlschema-instance"
   xsi:schemalocation="http://maven.apache.org/pom/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelversion>4.0.0</modelversion>
   <parent>
      <groupid>org.springframework.boot</groupid>
      <artifactid>spring-boot-starter-parent</artifactid>
      <version>2.5.3</version>
      <relativepath/> <!-- lookup parent from repository -->
   </parent>
   <groupid>com.ldx</groupid>
   <artifactid>book-manage</artifactid>
   <version>0.0.1-snapshot</version>
   <name>book-manage</name>
   <description>demo project for spring boot</description>
   <properties>
      <java.version>1.8</java.version>
   </properties>
   <dependencies>
      <dependency>
         <groupid>org.springframework.boot</groupid>
         <artifactid>spring-boot-starter</artifactid>
      </dependency>
      <dependency>
         <groupid>org.projectlombok</groupid>
         <artifactid>lombok</artifactid>
         <optional>true</optional>
      </dependency>
      <!-- user模块依赖 -->
      <dependency>
         <groupid>com.ldx</groupid>
         <artifactid>user</artifactid>
         <version>0.0.1-snapshot</version>
      </dependency>
   </dependencies>
   <build>
      <plugins>
         <plugin>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-maven-plugin</artifactid>
            <configuration>
               <excludes>
                  <exclude>
                     <groupid>org.projectlombok</groupid>
                     <artifactid>lombok</artifactid>
                  </exclude>
               </excludes>
            </configuration>
         </plugin>
      </plugins>
   </build>
</project>

5.3.2 修改启动类

直接获取user bean 并调用getuserinfo方法

import com.ldx.user.user;
import lombok.extern.slf4j.slf4j;
import org.springframework.boot.springapplication;
import org.springframework.boot.autoconfigure.springbootapplication;
import org.springframework.context.configurableapplicationcontext;
@slf4j
@springbootapplication
public class bookmanageapplication {
  public static void main(string[] args) {
    configurableapplicationcontext applicationcontext = springapplication.run(bookmanageapplication.class, args);
    user user = applicationcontext.getbean(user.class);
    log.info("user info === {}", user.getuserinfo());
  }
}

六、 在user模块中添加enable注解

import org.springframework.context.annotation.import;
import java.lang.annotation.*;
/**
 * 启用user配置信息注解
 * @author ludangxin
 * @date 2021/8/1
 */
@target(elementtype.type)
@retention(retentionpolicy.runtime)
@documented
@import(user.class)
public @interface enableuser {}

七、小结

不能直接在当前项目中使用jar中的bean（springboot默认使用importselector的方式加载meta-inf/spring.factories中指定的配置类，会导致只需要导入相应的第三方jar就可以使用其环境中的bean）
可以在当前项目中使用jar包中提供的enable注解来导入jar的bean配置

到此这篇关于springboot自动装配-import的文章就介绍到这了,更多相关springboot自动装配import内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！

赞 (0)

相关文章:

版权声明：本文内容由互联网用户贡献，该文观点仅代表作者本人。本站仅提供信息存储服务，不拥有所有权，不承担相关法律责任。 如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 2386932994@qq.com 举报，一经查实将立刻删除。

发表评论

验证码：
最近更新的文章
推荐阅读
大家感兴趣的文章
Copyright © 2017-2026  代码网 保留所有权利. 粤ICP备2024248653号
站长QQ:2386932994 | 联系邮箱：2386932994@qq.com