Bean的生命周期

最新推荐文章于 2022-09-07 15:43:55 发布
最新推荐文章于 2022-09-07 15:43:55 发布
阅读量103 收藏
点赞数 1
分类专栏： Spring 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45142871/article/details/121082606
版权

Bean的生命周期可分为四大步骤

  • Bean实例化
  • Bean属性赋值
  • Bean初始化
  • 销毁

在传统的Java应用中，bean的生命周期很简单，使用Java关键字 new 进行Bean 的实例化，然后该Bean 就能够使用了。一旦bean不再被使用，则由Java自动进行垃圾回收。Spring管理Bean的生命周期就复杂多了，Bean 的生命周期是还是Spring面试的一道热点问题。
下面是根据源码画的一个大致的Bean生命周期流程图，Bean生命周期主要逻辑在AbstractAutowireCapableBeanFactory类的doCreateBean()方法中，Bean实例化，属性赋值，初始化三个顺序执行
在这里插入图片描述

Bean实例化的时候会根据条件，选择合适的实例化方式进行实例化，，如工厂方法，带参构造实例化，无参构造实例化，

    // 部分源码
	protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
			throws BeanCreationException {

		if (instanceWrapper == null) {
			//创建bean实例化 使用合适的实例化策略来创建新的实例：工厂方法、构造函数自动注入、简单初始化。。
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
     }

进入创建Bean实例的方法，调用需要的实例化策略

    // createBeanInstance中的部分源码
	protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
		//从bean定义中解析出当前bean的class对象
		Class<?> beanClass = resolveBeanClass(mbd, beanName);

		/**
		 * 该方法是spring5.0 新增加的  如果存在 Supplier 回调，则使用给定的回调方法初始化策略
		 */
		Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
		if (instanceSupplier != null) {
			return obtainFromSupplier(instanceSupplier, beanName);
		}

		/**
		 * 工厂方法,我们通过配置类来进行配置的话 采用的就是工厂方法,方法名称就是tulingDao就是我们工厂方法的名称
		 * @Bean会在这创建实例
		 */
		if (mbd.getFactoryMethodName() != null) {
			return instantiateUsingFactoryMethod(beanName, mbd, args);
		}
		//若被解析过
		if (resolved) {
			if (autowireNecessary) {
				//通过有参的构造函数进行反射调用
				return autowireConstructor(beanName, mbd, null, null);
			}
			else {
				//调用无参数的构造函数进行创建对象
				return instantiateBean(beanName, mbd);
			}
		}

		/**
		 * 通过bean的后置处理器进行选举出合适的构造函数对象
		 */
		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
		/**
		 *  如果自定义了BeanPostProcessor返回了构造器   或者
		 *  使用构造器自动装配模式                      或者
		 *  设置了BeanDefinition构造器参数              或者
		 *  有参数:即getBean(String name, Object... args) 中的args
		 *  则使用自定义的构造器初始化
		 */
		if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
			//通过构造函数创建对象
			return autowireConstructor(beanName, mbd, ctors, args);
		}

		//使用无参数的构造函数调用创建对象
		return instantiateBean(beanName, mbd);
	}

Bean实例化后进行属性赋值，调用populateBean(beanName, mbd, instanceWrapper);方法进行属性赋值，根据不同的方式进行属性注入

// 部分源码
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
		/**
		 * 判断我们的bean的属性注入模型
		 * AUTOWIRE_BY_NAME 根据名称注入
		 * AUTOWIRE_BY_TYPE 根据类型注入
		 */

		if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
			//把PropertyValues封装成为MutablePropertyValues
			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
			//根据bean的属性名称注入
			if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME) {
				autowireByName(beanName, mbd, bw, newPvs);
			}
			//根据bean的类型进行注入
			if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
				autowireByType(beanName, mbd, bw, newPvs);
			}
			//把处理过的 属性覆盖原来的
			pvs = newPvs;
		}
}

属性注入后调用initializeBean(beanName, exposedObject, mbd);方法进行Bean的初始化。

	protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				invokeAwareMethods(beanName, bean);
				return null;
			}, getAccessControlContext());
		}
		else {
			//若我们的bean实现了XXXAware接口进行方法的回调
			invokeAwareMethods(beanName, bean);
		}

		Object wrappedBean = bean;
		if (mbd == null || !mbd.isSynthetic()) {
			//调用我们的bean的后置处理器的postProcessorsBeforeInitialization方法  
			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()) {
			//调用我们bean的后置处理器的PostProcessorsAfterInitialization方法
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}

		return wrappedBean;
	}

看源码可以发现，在调用真正的初始化方法之前会先调用invokeAwareMethods(beanName, bean);来检测是否实现了XXXAware接口
步骤：调用BeanNameAware接口的setBeanName方法》调用BeanClassLoaderAware的setBeanClassLoader方法》调用BeanFactoryAware的setBeanFactory方法，源码如下

	private void invokeAwareMethods(final String beanName, final Object bean) {
		if (bean instanceof Aware) {
			//我们的bean实现了BeanNameAware
			if (bean instanceof BeanNameAware) {
				((BeanNameAware) bean).setBeanName(beanName);
			}
			//实现了BeanClassLoaderAware接口
			if (bean instanceof BeanClassLoaderAware) {
				ClassLoader bcl = getBeanClassLoader();
				if (bcl != null) {
					((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
				}
			}
			//实现了BeanFactoryAware
			if (bean instanceof BeanFactoryAware) {
				((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
			}
		}
	}

调用自己的初始化方法

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

		//判断我们的容器中是否实现了InitializingBean接口
		boolean isInitializingBean = (bean instanceof InitializingBean);
		if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
			if (logger.isDebugEnabled()) {
				logger.debug("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的afterPropertiesSet()方法
				((InitializingBean) bean).afterPropertiesSet();
			}
		}

		// 调用initMethod
		if (mbd != null && bean.getClass() != NullBean.class) {
			//我们beanclass中看是否有自己定义的init方法
			String initMethodName = mbd.getInitMethodName();
			//判断自定义的init方法名称不叫afterPropertiesSet
			if (StringUtils.hasLength(initMethodName) &&
					!(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
					!mbd.isExternallyManagedInitMethod(initMethodName)) {
				//调用我们自己的初始化方法
				invokeCustomInitMethod(beanName, bean, mbd);
			}
		}
	}

Bean实例化之后会去调用调我们bean的后置处理器的PostProcessorsAfterInitialization方法，在执行这个方法的时候会为需要代理的类创建代理对象，也就是AOP代理

		if (mbd == null || !mbd.isSynthetic()) {
			//调用我们bean的后置处理器的PostProcessorsAfterInitialization方法
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}

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

		Object result = existingBean;
		//获取我们容器中的所有的bean的后置处理器
		for (BeanPostProcessor processor : getBeanPostProcessors()) {
			/**
			 *
			 * 在这里实现的是BeanPostProcessor接口的postProcessAfterInitialization来生成我们的代理对象
			 */
			Object current = processor.postProcessAfterInitialization(result, beanName);
			//若只有有一个返回null 那么直接返回原始的
			if (current == null) {
				return result;
			}
			result = current;
		}
		return result;
	}

Bean初始化完成之后就可以使用啦。

总结

  1. Spring启动的时候查找需要被Spring管理的Bean进行实例化
  2. 实例化后对Bean进行属性注入
  3. 如果Bean实现了BeanNameAware接口，Spring将Bean的Id传递给setBeanName()方法
  4. 如果Bean实现了BeanClassLoaderAware接口的话，Spring将调用setBeanClassLoader()方法
  5. 如果Bean实现了BeanFactoryAware接口的话，Spring将调用setBeanFactory()方法，将BeanFactory容器实例传入
  6. 如果Bean实现了BeanPostProcessor接口，Spring就将调用他们的postProcessBeforeInitialization()方法
  7. 如果Bean 实现了InitializingBean接口，Spring将调用他们的afterPropertiesSet()方法
  8. 如果Bean 实现了BeanPostProcessor接口，Spring就将调用他们的postProcessAfterInitialization()方法
  9. 如果bean实现了DisposableBean接口，Spring将调用它的destory()接口方法，同样，如果bean使用了destory-method 声明销毁方法，该方法也会被调用
weixin_45142871
关注
专栏目录
bean的生命周期
weixin_45723046的博客
05-02 2万+
六、bean的生命周期 https://liayun.blog.csdn.net/article/details/110670961 Bean 的初始化和销毁； 1、@Bean注解中使用init-method属性和destroy-method属性来指定初始化方法和销毁方法。 初始化和销毁方法的时机： 你有没有想过这样一个问题，初始化方法和销毁方法是在什么时候被调用的啊？ bean对象的初始化方法调用的时机：对象创建完成，如果对象中存在一些属性，并且这些属性也都赋好值之后，那么就会调用bean的初始化方
Spring源码第三讲 Bean生命周期
最新发布
m0_56369671的博客
08-16 512
一个受 Spring 管理的 bean，生命周期主要阶段有创建：根据 bean 的构造方法或者工厂方法来创建 bean 实例对象依赖注入：根据 @Autowired，@Value 或其它一些手段，为 bean 的成员变量填充值、建立关系初始化：回调各种 Aware 接口，调用对象的各种初始化方法销毁：在容器关闭时，会销毁所有单例对象（即调用它们的销毁方法）prototype 对象也能够销毁，不过需要容器这边主动调用。
谈谈我对Spring Bean 生命周期的理解
08-27
本文将详细介绍 Spring Bean 生命周期的概念、生命周期图、生命周期阶段、生命周期管理方式等相关知识点。 一、 Spring Bean 生命周期概述 Spring Bean 生命周期是指 Spring 容器中 Bean 的创建、初始化、销毁等...
Spring学习笔记之bean生命周期
08-28
《Spring学习笔记之bean生命周期》 在Spring框架中，Bean是核心组件，它们构成了应用程序的主要结构。理解Spring Bean的生命周期对于有效地管理和优化Spring应用程序至关重要。本文将深入探讨Spring Bean的生命周期...
Bean 生命周期详解
weixin_45985053的博客
09-07 4292
IoC，控制反转，想必大家都知道，所谓的控制反转，就是把 new 对象的权利交给容器，所有的对象都被容器控制，这就叫所谓的控制反转。IoC 很好地体现了面向对象设计法则之一 —— 好莱坞法则：“别找我们，我们找你”，即由 IoC 容器帮对象找相应的依赖对象并注入，而不是由对象主动去找。理解好 IoC 的关键是要明确 “谁控制谁，控制什么，为何是反转（有反转就应该有正转了），哪些方面反转了”。谁控制谁，控制什么？
Spring Bean生命周期详解
热门推荐
weixin_45723046的博客
04-10 1万+
站在设计者的角度考虑设计IOC容器 加载Bean的配置（比如xml配置） 比如不同类型资源的加载，解析成生成统一Bean的定义 根据Bean的定义加载生成Bean的实例，并放置在Bean容器中 比如Bean的依赖注入，Bean的嵌套，Bean存放（缓存）等 除了基础Bean外，还有常规针对企业级业务的特别Bean 比如国际化Message，事件Event等生成特殊的类结构去支撑 对容器中的Bean提供统一的管理和调用 比如用工厂模式管理，提供方法根据名字/类的类型等从容器中获取Bea
spring基础知识 （11）：bean的生命周期
YellowStar的博客
05-11 5586
Spring IOC 容器可以管理 Bean 的生命周期, Spring 允许在 Bean 生命周期的特定点执行定制的任务. Spring IOC 容器对 Bean 的生命周期进行管理的过程: 通过构造器或工厂方法创建 Bean 实例 为 Bean 的属性设置值和对其他 Bean 的引用 调用 Bean 的初始化方法 Bean 可以使用了 当容器关闭时, ...
Spring Bean生命周期详解与示例
最后，BeanPostProcessor是一种用于Bean生命周期钩子的接口，它提供了一系列预初始化和后初始化的方法，如preInitialization()和postInitialization()。开发者可以利用这些钩子在Bean实例化前后执行自定义逻辑，例如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值