Spring 3 Prart 4: Lifecycle Management

This is the 4th part of the Spring 3 Series.

Regardless of bean scope, initialization lifecycle callback methods are called on objects in Spring. There are 3 ways to achieve this

  1. interface based
  2. method based
  3. annotation based

Depend on your application requirements, you need to evaluate which mechanism is best. To achieve more portability third is the best because it is based on the JSR-250. If you are not concern of portability and in an application and needs lifecycle notification for many beans of the same type, then best is interface mechanism. When you share the bean among multiple spring projects , then interface mechanism is the best because interface mechanism based beans are self-contained.

spring lifecycle callback

Above diagram shows a high-level overview of how Spring manages the life cycle of the beans within its container(Harrop, Rob; Ho, Clarence (2012-04-18). Pro Spring 3 (Professional Apress) (p. 115). Apress. Kindle Edition).

It is important to remember that initialization callback in Spring is called after Spring finishes providing the dependencies, therefore in the initialization hook, you can perform the dependency check. If you are expecting to run schedule task, initialization hook is the best.

Method based mechanism

First start with the method based approach. 

package com.blogspot.ojitha.spring32.example.tut2;

import org.apache.log4j.Level;
import org.apache.log4j.Logger;

public class XMLBaseSimpleBean {
    
    static Logger logger = Logger.getLogger(XMLBaseSimpleBean.class);
    static {logger.setLevel(Level.INFO);}
    public XMLBaseSimpleBean(){
        
    }
        
    public void init(){
        logger.info("Initialize the bean");
    }
    
    public void shutdown(){
        logger.info("Destroy the bean");
    }

}

As shown in the above code, XMLBaseSimpleBean has two methods, init for initialization and shutdown for destroy method to execute when stop the application. This has been configured in the following Spring 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-3.2.xsd"
    default-lazy-init="true">

        <bean id="simpleBean"
        class="com.blogspot.ojitha.spring32.example.tut2.XMLBaseSimpleBean"
        init-method="init" destroy-method="shutdown"/>

</beans>

As shown in the line 9, initialize and destroy methods are defined. Client application is as follows:

package com.blogspot.ojitha.spring32.example.tut2;

import org.springframework.context.support.GenericXmlApplicationContext;

/**
 * Application Client
 *
 */
public class App 
{
    public static void main( String[] args )
    {
        GenericXmlApplicationContext ctx = new GenericXmlApplicationContext();
        ctx.load("classpath:spring\\lifecycle-xmlbased.xml");
        ctx.refresh(); //this is important.
        XMLBaseSimpleBean bean = (XMLBaseSimpleBean)ctx.getBean("simpleBean");
        System.out.println(bean);
        ctx.close(); //without this XMLBaseSimpleBean.shutdown() never work.
    }
}

Interface based mechanism

Next consider the interface based mechanism. 

package com.blogspot.ojitha.spring32.example.tut2;

import org.apache.log4j.Logger;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

public class InterfaceBaseSimpleBean implements InitializingBean, DisposableBean {

    Logger log = Logger.getLogger(InterfaceBaseSimpleBean.class);
    @Override
    public void afterPropertiesSet() throws Exception {
        log.info("Initialize the bean");
    }

    @Override
    public void destroy() throws Exception {
        log.info("Destroy the bean");        
    }

}

In the above code, two interfaces defined, afterPropertiesSet() from the InitializingBean and the destroy() method from the DisposableBean. 

<?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-3.2.xsd"
    default-lazy-init="true">

    <bean id="simpleBean"
        class="com.blogspot.ojitha.spring32.example.tut2.InterfaceBaseSimpleBean" />

</beans>

In the above code, not need either init-method or destroy-method because this requirement is fill by the interfaces.

//interface based mechanism
GenericXmlApplicationContext ctx = new GenericXmlApplicationContext();
ctx.load("classpath:spring\\lifecycle-interfacebased.xml");
ctx.refresh(); //this is important.
InterfaceBaseSimpleBean bean = (InterfaceBaseSimpleBean)ctx.getBean("simpleBean");
System.out.println(bean);
ctx.close(); //without this XMLBaseSimpleBean.shutdown() never work.
To run this you need to change the client code as above.

Annotation based mechanism

This mechanism is based on the JSR-250. 

package com.blogspot.ojitha.spring32.example.tut2;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

import org.apache.log4j.Level;
import org.apache.log4j.Logger;

public class AnnotationBaseSimpleBean {
    
    static Logger logger = Logger.getLogger(AnnotationBaseSimpleBean.class);
    static {logger.setLevel(Level.INFO);}
    public AnnotationBaseSimpleBean(){
        
    }
        
    @PostConstruct
    public void init(){
        logger.info("Initialize the bean");
    }
    
    @PreDestroy
    public void shutdown(){
        logger.info("Destroy the bean");
    }

}

However, in the Spring context you have to introduce the <context:annotation-config/> for annotations.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd">

    <bean id="simpleBean" class="com.blogspot.ojitha.spring32.example.tut2.AnnotationBaseSimpleBean"/>
    <context:annotation-config/>

</beans>

Here the client code

//annotation based mechanism
GenericXmlApplicationContext ctx = new GenericXmlApplicationContext();
ctx.load("classpath:spring\\lifecycle-annotationbased.xml");
ctx.refresh(); //this is important.
AnnotationBaseSimpleBean bean = (AnnotationBaseSimpleBean)ctx.getBean("simpleBean");
System.out.println(bean);
ctx.close(); //without this XMLBaseSimpleBean.shutdown() never work.

In the above code, instead of ctx.close(), you can use  ctx.getDefaultListableBeanFactory().destroySingletons(). There is another elegant solution to use the ctx.registerShutdownHook() very early(insert before the ctx.refresh() method) in the context in the Spring standard alone applications.

Source available to download for this blog.

Comments

Post a Comment

commented your blog

Popular posts from this blog

How To: GitHub projects in Spring Tool Suite

Image
The first step is sign up in the GitHub and create a  new project. For example I’ve created a new project Spring3part7 in the GitHub. Before add the projects you need to configure STS for GitHub access. For example, you need to add configuration as shown in the following picture Git local repository also important Now you are ready to pull the project from the GitHub, in the STS import menu select the following Now type the project name and click the ‘Search’ as shown in the following. However, when you select the found project click ‘Finish’ nothing will change in the STS interface. Now you are going to create real project. Here I am going to create simple utility project. This template project need to be created inside the imported GitHub project You have to give the same project name of the GitHub project as shown in the following project Now your project is ready to push. Before that you need to add ignore flag to all the folders and files except pom...
Continue »

Spring 3 Part 7: Spring with Databases

Image
This is the 7 th part of the Spring 3 Series . Create MySQL 5.6 database ‘payroll’, CREATE DATABASE payroll; Next create a user for example, user ‘ojitha’ CREATE USER 'ojitha'@'localhost' IDENTIFIED BY 'ojitha'; Need to grant the ‘payroll’ access to user ‘ojitha’ as shown in the following. GRANT SELECT, INSERT, UPDATE, DELETE, CREATE, DROP ON payroll.* TO 'ojitha'@'localhost'; You can download freeware of TOAD for MySQL from here . Let create a first table, that contains all the states in Australia. You can create a table using visually using the icon given directly below the Tables tab in the Object Explorer as shown in the above diagram. CREATE TABLE payroll.STATE ( CODE CHAR(3) ASCII COMMENT 'State code', STATE VARCHAR(30), PRIMARY KEY (CODE) ) ENGINE = InnoDB COMMENT = 'Australian states' ROW_FORMAT = DEFAULT; In the my sql console you can the newly added table using the following command SHOW ...
Continue »

Parse the namespace based XML using Python

In this blog, I am considering how to parser and modify the xml file using python. For example, I need to parser the following xml 1 (slightly modified for this blog) and need to write the modified xml to out.xml file. Here the country.xml <?xml version="1.0"?> <actors xmlns:fictional="http://characters.example.com" xmlns="http://people.example.com"> <actor type='T1'> <name>John Cleese</name> <fictional:character>Lancelot</fictional:character> <fictional:character>Archie Leach</fictional:character> </actor> <actor type='T2'> <name>Eric Idle</name> <fictional:character>Sir Robin</fictional:character> <fictional:character>Gunther</fictional:character> <fictional:character>Commander Clement</fictional:character> </actor> </actors> In ...
Continue »