spring-bean生命周期（实例化+初始化）

PacosonSWJTU2026-06-28 12:03

【1】README

  1. 正常业务应用显式构建bean过程：

    1. bean实例化：A a = new A()
    2. bean初始化：a.setXX(...) ，设置a这个bean的属性；

  2. 在spring应用中，无需我们显式构建bean，而是由spring框架自动帮我们完成的。由显式构建bean过程，我们不难推断spring构建bean的过程如出一辙，即先实例化bean（构造器创建bean），再初始化bean（如 @Autowire属性注入， @Value环境变量注入）；

  3. 【补充-特别注意】实例化与初始化区别；

    1. 实例化的单词是： Instantiate

    2. 初始化的单词是：Initialize(Initialization)

【2】spring实例化bean-AbstractAutowireCapableBeanFactory#createBean()

【2.1】bean实例化之前的逻辑

spring解析BeanDefinition，并找到构造器，传入构造器通过反射实例化bean；

spring在实例化bean的上下文（前后），提供了扩展功能，即修改bean属性的入口；

【构建bean源代码】

java 复制代码 
// 创建bean
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
        if (this.logger.isTraceEnabled()) {
            this.logger.trace("Creating instance of bean '" + beanName + "'");
        }

        RootBeanDefinition mbdToUse = mbd;
        Class<?> resolvedClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
        if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
            mbdToUse = new RootBeanDefinition(mbd);
            mbdToUse.setBeanClass(resolvedClass);

            try {
                mbdToUse.prepareMethodOverrides();
            } catch (BeanDefinitionValidationException ex) {
                throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", ex);
            }
        }

        try {
// bean实例化前解析
            Object bean = this.resolveBeforeInstantiation(beanName, mbdToUse);
            if (bean != null) {
                return bean;
            }
        } catch (Throwable ex) {
            throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", ex);
        }

        try {
// 创建bean实例
            Object beanInstance = this.doCreateBean(beanName, mbdToUse, args);
            if (this.logger.isTraceEnabled()) {
                this.logger.trace("Finished creating instance of bean '" + beanName + "'");
            }

            return beanInstance;
        } catch (ImplicitlyAppearedSingletonException | BeanCreationException ex) {
            throw ex;
        } catch (Throwable ex) {
            throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
        }

由上述源代码可知， 创建bean之前，先执行 resolveBeforeInstantiation()方法，如下。

  1. 调用 InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation方法；
  2. 若不为null，则调用BeanPostProcessor#postProcessAfterInitialization() 方法；

【补充-特别注意】实例化与初始化区别；

  1. 实例化的单词是： Instantiate
  2. 初始化的单词是：Initialize(Initialization)

【代码1】resolveBeforeInstantiation()方法

java 复制代码 
rotected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
        Object bean = null;
        if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
            if (!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) {
                Class<?> targetType = this.determineTargetType(beanName, mbd);
                if (targetType != null) {

// 实例化【前】应用bean后置处理器
                    bean = this.applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                    if (bean != null) {

// 初始化【后】应用bean后置处理器
                        bean = this.applyBeanPostProcessorsAfterInitialization(bean, beanName);
                    }
                }
            }

            mbd.beforeInstantiationResolved = bean != null;
        }

        return bean;
    }

// 实例化【前】应用bean后置处理器
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
        for(InstantiationAwareBeanPostProcessor bp : this.getBeanPostProcessorCache().instantiationAware) {
            Object result = bp.postProcessBeforeInstantiation(beanClass, beanName);
            if (result != null) {
                return result;
            }
        }

        return null;
    }

// 初始化【后】应用bean后置处理器
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException {
        Object result = existingBean;

        for(BeanPostProcessor processor : this.getBeanPostProcessors()) {
            Object current = processor.postProcessAfterInitialization(result, beanName);
            if (current == null) {
                return result;
            }

            result = current;
        }

        return result;
    }

【步骤1】实现InstantiationAwareBeanPostProcessor接口的postProcessBeforeInstantiation()方法

  1. 目的：在bean实例化前新增业务逻辑；
  2. 业务场景举例：仅返回代理对象，而非实际对象本身；这样spring不会执行后续的基于构造器使用反射创建bean和调用populateBean填充bean属性，而是直接跳过它们，继续执行BeanPostProcessor.afterInitialization()-初始化后的方法；
    1. 如 自动代理AbstractAutoProxyCreator 就是 InstantiationAwareBeanPostProcessor；

【2.1.1】 InstantiationAwareBeanPostProcessor接口

【代码2】【InstantiationAwareBeanPostProcessor接口定义】 继承 BeanPostProcessor接口

java 复制代码 
public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {

// bean实例化前的后置处理
    @Nullable
    default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        return null;
    }

// bean实例化后的后置处理
    default boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        return true;
    }

// 后置处理属性 
    @Nullable
    default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        return pvs;
    }
}

【2.1.2】【BeanPostProcessor接口定义】 bean初始化上下文的后置处理

【代码3】

java 复制代码 
public interface BeanPostProcessor {

// bean初始化前的后置处理
    @Nullable
    default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

// bean初始化后的后置处理
    @Nullable
    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
}

【2.1.3】【实现InstantiationAwareBeanPostProcessor接口示例】

【代码4】

java 复制代码 
public class TomInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

    public TomInstantiationAwareBeanPostProcessor() {
        super();
        log.info("TomInstantiationAwareBeanPostProcessor-构造器被调用");
    }

    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        log.info("postProcess BeforeInstantiation() 触发了");
        return InstantiationAwareBeanPostProcessor.super.postProcessBeforeInstantiation(beanClass, beanName);
    }

    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        log.info("postProcess AfterInstantiation() 触发了");
        return InstantiationAwareBeanPostProcessor.super.postProcessAfterInstantiation(bean, beanName);
    }

    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        log.info("postProcessProperties() 触发了");
        return InstantiationAwareBeanPostProcessor.super.postProcessProperties(pvs, bean, beanName);
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        log.info("postProcess BeforeInitialization() 触发了");
        return InstantiationAwareBeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        log.info("postProcess AfterInitialization() 触发了");
        return InstantiationAwareBeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
    }
}

【小结】bean实例化之前添加的逻辑

需要实现 InstantiationAwareBeanPostProcessor 接口，并重写postProcessBeforeInstantiation()方法；

如创建CGLIB代理对象的逻辑就可以放在 postProcessBeforeInstantiation()方法中，返回代理对象，而无需spring调用构造器创建bean；

【注意】

若postProcessBeforeInstantiation()方法返回bean不是null，则会继续调用BeanPostProcessor-postProcessAfterInitialization()方法-初始化后的后置处理方法；

又 InstantiationAwareBeanPostProcessor 继承了 BeanPostProcessor接口，所以也就是调用 InstantiationAwareBeanPostProcessor-postProcessAfterInitialization()-初始化后置处理逻辑，即bean属性设置完成后的后置处理逻辑；如TomInstantiationAwareBeanPostProcessor重写了 postProcessAfterInitialization(),postProcessAfterInitialization(); 就会先调用 TomInstantiationAwareBeanPostProcessor-postProcessAfterInitialization()，若该方法返回bean不为null，则继续调用 TomInstantiationAwareBeanPostProcessor-postProcessAfterInitialization()方法；

【2.2】bean实例化-AbstractAutowireCapableBeanFactory#doCreateBean()

本文主要关注3个方法：

  1. instanceWrapper = this.createBeanInstance(beanName, mbd, args); 创建bean实例；
  2. this.populateBean(beanName, mbd, instanceWrapper); 填充bean属性，如@Autowire，@Value注解标注的属性赋值；【属于bean初始化内容】
  3. exposedObject = this.initializeBean(beanName, exposedObject, mbd); 初始化bean；调用initMethod或InitializingBean-afterPropertiesSet方法 ；【属于bean初始化内容】

【代码5-创建bean实例】

java 复制代码 
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
        BeanWrapper instanceWrapper = null;
        if (mbd.isSingleton()) {
            instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
        }

        if (instanceWrapper == null) {
// 创建bean实例 
            instanceWrapper = this.createBeanInstance(beanName, mbd, args);
        }

        Object bean = instanceWrapper.getWrappedInstance();
        Class<?> beanType = instanceWrapper.getWrappedClass();
        if (beanType != NullBean.class) {
            mbd.resolvedTargetType = beanType;
        }

        synchronized(mbd.postProcessingLock) {
            if (!mbd.postProcessed) {
                try {
                    this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
                } catch (Throwable ex) {
                    throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", ex);
                }

                mbd.markAsPostProcessed();
            }
        }

        boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
        if (earlySingletonExposure) {
            if (this.logger.isTraceEnabled()) {
                this.logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
            }

            this.addSingletonFactory(beanName, () -> this.getEarlyBeanReference(beanName, mbd, bean));
        }

        Object exposedObject = bean;

        try {
// 填充bean属性
            this.populateBean(beanName, mbd, instanceWrapper);
// 初始化bean，调用bean的init-method方法，InitializingBean-afterPropertiesSet方法
            exposedObject = this.initializeBean(beanName, exposedObject, mbd);
        } catch (Throwable var18) {
            if (var18 instanceof BeanCreationException bce) {
                if (beanName.equals(bce.getBeanName())) {
                    throw bce;
                }
            }

            throw new BeanCreationException(mbd.getResourceDescription(), beanName, var18.getMessage(), var18);
        }

        // 先略过

        try {
            this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
            return exposedObject;
        } catch (BeanDefinitionValidationException ex) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
        }
    }

【2.2.1】createBeanInstance(beanName, mbd, args); 创建bean实例

为简单起见，本文仅考虑基于构造器使用反射创建bean的逻辑；

补充：FactoryBean的方法在本方法调用，但本文暂且忽略；

【代码6-基于构造器反射创建bean】

java 复制代码 
if (resolved) {
                    return autowireNecessary ? this.autowireConstructor(beanName, mbd, (Constructor[])null, (Object[])null) : this.instantiateBean(beanName, mbd);
                } else {
                    Constructor<?>[] ctors = this.determineConstructorsFromBeanPostProcessors(beanClass, beanName);
                    if (ctors == null && mbd.getResolvedAutowireMode() != 3 && !mbd.hasConstructorArgumentValues() && ObjectUtils.isEmpty(args)) {
                        ctors = mbd.getPreferredConstructors();
// 若使用有参构造器，则调用 autowireConstructor ；否则调用instantiateBean()方法
                        return ctors != null ? this.autowireConstructor(beanName, mbd, ctors, (Object[])null) : this.instantiateBean(beanName, mbd);
                    } else {
                        return this.autowireConstructor(beanName, mbd, ctors, args);
                    }
                }

// 无参构造器调用 
protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {
        try {
            Object beanInstance = this.getInstantiationStrategy().instantiate(mbd, beanName, this);
            BeanWrapper bw = new BeanWrapperImpl(beanInstance);
            this.initBeanWrapper(bw);
            return bw;
        } catch (Throwable ex) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName, ex.getMessage(), ex);
        }
    }

【3】实例化bean之后：spring初始化bean

本节主要关注3个方法：

  1. instanceWrapper = this.createBeanInstance(beanName, mbd, args); 创建bean实例；
  2. this.populateBean(beanName, mbd, instanceWrapper); 填充bean属性，如@Autowire，@Value注解标注的属性赋值；【属于bean初始化内容】
  3. exposedObject = this.initializeBean(beanName, exposedObject, mbd); 初始化bean；调用initMethod或InitializingBean-afterPropertiesSet方法 ；【属于bean初始化内容】

【3.1】populateBean(beanName, mbd, instanceWrapper) 填充bean属性

如为@Autowire，@Value注解标注的属性赋值；

本节主要关注3个方法：

  1. 调用InstantiationAwareBeanPostProcessor-postProcessAfterInstantiation()方法：实例化后的后置处理；
    1. 目的：用于控制是否执行后续的属性注入；若 postProcessAfterInstantiation 返回false，则不进行后续的属性注入；返回true，则执行属性注入；
  2. 为@Autowire注解标注的属性赋值；
  3. 调用InstantiationAwareBeanPostProcessor-postProcessProperties()方法：后置处理属性；
    1. 目的：spring对bean属性注入前的最后一次功能扩展机会点；如增加删除修改属性值，自定义注入注解如@DiyAutowire解析并注入属性；

【例】如代码4的TomInstantiationAwareBeanPostProcessor重写了InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation方法与postProcessProperties方法，这时就会调用TomInstantiationAwareBeanPostProcessor的对应方法；

【**代码6-**populateBean()方法-填充bean属性】

java 复制代码 
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
        if (bw == null) {
            // 
            }
        } else if (bw.getWrappedClass().isRecord()) {
            // 
            }
        } else {
            if (!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) {

// 调用postProcessAfterInstantiation() 执行实例化后的后置处理逻辑
                for(InstantiationAwareBeanPostProcessor bp : this.getBeanPostProcessorCache().instantiationAware) {
                    if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
// 若 postProcessAfterInstantiation 返回false，则不进行后续的属性注入
                        return;
                    }
                }
            }

            PropertyValues pvs = mbd.hasPropertyValues() ? mbd.getPropertyValues() : null;
            int resolvedAutowireMode = mbd.getResolvedAutowireMode();
            if (resolvedAutowireMode == 1 || resolvedAutowireMode == 2) {
                MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
                if (resolvedAutowireMode == 1) {
// 为@Autowire注解标注的属性赋值
                    this.autowireByName(beanName, mbd, bw, newPvs);
                }

                if (resolvedAutowireMode == 2) {
                    this.autowireByType(beanName, mbd, bw, newPvs);
                }

                pvs = newPvs;
            }

            if (this.hasInstantiationAwareBeanPostProcessors()) {
                if (pvs == null) {
                    pvs = mbd.getPropertyValues();
                }

// 调用 postProcessProperties()，后置处理属性，如修改属性值
                for(InstantiationAwareBeanPostProcessor bp : this.getBeanPostProcessorCache().instantiationAware) {
                    PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
                    if (pvsToUse == null) {
                        return;
                    }

                    pvs = pvsToUse;
                }
            }

            boolean needsDepCheck = mbd.getDependencyCheck() != 0;
            if (needsDepCheck) {
                PropertyDescriptor[] filteredPds = this.filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
                this.checkDependencies(beanName, mbd, filteredPds, pvs);
            }

            if (pvs != null) {
                this.applyPropertyValues(beanName, mbd, bw, pvs);
            }

        }
    }

【3.2】初始化bean-initializeBean()

++本节关注4个方法++：

  1. 调用invokeAwareMethods() ： 调用Aware方法；装配 BeanName，BeanClassLoader，BeanFactory ；
  2. 调用BeanPostProcessor的applyBeanPostProcessorsBeforeInitialization()：初始化前后置处理器；
  3. 调用 invokeInitMethods()： 调用init()方法；
    1. 调用 InitializingBean的afterPropertiesSet方法 ；
    2. 调用 Bean配置的InitMethod方法；
  4. 调用 BeanPostProcessor的applyBeanPostProcessorsAfterInitialization() ： 调用初始化后的bean后置处理器；

【代码7-initializeBean()方法】

java 复制代码 
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {

// 触发 Aware装配方法 
        this.invokeAwareMethods(beanName, bean);
        Object wrappedBean = bean;
        if (mbd == null || !mbd.isSynthetic()) {

// 调用 BeanPostProcessor的postProcessBeforeInitialization方法
            wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);
        }

// 调用init()方法  
        try {
            this.invokeInitMethods(beanName, wrappedBean, mbd);
        } catch (Throwable ex) {
            throw new BeanCreationException(mbd != null ? mbd.getResourceDescription() : null, beanName, ex.getMessage(), ex);
        }

// 调用BeanPostProcessor的postProcessAfterInitialization方法
        if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        }

        return wrappedBean;
    }

// invokeAwareMethods方法如下：
private void invokeAwareMethods(String beanName, Object bean) {
        if (bean instanceof Aware) {
            if (bean instanceof BeanNameAware) {
                BeanNameAware beanNameAware = (BeanNameAware)bean;
                beanNameAware.setBeanName(beanName);
            }

            if (bean instanceof BeanClassLoaderAware) {
                BeanClassLoaderAware beanClassLoaderAware = (BeanClassLoaderAware)bean;
                ClassLoader bcl = this.getBeanClassLoader();
                if (bcl != null) {
                    beanClassLoaderAware.setBeanClassLoader(bcl);
                }
            }

            if (bean instanceof BeanFactoryAware) {
                BeanFactoryAware beanFactoryAware = (BeanFactoryAware)bean;
                beanFactoryAware.setBeanFactory(this);
            }
        }

    }

// 调用 initMethod方法； invokeInitMethods；
protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd) throws Throwable {
        boolean isInitializingBean = bean instanceof InitializingBean;
        if (isInitializingBean && (mbd == null || !mbd.hasAnyExternallyManagedInitMethod("afterPropertiesSet"))) {
            if (this.logger.isTraceEnabled()) {
                this.logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
            }

// 调用 InitializingBean的afterPropertiesSet方法 
            ((InitializingBean)bean).afterPropertiesSet();
        }

        if (mbd != null && bean.getClass() != NullBean.class) {
            String[] initMethodNames = mbd.getInitMethodNames();
            if (initMethodNames != null) {
                for(String initMethodName : initMethodNames) {
                    if (StringUtils.hasLength(initMethodName) && (!isInitializingBean || !"afterPropertiesSet".equals(initMethodName)) && !mbd.hasAnyExternallyManagedInitMethod(initMethodName)) {

// 调用Bean配置的initMethod方法 
                        this.invokeCustomInitMethod(beanName, bean, mbd, initMethodName);
                    }
                }
            }
        }

    }

【3.3】补充：bean实例化+初始化完成后，注册bean销毁前的处理逻辑（本文不展开）

AbstractAutowireCapableBeanFactory-doCreateBean()方法最后一步：注册销毁bean前的处理逻辑。

【代码8】

java 复制代码 
try {
            this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
            return exposedObject;
        } catch (BeanDefinitionValidationException ex) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
        }

【4】bean生命周期-代码示例

【4.1】创建InstantiationAwareBeanPostProcessor实现类

实现生命周期各阶段方法

java 复制代码 
@Slf4j
public class TomInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

    public TomInstantiationAwareBeanPostProcessor() {
        super();
        log.info("TomInstantiationAwareBeanPostProcessor-构造器被调用");
    }

    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        log.info("postProcess BeforeInstantiation() 触发了");
        return InstantiationAwareBeanPostProcessor.super.postProcessBeforeInstantiation(beanClass, beanName);
    }

    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        log.info("postProcess AfterInstantiation() 触发了");
        return InstantiationAwareBeanPostProcessor.super.postProcessAfterInstantiation(bean, beanName);
    }

    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        log.info("postProcessProperties() 触发了");
        return InstantiationAwareBeanPostProcessor.super.postProcessProperties(pvs, bean, beanName);
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        log.info("postProcess BeforeInitialization() 触发了");
        return InstantiationAwareBeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        log.info("postProcess AfterInitialization() 触发了");
        return InstantiationAwareBeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
    }
}

【4.2】定义业务bean的类

java 复制代码 
@Getter
@Slf4j
public class TomAccountService implements ApplicationContextAware, EnvironmentAware, InitializingBean {

    private String testStr = "tom test";
    private ApplicationContext applicationContext;
    private Environment environment;

    public TomAccountService() {
        log.info("TomAccountService示例被创建");
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
        log.info("applicationContext-装配完成");
    }

    @Override
    public void setEnvironment(Environment environment) {
        this.environment = environment;
        log.info("environment-装配完成");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        this.testStr = testStr + "-afterPropertiesSet触发";
        log.info("InitializingBean-afterPropertiesSet()触发");
    }

    public void myInitMethod() {
        log.info("myInitMethod()方法触发");
    }
}

【4.3】运行结果

【beans.xml】

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 id="tomAccountService" class="com.tom.srccode.deep.analysis.chapter0501.beans.TomAccountService" init-method="myInitMethod" />
    <bean id="tomBeanPostProcessor" class="com.tom.srccode.deep.analysis.chapter0501.postprocessors.TomInstantiationAwareBeanPostProcessor" />
</beans>

【Main方法】

java 复制代码 
public class Chapter0501MainApplication {
    public static void main(String[] args) {
        ApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("/a_src_deep_analysis/chapter05/beans0501.xml");
        TomAccountService tomAccountService = applicationContext.getBean("tomAccountService", TomAccountService.class);
        System.out.println(tomAccountService.getTestStr());
    }
}

【运行结果】日志顺序

  1. TomInstantiationAwareBeanPostProcessor- 后置处理器BeanPostProcessor构造器被调用（BeanPostProcessor Bean被创建）；
  2. postProcess BeforeInstantiation() 触发了
  3. TomAccountService示例被创建； 如 A a = new A(); 【bean实例化】
  4. postProcess AfterInstantiation() 触发了
  5. postProcessProperties() 触发了;
  6. environment-装配完成
  7. applicationContext-装配完成
  8. postProcess BeforeInitialization() 触发了
  9. InitializingBean-afterPropertiesSet()触发 【bean初始化】
  10. myInitMethod()方法触发 【bean初始化】
  11. postProcess AfterInitialization() 触发了；

【补充】关于装配Environment，ApplicationContext的触发点

  1. 容器加载时：添加了 ApplicationContextAwareProcessor 这个BeanPostProcessor；

    1. ApplicationContextAwareProcessor#postProcessBeforeInitialization方法会在每个bean实例化后但初始化前被调用； postProcessBeforeInitialization会装配实现了

      复制代码 
      EnvironmentAware，ApplicationContextAware等Aware接口的bean的SetAware方法；

    // 新建容器时
    public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, @Nullable ApplicationContext parent) throws BeansException {
    super(parent);
    this.setConfigLocations(configLocations);
    if (refresh) {
    this.refresh();
    }

    复制代码 
     }

    // 刷新容器
    public void refresh() throws BeansException, IllegalStateException {
    this.startupShutdownLock.lock();

    复制代码 
         try {
         this.startupShutdownThread = Thread.currentThread();
         StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
         this.prepareRefresh();
         ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();

    // 准备bean容器
    this.prepareBeanFactory(beanFactory);
    ...
    }

    // prepareBeanFactory() 方法：准备bean容器，完善bean容器功能
    protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    beanFactory.setBeanClassLoader(this.getClassLoader());
    beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
    beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, this.getEnvironment()));

    // 新增 ApplicationContextAwareProcessor 这个BeanPostProcessor
    beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
    ...
    }

【ApplicationContextAwareProcessor 这个BeanPostProcessor 的postProcessBeforeInitialization方法】

java 复制代码 
class ApplicationContextAwareProcessor implements BeanPostProcessor {
    private final ConfigurableApplicationContext applicationContext;
    private final StringValueResolver embeddedValueResolver;

    public ApplicationContextAwareProcessor(ConfigurableApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
        this.embeddedValueResolver = new EmbeddedValueResolver(applicationContext.getBeanFactory());
    }

    @Nullable
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof Aware) {
            this.invokeAwareInterfaces(bean);
        }

        return bean;
    }

// 为实现Aware接口的bean装配 Environment，ApplicationContext等基础bean
    private void invokeAwareInterfaces(Object bean) {
        if (bean instanceof EnvironmentAware environmentAware) {
            environmentAware.setEnvironment(this.applicationContext.getEnvironment());
        }

        if (bean instanceof EmbeddedValueResolverAware embeddedValueResolverAware) {
            embeddedValueResolverAware.setEmbeddedValueResolver(this.embeddedValueResolver);
        }

        if (bean instanceof ResourceLoaderAware resourceLoaderAware) {
            resourceLoaderAware.setResourceLoader(this.applicationContext);
        }

        if (bean instanceof ApplicationEventPublisherAware applicationEventPublisherAware) {
            applicationEventPublisherAware.setApplicationEventPublisher(this.applicationContext);
        }

        if (bean instanceof MessageSourceAware messageSourceAware) {
            messageSourceAware.setMessageSource(this.applicationContext);
        }

        if (bean instanceof ApplicationStartupAware applicationStartupAware) {
            applicationStartupAware.setApplicationStartup(this.applicationContext.getApplicationStartup());
        }

        if (bean instanceof ApplicationContextAware applicationContextAware) {
            applicationContextAware.setApplicationContext(this.applicationContext);
        }

    }
}

【4.4】小结

复制代码 
BeanPostProcessor：有2个方法，postProcessBeforeInitialization+postProcessAfterInitialization，提供对所有bean初始化前后的后置处理逻辑；

  1. BeanPostProcessor子类，

    复制代码 
    InstantiationAwareBeanPostProcessor：有3个方法，包括 postProcessBeforeInstantiation, postProcessAfterInstantiation, postProcessProperties，提供对所有bean实例化前后的后置处理逻辑；

  2. BeanPostProcessor与InstantiationAwareBeanPostProcessor区别 ：

    1. BeanPostProcessor： bean初始化前后；
    2. InstantiationAwareBeanPostProcessor：bean实例化前后；

  3. 若不是对所有bean，而是对单个bean 的初始化新增扩展逻辑，如何实现：

    1. 单个bean实现 InitializingBean的afterPropertiesSet()方法；
    2. 单个bean对应@Bean注解配置 init-method属性, 如@Bean(initMethod=XXX)
      1. 或 beans.xml文件定义bean时新增 init-method属性；
热门推荐
012026年6月AI大模型全景报告：GPT-5.6、Claude Opus 4.8、Gemini 3.5，中美AI三足鼎立谁主沉浮？022026年6月AI行业全景：从百模大战到Agent元年，这30天发生了什么？032026 年 AI 编程工具终极横评：Cursor vs Claude Code vs Copilot vs Windsurf04Trae国际版与国内版深度测评：AI原生IDE的双生花05飞书长连接_事件订阅（接收消息，审批任务状态变更）06GitHub 镜像站点07【AI】2026 年具身智能模型和世界模型总结08Claude Code、Codex、Cursor三分天下：2026年AI编程Agent生态全景剖析092026年AI架构实战：彻底解决OpenAI接口超时与封号，Python调用GPT-5.2/Sora2企业级架构详解（附源码+压测报告）102026 AI 编程工具终极实战指南：Cursor vs Claude Code vs Copilot，开发者该怎么选？