Spring Bean初始化及@PostConstruc执行顺序示例详解

1. Bean初始化执行顺序

1. 构造函数 - 首先调用Bean的构造函数

2. 依赖注入 - 完成所有依赖项的注入（@Autowired等）

3. @PostConstruct方法 - 执行带有@PostConstruct注解的方法

4. InitializingBean的afterPropertiesSet() - 如果Bean实现了InitializingBean接口

5. 自定义init方法 - 执行通过@Bean(initMethod="...")或XML配置中init-method指定的方法

@Component
public class ExampleBean implements InitializingBean {
    public ExampleBean() {
        System.out.println("1. 构造函数");
    }
    @Autowired
    public void setDependency(SomeDependency dep) {
        System.out.println("2. 依赖注入");
    }
    @PostConstruct
    public void postConstruct() {
        System.out.println("3. @PostConstruct方法");
    }
    @Override
    public void afterPropertiesSet() {
        System.out.println("4. InitializingBean的afterPropertiesSet()");
    }
    @Bean(initMethod = "customInit")
    public void customInit() {
        System.out.println("5. 自定义init方法");
    }
}

2. 成员变量初始化顺序

在Java中，类的成员变量（非静态成员变量）的初始化时机取决于其定义方式（直接赋值、构造器赋值、初始化块等）以及是否涉及依赖注入（如Spring框架）。

2.1 普通Java类（非Spring环境）

成员变量的初始化顺序和时机如下：

(1) 默认初始化(即初始分配内存)

• 时机：对象实例化时（new关键字调用构造器之前）。

• 规则：所有成员变量先被赋予默认值（int→0，boolean→false，引用类型→null等）。

(2) 显式初始化

• 时机：紧随默认初始化之后，按代码中的声明顺序执行。

• 方式：

  • 直接赋值：

public class MyClass {
    private int a = 10;          // 显式赋值
    private String s = "hello";  // 显式赋值
}

• 初始化块（代码块）：

public class MyClass {
    private int x;
    {
        x = 20; // 初始化块赋值
    }
}

(3) 构造器初始化

• 时机：在显式初始化之后，构造器最后执行。

• 特点：构造器中的赋值会覆盖之前的默认值或显式赋值。

public class MyClass {
    private int value;
    public MyClass() {
        this.value = 30; // 构造器赋值
    }
}

(4)完整顺序

默认值 → 显式赋值/初始化块 → 构造器赋值

2.2 Spring管理的Bean（依赖注入场景）

在Spring中，成员变量的初始化分为依赖注入和普通成员变量初始化两部分：

(1) 普通成员变量

• 初始化规则与普通Java类一致（默认值 → 显式赋值 → 构造器）。

• 示例：

@Component
public class MyBean {
    private int count = 100;  // 显式赋值（Spring无关）
    public MyBean() {
        this.count = 200;     // 构造器覆盖
    }
}

(2) 依赖注入的成员变量

• 时机：在Bean实例化后，由Spring容器通过反射或Setter方法注入。

  • 字段注入（@Autowired）：
    在构造器和显式赋值之后，通过反射直接注入。

    @Component
    public class MyBean {
        @Autowired
        private Dependency dependency; // Spring在对象构造后注入
    }

  • 构造器注入：
    在实例化时通过构造器参数注入（等同于普通Java的构造器赋值）。

    @Component
    public class MyBean {
        private final Dependency dependency;
        public MyBean(Dependency dependency) {
            this.dependency = dependency; // 构造时注入
        }
    }

(3) 生命周期回调的影响

• @PostConstruct方法会在依赖注入完成后执行，此时所有成员变量（包括注入的依赖）已就绪：

  @Component
  public class MyBean {
      @Autowired
      private Dependency dependency;
      @PostConstruct
      public void init() {
          System.out.println(dependency); // 依赖已注入
      }
  }

(4)关键区别总结

2.3 final成员变量

• 必须在声明时、初始化块或构造器中赋值，否则编译错误。

public class MyClass {
    private final int x = 10;  // 声明时赋值
    private final int y;
    { y = 20; }  // 初始化块赋值
    private final int z;
    public MyClass() {
        z = 30;  // 构造器赋值
    }
}

2.4 常见面试问题

Q1: 为什么构造器里的赋值能覆盖显式赋值？

因为构造器是最后执行的，可以修改之前的值。

Q2: 以下代码的输出是什么？

public class Test {
    private int x = 10;
    { x = 20; }
    public Test() {
        System.out.println(x);
        x = 30;
    }
    public static void main(String[] args) {
        new Test(); // 输出？
    }
}
--
答案：20（显式赋值和初始化块先执行，构造器最后执行）。

到此这篇关于Spring Bean初始化及@PostConstruc执行顺序的文章就介绍到这了,更多相关Spring Bean初始化内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！