<think>我们正在讨论Spring
Bean的
生命周期，特别是构造函数、属性赋值和初始化
方法的执行顺序。
根据提供的引用，我们可以总结如下：
1. 引用[1]提到属性赋值可以通过@Value、@Autowired等注解完成。
2. 引用[2]和[3]提到了init-method和destroy-method，以及使用注解@PostConstruct和@PreDestroy。
3. 引用[4]和[5]则提供了关于构造函数、afterPropertiesSet和init-method执行顺序的信息。
具体执行顺序为：
1. 首先调用构造函数来实例化
Bean。
2. 然后进行属性赋值（例如通过setter
方法或字段注入，使用@Autowired、@Resource等）。
3. 如果
Bean实现了Initializing
Bean接口，则调用afterPropertiesSet
()方法。
4. 接着调用自定义的初始化
方法（通过@PostConstruct注解的
方法或通过init-method指定的
方法）。
注意：@PostConstruct注解的
方法会在afterPropertiesSet
()方法之前执行吗？实际上，根据Spring官方
文档：
- @PostConstruct注解的
方法会在依赖注入（即属性赋值）完成后被调用，并且在Initializing
Bean的afterPropertiesSet
()方法之前以及init-method之前执行。
因此，更详细的顺序应该是：
1. 构造函数
2. 属性赋值（依赖注入）
3. @PostConstruct 注解的
方法
4. Initializing
Bean的afterPropertiesSet
()方法
5. 自定义的init-method
方法
引用[4]中的例子是一个通过XML
配置的
bean，它有一个构造器参数和一个init-method。在这个例子中，构造器先执行（
传入参数），然后执行init-method。
引用[5]则说明了在构造函数中直接使用依赖注入的属性可能会出现问题，因为此时属性还没有被注入（即构造函数执行时，依赖注入还没有发生）。
所以，总结执行顺序为：
1. 构造函数（此时依赖还未注入，所以构造函数中不能使用依赖的属性）
2. 依赖注入（属性赋值）
3. 初始化
回调（按顺序）：
a. 使用@PostConstruct注解的
方法
b. 实现了Initializing
Bean接口的afterPropertiesSet
()方法
c. 自定义的init-method（通过XML或@
Bean(initMethod="...")指定）
验证：我们可以通过一个简单的例子来验证这个顺序。
例如，定义一个
Bean：
```java
public class Example
Bean implements Initializing
Bean {
private String name;
public Example
Bean() {
System.out.println("1. 构造函数");
}
public vo
id setName(String name) {
this.name = name;
System.out.println("2. 属性赋值");
}
@PostConstruct
public vo
id postConstruct
() {
System.out.println("3. @PostConstruct
方法");
}
@Overr
ide
public vo
id afterPropertiesSet
() throws Exception {
System.out.println("4. Initializing
Bean的afterPropertiesSet");
}
public vo
id initMethod
() {
System.out.println("5. 自定义的init-method");
}
}
```
在XML
配置中：
```xml
<
bean id="example
Bean" class="Example
Bean" init-method="initMethod">
<property name="name" value="Spring"/>
</
bean>
```
或者使用Java
配置：
```java
@
Bean(initMethod = "initMethod")
public Example
Bean example
Bean() {
Example
Bean example
Bean = new Example
Bean();
example
Bean.setName("Spring");
return example
Bean;
}
```
输出顺序应该是：
1. 构造函数
2. 属性赋值
3. @PostConstruct
方法
4. afterPropertiesSet
5. 自定义的init-method
因此，回答用户的问题：在Spring中，
Bean的创建过程首先是调用构造函数，然后进行属性赋值（依赖注入），接着依次执行@PostConstruct注解的
方法、Initializing
Bean接口的afterPropertiesSet
方法，最后执行自定义的init-method
方法。
注意：如果同时存在多种初始化
方法，那么它们的执行顺序就是上面列出的顺序。
另外，关于销毁
方法的顺序（与问题无关，但作为补充）：
1. @PreDestroy注解的
方法
2. Disposable
Bean接口的destroy
()方法
3. 自定义的destroy-method
方法
引用[3]中也提到了这些销毁
方法。
所以，最终回答如下：
</think>在Spring中，
Bean的构造函数、属性赋值与初始化
方法执行顺序遵循严格的
生命周期规范，具体顺序如下：
### 执行顺序详解
1. **构造函数调用**（实例化）
Spring首先调用
Bean的构造函数创建对象实例。
**注意**：此时依赖注入尚未完成，构造函数内无法使用注入的属性（否则会抛`NullPointerException`）[^5]。
2. **属性赋值**（依赖注入）
- 通过Setter
方法（如`<property>`标签）
- 或字段注入（如`@Autowired`、`@Resource`、`@Value`）
完成所有依赖项的注入[^1][^3]。
3. **初始化
方法执行**（按顺序）：
a. **`@PostConstruct`注解
方法**
b. **`Initializing
Bean.afterPropertiesSet
()`**（实现
接口）
c. **自定义`init-method`**（XML中`init-method`属性或`@
Bean(initMethod)`）[^2][^3][^4]
### 顺序验证示例
```java
public class Demo
Bean implements Initializing
Bean {
// 1. 构造函数先执行
public Demo
Bean() {
System.out.println("构造函数执行");
}
// 2. 属性注入（Setter或字段注入）
@Autowired
private Dependency dep;
// 3a. 最先执行的初始化
方法
@PostConstruct
public vo
id postConstruct
() {
System.out.println("@PostConstruct
方法执行");
}
// 3b. 接着执行
接口方法
@Overr
ide
public vo
id afterPropertiesSet
() {
System.out.println("afterPropertiesSet
()执行");
}
// 3c. 最后执行自定义init-method
public vo
id customInit
() {
System.out.println("init-method
方法执行");
}
}
```
**输出顺序**：
```
构造函数执行
@PostConstruct
方法执行
afterPropertiesSet
()执行
init-method
方法执行
```
### 关键规则
1. **属性必须在构造函数之后注入**：构造函数中无法使用未初始化的依赖[^5]。
2. **初始化
方法依赖注入结果**：所有初始化
方法（`@PostConstruct`、`afterPropertiesSet
()`、`init-method`）均可安全使用注入的属性[^3][^4]。
3. **销毁顺序**（补充）：
`@PreDestroy` → `Disposable
Bean.destroy
()` → 自定义`destroy-method`[^3]。
> 此顺序由Spring IoC容器严格保证，确保依赖可用性和
生命周期可控性[^1][^3][^4]。
本文详细解析了Spring框架中Bean从创建到销毁的完整生命周期，包括实例化、依赖注入、初始化及销毁等关键阶段，深入探讨各阶段触发的接口回调与方法执行顺序。
扫一扫
1062
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
