Spring Bean Life Cycle and Callbacks

The Spring Framework provide several call back methods to created a bean and some method to be destroy the bean in the Spring IoC Container.

@ImageSource-Youtube

The Spring Framework provides several marker interfaces to change the behavior of your bean in the container; they include InitializingBean and DisposableBean. Implementing these interfaces will result in the container calling afterPropertiesSet() for the former and destroy() for the latter to allow the bean to perform certain actions upon initialization and destruction.

Popular Tutorials

• Spring Tutorial
• Spring MVC Web Tutorial
• Spring Boot Tutorial
• Spring Security Tutorial
• Spring AOP Tutorial
• Spring JDBC Tutorial
• Spring HATEOAS
• Microservices with Spring Boot
• REST Webservice
• Core Java
• Hibernate Tutorial
• Spring Batch

The life cycle of a Spring bean is easy to understand. When a bean is instantiated, it may be required to perform some initialization to get it into a usable state. Similarly, when the bean is no longer required and is removed from the container, some cleanup may be required.

Though, there is lists of the activities that take place behind the scenes between the time of bean Instantiation and its destruction, but this chapter will discuss only two important bean lifecycle callback methods which are required at the time of bean initialization and its destruction.

Beans can be notified after creation and all properties are set, and before they are destroyed and removed from the bean container. This involves specifying the callback method to be invoked by the container. This is done in XML by specifying attributes init-method="myinit", for the initialization callback, and destroy-method="mydestroy", for the destroy callback. "myinit" and "cleanUp" are names of instance methods in the bean class.

Initialization callbacks:

Implementing the org.springframework.beans.factory.InitializingBean interface allows a bean to perform initialization work after all necessary properties on the bean are set by the container. The InitializingBean interface specifies exactly one method:
org.springframework.beans.factory.InitializingBean interface  provide Initialization callbacks method as given below..

void afterPropertiesSet() throws Exception

Now we can implements above interface and do some initialization functionality with in this method. As below..

public class Triangle implements InitializingBean
{
     @Override
     public void afterPropertiesSet() throws Exception
     {
       //To do some initialization works here
       System.out.println("InitializingBean init method is called for Triangle");
     }
}

Generally, the use of the InitializingBean interface can be avoided (and is discouraged since it unnecessarily couples the code to Spring). A bean definition provides support for a generic initialization method to be specified. In the case of XML-based configuration metadata, this is done using the 'init-method' attribute. For example, the following definition:
In the case of XML-based configuration metadata, we can use the init-method attribute to specify the name of the method that has a void no-argument signature. For example:

<bean class="com.dineshonjava.sdnext.callbackLifecycle.tutorial.Triangle" id="triangle" init-method="myInit"></bean>

Now following has myInit method in class.

public class Triangle
{
  public void myInit()
  {
     //To do some initialization works here
     System.out.println("My init method is called for Triangle");
  }
}

Now using Java annotations can also be used to declare life-cycle callbacks.

public class Triangle
{
  //init callback
  @PostConstruct
  public void myInit()
  {
     //To do some initialization works here
     System.out.println("My init method is called for Triangle");
  }
}

void destroy() throws Exception

public class Triangle implements DisposableBean 
{
     @Override
     public void destroy() throws Exception
     {
       //To do some Destruction works here
       System.out.println("DisposableBean destroy method is called for Triangle");
     }
}

<bean class="com.dineshonjava.sdnext.callbackLifecycle.tutorial.Triangle" destroy-method="cleanUp" id="triangle"></bean>

public class Triangle
{
  public void cleanUp()
  {
     //To do some Destruction works here
     System.out.println("cleanUp method is called for Triangle");
  }
}

public class Triangle
{
  //destroy callback
  @PreDestroy
  public void myInit()
  {
     //To do some Destruction works here
     System.out.println("cleanUp method is called for Triangle");
  }
}

package com.dineshonjava.sdnext.callbackLifecycle.tutorial;

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


public class Triangle implements InitializingBean, DisposableBean
{
 private Point pointA;
 private Point pointB;
 private Point pointC;
 /**
  * @param pointA the pointA to set
  */
 public void setPointA(Point pointA) {
  this.pointA = pointA;
 }

 /**
  * @param pointB the pointB to set
  */
 public void setPointB(Point pointB) {
  this.pointB = pointB;
 }

 /**
  * @param pointC the pointC to set
  */
 public void setPointC(Point pointC) {
  this.pointC = pointC;
 }

 public void draw()
 {
System.out.println("PointA is ("+pointA.getX()+", "+pointA.getY()+")");
System.out.println("PointB is ("+pointB.getX()+", "+pointB.getY()+")");
System.out.println("PointC is ("+pointC.getX()+", "+pointC.getY()+")");
 }

 @Override
 public void afterPropertiesSet() throws Exception
 {
System.out.println("InitializingBean init method is called for Triangle");
 }

 @Override
 public void destroy() throws Exception
 {
System.out.println("DisposableBean destroy method is called for Triangle");
 }
 
 public void myInit()
 {
   System.out.println("My init method is called for Triangle");
 }
 
 public void cleanUp()
 {
   System.out.println("cleanUp method is called for Triangle");
 }
}

package com.dineshonjava.sdnext.callbackLifecycle.tutorial;

public class Point
{
 private int x;
 private int y;
 /**
  * @return the x
  */
 public int getX() {
  return x;
 }
 /**
  * @param x the x to set
  */
 public void setX(int x) {
  this.x = x;
 }
 /**
  * @return the y
  */
 public int getY() {
  return y;
 }
 /**
  * @param y the y to set
  */
 public void setY(int y) {
  this.y = y;
 }
}

<beans xmlns:aop="http://www.springframework.org/schema/aop" xmlns:p="http://www.springframework.org/schema/p" xmlns:security="http://www.springframework.org/schema/security" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xsi:schemalocation="http://www.springframework.org/schema/beans">
  
<bean autowire="byName" class="com.dineshonjava.sdnext.callbackLifecycle.tutorial.Triangle" destroy-method="cleanUp" id="triangle" init-method="myInit">
</bean>

<bean class="com.dineshonjava.sdnext.callbackLifecycle.tutorial.Point" id="pointA">
  <property name="x" value="0"></property>
  <property name="y" value="0"></property>
</bean>
  
<bean class="com.dineshonjava.sdnext.callbackLifecycle.tutorial.Point" id="pointB">
   <property name="x" value="-20"></property>
   <property name="y" value="0"></property>
</bean>
  
<bean class="com.dineshonjava.sdnext.callbackLifecycle.tutorial.Point" id="pointC">
  <property name="x" value="20"></property>
  <property name="y" value="0"></property>
</bean>
</beans>

package com.dineshonjava.sdnext.callbackLifecycle.tutorial;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;


/**
 * @author Dinesh Rajput
 *
 */
public class DrawingApp 
{
 /**
  * @param args
  */
 public static void main(String[] args) 
 {
AbstractApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
context.registerShutdownHook();
Triangle triangle = (Triangle) context.getBean("triangle");
triangle.draw();
 }

}