Spring Bean初始化过程

最新推荐文章于 2023-10-14 18:19:03 发布
最新推荐文章于 2023-10-14 18:19:03 发布
阅读量199 收藏 1
点赞数
分类专栏： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CSDN__luo/article/details/119720357
版权

Spring Bean初始化过程

1.执行实例化前置处理器InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation

AbstractAutowireCapableBeanFactory#resolveBeforeInstantiation方法

protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
		Object bean = null;
		if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
			// Make sure bean class is actually resolved at this point.
			if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
				Class<?> targetType = determineTargetType(beanName, mbd);
				if (targetType != null) {
                    //执行实例化前置处理器
					bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
					if (bean != null) {
						bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
					}
				}
			}
			mbd.beforeInstantiationResolved = (bean != null);
		}
		return bean;
}

2.实例化Bean

AbstractAutowireCapableBeanFactory#createBeanInstance

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
		// Make sure bean class is actually resolved at this point.
		Class<?> beanClass = resolveBeanClass(mbd, beanName);

		if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
					"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
		}

		Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
		if (instanceSupplier != null) {
			return obtainFromSupplier(instanceSupplier, beanName);
		}

		if (mbd.getFactoryMethodName() != null) {
			return instantiateUsingFactoryMethod(beanName, mbd, args);
		}

		// Shortcut when re-creating the same bean...
		boolean resolved = false;
		boolean autowireNecessary = false;
		if (args == null) {
			synchronized (mbd.constructorArgumentLock) {
				if (mbd.resolvedConstructorOrFactoryMethod != null) {
					resolved = true;
					autowireNecessary = mbd.constructorArgumentsResolved;
				}
			}
		}
		if (resolved) {
			if (autowireNecessary) {
				return autowireConstructor(beanName, mbd, null, null);
			}
			else {
				return instantiateBean(beanName, mbd);
			}
		}

		//使用自动注入的构造方法，构造方法的参数从Spring容器中获取
		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
		if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
			return autowireConstructor(beanName, mbd, ctors, args);
		}

		//使用首选的构造方法，
		ctors = mbd.getPreferredConstructors();
		if (ctors != null) {
			return autowireConstructor(beanName, mbd, ctors, null);
		}

		//使用无参构造方法
		return instantiateBean(beanName, mbd);
	}

3.执行实例化后置处理器InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation

AbstractAutowireCapableBeanFactory#populateBean

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
		//省略。。

        //执行执行实例化后置处理器
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
						continueWithPropertyPopulation = false;
						break;
					}
				}
			}
		}

		//省略。。。
	}

4.属性填充。

AbstractAutowireCapableBeanFactory#populateBean

PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
		//省略。。
		int resolvedAutowireMode = mbd.getResolvedAutowireMode();
		if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
			//byName方式注入
			if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
				autowireByName(beanName, mbd, bw, newPvs);
			}
			//byName方式注入
			if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
				autowireByType(beanName, mbd, bw, newPvs);
			}
			pvs = newPvs;
		}
       //省略。。
}

5.调用Aware结尾的接口

AbstractAutowireCapableBeanFactory#invokeAwareMethods

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

6.执行初始化前置处理器BeanPostProcessor#postProcessBeforeInitialization

AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInitialization

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;
}

7.执行@PostConstruct方法

执行自定义初始化方法其实是在初始化前置处理器中执行，只不过它的优先级被设置成了最低。

InitDestroyAnnotationBeanPostProcessor#invokeInitMethods

public void invokeInitMethods(Object target, String beanName) throws Throwable {
			Collection<LifecycleElement> checkedInitMethods = this.checkedInitMethods;
			Collection<LifecycleElement> initMethodsToIterate =
					(checkedInitMethods != null ? checkedInitMethods : this.initMethods);
			if (!initMethodsToIterate.isEmpty()) {
				for (LifecycleElement element : initMethodsToIterate) {
					if (logger.isTraceEnabled()) {
						logger.trace("Invoking init method on bean '" + beanName + "': " + element.getMethod());
					}
					element.invoke(target);
				}
			}
}

8.执行InitializingBean#afterPropertiesSet方法

AbstractAutowireCapableBeanFactory#invokeInitMethods

protected void invokeInitMethods(String beanName, final 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#afterPropertiesSet方法
						((InitializingBean) bean).afterPropertiesSet();
						return null;
					}, getAccessControlContext());
				}
				catch (PrivilegedActionException pae) {
					throw pae.getException();
				}
			}
			else {
				((InitializingBean) bean).afterPropertiesSet();
			}
		}
		//省略代码
	}

9.初始化，执行自定义初始化方法

@PostConstruct

@initMethod

protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
			throws Throwable {
		//省略代码
		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);
			}
		}
		//省略代码
	}

10.执行初始化后置处理器BeanPostProcessor#postProcessAfterInitialization

AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization\

@Override
	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;
}

11.执行Bean销毁方法DisposableBean#destroy

finalTime丶
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Bean创建初始化流程.docx
03-04
9. **Bean初始化**： 最后，`initializeBean(beanName, exposedObject, mbd)`对创建好的Bean进行初始化，包括调用初始化方法（如果有`@PostConstruct`注解的方法），以及执行AOP代理等操作。 整个流程中，Spring...
Spring Bean的初始化过程 initializeBean
颜值即正义
12-12 3706
System.out.println(" construct之后 进行... ");}@Override}@Override}@OverrideSystem.out.println(" 属性配置完成之后 进行了什么操作... ");}@Override}@Override}@Override}}上面是对象。
Spring Bean的初始化过程
ysmdelog的博客
04-15 1221
1.创建容器。 2.反射调用构造器创建实体(此时该实体还不是bean)。 3.Spring会识别被配置成bean的信息，扫描注解的包。把实体对应的类信息封闭成一个BeanDefinition对象，会把这些BeanDefinition对象放入到一个Map中。会根据配置判断是否是单例，如果是单例，会放到单例池。再进行验证，最后进入依赖注入。 4.set方法。 5.(如果实现了BeanNameAware接口)，就会调用setBeanName方法。 6.(如果实现了BeanFactoryAware接口)，就会调用s
Spring生命周期Bean初始化过程详解
热门推荐
JAVA技术爱好者
10-25 1万+
Spring声明周期Bean初始化过程详解Spring 容器初始化Spring Bean初始化BeanFactory和FactoryBean源码分析Bean的实例化preInstantiateSingletonsgetMergedLocalBeanDefinitiongetBean方法getObjectForBeanInstance例子分析@DependsOn Spring 容器初始化 在spring中，不管是以xml文件的方式配置的Bean还是以注解的方式进行配置，最后都会将单例Bean放入到Spring
SpringBean的初始化流程
最新发布
汤键的博客
10-14 842
SpringBean的初始化流程
Spring总结一：Bean的初始化过程
u014753478的博客
05-26 2317
前言： 这篇文章并不是真正的关于Spring中Bean的初始化过程的详细介绍，只是简单介绍，在介绍Spring设计模式的文章中因为需要，链接到这篇文章，对bean的初始化过程简单说明。 bean容器的启动： 读取bean的xml配置文件或者解析特定注解的类，将bean元素转换成BeanDefinition对象（BeanDefinition对象存储了bean对象的所有特征，是否单例，是否懒加载，factoryBeanName等） 通过DeanDefinitionRegistry将这些bean注册到be
详解Spring 中如何控制2个bean中的初始化顺序
08-29
Spring 中控制 2 个 bean 的初始化顺序 在 Spring 框架中，控制多个 bean 的初始化顺序是一个常见的问题。本篇文章将详细介绍如何控制 2 个 bean 的初始化顺序，提供了多种实现方式，并分析了每种方式的优缺。 ...
浅谈spring容器中bean的初始化
09-02
本文将深入探讨Spring容器中Bean的初始化过程。 首先，Spring容器根据XML配置文件（如`applicationContext.xml`）来解析Bean的定义。在示例中，我们定义了一个名为`people`的Bean，它对应于`People`类。默认情况下...
Spring Bean初始化及销毁多种实现方式
08-25
Spring 框架提供了相关功能，围绕 Spring Bean 生命周期，可以在 Bean 创建过程初始化资源，以及销毁 Bean 过程释放资源。 二、姿势剖析 2.1、init-method/destroy-method init-method/destroy-method 是一种常用...
Spring Bean的初始化和销毁实例详解
08-25
Spring Bean的初始化和销毁实例详解 Spring Bean的初始化和销毁是Spring框架中一个非常重要的概念，它们都是Bean生命周期中不可或缺的一部分。在Spring框架中，我们可以使用多种方式来控制Bean的初始化和销毁，以下...
Spring bean初始化过程
zhengkun51的博客
10-26 2468
1：实例化一个ApplicationContext的对象； 2：调用bean工厂后置处理器完成扫描； 3：循环解析扫描出来的类信息； 4：实例化一个BeanDefinition对象来存储解析出来的信息； 5：把实例化好的beanDefinition对象put到beanDefinitionMap当中缓存起来，以便后面实例化bean； 6：再次调用bean工厂后置处理器； 7：当然spring还会干很多事情，比如国际化，比如注册BeanPostProcessor等等，如果我们只关心如何实例化一个bean的话那么
Bean的初始化过程
weixin_44778073的博客
02-17 3970
1.生成BeanDefinition 扫描某个包路径，并得到BeanDefinition的Set集合 2. 合并BeanDefinition Spring中支持父子BeanDefinition。根据child来生成Bean对象之前，需要进行BeanDefinition的合并，得到完整的child的 BeanDefinition。 3.加载类 BeanDefinition合并之后，就可以去创建Bean对象了，而创建Bean就必须实例化对象，而实例化就 必须先加载当前BeanDefinition所对应.
【保姆级·创建对象】如何利用resolveBeforeInstantiation()在预处理阶段返回一个Bean的实例对象
aqin1012的博客
11-15 1292
本文我们来盘盘prepareMethodOverrides()方法后面的resolveBeaforeInstantiation()的函数，看过之前文章介绍的同学应该有印象，它是应用实例化前的前置处理器，是在正式实例化前的一种预处理方式（即在预处理阶段给BeanPostProcessors们一个机会来返回代理来代替真正的实例）所以如果我们想要进入if的逻辑中，就需要同时满足这两个条件，直接用Spring源码debug是不会进入的，所以我们需要创造条件，让程序进入if的逻辑中。
【spring】Bean的初始化过程
morris
03-10 3232
AbstractAutowireCapableBeanFactory#applyMergedBeanDefinitionPostProcessors 使用BeanPostProcessor收集带有注解的方法和属性，方便下面初始化时调用。 org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyMergedBeanDefinitionPostProcessors protected void appl.
最全Spring初始化Bean的方法
just_for_that_moment的博客
11-14 3864
最全Spring初始化Bean的方法
spring bean的初始化流程（生命周期）总结
范文聪
05-24 7411
bean的初始化流程大概如下： 以下图片来自：https://www.cnblogs.com/javazhiyin/p/10905294.html 上面的流程我补充一点哈，在调用BeanPostProcessor接口的postProcessBeforeInitialization方法后，下面会继续调用bean被@PostConstruct注解的方法，然后才会调用afterPropertiesSet()方法（前提是你的bean实现了InitializingBean接口）。 下面是我自己的验证的结果：
阿里三面：说说你对Spring ioc启动原理的理解！
SQY0809的博客
03-03 266
1. IOC概述 1.1 是什么？ 两个概念：控制反转，依赖注入 **来看一下传统的干活方式：**在对象单一职责原则的基础上，一个对象很少有不依赖其他对象而完成自己的工作，所以这个时候就会出现对象之间的依赖。而体现在我们的开发中，就是需要什么对象的时候，就创建什么对象，此时对象创建的控制权在我们自己手里。当对象创建的太多的时候，就会出现一个对象更改，就得更改所有依赖它的对象，耦合性大。自主性体现的同时也出现了对象耦合严重的情况。 这个时候，我们就会思考，能不能我们在用的时候直接拿到这个对象去用，而将创建对
还记不住Spring Bean的生命周期？看这篇你就知道方法了！
阳阳的博客
10-16 4148
一、前言 上次我们在手把手教你解决循环依赖，一步一步地来窥探出三级缓存的奥秘中分析了Spring解决循环依赖的方式，在第6节中的doCreateBean（AbstractAutowireCapableBeanFactory类中）其实已经隐约看到了Bean的生命周期的几个阶段。 protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] ar
Spring中Bean的初始化流程
lyflyyvip的博客
03-21 3962
SpringBean的初始化流程ApplicationContext和BeanFactory的区别 Spring Bean 的初始化主要实现在bean.factory包下的AbstractAutowireCapableBeanFactory类中 具体实现流程为这个类里的三个初始化流程，分别为 实例化createBeanInstance【里面包含了推断构造方法，简单来说就是对bean进行实例化】 属性赋值populateBean 【填充属性，处理@AutoWried，调用bean的实例化后的方法】 B
springbean 初始化 详细
05-11
在 Spring 中，我们可以通过定义 Bean 来管理我们的 Java 对象。Bean 是由 Spring 容器来创建、组装和管理的。 在容器启动时，Spring 会读取配置文件（如 XML、JavaConfig 等）中的 Bean 定义，并通过反射机制创建 Bean 对象，然后将这些 Bean 对象放入容器中进行管理。 在创建 Bean 对象时，Spring 提供了多种初始化方式： 1. 实现 InitializingBean 接口，重写 afterPropertiesSet() 方法，该方法会在 Bean 实例化后、属性注入完成后被调用。 2. 在配置文件中使用 init-method 属性，该属性指定一个自定义的初始化方法，Spring 容器会在 Bean 实例化后、属性注入完成后调用该方法。 3. 使用 @PostConstruct 注解标注一个自定义的初始化方法，该方法会在 Bean 实例化后、属性注入完成后调用。 4. 在配置文件中使用工厂方法创建 Bean，该方法返回的对象就是要创建的 Bean，同时可以指定一个自定义的初始化方法，Spring 容器会在 Bean 实例化后、属性注入完成后调用该方法。 以上方法都可以用来实现 Bean 的初始化操作。需要注意的是，在使用以上方法时，Bean 的属性已经被注入，所以可以在初始化方法中使用 Bean 的属性。 同时需要注意的是，如果 Bean 实现了 DisposableBean 接口或者配置了 destroy-method 属性或者使用 @PreDestroy 注解标注的销毁方法，Spring 容器会在容器关闭时调用销毁方法，进行资源的释放等操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值