春季豆子的生命周期
今天我们将研究Spring Bean的生命周期。Spring的Bean是任何Spring应用程序中最重要的部分。Spring的ApplicationContext负责初始化在Spring Bean配置文件中定义的Spring Beans。
Spring Bean的生命周期
Spring Context 负责在 bean 中注入依赖项,可以通过 setter 方法、构造方法或者 Spring 自动装配来完成。有时候我们希望在 bean 类中初始化资源,例如在客户端请求之前初始化数据库连接或验证第三方服务。Spring 框架提供了多种方式来提供在 spring bean 生命周期中执行后初始化和销毁前方法的途径。
-
- 通过实现InitializingBean和DisposableBean接口-这两个接口声明了一个方法,我们可以在bean中初始化/关闭资源。对于后初始化,我们可以实现InitializingBean接口并提供afterPropertiesSet()方法的实现。对于预销毁,我们可以实现DisposableBean接口并提供destroy()方法的实现。这些方法是回调方法,类似于Servlet监听器的实现。这种方法使用简单,但不推荐,因为它会在我们的bean实现中与Spring框架紧密耦合。
- 通过在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.Olivia.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.Olivia.spring.service;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import com.Olivia.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框架,因此让我们创建另一种形式的员工服务类,其中我们将使用post-init和pre-destroy Spring的生命周期方法,并在Spring bean配置文件中进行配置。
package com.Olivia.spring.service;
import com.Olivia.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注解。
春天的Bean生命周期 – @PostConstruct,@PreDestroy
以下是一个简单的类,将被配置成Spring Bean,并且我们使用了@PostConstruct和@PreDestroy注解来定义该类的后初始化和销毁前的方法。
package com.Olivia.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");
}
}
春季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.Olivia.spring.bean.Employee" />
<bean name="employeeService" class="com.Olivia.spring.service.EmployeeService">
<property name="employee" ref="employee"></property>
</bean>
<bean name="myEmployeeService" class="com.Olivia.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.Olivia.spring.service.MyService" />
</beans>
请注意,我在它的bean定义中没有初始化员工名称。由于EmployeeService使用了接口,所以我们在这里不需要任何特殊的配置。对于MyEmployeeService bean,我们使用init-method和destroy-method属性来让spring框架知道我们要执行的自定义方法。MyService bean的配置没有任何特殊之处,但是正如你所看到的,我启用了注解式配置。我们的应用程序已经准备就绪,让我们编写一个测试程序来查看不同的方法如何被执行。
春季豆生命周期-测试程序
package com.Olivia.spring.main;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.Olivia.spring.service.EmployeeService;
import com.Olivia.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
春天的Bean生命周期重要点:
- From the console output it’s clear that Spring Context is first using no-args constructor to initialize the bean object and then calling the post-init method.
- The order of bean initialization is same as it’s defined in the spring bean configuration file.
- The context is returned only when all the spring beans are initialized properly with post-init method executions.
- Employee name is printed as “Pankaj” because it was initialized in the post-init method.
- When context is getting closed, beans are destroyed in the reverse order in which they were initialized i.e in LIFO (Last-In-First-Out) order.
你可以取消代码的注释,以获取类型为MyEmployeeService的bean,并确认输出将类似并遵循以上提到的所有要点。
春季意识接口
有时候我们需要在我们的bean中使用Spring Framework对象来执行一些操作,比如读取ServletConfig和ServletContext参数,或者了解ApplicationContext加载的bean定义。这就是为什么Spring Framework提供了一系列我们可以在我们的bean类中实现的*Aware接口。org.springframework.beans.factory.Aware是所有这些Aware接口的根标记接口。所有的*Aware接口都是Aware接口的子接口,并声明一个要由该bean实现的单一setter方法。然后Spring上下文使用基于setter的依赖注入将相应的对象注入到bean中,并使其可供我们使用。Spring Aware接口类似于具有回调方法和实现观察者设计模式的servlet监听器。一些重要的Aware接口有:
- ApplicationContextAware – to inject ApplicationContext object, example usage is to get the array of bean definition names.
- BeanFactoryAware – to inject BeanFactory object, example usage is to check scope of a bean.
- BeanNameAware – to know the bean name defined in the configuration file.
- ResourceLoaderAware – to inject ResourceLoader object, example usage is to get the input stream for a file in the classpath.
- ServletContextAware – to inject ServletContext object in MVC application, example usage is to read context parameters and attributes.
- ServletConfigAware – to inject ServletConfig object in MVC application, example usage is to get servlet config parameters.
让我们通过在一个类中实现其中几个来实际了解 Aware 接口的用法,并将该类配置为 Spring bean。
package com.Olivia.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 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" class="com.Olivia.spring.bean.Employee" />
<bean name="myAwareService" class="com.Olivia.spring.service.MyAwareService" />
</beans>
春天意识测试计划
package com.Olivia.spring.main;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.Olivia.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的内容。请从下面的链接下载示例项目并进行分析,以便更深入了解它们。
下载Spring Bean生命周期项目