标签：
Spring Beans are the most important part of any Spring application. Spring ApplicationContext is responsible to initialize the Spring Beans defined in spring bean configuration file.
Spring Context is also responsible for injection dependencies in the bean, either through setter/constructor methods or by spring autowiring.
Sometimes we want to initialize resources in the bean classes, for example creating database connections or validating third party services at the time of initialization before any client request. Spring framework provide different ways through which we can provide post-initialization and pre-destroy methods in a spring 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.
This approach is simple to use but it’s not recommended because it will create tight coupling with the Spring framework in our bean implementations.
Note that both post-init and pre-destroy methods should have no arguments but they can throw Exceptions. We would also require to get the bean instance from the spring application context for these methods invocation.
Spring framework also support @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.
Let’s write a simple Spring application to showcase the use of above configurations. Create a Spring Maven project in Spring Tool Suite, final project will look like below image.
We don’t need to include any extra dependencies for configuring spring bean life cycle methods, our pom.xml file is like any other standard spring maven project.
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://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>
Let’s create a simple java bean class that will be used in service classes.
package com.journaldev.spring.bean; public class Employee { private String name; public String getName() { return name; } public void setName(String name) { this.name = name; } }
Let’s create a service class where we will implement both the interfaces for post-init and pre-destroy methods.
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"); } } }
Since we don’t want our services to have direct spring framework dependency, let’s create another form of Employee Service class where we will have post-init and pre-destroy methods and we will configure them in the spring bean configuration file.
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"); } } }
We will look into the spring bean configuration file in a bit. Before that let’s create another service class that will use @PostConstruct and @PreDestroy annotations.
Below is a simple class that will be configured as spring bean and for post-init and pre-destroy methods, we are using @PostConstruct and @PreDestroy annotations.
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"); } }
Let’s see how we will configure our beans in spring context file.
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://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>
Notice that I am not initializing employee name in it’s bean definition. Since EmployeeService is using interfaces, we don’t need any special configuration here.
For MyEmployeeService bean, we are using init-method and destroy-method attributes to let spring framework know our custom methods to execute.
MyService bean configuration doesn’t have anything special, but as you can see that I am enabling annotation based configuration for this.
Our application is ready, let’s write a test program to see how different methods get executed.
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"); } }
When we run above test program, we get below output.
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
Important Points:
You can uncomment the code to get bean of type MyEmployeeService and confirm that output will be similar and follow all the points mentioned above.
Sometimes we need Spring Framework objects in our beans to perform some operations, for example reading ServletConfig and ServletContext parameters or to know the bean definitions loaded by the ApplicationContext. That’s why spring framework provides a bunch of *Aware interfaces that we can implement in our bean classes.
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 Aware interfaces are similar to servlet listeners with callback methods and implementing observer design pattern.
Some of the important Aware interfaces are:
Let’s see these Aware interfaces usage in action by implementing few of them in a class that we will configure as 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"); } }
Very simple spring bean configuration file.
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://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(); } }
Now when we execute above class, we get following output.
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
Console output of the test program is simple to understand, I won’t go into much detail about that.
That’s all for the Spring Bean life cycle methods and injecting framework specific objects into the spring beans. Please download sample project from below link and analyze it to learn more about them.
原文地址：http://www.journaldev.com/2637/spring-bean-life-cycle-methods-initializingbean-disposablebean-postconstruct-predestroy-aware-interfaces
标签：
原文地址：http://www.cnblogs.com/linjian/p/4651065.html
