Sunday, February 2, 2014

Life Cycle Management of a Spring Bean

October 26, 2007 by Krishna Srinivasan 6 Comments

SHARE & COMMENT :
0
5
0


1) Introduction

This article would brief about how a Spring Bean is managed in IOC (Inversion of Control) Container. Spring Beans exist within the Container as long as they are needed by the Application. There are various life-cycle interfaces and methods that will be called by the IOC Container. The pre-requisite for this article is some basic knowledge in Spring which can be got by reading the article in Javabeat Introduction to Spring Web Framework.
also read:

2) Bean Life Cycle

Spring Bean represents a POJO component performing some useful operation. All Spring Beans reside within a Spring Container also known as IOC Container. The Spring Framework is transparent and thereby hides most of the complex infrastructure and the communication that happens between the Spring Container and the Spring Beans. This section lists the sequence of activities that will take place between the time of Bean Instantiation and hand over of the Bean reference to the Client Application.
  1. The Bean Container finds the definition of the Spring Bean in the Configuration file.
  2. The Bean Container creates an instance of the Bean using Java Reflection API.
  3. If any properties are mentioned, then they are also applied. If the property itself is a Bean, then it is resolved and set.
  4. If the Bean class implements the BeanNameAware interface, then the setBeanName() method will be called by passing the name of the Bean.
  5. If the Bean class implements the BeanClassLoaderAware interface, then the method setBeanClassLoader()method will be called by passing an instance of the ClassLoader object that loaded this bean.
  6. If the Bean class implements the BeanFactoryAware interface, then the method setBeanFactory() will be called by passing an instance of BeanFactory object.
  7. If there are any BeanPostProcessors object associated with the BeanFactory that loaded the Bean, then the method postProcessBeforeInitialization() will be called even before the properties for the Bean are set.
  8. If the Bean class implements the InitializingBean interface, then the method afterPropertiesSet() will be called once all the Bean properties defined in the Configuration file are set.
  9. If the Bean definition in the Configuration file contains a 'init-method' attribute, then the value for the attribute will be resolved to a method name in the Bean class and that method will be called.
  10. The postProcessAfterInitialization() method will be called if there are any Bean Post Processors attached for the Bean Factory object.
  11. If the Bean class implements the DisposableBean interface, then the method destroy() will be called when the Application no longer needs the bean reference.
  12. 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.

3) Life Cycle phases

3.1) Bean Name Aware Interface

If the Bean Implementation class wants to know the name of the Bean as configured and maintained by the Bean Factoryclass, then the Bean class should implement the interface BeanNameAware and override the setBeanName() method. TheBean Factory after reading the Bean definition from the Configuration file will come to know the name of the Bean and will pass this name as an argument to the setBeanName() method.
LanguageBean.java
1
package javabeat.net.articles.spring.lifecycle;
2

3
import org.springframework.beans.factory.BeanNameAware;
4

5
public class LanguageBean implements BeanNameAware
6
{
7
    private String languageName;
8
    private String beanName;
9

10
    public LanguageBean()
11
    {
12
    }
13

14
    public String getLanguageName()
15
    {
16
        return languageName;
17
    }
18

19
    public void setLanguageName(String languageName)
20
    {
21
        this.languageName = languageName;
22
    }
23

24
    @Override
25
    public void setBeanName(String beanName)
26
    {
27
        this.beanName = beanName;
28
    }
29

30
    public String getBeanName()
31
    {
32
        return beanName;
33
    }
34
}
The above sample class provides one such implementation and the below client code uses the above class to know the name of the bean.
1
static void beanNameAwareTest()
2
{
3
    Resource resource = new FileSystemResource("./src/resources/bean-lifecycle.xml");
4
    BeanFactory beanFactory = new XmlBeanFactory(resource);
5
    LanguageBean javaLanguage = (LanguageBean)beanFactory.getBean("javaLanguage");
6
    System.out.println(javaLanguage.getLanguageName());
7
    System.out.println(javaLanguage.getBeanName());
8
}
The following piece of Xml code snippet goes into the Xml Configuration file.
1
<bean id="javaLanguage">
2
    <property name="languageName" value="Java"/>
3
</bean>

3.2) Bean Class Loader Aware Interface

TestBeanWithClassLoaderAware.java
1
package javabeat.net.articles.spring.lifecycle;
2

3
import org.springframework.beans.factory.BeanClassLoaderAware;
4

5
public class TestBeanWithClassLoaderAware implements BeanClassLoaderAware
6
{
7
    private ClassLoader classLoader;
8

9
    @Override
10
    public void setBeanClassLoader(ClassLoader classLoader)
11
    {
12
        this.classLoader = classLoader;
13
    }
14

15
    public ClassLoader getBeanClassLoader()
16
    {
17
        return classLoader;
18
    }
19
}
At times, a Client Application may wish to know the details of the Class Loader through which Bean objects are loaded. In such a case, the Bean class should implement the BeanClassLoaderAware interface and override thesetBeanClassLoader() method. The Bean Factory object will pass an instance of the ClassLoader object that loaded this Bean to the setBeanClassLoader() method.
1
static void beanClassLoaderAwareTest()
2
{
3
    Resource resource = new FileSystemResource("./src/resources/bean-lifecycle.xml");
4
    BeanFactory beanFactory = new XmlBeanFactory(resource);
5
    TestBeanWithClassLoaderAware classLoaderAwareBean =
6
        (TestBeanWithClassLoaderAware)beanFactory.getBean("classLoaderAwareBean");
7
    ClassLoader beanClassLoader = classLoaderAwareBean.getBeanClassLoader();
8
    System.out.println(beanClassLoader.getClass());
9
}
The above client program uses the TestBeanWithClassLoaderAware object and the following is the Xml configuration information for the above Spring Bean.
1
<bean id="classLoaderAwareBean"class="javabeat.net.articles.spring.lifecycle.TestBeanWithClassLoaderAware">
2
</bean>

3.3) Bean Factory Aware Interface

Bean Factory object is responsible for loading and creating Bean instances. This object is sufficient for simple cases. However situations may demand the usage of ApplicationContext and WebApplicationContext for complex scenarios. Both ApplicationContext and WebApplicationContext extend the BeanFactory class and provides advanced configuration such as loading resourcespublishing events etc. So, there must be way for the Spring Bean to know which Bean Factory has actually loaded it. Here comes the BeanFactoryAware interface in which the methodsetBeanFactory() will be passed an instance of the Bean Factory object that configured and created this Bean.
BeanWithBeanFactoryAware.java
1
package javabeat.net.articles.spring.lifecycle;
2

3
import org.springframework.beans.BeansException;
4
import org.springframework.beans.factory.BeanFactory;
5
import org.springframework.beans.factory.BeanFactoryAware;
6

7
public class BeanWithBeanFactoryAware implements BeanFactoryAware
8
{
9
    private BeanFactory beanFactory;
10

11
    @Override
12
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException
13
    {
14
        this.beanFactory = beanFactory;
15
    }
16

17
    public BeanFactory getBeanFactory()
18
    {
19
        return beanFactory;
20
    }
21
}
The following client code makes use of the above BeanWithBeanFactoryAware Bean. The Bean Factory object can either be an instance of BeanFactoryApplicationContextWebApplicationContext, etc.
1
static void beanFactoryAwareTest()
2
{
3
    Resource resource = new FileSystemResource("./src/resources/bean-lifecycle.xml");
4
    BeanFactory xmlBeanFactory = new XmlBeanFactory(resource);
5
    BeanWithBeanFactoryAware beanFactoryAwareBean =
6
        (BeanWithBeanFactoryAware)xmlBeanFactory.getBean("beanFactoryAwareBean");
7
    BeanFactory beanFactory = beanFactoryAwareBean.getBeanFactory();
8
    // Do something with this beanFactory object.
9
}
The following code is the Bean definition information for the above Bean which goes into the Configuration file.
1
<bean id="beanFactoryAwareBean"class="javabeat.net.articles.spring.lifecycle.BeanWithBeanFactoryAware">
2
</bean>

3.4) Bean Post Processor

Customization of Bean instances in an Application can happen for variety of reasons. For example, once a Bean object is created, various other data from a legacy system has to be populated on the Bean object. It may not be possible to configure the legacy data information in the Configuration file.
DatabaseRow.java
1
package javabeat.net.articles.spring.lifecycle;
2

3
import java.util.List;
4

5
import org.springframework.beans.BeansException;
6
import org.springframework.beans.factory.config.BeanPostProcessor;
7

8
public class DatabaseRow
9
{
10
    private String rowId;
11
    private int noOfColumns;
12
    private List values;
13

14
    public DatabaseRow()
15
    {
16
    }
17

18
    public String getRowId()
19
    {
20
        return rowId;
21
    }
22

23
    public void setRowId(String rowId)
24
    {
25
        this.rowId = rowId;
26
    }
27

28
    public int getNoOfColumns()
29
    {
30
        return noOfColumns;
31
    }
32

33
    public void setNoOfColumns(int noOfColumns)
34
    {
35
        this.noOfColumns = noOfColumns;
36
    }
37

38
    public List getValues()
39
    {
40
        return values;
41
    }
42

43
    public void setValues(List values)
44
    {
45
        this.values = values;
46
    }
47
}
Let us consider a simple example for this. The above class represents a Database row and let us consider that even before the properties are set for this Bean object, the row-id and the number of columns in the row has to be populated. And once all the properties are set, then some other dependant properties also has to be set.DBRowBeanPostProcessor.java
1
package javabeat.net.articles.spring.lifecycle;
2

3
import java.util.Arrays;
4

5
import org.springframework.beans.BeansException;
6
import org.springframework.beans.factory.config.BeanPostProcessor;
7

8
public class DBRowBeanPostProcessor implements BeanPostProcessor
9
{
10

11
    @Override
12
    public Object postProcessBeforeInitialization(Object bean, String beanName)
13
        throws BeansException
14
    {
15
        System.out.println("Before Initialization");
16
        System.out.println("Bean object: " + bean);
17
        System.out.println("Bean name: " + beanName);
18

19
        DatabaseRow dbRow = null;
20
        if (bean instanceof DatabaseRow)
21
        {
22
            dbRow = (DatabaseRow)bean;
23
            dbRow.setRowId("ROWID-001");
24
            dbRow.setNoOfColumns(3);
25
            return dbRow;
26
        }
27
        return null;
28
    }
29

30
    @Override
31
    public Object postProcessAfterInitialization(Object bean, String beanName)
32
        throws BeansException
33
    {
34
        System.out.println("After Initialization");
35
        System.out.println("Bean object: " + bean);
36
        System.out.println("Bean name: " + beanName);
37

38
        DatabaseRow dbRow = null;
39
        if (bean instanceof DatabaseRow)
40
        {
41
            dbRow = (DatabaseRow)bean;
42
            dbRow.setValues(Arrays.asList("Antony""10""93232"));
43
            return dbRow;
44
        }
45
        return null;
46
    }
47
}
We have defined one Bean Post Processor class for customizing the behavior for some set of Beans with common nature. The method postProcessBeforeInitialization() will be called even before the properties for the Bean are set. And the method postProcessAfterInitialization() will be called after the properties for the Bean object are set.
1
static void beanPostProcessorTest()
2
{
3
    Resource resource = new FileSystemResource("./src/resources/bean-lifecycle.xml");
4
    ConfigurableBeanFactory xmlBeanFactory = new XmlBeanFactory(resource);
5

6
    DBRowBeanPostProcessor processor = new DBRowBeanPostProcessor();
7
    xmlBeanFactory.addBeanPostProcessor(processor);
8

9
    DatabaseRow databaseRow =
10
        (DatabaseRow)xmlBeanFactory.getBean("databaseRow");
11
    System.out.println("Row Id: " + databaseRow.getRowId());
12
    System.out.println("Columns: " + databaseRow.getNoOfColumns());
13
    System.out.println("Values : " + databaseRow.getValues().toString());
14
}
The above client code registers the custom Bean Post Processor to the Bean Factory object by calling the methodBeanFactory.addBeanPostProcessor(). It is possible to add any number of Bean Post Processor objects.
1
<bean id="databaseRow" class="javabeat.net.articles.spring.lifecycle.DatabaseRow">
2
</bean>

3.5) Initializing Bean

EmployeeBean.java
1
package javabeat.net.articles.spring.lifecycle;
2

3
import org.springframework.beans.factory.InitializingBean;
4

5
public class EmployeeBean implements InitializingBean
6
{
7
    private String name;
8
    private int age;
9
    private double salary;
10

11
    public EmployeeBean()
12
    {
13
    }
14

15
    public String getName()
16
    {
17
        return name;
18
    }
19

20
    public void setName(String name)
21
    {
22
        this.name = name;
23
    }
24

25
    public int getAge()
26
    {
27
        return age;
28
    }
29

30
    public void setAge(int age)
31
    {
32
        this.age = age;
33
    }
34

35
    public double getSalary()
36
    {
37
        return salary;
38
    }
39

40
    public void setSalary(double salary)
41
    {
42
        this.salary = salary;
43
    }
44

45
    @Override
46
    public void afterPropertiesSet() throws Exception
47
    {
48
        if (name == null || age == 0 || salary == 0.0d)
49
        {
50
            throw new Exception("Mandatory field not set.");
51
        }
52
    }
53
}
The InitializingBean interface may be implemented by Bean class who wish to do some post processing actions when all the properties have been set. For example, the above sample code tries to check whether all the properties are set and if not and an exception is thrown.
1
static void initializingBeanTest()
2
{
3
    try
4
    {
5
        Resource resource = new FileSystemResource(
6
            "./src/resources/bean-lifecycle.xml");
7
        BeanFactory xmlBeanFactory = new XmlBeanFactory(resource);
8
        EmployeeBean johnson = (EmployeeBean)xmlBeanFactory.getBean("johnson");
9
        System.out.println("Name: " + johnson.getName());
10
        System.out.println("Age: " + johnson.getAge());
11
        System.out.println("Salary: " + johnson.getSalary());
12
    }
13
    catch (Exception exception)
14
    {
15
        exception.printStackTrace();
16
    }
17
}
In the configuration file, we have purposely omitted the property 'name' which means that we an instance of the Bean object is created the name variable will be pointing to null, thereby throwing an exception in the afterPropertiesSet()method.
1
<bean id="johnson" class="javabeat.net.articles.spring.lifecycle.EmployeeBean">
2
<property name "age" value "43" />
3
<property name "salary" value "4834938.32" />
4
</bean>

3.6) Custom Init Method

CustomInitMethodBean.java
1
package javabeat.net.articles.spring.lifecycle;
2

3
public class CustomInitMethodBean
4
{
5
    public void customInitMethod()
6
    {
7
        System.out.println("Custom init method called for this bean");
8
    }
9
}
One of the drawbacks with the InitializingBean interface is that the client code is dependant on Spring specific APIs. If you feel that approach is not fine, then you can define your own initialization method in your Spring class and configure the method in the Xml file.
1
static void customInitMethodTest()
2
{
3
    Resource resource = new FileSystemResource("./src/resources/bean-lifecycle.xml");
4
    BeanFactory xmlBeanFactory = new XmlBeanFactory(resource);
5
    CustomInitMethodBean bean =
6
        (CustomInitMethodBean)xmlBeanFactory.getBean("customInitMethodBean");
7
}
For the above Bean class, we have defined a method called customInitMethod() and we have configured the same in the'init-method' attribute. This means that the method customInitMethod() will be called once all the properties for the Bean is set.
1
<bean id="customInitMethodBean"class="javabeat.net.articles.spring.lifecycle.CustomInitMethodBean"
2
    init-method "customInitMethod">
3
</bean>

3.7) Disposable Bean

ConnectionManager.java
1
package javabeat.net.articles.spring.lifecycle;
2

3
import java.util.ArrayList;
4
import java.util.List;
5

6
import org.springframework.beans.factory.DisposableBean;
7

8
public class ConnectionManager implements DisposableBean
9
{
10
    private List connections = new ArrayList();
11

12
    public ConnectionManager()
13
    {
14
        for (int i = 0; i < 5; i++)
15
        {
16
            Connection connection = new Connection();
17
            connection.open();
18
            connections.add(connection);
19
        }
20
    }
21

22
    @Override
23
    public void destroy() throws Exception
24
    {
25
        System.out.println("Closing all connections");
26
        for (Connection connection : connections)
27
        {
28
            connection.close();
29
        }
30
    }
31

32
    class Connection
33
    {
34
        public void open() {}
35
        public void close() {}
36
    }
37
}
This interface is exactly the reverse of InitializingBean interface. The method destroy() in the DisposableBean will be called once the Bean reference is no longer needed by the Application code, or the Bean instance is forced to be removed through some APIs.
1
static void disposableBeanTest()
2
{
3
    Resource resource = new FileSystemResource("./src/resources/bean-lifecycle.xml");
4
    ConfigurableListableBeanFactory xmlBeanFactory = new XmlBeanFactory(resource);
5
    ConnectionManager connectionManager =
6
        (ConnectionManager)xmlBeanFactory.getBean("myConnectionManager");
7
    xmlBeanFactory.destroySingletons();
8
}
The default scope for all the Beans is singleton, which means that only one instance is created irrespective of the number of calls made to BeanFactory.getBean("beanName"). In the above client code, we have called the methodBeanFactory.destroySingletons() which will forcibly remove the Bean instance managed by the Bean Factory in which case the destroy method will be called.
1
<bean id="myConnectionManager" class="javabeat.net.articles.spring.lifecycle.ConnectionManager">
2
</bean>

3.8) Custom Destroy Method

CustomDestroyMethodBean.java
1
package javabeat.net.articles.spring.lifecycle;
2

3
public class CustomDestroyMethodBean
4
{
5
    public void customDestroyMethod()
6
    {
7
        System.out.println("This method will be called upon bean destruction.");
8
    }
9
}
If we dont prefer a Spring Bean to depend on Spring specific API for destruction, then all we can do is to define a custom method in the implementation class and make appropriate configuration in the Xml file.
1
static void customDestroyMethodTest()
2
{
3
    Resource resource = new FileSystemResource("./src/resources/bean-lifecycle.xml");
4
    ConfigurableListableBeanFactory xmlBeanFactory = new XmlBeanFactory(resource);
5
    CustomDestroyMethodBean bean =
6
        (CustomDestroyMethodBean)xmlBeanFactory.getBean("customDestroyMethodBean");
7
    xmlBeanFactory.destroySingletons();
8
}
The method customDestroyMethod defined in the above Bean in configured through the means of the attribute'destroy-method'.
1
"customDestroyMethodBean"class="javabeat.net.articles.spring.lifecycle.CustomDestroyMethodBean"
2
   destroy-method = "customDestroyMethod">
3

4) Conclusion

In this article, we have discussed the contract between Spring Beans and the IOC Container. We have also listed down the series of steps that will be occurring at relevant intervals during the entire life cycle of Spring Beans.
also read:


4 comments:

oakleyses said...

louis vuitton handbags, oakley sunglasses, louboutin, longchamp outlet, nike shoes, louis vuitton outlet stores, chanel handbags, burberry outlet, prada outlet, jordan shoes, tiffany and co, michael kors outlet, tory burch outlet, louis vuitton outlet, longchamp handbags, nike free, true religion jeans, michael kors outlet, kate spade outlet, polo ralph lauren outlet, tiffany and co, prada handbags, polo ralph lauren outlet, michael kors outlet, michael kors outlet, longchamp handbags, oakley sunglasses, ray ban sunglasses, kate spade handbags, burberry outlet, louis vuitton outlet, louboutin outlet, louboutin, coach factory outlet, air max, air max, coach outlet, gucci outlet, christian louboutin shoes, michael kors outlet, coach purses, ray ban sunglasses, michael kors outlet, louis vuitton, coach outlet store online, true religion jeans, oakley sunglasses cheap

oakleyses said...

ralph lauren, lululemon, air max, hollister, north face, nike air max, polo lacoste, vanessa bruno, timberland, vans pas cher, louboutin, louis vuitton, oakley pas cher, air max pas cher, nike roshe run, air max, true religion outlet, barbour, sac longchamp, air force, hollister, sac louis vuitton, nike free, polo ralph lauren, nike trainers, louis vuitton uk, nike roshe, sac hermes, longchamp, michael kors, sac burberry, sac guess, mulberry, new balance pas cher, converse pas cher, sac louis vuitton, hogan outlet, nike tn, north face, true religion outlet, ray ban pas cher, michael kors, air jordan, nike blazer, nike free pas cher, michael kors pas cher, abercrombie and fitch, ray ban sunglasses

oakleyses said...

mac cosmetics, mont blanc, marc jacobs, canada goose outlet, nike huarache, vans shoes, soccer jerseys, hollister, giuseppe zanotti, beats by dre, abercrombie and fitch, longchamp, insanity workout, celine handbags, bottega veneta, ghd, nfl jerseys, north face outlet, chi flat iron, ugg boots, birkin bag, ugg australia, canada goose, herve leger, ugg pas cher, rolex watches, valentino shoes, canada goose uk, canada goose, ferragamo shoes, canada goose, ugg boots, uggs outlet, north face jackets, soccer shoes, asics running shoes, new balance shoes, p90x, lululemon outlet, canada goose jackets, mcm handbags, instyler, babyliss pro, ugg, wedding dresses, jimmy choo outlet, reebok outlet, nike roshe run

oakleyses said...

parajumpers, karen millen, air max, converse, pandora charms, moncler, louboutin, moncler, links of london, lancel, juicy couture outlet, oakley, hollister, pandora charms, supra shoes, thomas sabo, canada goose, gucci, wedding dresses, timberland boots, swarovski crystal, air max, coach outlet store online, moncler, ray ban, canada goose, moncler, ugg, louis vuitton, swarovski, hollister, montre homme, moncler, hollister clothing store, ralph lauren, rolex watches, moncler outlet, moncler, iphone 6 cases, baseball bats, juicy couture outlet, toms shoes, vans, pandora jewelry, ugg, converse shoes