Spring Bean生命周期执行流程详解

于 2025-04-10 17:36:26 发布
阅读量1.1k 收藏 10
点赞数 8
文章标签： spring java Bean生命周期
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_43600166/article/details/147121071
版权

文章目录

一、什么是Spring Bean生命周期？

Spring Bean生命周期是指从Bean的创建到销毁的整个过程，其中涉及到Spring容器对Bean的一系列处理操作，包对Bean的实例化、依赖注入、初始化和销毁。Spring框架中Bean的生命周期主要包括以下关键步骤：

  1. 实例化Bean：Spring容器根据Bean的定义从容器中取出Bean的类，通过反射机制进行实例化。
  2. 属性填充：Spring容器从Bean定义中获取属性值，将这些属性值注入到新创建的Bean实例中，这个过程也叫做依赖注入。
  3. Aware接口回调：如果Bean涉及到实现了BeanNameAware、BeanClassLoaderAware、BeanFactoryAware接口，则会触发BeanNameAware.setBeanName、BeanClassLoaderAware.setBeanClassLoader、BeanFactory.setBeanFactory方法的调用。
  4. BeanPostProcessor接口回调：触发前置方法BeanPostProcessor.postProcessBeforeInitialization。注意的是ApplicationContextAwareProcessor和InitDestroyAnnotationBeanPostProcessor都是BeanPostProcessor的实现类，因此可能触发ApplicationContextAware的setApplicationContext方法回调和init-Method回调。
  5. InitializingBean接口回调：触发InitializingBean.afterPropertiesSet方法。
  6. BeanPostPorcessor接口回调：触发后置方法BeanPostProcessor.postProcessAfterInitialization方法。
  7. Bean初始化完成，可以投入使用
  8. 当Bean实现了DisposableBean接口时，Spring容器关闭时，会回调DisposableBean.destory方法。
  9. Bean被销毁，生命周期结束。

工作流程图：

在这里插入图片描述

二、Bean生命周期执行流程验证

1.编写测试代码验证结果

定义一个LifeCycleBean类，将其作为SpringBean进行管理，让其实现BeanNameAware, BeanFactoryAware, BeanPostProcessor, ApplicationContextAware, InitializingBean, DisposableBean接口，在实现方法中打印对应的信息，查看方法调用的顺序。


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.springframework.stereotype.Component;
import javax.annotation.PostConstruct;

@Component
public class LifeCycleBean implements BeanNameAware, BeanFactoryAware, BeanPostProcessor, ApplicationContextAware, InitializingBean, DisposableBean {

    //前置处理是否被调用标识
    private volatile boolean beforeInitializationInvoked = false;
    //后置处理是否被调用标识
    private volatile boolean afterInitializationInvoked = false;

    @Override
    public void setBeanName(String name) {
        System.out.println("BeanNameAware.name be invoked");
    }

    @PostConstruct
    public void init() {
        System.out.println("PostConstruct.init be invoked");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("DisposableBean.destroy be invoked");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("InitializingBean.afterPropertiesSet be invoked");
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("ApplicationContextAware.setApplicationContext be invoked");
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (!beforeInitializationInvoked) {
            beforeInitializationInvoked = true;
            System.out.println("BeanPostProcessor.postProcessBeforeInitialization be invoked");
        }
        return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (!afterInitializationInvoked) {
            afterInitializationInvoked = true;
            System.out.println("BeanPostProcessor.postProcessAfterInitialization be invoked");
        }
        return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("BeanFactoryAware.setBeanFactory be invoked");
    }
}

启动项目，查看控制台打印结果如下：
在这里插入图片描述
关闭容器后，控制台打印如下:
在这里插入图片描述
因此可以得出，Bean启动后，初始化的执行顺序是：BeanNameAware->BeanFactoryAware->ApplicationContextAware(由ApplicationContextAwareProcessor调用)->PostConstruct（由InitDestroyAnnotationBeanPostProcessor调用）->BeanPostProcessor.postProcessBeforeInitialization(自定义)->InitializingBean.afterPropertiesSet->BeanPostProcessor.postProcessAfterInitialization–>DisposableBean.destory。

2.源码追溯Bean初始化回调过程

通过断点可以得出Bean初始化的入口在AbstractAutowireCapableBeanFactory.initializeBean方法。

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				invokeAwareMethods(beanName, bean);
				return null;
			}, getAccessControlContext());
		}
		else {
			invokeAwareMethods(beanName, bean);
		}

		Object wrappedBean = bean;
		if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}

		try {
			invokeInitMethods(beanName, wrappedBean, mbd);
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					(mbd != null ? mbd.getResourceDescription() : null),
					beanName, "Invocation of init method failed", ex);
		}
		if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}

		return wrappedBean;
	}

其中的一个方法invokeAwareMethods的命名十分明显，用于调用一些Aware接口的实现类，进入invokeAwareMethods方法后，通过判断当前bean是否为Aware类型，如果是则进一步判断是Aware接口下的哪一种类型，然后进行类型转换调用对应的方法。

	private void invokeAwareMethods(String beanName, Object bean) {
		if (bean instanceof Aware) {
			if (bean instanceof BeanNameAware) {
				((BeanNameAware) bean).setBeanName(beanName);
			}
			if (bean instanceof BeanClassLoaderAware) {
				ClassLoader bcl = getBeanClassLoader();
				if (bcl != null) {
					((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
				}
			}
			if (bean instanceof BeanFactoryAware) {
				((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
			}
		}
	}

执行完invokeAwareMethods后，则调用initializeBean方法中的applyBeanPostProcessorsBeforeInitialization方法，通过遍历现有的BeanPostProcessor类，依次调用其postProcessBeforeInitialization方法。

	@Override
	public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
			throws BeansException {

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

其中重点关注ApplicationContextAwareProcessor和InitDestroyAnnotationBeanPostProcessor两个类，他们都属于BeanPostPorcessor的实现类，因此在循环时都会调用其postProcessBeforeInitialization方法。ApplicationContextAwareProcessor.postProcessBeforeInitialization方法中有一个比较重要的方法invokeAwareInterfaces，该方法也是用于回调一些实现了Aware接口的类。其中ApplicationContextAware.setApplicationContext就是在此处被调用，当然还涉及到EnvironmentAware、EmbeddedValueResolverAware、MessageSourceAware等的回调。

	private void invokeAwareInterfaces(Object bean) {
		if (bean instanceof EnvironmentAware) {
			((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
		}
		if (bean instanceof EmbeddedValueResolverAware) {
			((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
		}
		if (bean instanceof ResourceLoaderAware) {
			((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
		}
		if (bean instanceof ApplicationEventPublisherAware) {
			((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
		}
		if (bean instanceof MessageSourceAware) {
			((MessageSourceAware) bean).setMessageSource(this.applicationContext);
		}
		if (bean instanceof ApplicationContextAware) {
			((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
		}
	}

InitDestroyAnnotationBeanPostProcessor.postProcessBeforeInitialization方法重要是通过反射机制调用被注释PostConstruct修饰的init-Method.

在完成applyBeanPostProcessorsBeforeInitialization调用后，则会调用invokeInitMethods方法， 如果Bean实现了InitializingBean接口，Spring容器会调用其afterPropertiesSet()方法。

protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd)
			throws Throwable {

		boolean isInitializingBean = (bean instanceof InitializingBean);
		if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
			if (logger.isTraceEnabled()) {
				logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
			}
			if (System.getSecurityManager() != null) {
				try {
					AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
						((InitializingBean) bean).afterPropertiesSet();
						return null;
					}, getAccessControlContext());
				}
				catch (PrivilegedActionException pae) {
					throw pae.getException();
				}
			}
			else {
				((InitializingBean) bean).afterPropertiesSet();
			}
		}

		if (mbd != null && bean.getClass() != NullBean.class) {
			String initMethodName = mbd.getInitMethodName();
			if (StringUtils.hasLength(initMethodName) &&
					!(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
					!mbd.isExternallyManagedInitMethod(initMethodName)) {
				invokeCustomInitMethod(beanName, bean, mbd);
			}
		}
	}

最调用applyBeanPostProcessorsAfterInitialization方法，通过遍历BeanPostProcessor的实现类，调用其postProcessAfterInitialization后置方法。

	public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
			throws BeansException {

		Object result = existingBean;
		for (BeanPostProcessor processor : getBeanPostProcessors()) {
			Object current = processor.postProcessAfterInitialization(result, beanName);
			if (current == null) {
				return result;
			}
			result = current;
		}
		return result;
	}
SpringBean生命周期详解 | 有图有真相
流楚丶格念的博客
08-26 9961
既然叫反转，肯定就有正转，正转其实就是对象去找实例，而反转就反过来了嘛，让实例来找对象；怎么找呢？当然是通过容器啦！
Bean（Spring）的执行流程和生命周期
GoodManS的优快云
02-13 2553
Spring 和 Bean 的重点，也是常见的面试问答
Spring Bean 生命周期的执行流程
2301_79438104的博客
02-19 747
在 Spring 应用启动时，会读取配置文件（如 XML 配置、Java 注解配置等）或者扫描带有特定注解（如@Component@Service等）的类，将这些 Bean 的定义信息加载到 Spring 的或中。这些定义信息包括 Bean 的类名、作用域、依赖关系等。Spring Bean 的生命周期可以概括为：定义 -> 实例化 -> 属性注入 -> 初始化前 -> 初始化 -> 初始化后 -> 使用 -> 销毁前 -> 销毁。
Spring中Bean生命周期与Spring的执行流程
weixin_48438454的博客
09-28 169
Spring中Bean的生命周期 实例化bean对象，并设置属性 检查Aware接口，并设置依赖 调用 BeanPostProcess的前置初始化方法postProcessBeforeInitialization() 调用InitializingBean的afterPropertiesSet()方法 调用自身init-method方法 调用 BeanPostProcess的后置初始化方法postProcessAfterInitialization() 完成创建- 使用 销毁 检查DisposableBe
Spring Bean 生命周期详解
常备不懈
06-22 1943
在 Spring 框架中，Bean 的生命周期由 Spring 容器全权管理。了解和掌握 Bean 的生命周期对于使用 Spring 开发稳定且高效的应用程序至关重要。本文将详细介绍 Spring Bean 生命周期的五个主要阶段：实例化、属性注入、初始化、使用和销毁，并涵盖各个阶段的关键步骤和扩展点。
谈谈我对Spring Bean 生命周期的理解
08-27
"Spring Bean 生命周期详解" Spring Bean 生命周期是 Spring 框架中的一个核心概念，了解 Spring Bean 的生命周期对我们了解整个 Spring 框架会有很大的帮助。本文将详细介绍 Spring Bean 生命周期的概念、生命周期...
Spring Bean 生命周期的执行流程详解
最新发布
LiuYuHao_的博客
02-19 695
Spring Bean的生命周期是指从Bean被创建到最终被销毁的整个过程。这个过程中包含了多个步骤，每个步骤都有特定的目的和作用。创建前准备阶段：在创建Bean实例之前进行的准备工作。创建实例阶段：通过构造函数或工厂方法创建Bean的实例。依赖注入阶段：为Bean设置属性值并进行依赖注入。容器缓存阶段：将Bean实例注册到Spring容器中，并进行必要的后处理。销毁实例阶段：当Spring容器关闭时，调用销毁方法清理资源。为了更好地理解这些阶段，我们将使用一个简单的示例来说明每个阶段的具体操作。
Spring的执行流程与Bean的生命周期
x2656271356的博客
10-27 419
Spring的执行流程和Bean的生命周期
spring执行流程
qq_29669265的博客
01-25 403
记录一次跟踪spring生成普通bean的流程
spring中bean的生命周期（简单5步）
快乐学习
02-11 3757
1.生命是bean的生命周期？ 答：spring其实就是管理bean对象的工厂，它负责对象的创建，对象的销毁。生命周期就是从创建到最终的销毁的整个过程。 3.bean的生命周期按照粗略的五步 第一步：实例化bean（调用无参数构造方法） 第二步：给bean属性赋值（调用set方法） 第三步：初始化bean（调用bean的init方法。这个init方法要自己写，自己配） 第四步：使用bean 第五步：销毁bean（调用bean的destroy方法。这个destroy方法要自己写，自己配）
Spring执行流程和Bean的生命周期
Original0的博客
06-18 1077
Spring执行流程（Bean执行流程）：1、在启动类中遇到了ApplicationContext的时候就会启动 Spring 容器 -> 2、根据容器设置的配置文件，去找相应的配置文件；->3、如果有base-package，那么就去base-package里循环找所有的类，看有没有五大类注解和方法注解；->4、 如果有注解，进行初始化和属性依赖赋值。
Spring Bean生命周期详解
永无止境
04-18 6385
文章目录Spring bean生命周期13个环节阶段1：Bean元信息配置阶段阶段2：Bean元信息解析阶段阶段3：Spring Bean注册阶段 Spring bean生命周期13个环节 阶段1：Bean元信息配置阶段 阶段2：Bean元信息解析阶段 阶段3：将Bean注册到容器中 阶段4：BeanDefinition合并阶段 阶段5：Bean Class加载阶段 阶段6：Bean实例化阶段（...
Spring之Bean的生命周期
weixin_74352229的博客
08-18 2294
所谓 Bean 的生命周期，就是一个 Bean 从创建到销毁，所经历的各种方法调用。简单的来说，一个Bean的生命周期分为四个阶段实例化(Instantiation)属性设置(populate)初始化(Initialization)销毁(Destruction)。
Spring源码阅读：Spring事务执行流程
热门推荐
weixin_55229531的博客
05-23 5万+
Spring事务执行的流程如下图，我们将按照下面的执行顺序，介绍Spring的事务。
Spring - Bean的实例化流程及生命周期
weixin_51351637的博客
06-07 1604
加载xml配置文件，解析获取配置中的每个的信息，封装成一个个的BeanDefinition对象将BeanDefinition存储在一个名为beanDefinitionMap的Map中ApplicationContext底层遍历beanDefinitionMap，创建Bean实例对象创建好的Bean实例对象，被存储到一个名为singletonObjects的Map中。
spring bean的生命周期流程图
05-10
Spring Bean的生命周期可以分为以下过程：实例化、属性注入、BeanPostProcessor前置处理、初始化、BeanPostProcessor后置处理、销毁。 首先，在容器初始化时，Spring会读取配置文件或注解等方式，找到并实例化Bean。Bean的实例化可以通过构造器进行，也可以通过工厂方法进行。当容器调用构造器或者工厂方法时，Bean就会被实例化，但此时Bean还未被初始化。 其次，在实例化后，Spring会将Bean的属性注入。属性注入的方式有两种：setter注入和构造器注入。如果选择setter注入，则Spring会通过反射机制将属性值注入到Bean中。如果是构造器注入，则Spring容器会找到匹配的构造器，并将属性值注入到Bean中。 接下来，对Bean进行初始化。在初始化过程中，Spring框架会使用各种回调方法，以达到对Bean的加工和改造的目的。Bean的初始化可以通过实现接口来完成，也可以通过注解等方式完成。其中最常用的是InitializingBean接口和@PostConstruct注解。 初始化完成后，Spring会进行BeanPostProcessor前置处理。在该处理过程中，Spring会检查是否有实现BeanPostProcessor接口的类，如果有则会调用其中两个方法postProcessBeforeInitialization(…)和postProcessAfterInitialization(…)，分别在Bean的初始化前和初始化后进行处理。 最后，当Bean不再被使用时，Spring会调用销毁方法进行销毁操作。Bean的销毁可以通过实现DisposableBean接口完成，也可以通过注解等方式完成。其中最常用的是DisposableBean接口和@PreDestroy注解。 综上所述，Spring Bean的生命周期流程包括：实例化、属性注入、BeanPostProcessor前置处理、初始化、BeanPostProcessor后置处理、销毁。对于每个Bean，Spring会按照以上流程进行处理，确保Bean能够达到预期的效果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值