Spring Bean的生命周期

原创 已于 2022-12-22 20:10:29 修改 · 置顶 · 1.2k 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#spring #java #后端
于 2022-10-25 17:41:24 首次发布
本文详细阐述了Spring中Bean的生命周期，从BeanDefinition的生成、Bean的创建过程（包括生成、合并、加载类、实例化前、实例化、BeanDefinition后置处理等步骤）到Bean的销毁过程，揭示了Spring如何管理Bean的整个生命周期。内容涵盖实例化前后的扩展点、自动注入、Aware接口回调以及初始化前后的方法执行。

文章目录


请添加图片描述

生命周期图

Bean生命周期含义：在Spring中，一个Bean是如何生成的，如何销毁的
Bean 生命周期

Bean扫描

在这里插入图片描述在这里插入图片描述

Bean 的创建过程

1. 生成BeanDefinition

  1. 通过ResourcePatternResolver获取指定路径下所有的.class文件(封装为Resource对象)
  2. 遍历所有Resource对象
  3. 利用MetadataReaderFactory(具体实现类:CachingMetadataReaderFactory)解析Resource对象获得MetadataReader(具体实现类:SimpleMetadataReader)
  4. 通过MetadataReader来进行excludeFilters和includeFilters过滤，并通过条件注解@Condition进行筛选(如果有@Condition注解则调用match()方法进行匹配筛选)
  5. 基于metadataReader生成对应的ScannedGenericBeanDefination
  6. 再次基于metadataReader进行筛选(判断是否为非顶级类、非静态内部类、接口、抽象类等)
  7. 通过筛选的类，将其ScannedGenericBeanDefinition加入结果集(扫描到一个Bean)

除了扫描生成BeanDefinition对象之外，还可以通过直接定义BeanDefinition，或解析spring.xml配置文件中的<bean/>，或用@Bean注解得到BeanDefinition对象。

MetadataReader 作用

  1. 类名
  2. 父类名
  3. 所有实现的接口名
  4. 所有内部类名
  5. 是否为抽象类
  6. 是否为接口
  7. 是否是一个注解
  8. 获取已有的注解的所有方法集合
  9. 获取所有注解信息
  10. 获取所有注解类型集合

CachingMetadataReaderFactory解析.class文件得到的MetadataReader对象是通过ASM技术获取的，并未去加载这个类！！！

得到的SccannedGenericBeanDefinition对象中，beanClass属性存储的只是当前类的名字，并非class对象！ (beanClass属性的类型为Object，既可以存储类的名字(String)，也可以存储class对象(Class<?>))

2.合并BeanDefinition

在 Spring 中，支持父子 BeanDefinition！
可以通过父子BeanDefinition继承一些属性。

<bean id="parent" class="Parent" scope="prototype"/>
<bean id="child" class="Child" parent="parent"/>

在该例子中，由于 child 指定父亲 BeanDefinition 为 parent ，因此继承 parent 中的 scope 属性的值 prototype。

而在根据 child 来生成 Bean 对象之前，需要进行 BeanDefinition 的合并，才能得到完整的 child 的 BeanDefinition。

-> MergedBeanDefinition

3.加载类

合并 BeanDefinition 后便可以创建 Bean 对象，而创建 Bean 对象就必须要 实例化 对象， 因此需要先加载当前 BeanDefinition 对应的 class 。

AbstractAutowireCapableBeanFactory 的 createBean() 方法中：

Class<?> resolvedClass = resolveBeanClass(mdb, beanName);

resolveBeanClass() 方法便是去加载类的。

if (mbd.hasBeanClass()) {
	return mbd.getBeanClass();
}
if (System.getSecurityManager() != null) {
	return AccessController.doPrivileged((PrivilegedExceptionAction<Class<?>>) () ‐>
	doResolveBeanClass(mbd, typesToMatch), getAccessControlContext());
} else {
	return doResolveBeanClass(mbd, typesToMatch);
}

hasBeanClass() :
判读 beanClass 属性是否为 Class 实例（是否被加载过）

public boolean hasBeanClass() {
	return (this.beanClass instance Class);
}

会使用 BeanFactory 所设置的类加载器来加载类，如果没有设置类加载器，则默认使用 ClassUtils.getDefaultClassLoader() 返回的类加载器来加载。

ClassUtils.getDefaultClassLoader()

  1. 优先返回当前线程中的 ClassLoader
  2. 线程中类加载器为 null 时，返回 ClassUtils 类的类加载器
  3. 如果 ClassUtils 类的类加载器为 null ，则表示由 Bootsrap 类加载器加载的 ClassUtils 类，那么直接返回系统类加载器

4.实例化前

在类被加载后，实例化前，Spring 提供了一个扩展点，允许用户来控制是否在某个或某些 Bean 实例化前做一些启动动作。

扩展点：InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()

实现 InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation()方法

/**
	当每有一个 Bean 对象实例化前，会打印 “实例化前”
*/
@Component
public class MyBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
	@Override
	public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName)
	throws BeansException {
		System.out.println("实例化前");
		return null;
	}
}

注意：
postProcessBeforeInstantiation() 是有返回值的，如果返回非空对象，则会在实例化前直接返回我们返回的对象。如果这样做，则表示不需要再由 Spring 来实例化，并且后续的 Spring 依赖注入也不会再进行！直接执行初始化后这一阶段。


@Nullable
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.
		// synthetic表示合成，如果某些Bean式合成的，那么则不会经过BeanPostProcessor的处理
		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;
}

5.实例化

5.1 Supplier 创建对象

首先检测 BeanDefinition 中是否设置了 Supplier ，如果存在则调用 Supplier 的 get() 方法获取对象。

// BeanDefinition中添加了Supplier，则调用Supplier来得到对象
Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
	return obtainFromSupplier(instanceSupplier, beanName);
}

5.2 工厂方法创建对象

如果没有设置 Supplier ，则检查 BeanDefinition 中是否设置了 factoryMethod，也就是工厂方法。（两种设置 factoryMethod的方式）

// @Bean对应的BeanDefinition
if (mbd.getFactoryMethodName() != null) {
	return instantiateUsingFactoryMethod(beanName, mbd, args);
}

方式一： 指定 factoryMethod 为当前类的方法

<bean id="userService" class="UserService" factory‐
method="createUserService" />

对应的 UserService 类：

public class UserService {
	public static UserService createUserService() {
		System.out.println("执行createUserService()");
		UserService userService = new UserService();
		return userService;
	}
}

方式二： 指定 factoryMedthod 为其他类的方法

<bean id="commonService" class="CommonService"/>
<bean id="userService" factory‐bean="commonService" factory‐method="createUserService"
/>

对应的 CommonService 类：

public class CommonService {
	public UserService createUserService() {
		return new UserService();
	}
}

若设置了 工厂方法，则 Spring 会调用工厂方法获取对象。

注意：
如果通过 @Bean 注解定义的 BeanDefinition，也是存在 factoryMethod 和 factoryBean 的！与 方式二 类似，@Bean 所注解的方法就是 factoryMetod， 所在的类的对象就是 factoryBean。 如果 @Bean 所注解的方法是 static 的，则对应 方式一。

5.3 推断构造方法

根据传入的参数推断使用的构造方法，用它来实例化。

在推断构造方法逻辑中，除去选择构造方法与查找入参对象之外，还会判断是否在对应的类中是否存在 @Lookup 注解的方法。 如果存在，则把该方法封装为 LookupOverride 对象并添加到 BeanDefinition 中。

在实例化时，如果当前 BeanDefinition 中存在 LookupOverride 对象（该类存在 @Lookup注解了的方法）则会生成一个 代理对象；否则直接反射调用构造方法获取一个实例对象。

@Looup 注解就是 方法注入

@Component
public class UserService {
	private OrderService orderService;
	public void test() {
		OrderService orderService = createOrderService();
		System.out.println(orderService);
	}
	@Lookup("orderService")
	public OrderService createOrderService() {
		return null;
	}
}

6. BeanDefinition 的后置处理

实例化 Bean 之后，接下来需要给对象属性赋值。在真正给属性赋值之前， Spring 提供了一个扩展点
MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition()
可以对当前的 BeanDefinition 加工！

在 Spring 源码中，AutowiredAnnotationBeanPostProcessor 就是一个 JMergedBeanDefinitionPostProcessor，它的 postProcessMergedBeanDefinition() 会去查找注入点，并缓存在 AutowiredAnnotationBeanPostProcessor 对象的一个 Map 中(injectionMetadataCache)。

7.实例化后

在处理完 BeanDefinition 后，Spring还提供了一个扩展点：
InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()
返回值类型为 boolean，如果返回 false 则会结束后续的postProcessAfterInstantitaion()和postProcessPropertiesValues()的执行！！！


boolean continueWithPropertyPopulation = true;

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

if (!continueWithPropertyPopulation) {
	return;
}

但是该扩展点在 Spring 中基本没有被使用到。

8.自动注入

9.处理属性

处理 @Autowired 、@Resource 、@Value 等注解，都是通过实现 InstantiationAwareBeanPostProcessor.postProcessProperties() 扩展点来实现的。

这个方法通常是给目标 bean 设值，这个过程发生只有在postProcessAfterInstantiation() 方法的结果返回 true 才会被执行!

@Component
public class MyInstantiationAwareBeanPostProcessor implements
InstantiationAwareBeanPostProcessor {
	@Override
	public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
		if ("userService".equals(beanName)) {
			for (Field field : bean.getClass().getFields()) {
				if (field.isAnnotationPresent(ZhouyuInject.class)) {
					field.setAccessible(true);
					try {
						field.set(bean, "123");
					} catch (IllegalAccessException e) {
						e.printStackTrace();
					}
				}
			}
		}
		return pvs;
	}
}

在 AbstractAutowireCapableBeanFactory 类的方法 populateBean 中会执行到该扩展点:


boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);

if (hasInstAwareBpps || needsDepCheck) {
	PropertyDescriptor[] filteredPds = 
			filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
	if (hasInstAwareBpps) {
		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			if (bp instanceof InstantiationAwareBeanPostProcessor) {
				InstantiationAwareBeanPostProcessor ibp = 
									(InstantiationAwareBeanPostProcessor) bp;
				pvs = ibp.postProcessPropertyValues(pvs, filteredPds, 
								bw.getWrappedInstance(), beanName);
				if (pvs == null) {
					return;
				}
			}
		}
	}
	if (needsDepCheck) {
		checkDependencies(beanName, mbd, filteredPds, pvs);
	}
}

applyPropertyValues(beanName, mbd, bw, pvs);

可以看到，如果这个方法返回为空，也不会对目标bean设值

10. 执行部分 Aware

在完成属性赋值后，Spring 还会调用一些列实现了 Aware 接口的回调方法。

  1. BeanNameAware: 将 beanName 注入到 bean 对象中
  2. BeanClassLoaderAware: 将 classLoader 注入到 bean 对象中
  3. BeanFactoryAware
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);
		}
	}
}

11. 初始化前

在初始化前 Spring 提供了一个扩展点：
BeanPostProcessor.postProcessBeforeInitialization()

@Nullable
default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
	return bean;
}  

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

返回值：可以是原始的Bean实例，也可以是包装的Bean实例；如果为空，则不会调用后续的 BeanPostProcessors 的 postProcessBeforeInitialization() 方法！

@PostConstruct

InitDestroyAnnotationBeanPostProcessor 会在初始前执行有 @PostConstruct 注解的方法。

ApplicationContextAwareProcessor

ApplicationContextAwareProcessor 会在初始化前进行其他 Aware 的回调。

  1. EnvironmentAware：回传环境变量
  2. EmbeddedValueResolverAware：回传占位符解析器
  3. ResourceLoaderAware：回传资源加载器
  4. ApplicationEventPublisherAware：回传事件发布器
  5. MessageSourceAware：回传国际化资源
  6. ApplicationStartupAware：回传应用其他监听对象，可忽略
  7. ApplicationContextAware：回传Spring容器ApplicationContext

12. 初始化

InitializingBean

如果 Bean 对象实现了 InitializingBean 接口，则调用其 afterPropertiesSet() 方法

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

BeanDefinition 中指定的初始化方法

执行 BeanDefinition 中指定的初始化方法

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

13. 初始化后

这是 Bean 创建生命周期中的最后一个步骤，也是 Spring 提供的一个扩展点
BeanPostProcessor.postProcessAfterInitialization()

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

若返回 null ，则会提前结束，取消执行后续的 BeanPostProcessor 的 postProcessAfterInitialization() 方法！

Bean 的销毁过程

Bean 销毁是发生在 Spring 容器关闭过程中的。context.close()

判断是否属于 DisposableBean

在 Bean 创建过程中，初始化后，会去判断当前创建的 Bean 是否属于 DisposableBean

  1. 是否实现 DisposableBean 接口
  2. 是否实现 AutoCloseable 接口
  3. BeanDefinition 中是否指定了 destroyMethod
  4. DestructionAwareBeanPostProcessor.requiresDestruction(bean) 中判断
    • ApplicationListenerDetector:是否实现 ApplicationListener
    • InitDestroyAnnotationBeanPostProcessor: 检测是否有 @PreDestroy 注解的方法
  5. 将符合以上任意一个条件的 Bean 适配成 DisposableBeanAdapter 对象，并存储在 disposableBeans 中(一个 LinkedHashMap)

销毁过程

  1. 首先发布 ContextClosedEvent 事件
  2. 调用 lifecycleProcessor 的 onClose() 方法
  3. 销毁单例 Bean
    • 遍历 disposableBeans
      • 把每个 disposableBean 从单例池中移除
      • 调用 disposableBean 的 destroy()
      • 如果该 disposableBean 被其他 Bean 依赖，则同时销毁其他 Bean
      • 如果该 disposableBean 包含 inner beans ，则将这些 Bean 从单例池中移除
    • 清空 manualSingletonNames(存储着 用户手动注册 的单例 Bean 的 beanName 的 Set)
    • 清空 allBeanNamesByType(Map<Class<?>,String[]>)
    • 清空 singletonBeanNamesByType(只存储了单例Bean)
【保姆级·创建对象】如何利用resolveBeforeInstantiation()在预处理阶段返回一个Bean的实例对象
aqin1012的博客
11-15 1714
本文我们来盘盘prepareMethodOverrides()方法后面的resolveBeaforeInstantiation()的函数，看过之前文章介绍的同学应该有印象，它是应用实例化前的前置处理器，是在正式实例化前的一种预处理方式（即在预处理阶段给BeanPostProcessors们一个机会来返回代理来代替真正的实例）所以如果我们想要进入if的逻辑中，就需要同时满足这两个条件，直接用Spring源码debug是不会进入的，所以我们需要创造条件，让程序进入if的逻辑中。
Bean 的初始化的一个过程？
学无止境
10-22 462
总的来说，Spring 容器的初始化过程是将配置信息转化为实际的 Bean 对象并准备好供应用程序使用的过程。Spring 的不同模块，如 Spring Core Container、Spring Boot 等，也可以提供不同的初始化机制和特性。：Spring 容器将对加载的配置文件进行解析，这意味着它将理解文件中定义的各种元素，如 beans、dependencies、属性等。在 Spring 框架中，将从文件中解析配置信息并生成对象的过程是 Spring 容器的初始化过程。这可以是 Bean 实现的。
SpringBean的初始化流程
汤键的博客
10-14 1902
SpringBean的初始化流程
Bean的初始化过程
weixin_44778073的博客
02-17 4151
1.生成BeanDefinition 扫描某个包路径，并得到BeanDefinition的Set集合 2. 合并BeanDefinition Spring中支持父子BeanDefinition。根据child来生成Bean对象之前，需要进行BeanDefinition的合并，得到完整的child的 BeanDefinition。 3.加载类 BeanDefinition合并之后，就可以去创建Bean对象了，而创建Bean就必须实例化对象，而实例化就 必须先加载当前BeanDefinition所对应.
Bean初始化
sxudong2010的博客
06-05 2348
原文转载：https://www.cnblogs.com/twelve-eleven/p/8080038.html 一、简单介绍 1、init-method方法，初始化bean的时候执行，可以针对某个具体的bean进行配置。init-method需要在applicationContext.xml配置文档中bean的定义里头写明。 例如： <bean id="TestBean" class="...
【Spring】Spring的Bean的生命周期
qq_46096136的博客
01-28 1万+
在Java中，Bean是一个重要的概念，它代表了应用程序中的一个对象。在开发中，我们经常使用Bean来管理对象的生命周期。本文将介绍Bean的生命周期，并详细讲解如何在Spring框架中管理Bean的生命周期。Spring其实就是一个管理Bean对象的工厂。它负责对象的创建，对象的销毁等。所谓的生命周期就是：对象从创建开始到最终销毁的整个过程。Spring为每个Bean定义了若干个回调方法，使得开发人员可以在某个特定的时间点对Bean进行特定的操作。
Spring 中Bean 的生命周期
程序员cxuan的个人主页
05-11 7533
Spring 中Bean 的生命周期 文章目录Spring 中Bean 的生命周期前言一、Bean 的完整生命周期二、Bean 的生命周期验证 前言 ​ 这其实是一道面试题，是我在面试百度的时候被问到的，当时没有答出来(因为自己真的很菜)，后来在网上寻找答案，看到也是一头雾水，直到看到了《Spring in action》这本书，书上有对Bean声明周期的大致解释，但是没有代码分析，所以就自己上...
Spring Bean 的生命周期
实践是最好的方法
08-05 3万+
目录 一、BeanFactory实例化Bean相关接口 二、BeanFactory的bean生命周期相关代码 三、关于BeanFactory的Bean生命周期接口的总结 四、ApplicationContext的Bean生命周期 五、ApplicationContext的Bean生命周期代码演示 六、总结 Spring的生命周期是指实例化Bean时所经历的一系列阶段，即通过getBe...
Spring bean生命周期详解
weixin_44145478的博客
10-27 1万+
Spring Bean的完整生命周期从创建Spring容器开始，直到最终Spring容器销毁Bean，这其中包含了一系列关键点。 Spring bean生命周期 四个阶段 Bean的实例化阶段 Bean的设置属性阶段 Bean的 初始化阶段 Bean的销毁阶段 Spring bean生命周期13个环节 阶段1：Bean元信息配置阶段 阶段2：Bean元信息解析阶段 阶段3：将Bean注册到容器中 阶段4：BeanDefinition合并阶段 阶段5：Bean Class加载阶段 阶段6：Bean实例化阶
Spring中bean的生命周期
热门推荐
kykangyuky的博客
02-24 3万+
Spring中的bean的生命周期主要包含四个阶段：实例化Bean --＞ Bean属性填充 --＞ 初始化Bean --＞销毁Bean 首先是实例化Bean，当客户向容器请求一个尚未初始化的bean时，或初始化bean的时候需要注入另一个尚末初始化的依赖时，容器就会调用doCreateBean()方法进行实例化，实际上就是通过反射的方式创建出一个bean对象 Bean实例创建出来后，接着就是给这个Bean对象进行属性填充，也就是注入这个Bean依赖的其它bean对象 属性填充完成后，进行...
Spring Bean的初始化过程是怎么样的？
sinat_53467514的博客
03-19 2288
BeanPostProcessor是Spring IOC容器给我们提供的一个扩展接口，他的主要作用主要是帮我们在Bean的初始化前后添加一些自己的逻辑处理，Spring内置了很多BeanPostProcessor，我们也可以定义一个或者多个 BeanPostProcessor 接口的实现，然后注册到容器中。其实就是先确保这个Bean对应的类已经被加载，然后确保它是public的，然后如果有工厂方法，则直接调用工厂方法创建一本Bean，如果没有的话就调用它的构造方法来创建这个Bean。
Spring之bean的生命周期
m0_67768699的博客
07-21 701
目录 一、bean的初始化过程 Spring Bean的生命周期： 1）通过XML、Java annotation（注解）以及Java Configuration（配置类） 等方式加载Spring Bean 2）BeanDefinitionReader：解析Bean的定义。 3）BeanDefinition：包含了很多属性和方法。 4）BeanFactoryPostProcessor：是Spring容器功能的扩展接口。 5）BeanFactory：bean工厂。它按照我们的要求生产我们需要的
Bean的初始化流程
I want to know a little more.
07-03 2166
通过main函数启动spring容器加载bean时，会有以下流程： 1、通过实现BeanFactoryPostProcessor并覆盖postProcessBeanFactory()可以在spring容器初始化时拿到ConfigurableListableBeanFactory的实例，ConfigurableListableBeanFactory是所有bean的容器，也是BeanFactory的基础实现。此处可以对ConfigurableListableBeanFactory做扩展。 2、执行当前b
Spring生命周期Bean初始化过程详解
JAVA技术爱好者
10-25 1万+
Spring声明周期Bean初始化过程详解Spring 容器初始化Spring Bean初始化BeanFactory和FactoryBean源码分析Bean的实例化preInstantiateSingletonsgetMergedLocalBeanDefinitiongetBean方法getObjectForBeanInstance例子分析@DependsOn Spring 容器初始化 在spring中，不管是以xml文件的方式配置的Bean还是以注解的方式进行配置，最后都会将单例Bean放入到Spring
Spring bean的初始化
cxbtdd的博客
11-01 2298
常用的spring bean的初始化方法有以下四种：(1)@PostConstruct注解的方法；(2)类实现了InitializingBean接口，实现了afterPropertiesSet方法；(3)通过XML配置文件在标签中的init-method属性指定初始化方法，或者@Bean的initMethod属性指定的方法，如@Bean(initMethod = "init")，其中init是一个方法；
24.AOP的第一个时机之resolveBeforeInstantiation
qq_30635523的博客
06-09 657
highlight: arduino-light 在spring aop中，如果我们的类属符合如下条件：被切面的pointcut匹配到、或者属于自定义的Advisor接口实现类，那么spring在bean完成实例化之后，会为类生成代理对象。这是众所周知的aop流程。 此外，spring还为我们提供了TargetSourceCreator接口，该接口的功能是：在bean实例化之前，就为类生成...
bean初始化的三种方式
object_oriented的博客
07-05 1万+
概念的个人理解：    IoC（控制反转）：对于这个的理解首先要明白的是反转了什么，既然有反转那么正向是什么？    在没有spring之前是应用程序直接自己控制资源而有了spring之后应用程序就不需要自己去了解资源底层的一切    由容器去控制资源了，这里对资源的控制权发生了改变，这就叫控制反转DI（依赖注入）：现在应用程序如果需要资源就直接向容器要，它不用管这个资源怎么来的只需要用它就可以了...
Spring Bean的初始化过程 initializeBean
颜值即正义
12-12 4310
System.out.println(" construct之后 进行... ");}@Override}@Override}@OverrideSystem.out.println(" 属性配置完成之后 进行了什么操作... ");}@Override}@Override}@Override}}上面是对象。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值