A step by step analysis of spring bean life cycle

About spring bean life cycle is the basis for in-depth study of the spring, but also difficult, this article will use the code + graphic way to explain the conclusions of spring bean life cycle,

This article will explain clearly the figure below.

A project structure and source code

1. Directory Structure

2.applicationContext.xml

<?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.xsd">

    <bean class="com.demo.dao.UserDao" id="userDao" scope="singleton" init-method="myInit" destroy-method="myDestroy">
        <property name="userName" value="Alan_beijing"/>
    </bean>

    <bean class="com.demo.dao.MyBeanPostProcessor" id="myBeanPostProcessor"/>

</beans>

3.UserDao.java

package com.demo.dao;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.apache.log4j.Logger;

public class UserDao implements BeanNameAware, BeanFactoryAware, ApplicationContextAware, InitializingBean,
        DisposableBean{

    private String userName;
    private int count = 0;

    public String, getUserName () {
         return the userName; 
    } 

    // 2. Properties injection, injection property is the userName 
    public  void setUserName (String the userName) { 
        COUNT ++ ; 
        System.out.println (COUNT + ": = injecting property the userName" + the userName );
         the this .userName = the userName; 
    } 

    // 1. constructor with no arguments for calling the constructor when instantiating 
    public UserDao () { 
        COUNT ++ ; 
        System.out.println (COUNT + ": UserDao calling the constructor () " ); 
    } 

    // 3. implemented BeanNameAware, ID obtaining the bean 
    public  voidsetBeanName (String S) { 
        COUNT ++ ; 
        System.out.println (COUNT + ": call setBeanName () Gets ID bean, bean ID =" + S); 
    } 

    // 4. implemented BeanFactoryAware, obtaining bean factory 
    public  void setBeanFactory (the beanFactory beanFactory) throws BeansException { 
        COUNT ++ ; 
        System.out.println (COUNT + ": setBeanFactory call () Gets bean plants, beanFactory =" + beanFactory); 
    } 

    // 5. The implement ApplicationContextAware, bean context obtaining 
    public  void setApplicationContext (ApplicationContext applicationContext) throws  BeansException {
        COUNT++ ; 
        System.out.println (COUNT + ": call setApplicationContext () Gets bean context, applicationContext =" + applicationContext); 
    } 

    // 6. The implement InitializingBean, obtaining afterPropertiesSet 
    public  void afterPropertiesSet () throws Exception { 
        COUNT ++ ; 
        System.out.println (COUNT + ": call afterPropertiesSet ()" ); 
    } 

    // 7. The custom initialization method MyInit () 
    public  void MyInit () { 
        COUNT ++ ; 
        System.out.println (COUNT + ": call custom MyInit () " );
    } 

    //8. achieve DisposableBean, acquires the destroy () 
    public  void the destroy () throws Exception { 
        COUNT ++ ; 
        System.out.println (COUNT + ": the destroy ()" ); 
    } 

    // 9. The method of destruction custom myDestroy () 
    public  void myDestroy () { 
        COUNT ++ ; 
        System.out.println (COUNT + ": custom calls the destroy ()" ); 
    } 
}

4.MyBeanPostProcessor.java

package com.demo.dao;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

public  class MyBeanPostProcessor implements BeanPostProcessor {
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("=====调用postProcessBeforeInitialization()=====");
        return bean;
    }

    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("=====调用postProcessAfterInitialization()=====");
        return bean;
    }
}

Two test code and test results

1.test.java

package com.demo.test;

import com.demo.dao.UserDao;
import org.junit.Test;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {

    @Test
    public void test() {
        //定义容器并初始化
        //ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        AbstractApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        to applicationContext.getBean (UserDao. class );
         // be in the closed container, will destroy method is called 
        applicationContext.registerShutdownHook (); 
    } 
}

2. Test results

Analysis of Three

With the above test results, bean lifecycle process is as follows:

1. Assembly bean

bean assembly for the first part of the life cycle of bean. The so-called bean assembly, refers to the process of converting the bean java object. In this example, UserDao.jave and MyBeanPostProcessor xml manner into the bean.

Note: spring mounting frame supports four way bean: xml embodiment, java codes embodiment, automatic assembly and mixing assembly methods

2. Load and instantiate applicationContext.xml

Loaded and instantiated bean bean is the second part of the life cycle. Exemplified herein by the ClassPathXmlApplicationContext to load () and, when the bean is singleton, this process is instantiated objects, without having to wait

Call applicationContext.getBean () Gets bean when instantiating an object, which prototype is not the same.