Spring Bean Lifecycle: Definition, Initialization, Invocation, and Destruction

First, a brief overview (the following serves as a reference template for answering interview questions):

1. Instantiating a Bean – essentially a new operation.

2. Configuring the Bean according to the Spring context – i.e., IoC injection.

3. If the Bean implements BeanNameAware , Spring calls setBeanName(String) with the Bean's id from the configuration file.

4. If the Bean implements BeanFactoryAware , Spring calls setBeanFactory(BeanFactory) , passing the BeanFactory itself (useful for obtaining other Beans).

5. If the Bean implements ApplicationContextAware , Spring calls setApplicationContext(ApplicationContext) , providing the full application context.

6. If the Bean is associated with a BeanPostProcessor , Spring invokes postProcessBeforeInitialization(Object, String) before the Bean's initialization completes.

7. If the Bean definition includes an init-method attribute, Spring automatically calls that method after property injection.

8. After initialization, if a BeanPostProcessor is present, Spring calls postProcessAfterInitialization(Object, String) .

Note: After the above steps, the Bean is ready for use. By default it is a singleton, so repeated look‑ups return the same instance unless the scope is changed in the configuration.

9. When the Bean is no longer needed, Spring enters the destruction phase; if the Bean implements DisposableBean , its destroy() method is invoked.

10. Finally, if a destroy-method attribute is defined, Spring calls that method automatically.

1. Bean Definition

Spring typically defines Beans in an XML configuration file, for example:

<?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-2.0.xsd">
    <bean id="HelloWorld" class="com.pqf.beans.HelloWorld">
        <property name="msg">
            <value>HelloWorld</value>
        </property>
    </bean>
</beans>

This configuration defines a Bean with the identifier HelloWorld . Multiple Beans can be defined in the same file.

2. Bean Initialization

There are two common ways to initialize a Bean.

1) Using the init-method attribute in the configuration file

Define an initialization method in the Bean class, e.g. init() :

public class HelloWorld {
    public String msg = null;
    public Date date = null;

    public void init() {
        msg = "HelloWorld";
        date = new Date();
    }
    // ... other members ...
}

Then specify init-method="init" on the <bean> element.

2) Implementing org.springframework.beans.factory.InitializingBean

Implement the interface and provide afterPropertiesSet() :

public class HelloWorld implements InitializingBean {
    public String msg = null;
    public Date date = null;

    public void afterPropertiesSet() {
        msg = "Hello to the world!";
        date = new Date();
    }
    // ... other members ...
}

Spring will invoke afterPropertiesSet() after all properties have been set, eliminating the need for an init-method attribute.

3. Bean Invocation

Beans can be obtained and used in three ways:

1) Using BeanWrapper

HelloWorld hw = new HelloWorld();
BeanWrapper bw = new BeanWrapperImpl(hw);
bw.setPropertyValue("msg", "HelloWorld");
System.out.println(bw.getPropertyValue("msg"));

2) Using BeanFactory

InputStream is = new FileInputStream("config.xml");
XmlBeanFactory factory = new XmlBeanFactory(is);
HelloWorld hw = (HelloWorld) factory.getBean("HelloWorld");
System.out.println(hw.getMsg());

3) Using ApplicationContext

ApplicationContext ctx = new FileSystemXmlApplicationContext("config.xml");
HelloWorld hw = (HelloWorld) ctx.getBean("HelloWorld");
System.out.println(hw.getMsg());

4. Bean Destruction

1) Using the destroy-method attribute in the configuration file

Define a cleanup method in the Bean class and reference it with destroy-method . Spring will call it automatically when the Bean is destroyed.

2) Implementing org.springframework.beans.factory.DisposableBean

If the Bean implements DisposableBean , Spring invokes its destroy() method during the destruction phase, so the Bean must provide that method.

Diagram:

Selected common interview questions and technical points help developers fill knowledge gaps.