Spring Bean 管理与 Spring Boot 自动配置原理 | 极客日志

Javajava

Spring Bean 管理与 Spring Boot 自动配置原理

Spring Bean 管理包含作用域与生命周期机制。作用域如 singleton、prototype 等决定实例化范围。生命周期涵盖实例化、注入、初始化、使用和销毁。Spring Boot 自动配置通过@EnableXxxx 注解封装@Import，结合 ImportSelector 接口实现依赖的自动化加载，减少手动配置，简化开发流程。

蜜桃汽水发布于 2026/3/16更新于 2026/4/2714 浏览

Spring Bean 管理与 Spring Boot 自动配置原理

Spring Bean 管理与 Spring Boot 自动配置原理

1. Bean 的作用域和生命周期

1.1 Bean 的作用域

在 Spring 中，Bean 的作用域（Scope）决定了 Bean 的实例化方式以及其生命周期。以下是 Spring 中常见的 Bean 作用域：

作用域	说明
singleton	每个 Spring IoC 容器内同名称的 bean 只有一个实例 (单例) (默认)
prototype	每次使用该 bean 时会创建新的实例 (非单例)
request	每个 HTTP 请求生命周期内，创建新的实例
session	每个 HTTP Session 生命周期内，创建新的实例
application	每个 ServletContext 生命周期内，创建新的实例
websocket	每个 WebSocket 生命周期内，创建新的实例

测试不同作用域的 Bean 取到的对象是否一样：

创建一个 Dog 实体类：

public class Dog {
    private String name;

    public String getName() {
        return name;
    }

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

创建一个 DogComponent 类（交给 Spring 进行管理）：

@Component
public class DogComponent {
    @Bean
    public Dog dog() {
        return new Dog();
    }

    // 单例
    @Bean
    public Dog singleDog() {
          ();
    }

    
    
    
     Dog  {
          ();
    }

    
    
    
     Dog  {
          ();
    }

    
    
    
     Dog  {
          ();
    }

    
    
    
     Dog  {
          ();
    }
}

@RestController
@RequestMapping("/dog")
public class DogController {
    @Autowired
    ApplicationContext context;

    // 单例作用域
    @Resource(name = "singleDog")
    Dog singleDog;

    // 多例作用域 (原型)
    @Resource(name = "prototypeDog")
    Dog prototypeDog;

    @RequestMapping("/singleton")
    public String singleton() {
        Dog contextDog = context.getBean("singleDog", Dog.class);
        return "contextDog" + contextDog + ",resource" + singleDog;
    }

    @RequestMapping("/prototype")
    public String prototype() {
        Dog contextDog = context.getBean("prototypeDog", Dog.class);
        return "contextDog" + contextDog + ",resource" + prototypeDog;
    }

    @RequestMapping("/request")
    public String request() {
        Dog contextDog = context.getBean("requestDog", Dog.class);
        return "contextDog" + contextDog + ",resource" + requestDog;
    }

    @RequestMapping("/session")
    public String session() {
        Dog contextDog = context.getBean("sessionDog", Dog.class);
        return "contextDog" + contextDog + ",resource" + sessionDog;
    }

    @RequestMapping("/application")
    public String application() {
        Dog contextDog = context.getBean("applicationDog", Dog.class);
        return "contextDog" + contextDog + ",resource" + applicationDog;
    }
}

@SpringBootApplication
public class SpringPrincipleApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringPrincipleApplication.class, args);
    }
}

import jakarta.annotation.PostConstruct;
import jakarta.annotation.PreDestroy;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class BeanLifeComponent implements BeanNameAware {
    // @Autowired
    // private DogCompoent dogCompoent;

    // 1. 实例化
    public BeanLifeComponent() {
        System.out.println("执行构造方法....");
    }

    // 2. 属性赋值 (setter 方法注入)
    @Autowired
    public void setDogCompoent(DogComponent dogCompoent) {
        this.dogCompoent = dogCompoent;
        System.out.println("执行属性赋值");
    }

    // 获取 Bean 的名称
    @Override
    public void setBeanName(String name) {
        System.out.println("执行 BeanNameAware,beanName:" + name);
    }

    // 初始化方法
    @PostConstruct
    public void init() {
        System.out.println("初始化方法...");
    }

    // 4. 使用 Bean
    public void use() {
        System.out.println("使用 Bean，执行 use 方法");
    }

    // 5. 销毁 Bean
    @PreDestroy
    public void destroy() {
        System.out.println("销毁 bean");
    }
}

@Test
void testBean() {
    BeanLifeComponent bean = context.getBean(BeanLifeComponent.class);
    bean.use();
}

import org.springframework.context.annotation.Configuration;

// 第三方
@Configuration
public class Sliqverconfig {
    public void study() {
        System.out.println("Sliqverconfig study... ");
    }
}

@Autowired
ApplicationContext context;

@Test
void testBean() {
    Sliqverconfig bean = context.getBean(Sliqverconfig.class);
    System.out.println(bean);
}

@ComponentScan(basePackages = "com.config")
@SpringBootApplication
public class SpringPrincipleApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringPrincipleApplication.class, args);
    }
}

@Import(Sliqverconfig.class)
@SpringBootApplication
public class SpringPrincipleApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringPrincipleApplication.class, args);
    }
}

public class MySelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        return new String[]{"com.config.Sliqverconfig"};
    }
}

@Import(MySelector.class)
@SpringBootApplication
public class SpringPrincipleApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringPrincipleApplication.class, args);
    }
}

import org.springframework.context.annotation.Import;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

// 注解
// 类
@Target(ElementType.TYPE)
// 生命周期
@Retention(RetentionPolicy.RUNTIME)
@Import(MySelector.class)
// 指定要导入的类
public @interface EnableSliqversConfig {}

// 通过第三方注解 @EnableSliqversConfig
@EnableSliqversConfig
@SpringBootApplication
public class SpringPrincipleApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringPrincipleApplication.class, args);
    }
}