【Spring】实例化、初始化、InitializingBean等执行顺序

今天先来测试一下Spring 初始化IOC流程中， 构造函数、@PostConstruct、InitializingBean接口，InstantiationAwareBeanPostProcessor接口，initMethod 等执行顺序。

        
            org.springframework
            spring-context
            5.3.12
        

        
            junit
            junit
            4.13.2
            test
        

package com.gane.spring.config;


public class Maple {

    private String name;

    private int age;

    public Maple(String name, int age) {
        System.out.println("实例化：Maple的有参构造器");
        this.name = name;
        this.age = age;
    }

    private void initMethod(){
        System.out.println("Maple的init-method...");
    }

    private void destroy(){
        System.out.println("Maple的destroy...");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package com.gane.spring.config;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

import javax.annotation.PostConstruct;


@ComponentScan("com.gane.spring.config")
@Configuration
public class SpringOrderConfig implements InstantiationAwareBeanPostProcessor, InitializingBean {

    public SpringOrderConfig() {
        System.out.println("实例化：SpringOrderConfig的构造函数");
    }

    @PostConstruct
    public void postConstruct() {
        System.out.println("PostConstruct");
    }

    @Override
    public Object postProcessBeforeInstantiation(Class beanClass, String beanName) throws BeansException {
        System.out.println("实例化 " + beanName + " 之前：postProcessBeforeInstantiation");
        return null;
    }

    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        System.out.println("实例化 " + beanName + " 之后：postProcessAfterInstantiation");
        return true;
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("初始化 " + beanName + " 之前：postProcessBeforeInitialization");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("初始化 " + beanName + " 之后：postProcessAfterInitialization");
        return bean;
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("实现了InitializingBean接口");
    }

    @Bean(initMethod = "initMethod", destroyMethod = "destroy")
    public Maple maple() {
        return new Maple("maple", 18);
    }
}

import com.gane.spring.config.SpringOrderConfig;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;


public class ApplicationTest {

    @Test
    public void test(){

        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringOrderConfig.class);

        System.out.println("IOC容器初始化成功");
    }
}

 可以看到首先是： 

1、SpringOrderConfig的构造函数Construct

2、然后是 在构造函数之后的PostConstruct 

3、然后是实现了InitializingBean接口重写afterPropertiesSet方法

4、然后走到Maple的时候，是先执行 实例化Maple之前的postProcessBeforeInstantiation

5、实例化Maple的构造函数Construct

6、实例化Maple之后的postProcessAfterInstantiation

7、实例化之后就是初始化了，初始化 Maple 之前 的postProcessBeforeInitialization

8、初始化Maple，执行Maple的init-method方法

9、初始化 Maple 之后 的postProcessAfterInitialization

执行顺序我们知道了，下面我们看看每一个组件的使用场景是什么