启动Java应用的黑魔法：初始化性能解密@PostConstrut,InitialzingBean,init-method，BeanPostProcessor

我们在项目中经常会遇到启动时做一些逻辑的处理，比如配置信息的预加载，缓存信息的预加载等等，那都有哪些方法了，我们一起来探讨一下：

1. 方式

1. 构造方法初始化： 使用构造方法进行对象的基本属性初始化。这是最基本的初始化方式。

public class MyBean {
    private String name;
    private int age;

    public MyBean(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

2.JDK @PostConstruct注解： 使用@PostConstruct注解标记一个方法，该方法会在Bean创建后自动调用。

import javax.annotation.PostConstruct;

public class MyBean {
    private String name;

    @PostConstruct
    public void init() {
        // 初始化操作
    }
}

3. Spring 的InitializingBean接口： 实现InitializingBean接口，重写afterPropertiesSet()方法，该方法会在Bean创建后自动调用。

import org.springframework.beans.factory.InitializingBean;

public class MyBean implements InitializingBean {
    @Override
    public void afterPropertiesSet() {
        // 初始化操作
    }
}

4.Spring 的@Bean初始化方法： 如果你使用Java配置类定义Bean，可以在@Bean注解中指定初始化方法

@Configuration
public class MyConfig {
    
    @Bean(initMethod = "customInitMethod")
    public MyBean myBean() {
        return new MyBean();
    }
}

class MyBean{
	private void init(){
		//初始化操作
	}

}

5.Spring 提供的BeanPostProcessor

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

public class CustomBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        // 在Bean的初始化前执行自定义操作
        if (bean instanceof MyBean) {
            ((MyBean) bean).setCustomProperty("Custom initialization");
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        // 在Bean的初始化后执行自定义操作
        return bean;
    }
}

执行顺序

首先，创建一个Spring Boot应用程序。

1.创建Spring Boot应用程序的主类 MySpringBootApplication.java

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MySpringBootApplication {

    public static void main(String[] args) {
        SpringApplication.run(MySpringBootApplication.class, args);
    }
}

2. 创建一个Bean类 MyBean.java

import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;

@Component
public class MyBean implements InitializingBean {

    public MyBean() {
        System.out.println("Constructor: Bean is being created.");
    }

    @PostConstruct
    public void postConstructInit() {
        System.out.println("@PostConstruct: Custom initialization after construction.");
    }

    @Override
    public void afterPropertiesSet() {
        System.out.println("InitializingBean: Custom initialization after property set.");
    }

    public void customInitMethod() {
        System.out.println("init-method: Custom initialization method defined in Spring Boot.");
    }
}

3.创建一个自定义的BeanPostProcessor类 CustomBeanPostProcessor.java

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

@Component
public class CustomBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("BeanPostProcessor - BeforeInitialization: " + beanName);
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("BeanPostProcessor - AfterInitialization: " + beanName);
        return bean;
    }
}

运行Spring Boot应用程序后，您将看到初始化过程中的打印输出。在控制台上，您将看到它们的执行顺序如下：

Constructor: Bean is being created.
@PostConstruct: Custom initialization after construction.
InitializingBean: Custom initialization after property set.
BeanPostProcessor - BeforeInitialization: myBean
init-method: Custom initialization method defined in Spring Boot.
BeanPostProcessor - AfterInitialization: myBean

这显示了它们的典型执行顺序，即构造方法 > @PostConstruct > InitializingBean > init-method > BeanPostProcessor（在初始化之前和之后执行）。这些初始化方法可以根据需求组合使用，以自定义Bean的初始化过程。

3.比较

以下是一个使用Markdown表格形式来比较@PostConstruct、InitializingBean、自定义初始化方法（@Bean初始化方法）、以及BeanPostProcessor的特点和执行顺序：

特点/方法	@PostConstruct	InitializingBean	自定义初始化方法（@Bean初始化方法）	BeanPostProcessor
需要导入的包	import javax.annotation.PostConstruct;	import org.springframework.beans.factory.InitializingBean;	无需导入特定包	import org.springframework.beans.BeansException;
执行顺序	在Bean的构造后执行	在Bean的构造后执行	在Bean的构造后执行	在Bean的初始化前和后执行
适用对象	所有Spring Bean	所有Spring Bean	所有Spring Bean	针对特定Bean或所有Bean
执行时机	Bean创建后，属性设置之后	Bean创建后，属性设置之后	Bean创建后，属性设置之后	Bean创建后，初始化前和后
用途	自定义初始化操作	自定义初始化操作	自定义初始化操作	自定义初始化和后处理操作
配置方式	使用@PostConstruct注解	实现InitializingBean接口	在Spring配置中使用init-method属性	注册为Bean并由Spring容器自动应用
主要优点	简便易用，无需额外接口实现	简便易用，无需额外接口实现	可用于不使用注解的情况，较灵活	强大的自定义初始化和后处理功能
主要适用场景	通常用于自定义初始化逻辑	通常用于自定义初始化逻辑	在XML配置中使用时比较有用	需要高度自定义的初始化和后处理操作