Spring 框架入门教程-7. Spring Bean 的生命周期-55编程教程网

今天我们来看看Spring Bean的生命周期。Spring Bean是任何Spring应用程序中最重要的部分。Spring应用程序上下文负责初始化在Spring Bean配置文件中定义的Spring Bean。

1Spring Bean生命周期
2感知Spring接口
- 2.1支持Spring*的示例配置文件
- 2.2Spring*感知测试程序

Spring Bean生命周期

springcontext还负责注入依赖性在bean中，通过setter或构造函数方法或Spring自动布线.

有时我们希望初始化bean类中的资源，例如在初始化任何客户端请求之前创建数据库连接或验证第三方服务。Spring框架提供了不同的方法，我们可以通过这些方法在Spring Bean生命周期中提供初始化后和销毁前的方法。

通过实施初始化Bean和一次性豆接口–；这两个接口都声明了一个方法，我们可以在这个方法中初始化/关闭bean中的资源。对于后初始化，我们可以实现InitializingBean interface and provide implementation of afterPropertiesSet() method. For pre-destroy, we can implement DisposableBean interface and provide implementation of destroy() method. These methods are the callback methods and similar to servlet listener implementations.
这种方法使用简单，但不推荐使用，因为它将在bean实现中与Spring框架建立紧密耦合。
提供初始化方法和销毁方法Spring Bean配置文件中bean的属性值。这是推荐的方法，因为它不直接依赖于spring框架，而且我们可以创建自己的方法。

注意这两个初始化后和预销毁方法应该没有参数，但可以引发异常。我们还需要从spring应用程序上下文中获取bean实例来调用这些方法。

Spring Bean生命周期–；@PostConstruct，@PreDestroy注解

Spring框架还支持@PostConstruct and @PreDestroy annotations for defining post-init and pre-destroy methods. These annotations are part of javax.annotation package. However for these annotations to work, we need to configure our spring application to look for annotations. We can do this either by defining bean of type org.springframework.context.annotation.CommonAnnotationBeanPostProcessor or by context:annotation-config element in spring bean configuration file.

让我们编写一个简单的Spring应用程序来展示上述配置在Spring Bean生命周期管理中的使用。在Spring工具套件中创建一个springmaven项目，最终的项目将如下图所示。

Spring Bean生命周期和Maven依赖关系

对于配置Spring Bean生命周期方法，我们不需要包含任何额外的依赖关系pom.xml文件文件和任何其他标准springmaven项目一样。


<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生命周期和模型类

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


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生命周期–初始化Bean，DisposableBean

让我们创建一个服务类，在这里我们将实现post init和pre destroy方法的接口。


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生命周期和自定义post init、pre-destroy

因为我们不想让我们的服务直接依赖于spring框架，所以让我们创建另一种形式的Employee服务类，在这个类中我们有post init和pre destroy 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生命周期&建设后、动工前

下面是一个将被配置为Spring Bean的简单类，对于post init和pre destroy方法，我们使用@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 17中了解如何配置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" />

<bean name="employeeService">
	<property name="employee" ref="employee"></property>
</bean>

<bean name="myEmployeeService"
		init-method="init" destroy-method="destroy">
	<property name="employee" ref="employee"></property>
</bean>

<!-- initializing CommonAnnotationBeanPostProcessor is same as context:annotation-config -->
<bean />
<bean name="myService" />
</beans>

请注意，我没有在它的bean定义中初始化employee name。由于EmployeeService使用接口，因此在这里不需要任何特殊配置。

对于MyEmployeeService bean，我们使用init method和destroy method属性让spring框架知道要执行的自定义方法。

myservicebean配置没有任何特殊之处，但是您可以看到，我为此启用了基于注解的配置。

我们的应用程序已经准备好了，让我们编写一个测试程序，看看如何执行不同的方法。

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首先使用no-args构造函数初始化bean对象，然后调用post-init方法。
bean初始化的顺序与Spring Bean配置文件中定义的顺序相同。
只有当所有的Spring Bean都使用post-init方法执行正确初始化时，才会返回上下文。
Employee name被打印为“；Pankaj”；，因为它是在post init方法中初始化的。
当上下文关闭时，bean将按初始化时的相反顺序（即后进先出）销毁。

您可以取消代码注解以获取类型为的beanMyEmployeeService and confirm that output will be similar and follow all the points mentioned above.

感知Spring接口

有时我们需要bean中的Spring框架对象来执行一些操作，例如读取ServletConfig和ServletContext参数，或者知道ApplicationContext加载的bean定义。这就是为什么spring框架提供了一系列可以在bean类中实现的*感知接口。

org.springframework.beans.factory.Aware is the root marker interface for all these Aware interfaces. All of the *Aware interfaces are sub-interfaces of Aware and declare a single setter method to be implemented by the bean. Then spring context uses setter-based dependency injection to inject the corresponding objects in the bean and make it available for our use.

Spring感知接口类似于servlet侦听器使用回调方法并实现观察者设计模式.

了解一些重要的接口：

应用程序集成感知&#为了注入ApplicationContext对象，示例用法是获取bean定义名称的数组。
BeanFactoryAware公司&#为了注入BeanFactory对象，示例用法是检查bean的范围。
豆制品–；以了解配置文件中定义的bean名称。
ResourceLoaderware&#为了注入ResourceLoader对象，示例用法是获取类路径中文件的输入流。
ServletContextAware&#要在MVC应用程序中注入ServletContext对象，示例用法是读取上下文参数和属性。
ServletConfigAware&#要在MVC应用程序中注入ServletConfig对象，示例用法是获取servlet配置参数。

让我们通过在一个我们将配置为Spring 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");
		System.out.println("setApplicationContext:: Bean Definition Names="
				+ Arrays.toString(ctx.getBeanDefinitionNames()));
	}

	@Override
	public void setBeanName(String beanName) {
		System.out.println("setBeanName called");
		System.out.println("setBeanName:: Bean Name defined in context="
				+ beanName);
	}

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

	@Override
	public void setResourceLoader(ResourceLoader resourceLoader) {
		System.out.println("setResourceLoader called");
		Resource resource = resourceLoader.getResource("classpath:spring.xml");
		System.out.println("setResourceLoader:: Resource File Name="
				+ resource.getFilename());
	}

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

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

	@Override
	public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
		System.out.println("setBeanFactory called");
		System.out.println("setBeanFactory:: employee bean singleton="
				+ beanFactory.isSingleton("employee"));
	}

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

}

支持Spring*的示例配置文件

非常简单的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">

<bean name="employee" />

<bean name="myAwareService" />

</beans>

Spring*感知测试程序


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

测试程序的控制台输出很容易理解，我不想详细介绍。

这就是Spring Bean生命周期方法和将特定于框架的对象注入Spring Bean的全部内容。请从下面的链接下载示例项目并对其进行分析，以了解更多有关它们的信息。