Spring Context 还负责向 bean 中注入依赖，可以通过 setter 方法或构造函数方法，或者通过 Spring 的自动装配来实现。有时我们希望在 bean 类中初始化资源，例如在任何客户端请求之前创建数据库连接或验证第三方服务。Spring 框架提供了不同的方式，让我们在 Spring bean 生命周期中提供后初始化（post-initialization）和前销毁（pre-destroy）方法。

1. 通过实现 InitializingBean 和 DisposableBean 接口 - 这两个接口都声明了一个单一方法，我们可以在其中初始化/关闭 bean 中的资源。对于后初始化，我们可以实现 InitializingBean 接口并提供 afterPropertiesSet() 方法的实现。对于前销毁，我们可以实现 DisposableBean 接口并提供 destroy() 方法的实现。这些方法是回调方法，类似于 servlet 监听器的实现。这种方法使用简单，但不推荐使用，因为它会在我们的 bean 实现中与 Spring 框架产生紧密耦合。
2. 在 Spring bean 配置文件中为 bean 提供 init-method 和 destroy-method 属性值。这是推荐的方法，因为它没有对 Spring 框架的直接依赖，我们可以创建自己的方法。

注意，post-init 和 pre-destroy 方法都不应有参数，但它们可以抛出异常。我们还需要从 Spring 应用上下文中获取 bean 实例来调用这些方法。

Spring Bean 生命周期 - @PostConstruct, @PreDestroy 注解

Spring 框架还支持使用 @PostConstruct 和 @PreDestroy 注解来定义后初始化和前销毁方法。这些注解属于 javax.annotation 包。但是，要使这些注解生效，我们需要配置 Spring 应用以识别注解。我们可以通过定义类型为 org.springframework.context.annotation.CommonAnnotationBeanPostProcessor 的 bean，或者在 Spring bean 配置文件中使用 context:annotation-config 元素来实现。让我们编写一个简单的 Spring 应用来展示上述配置在 Spring bean 生命周期管理中的使用。在 Spring Tool Suite 中创建一个 Spring Maven 项目，最终项目结构如下图所示。

Spring Bean 生命周期 - Maven 依赖

配置 Spring bean 生命周期方法不需要包含任何额外的依赖，我们的 pom.xml 文件与任何标准的 Spring Maven 项目相同。

<project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>org.springframework.samples</groupId>
  <artifactId>SpringBeanLifeCycle</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  
  <properties>

		<!-- Generic properties -->
		<java.version>1.7</java.version>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

		<!-- Spring -->
		<spring-framework.version>4.0.2.RELEASE</spring-framework.version>

		<!-- Logging -->
		<logback.version>1.0.13</logback.version>
		<slf4j.version>1.7.5</slf4j.version>

	</properties>
	
	<dependencies>
		<!-- Spring and Transactions -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring-framework.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-tx</artifactId>
			<version>${spring-framework.version}</version>
		</dependency>

		<!-- Logging with SLF4J & LogBack -->
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-api</artifactId>
			<version>${slf4j.version}</version>
			<scope>compile</scope>
		</dependency>
		<dependency>
			<groupId>ch.qos.logback</groupId>
			<artifactId>logback-classic</artifactId>
			<version>${logback.version}</version>
			<scope>runtime</scope>
		</dependency>

	</dependencies>	
</project>

Spring Bean 生命周期 - 模型类

让我们创建一个简单的 Java bean 类，将在服务类中使用。

package com.journaldev.spring.bean;

public class Employee {

	private String name;

	public String getName() {
		return name;
	}

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

Spring Bean 生命周期 - InitializingBean, DisposableBean

让我们创建一个服务类，在其中实现这两个接口来处理后初始化和前销毁方法。

package com.journaldev.spring.service;

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

import com.journaldev.spring.bean.Employee;

public class EmployeeService implements InitializingBean, DisposableBean{

	private Employee employee;

	public Employee getEmployee() {
		return employee;
	}

	public void setEmployee(Employee employee) {
		this.employee = employee;
	}
	
	public EmployeeService(){
		System.out.println("EmployeeService no-args constructor called");
	}

	@Override
	public void destroy() throws Exception {
		System.out.println("EmployeeService Closing resources");
	}

	@Override
	public void afterPropertiesSet() throws Exception {
		System.out.println("EmployeeService initializing to dummy value");
		if(employee.getName() == null){
			employee.setName("Pankaj");
		}
	}
}

Spring Bean 生命周期 - 自定义后初始化、前销毁

由于我们不希望我们的服务类直接依赖 Spring 框架，让我们创建另一种形式的 Employee Service 类，其中包含后初始化和前销毁的 Spring 生命周期方法，并在 Spring bean 配置文件中配置它们。

package com.journaldev.spring.service;

import com.journaldev.spring.bean.Employee;

public class MyEmployeeService{

	private Employee employee;

	public Employee getEmployee() {
		return employee;
	}

	public void setEmployee(Employee employee) {
		this.employee = employee;
	}
	
	public MyEmployeeService(){
		System.out.println("MyEmployeeService no-args constructor called");
	}

	//pre-destroy method
	public void destroy() throws Exception {
		System.out.println("MyEmployeeService Closing resources");
	}

	//post-init method
	public void init() throws Exception {
		System.out.println("MyEmployeeService initializing to dummy value");
		if(employee.getName() == null){
			employee.setName("Pankaj");
		}
	}
}

我们稍后会查看 Spring bean 配置文件。在此之前，让我们创建另一个使用 @PostConstruct 和 @PreDestroy 注解的服务类。

Spring Bean 生命周期 - @PostConstruct, @PreDestroy

下面是一个简单的类，将被配置为 Spring bean，对于后初始化和前销毁方法，我们使用 @PostConstruct 和 @PreDestroy 注解。

package com.journaldev.spring.service;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

public class MyService {

	@PostConstruct
	public void init(){
		System.out.println("MyService init method called");
	}
	
	public MyService(){
		System.out.println("MyService no-args constructor called");
	}
	
	@PreDestroy
	public void destory(){
		System.out.println("MyService destroy method called");
	}
}

Spring Bean 生命周期 - 配置文件

让我们看看如何在 Spring 上下文文件中配置我们的 bean。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="https://www.springframework.org/schema/beans"
	xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="https://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd">

<!-- Not initializing employee name variable-->
<bean name="employee" class="com.journaldev.spring.bean.Employee" />

<bean name="employeeService" class="com.journaldev.spring.service.EmployeeService">
	<property name="employee" ref="employee"></property>
</bean>

<bean name="myEmployeeService" class="com.journaldev.spring.service.MyEmployeeService"
		init-method="init" destroy-method="destroy">
	<property name="employee" ref="employee"></property>
</bean>

<!-- initializing CommonAnnotationBeanPostProcessor is same as context:annotation-config -->
<bean class="org.springframework.context.annotation.CommonAnnotationBeanPostProcessor" />
<bean name="myService" class="com.journaldev.spring.service.MyService" />
</beans>

注意，我没有在 employee bean 定义中初始化 employee name。由于 EmployeeService 使用接口，这里不需要任何特殊配置。对于 MyEmployeeService bean，我们使用 init-method 和 destroy-method 属性来告知 Spring 框架执行我们的自定义方法。MyService bean 配置没有特别之处，但可以看到我启用了基于注解的配置。我们的应用已准备就绪，让我们编写一个测试程序来查看不同方法的执行顺序。

Spring Bean 生命周期 - 测试程序

package com.journaldev.spring.main;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.journaldev.spring.service.EmployeeService;
import com.journaldev.spring.service.MyEmployeeService;

public class SpringMain {

	public static void main(String[] args) {
		ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("spring.xml");

		System.out.println("Spring Context initialized");
		
		//MyEmployeeService service = ctx.getBean("myEmployeeService", MyEmployeeService.class);
		EmployeeService service = ctx.getBean("employeeService", EmployeeService.class);

		System.out.println("Bean retrieved from Spring Context");
		
		System.out.println("Employee Name="+service.getEmployee().getName());
		
		ctx.close();
		System.out.println("Spring Context Closed");
	}

}

运行上述测试程序时，我们会得到以下输出。

Apr 01, 2014 10:50:50 PM org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@c1b9b03: startup date [Tue Apr 01 22:50:50 PDT 2014]; root of context hierarchy
Apr 01, 2014 10:50:50 PM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [spring.xml]
EmployeeService no-args constructor called
EmployeeService initializing to dummy value
MyEmployeeService no-args constructor called
MyEmployeeService initializing to dummy value
MyService no-args constructor called
MyService init method called
Spring Context initialized
Bean retrieved from Spring Context
Employee Name=Pankaj
Apr 01, 2014 10:50:50 PM org.springframework.context.support.ClassPathXmlApplicationContext doClose
INFO: Closing org.springframework.context.support.ClassPathXmlApplicationContext@c1b9b03: startup date [Tue Apr 01 22:50:50 PDT 2014]; root of context hierarchy
MyService destroy method called
MyEmployeeService Closing resources
EmployeeService Closing resources
Spring Context Closed

Spring Bean 生命周期重要要点：

• 从控制台输出来看，Spring Context 首先使用无参构造函数初始化 bean 对象，然后调用后初始化方法。
• bean 初始化顺序与 Spring bean 配置文件中定义的顺序相同。
• 只有在所有 Spring bean 正确初始化并执行后初始化方法后，context 才会返回。
• Employee name 显示为“Pankaj”，因为它是在后初始化方法中初始化的。
• 当 context 关闭时，bean 按照与初始化相反的顺序销毁，即 LIFO（Last-In-First-Out）顺序。

你可以取消注释获取 MyEmployeeService 类型 bean 的代码，确认输出类似并遵循上述所有要点。

package com.journaldev.spring.service;

import java.util.Arrays;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanClassLoaderAware;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;
import org.springframework.context.EnvironmentAware;
import org.springframework.context.ResourceLoaderAware;
import org.springframework.context.annotation.ImportAware;
import org.springframework.core.env.Environment;
import org.springframework.core.io.Resource;
import org.springframework.core.io.ResourceLoader;
import org.springframework.core.type.AnnotationMetadata;

public class MyAwareService implements ApplicationContextAware,
		ApplicationEventPublisherAware, BeanClassLoaderAware, BeanFactoryAware,
		BeanNameAware, EnvironmentAware, ImportAware, ResourceLoaderAware {

	@Override
	public void setApplicationContext(ApplicationContext ctx)
			throws BeansException {
		System.out.println("setApplicationContext called");  // setApplicationContext 被调用
		System.out.println("setApplicationContext:: Bean Definition Names="  // setApplicationContext:: Bean 定义名称 =
				+ Arrays.toString(ctx.getBeanDefinitionNames()));
	}

	@Override
	public void setBeanName(String beanName) {
		System.out.println("setBeanName called");  // setBeanName 被调用
		System.out.println("setBeanName:: Bean Name defined in context="  // setBeanName:: 容器中定义的 Bean 名称 =
				+ beanName);
	}

	@Override
	public void setBeanClassLoader(ClassLoader classLoader) {
		System.out.println("setBeanClassLoader called");  // setBeanClassLoader 被调用
		System.out.println("setBeanClassLoader:: ClassLoader Name="  // setBeanClassLoader:: ClassLoader 名称 =
				+ classLoader.getClass().getName());
	}

	@Override
	public void setResourceLoader(ResourceLoader resourceLoader) {
		System.out.println("setResourceLoader called");  // setResourceLoader 被调用
		Resource resource = resourceLoader.getResource("classpath:spring.xml");
		System.out.println("setResourceLoader:: Resource File Name="  // setResourceLoader:: 资源文件名称 =
				+ resource.getFilename());
	}

	@Override
	public void setImportMetadata(AnnotationMetadata annotationMetadata) {
		System.out.println("setImportMetadata called");  // setImportMetadata 被调用
	}

	@Override
	public void setEnvironment(Environment env) {
		System.out.println("setEnvironment called");  // setEnvironment 被调用
	}

	@Override
	public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
		System.out.println("setBeanFactory called");  // setBeanFactory 被调用
		System.out.println("setBeanFactory:: employee bean singleton="  // setBeanFactory:: employee bean 是单例 =
				+ beanFactory.isSingleton("employee"));
	}

	@Override
	public void setApplicationEventPublisher(
			ApplicationEventPublisher applicationEventPublisher) {
		System.out.println("setApplicationEventPublisher called");  // setApplicationEventPublisher 被调用
	}

}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="https://www.springframework.org/schema/beans"
	xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="https://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd">

<bean name="employee" class="com.journaldev.spring.bean.Employee" />

<bean name="myAwareService" class="com.journaldev.spring.service.MyAwareService" />

</beans>

package com.journaldev.spring.main;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.journaldev.spring.service.MyAwareService;

public class SpringAwareMain {

	public static void main(String[] args) {
		ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("spring-aware.xml");

		ctx.getBean("myAwareService", MyAwareService.class);
		
		ctx.close();
	}

}

Apr 01, 2014 11:27:05 PM org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@60a2f435: startup date [Tue Apr 01 23:27:05 PDT 2014]; root of context hierarchy
Apr 01, 2014 11:27:05 PM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [spring-aware.xml]
setBeanName called
setBeanName:: Bean Name defined in context=myAwareService
setBeanClassLoader called
setBeanClassLoader:: ClassLoader Name=sun.misc.Launcher$AppClassLoader
setBeanFactory called
setBeanFactory:: employee bean singleton=true
setEnvironment called
setResourceLoader called
setResourceLoader:: Resource File Name=spring.xml
setApplicationEventPublisher called
setApplicationContext called
setApplicationContext:: Bean Definition Names=[employee, myAwareService]
Apr 01, 2014 11:27:05 PM org.springframework.context.support.ClassPathXmlApplicationContext doClose
INFO: Closing org.springframework.context.support.ClassPathXmlApplicationContext@60a2f435: startup date [Tue Apr 01 23:27:05 PDT 2014]; root of context hierarchy