Spring Bean Life Cycle Tutorial?

Spring framework is based on IOC so we call it as IOC container also So Spring beans reside inside the IOC container. Spring beans are nothing but Plain old java object (POJO).

Following steps explain their life cycle inside the container.

1.    The container will look the bean definition inside configuration file (e.g. bean.xml).

2.    Using reflection container will create the object and if any property is defined inside the bean definition then it will also be set.

3.    If the bean implements the BeanNameAware interface, the factory calls setBeanName() passing the bean’s ID.

4.    If the bean implements the BeanFactoryAware interface, the factory calls setBeanFactory(), passing an instance of itself.

5.    If there are any BeanPostProcessors associated with the bean, their post- ProcessBeforeInitialization() methods will be called before the properties for the Bean are set.

6.    If an init() method is specified for the bean, it will be called.

7.    If the Bean class implements the DisposableBean interface, then the method destroy() will be called when the Application no longer needs the bean reference.

8.    If the Bean definition in the Configuration file contains a 'destroy-method' attribute, then the corresponding method definition in the Bean class will be called. 

Spring bean factory is responsible for managing the life cycle of beans created through spring container. The life cycle of beans consist of call back methods which can be categorized broadly in two groups:

1.    Post initialization call back methods

2.    Pre destruction call back methods

Spring framework provides following 4 ways for controlling life cycle events of bean:

1.    InitializingBean and DisposableBean callback interfaces

2.    Other Aware interfaces for specific behavior

3.    custom init() and destroy() methods in bean configuration file

4.    @PostConstruct and @PreDestroy annotations

1.   InitializingBean and DisposableBean callback interfaces

The org.springframework.beans.factory.InitializingBean interface allows a bean to perform initialization work after all necessary properties on the bean have been set by the container. The InitializingBean interface specifies a single method:

void afterPropertiesSet() throws Exception;

This is not a preferrable way to initialize the bean because it tightly couple your bean class with spring container. A better approach is to use “init-method” attribute in bean definition in applicationContext.xml file.

Similarly, implementing the org.springframework.beans.factory.DisposableBean interface allows a bean to get a callback when the container containing it is destroyed. The DisposableBean interface specifies a single method:

void destroy() throws Exception;

A sample bean implementing above interfaces would look like this:

package com.javathinkingbeyond.task; import org.springframework.beans.factory.DisposableBean; import org.springframework.beans.factory.InitializingBean; public class DemoBeanTypeOne implements InitializingBean, DisposableBean {     //Other bean attributes and methods           @Override     public void afterPropertiesSet() throws Exception {         //Bean initialization code     }         @Override     public void destroy() throws Exception {         //Bean destruction code     } }

2. Other Aware interfaces for specific behaviour

Spring offers a range of Aware interfaces that allow beans to indicate to the container that they require a certain infrastructure dependency. Each interface will require you to implement a method to inject the dependency in bean.

These interfaces can be summarized as :

AWARE INTERFACE	METHOD TO OVERRIDE	PURPOSE
ApplicationContextAware	void setApplicationContext(ApplicationContext applicationContext) throws BeansException;	Interface to be implemented by any object that wishes to be notified of the ApplicationContext that it runs in.
ApplicationEventPublisherAware	void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher);	Set the ApplicationEventPublisher that this object runs in.
BeanClassLoaderAware	void setBeanClassLoader(ClassLoader classLoader);	Callback that supplies the bean class loader to a bean instance.
BeanFactoryAware	void setBeanFactory(BeanFactory beanFactory) throws BeansException;	Callback that supplies the owning factory to a bean instance.
BeanNameAware	void setBeanName(String name);	Set the name of the bean in the bean factory that created this bean.
BootstrapContextAware	void setBootstrapContext(BootstrapContext bootstrapContext);	Set the BootstrapContext that this object runs in.
LoadTimeWeaverAware	void setLoadTimeWeaver(LoadTimeWeaver loadTimeWeaver);	Set the LoadTimeWeaver of this object’s containing ApplicationContext.
MessageSourceAware	void setMessageSource(MessageSource messageSource);	Set the MessageSource that this object runs in.
NotificationPublisherAware	void setNotificationPublisher(NotificationPublisher notificationPublisher);	Set the NotificationPublisher instance for the current managed resource instance.
PortletConfigAware	void setPortletConfig(PortletConfig portletConfig);	Set the PortletConfig this object runs in.
PortletContextAware	void setPortletContext(PortletContext portletContext);	Set the PortletContext that this object runs in.
ResourceLoaderAware	void setResourceLoader(ResourceLoader resourceLoader);	Set the ResourceLoader that this object runs in.
ServletConfigAware	void setServletConfig(ServletConfig servletConfig);	Set the ServletConfig that this object runs in.
ServletContextAware	void setServletContext(ServletContext servletContext);	Set the ServletContext that this object runs in.
ApplicationEventPublisherAware	void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher);	Set the ApplicationEventPublisher that this object runs in.

A sample implementation will look like this:

package com.javathinkingbeyond.task; 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.MessageSource; import org.springframework.context.MessageSourceAware; import org.springframework.context.ResourceLoaderAware; import org.springframework.context.weaving.LoadTimeWeaverAware; import org.springframework.core.io.ResourceLoader; import org.springframework.instrument.classloading.LoadTimeWeaver; import org.springframework.jmx.export.notification.NotificationPublisher; import org.springframework.jmx.export.notification.NotificationPublisherAware; public class BemoBeanTypeTwo implements ApplicationContextAware,         ApplicationEventPublisherAware, BeanClassLoaderAware, BeanFactoryAware,         BeanNameAware, LoadTimeWeaverAware, MessageSourceAware,         NotificationPublisherAware, ResourceLoaderAware {     @Override     public void setResourceLoader(ResourceLoader arg0) {         // TODO Auto-generated method stub     }     @Override     public void setNotificationPublisher(NotificationPublisher arg0) {         // TODO Auto-generated method stub     }     @Override     public void setMessageSource(MessageSource arg0) {         // TODO Auto-generated method stub     }     @Override     public void setLoadTimeWeaver(LoadTimeWeaver arg0) {         // TODO Auto-generated method stub     }     @Override     public void setBeanName(String arg0) {         // TODO Auto-generated method stub     }     @Override     public void setBeanFactory(BeanFactory arg0) throws BeansException {         // TODO Auto-generated method stub     }     @Override     public void setBeanClassLoader(ClassLoader arg0) {         // TODO Auto-generated method stub     }     @Override     public void setApplicationEventPublisher(ApplicationEventPublisher arg0) {         // TODO Auto-generated method stub     }     @Override     public void setApplicationContext(ApplicationContext arg0)             throws BeansException {         // TODO Auto-generated method stub     } }

3. Custom init() and destroy() methods in bean configuration file

The default init and destroy methods in bean configuration file can be defined in two ways:

1.    Bean local definition applicable to a single bean

2.    Global definition applicable to all beans defined in beans context

Local definition is given as below.

<beans>     <bean id="demoBean" class="com.howtodoinjava.task.DemoBean" init-method="customInit" destroy-method="customDestroy"></bean> </beans>

Where as global definition is given as below. These methods will be invoked for all bean definitions given under <beans> tag. They are useful when you have a pattern of defining common method names such as init() and destroy() for all your beans consistently. This feature helps you in not mentioning the init and destroy method names for all beans independently. 

<beans default-init-method="customInit" default-destroy-method="customDestroy">                <bean id="demoBean" class="com.howtodoinjava.task.DemoBean"></bean> </beans>

A sample implementation for this type of life cycle will be:

package com.javathinkingbeyond.task; public class BemoBeanTypeThree {     public void customInit() {         System.out.println("Method customInit() invoked...");     }     public void customDestroy() {         System.out.println("Method customDestroy() invoked...");     } }

4. @PostConstruct and @PreDestroy annotations

Spring 2.5 onwards, you can use annotations also for specifying life cycle methods using @PostConstruct and @PreDestroy annotations.

@PostConstruct annotated method will be invoked after the bean has been constructed using default constructor and just before it’s instance is returned to requesting object.

@PreDestroy annotated method is called just before the bean is about be destroyed inside bean container.

A sample implementation will look like this:

package com.javathinkingbeyond.task; import javax.annotation.PostConstruct; import javax.annotation.PreDestroy; public class BemoBeanTypeFour {     @PostConstruct     public void customInit() {         System.out.println("Method customInit() invoked...");     }         @PreDestroy     public void customDestroy() {        System.out.println("Method customDestroy() invoked...");     } }

[Spring Interview Questions]

We recommend you take Big Data Hadoop class room training at eMexo Technologies in electronic city, Bangalore to learn more about Big Data Hadoop.