Spring__Bean的生命周期

最新推荐文章于 2024-08-06 21:54:54 发布
最新推荐文章于 2024-08-06 21:54:54 发布
阅读量163 收藏
点赞数
分类专栏： SpringFramework
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37432174/article/details/95792770
版权

这篇可以说是对前面那些接口的总结，总结完后，发现其实就是bean生命周期用的这些接口：
BeanFactoryPostProcessor
InstantiationAwareBeanPostProcessor
Aware
BeanPostProcessor
@PostConstruct与@PreDestroy
InitializingBean与DisposableBean
init-method与destroy-method

在IoC容器启动之后，并不会马上就实例化相应的bean，此时容器仅仅拥有所有对象的BeanDefinition(BeanDefinition：是容器依赖某些工具加载的XML配置信息进行解析和分析，并将分析后的信息编组为相应的BeanDefinition)。只有当getBean()调用时才是有可能触发Bean实例化阶段的活动


可以简述为以下九步

实例化bean对象(通过构造方法或者工厂方法)
设置对象属性(setter等)（依赖注入）
如果Bean实现了BeanNameAware接口，工厂调用Bean的setBeanName()方法传递Bean的ID。（和下面的一条均属于检查Aware接口）
如果Bean实现了BeanFactoryAware接口，工厂调用setBeanFactory()方法传入工厂自身
将Bean实例传递给Bean的前置处理器的postProcessBeforeInitialization(Object bean, String beanname)方法
调用Bean的初始化方法
将Bean实例传递给Bean的后置处理器的postProcessAfterInitialization(Object bean, String beanname)方法
使用Bean
容器关闭之前，调用Bean的销毁方法

较详细总结：

1、如果实现了BeanFactoryPostProcessor接口，那么在容器启动的时候，该接口中的postProcessBeanFactory方法可以修改Bean中元数据中的信息。
该方法是在实例化对象之前执行。

2、如果实现了InstantiationAwareBeanPostProcessor接口，那么在实例化Bean对象之前会调用postProcessBeforeInstantiation方法，该方法如果返回的不为null则会直接调用postProcessAfterInitialization方法，而跳过了Bean实例化后及初始化前的相关方法，如果返回null则正常流程，postProcessAfterInstantiation在实例化成功后执行，这个时候对象已经被实例化，但是该实例的属性还未被设置，都是null。因为它的返回值是决定要不要调用postProcessPropertyValues方法的其中一个因素（因为还有一个因素是mbd.getDependencyCheck()）；如果该方法返回false,并且不需要check，那么postProcessPropertyValues就会被忽略不执行；如果返回true, postProcessPropertyValues就会被执行,postProcessPropertyValues用来修改属性，在初始化方法之前执行。

3、如果实现了Aware相关的结果，那么相关的set方法会在初始化之前执行。

4、如果实现了BeanPostProcessor接口，那么该接口的方法会在实例化后的初始化方法前后执行。

5、如果指定了@PostConstruct则在初始化的时候会执行标注的方法。

6、如果实现了InitializingBean接口则在初始化的时候执行afterPropertiesSet。

7、如果指定了init-method属性则在初始化的时候会执行指定的方法。

8、到此对象创建完成。

9、当对象需要销毁的时候。

10、如果指定了@PreDestroy注解则会执行标注的方法。

11、如果实现了DisposableBean接口会执行destroy方法。

12、如果指定了destroy-method属性则会执行指定的方法。

执行顺序：（非一定流程）

对象创建：

1、如果实现了BeanFactoryPostProcessor接口在容器启动的时，bean实例化前，可以获取bean的相关定义信息，可以修改bean的元数据  --
2、如果实现了InstantiationAwareBeanPostProcessor接口,它的postProcessBeforeInstantiation方法会在bean实例化之前被调用，返回值不为null则跳过实例化后与初始化前的执行方法，直接执行BeanPostProcessor接口中的postProcessAfterInitialization方法， postProcessAfterInitialization方法是在初始化后执行的；如果返回值为null，那么会按正常流程走，不跳过流程；---

3、无参构造实例化对象 -

4、依赖注入 -

5、如果指定了@PostConstruct则在初始化的时候会执行标注的方法。--

6、如果实现了InitializingBean接口则在初始化的时候执行afterPropertiesSet。---

7、如果指定了init-method属性则在初始化的时候会执行指定的方法。---

8、到此对象创建完成。

对象销毁：

9、如果指定了@PreDestroy注解则会执行标注的方法。--->

10、如果实现了DisposableBean接口会执行destroy方法。-

11、如果指定了destroy-method属性则会执行指定的方法。-

ZslBeanFactoryPostProcessor 实现了BeanFactoryPostProcessor:

package com.pojo;

import org.springframework.beans.BeansException;
import org.springframework.beans.MutablePropertyValues;
import org.springframework.beans.PropertyValue;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;

public class ZslBeanFactoryPostProcessor implements BeanFactoryPostProcessor{

	@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
		// TODO Auto-generated method stub
		System.out.println("进入了BeanFactoryPostProcessor中的postProcessBeanFactory方法开始执行");
		
		/**
		 * 获取在IOC容器中注册了的bean的名称
		 */
		String[] definitionNames = beanFactory.getBeanDefinitionNames();
		for (String dname : definitionNames) {
			System.out.println("dname:"+dname);
			if (dname.equals("studentA")) {// 找到我们需要的bean的名称，与配置文件里的id或者name一致
				/**
				 *Spring容器启动的过程中，会将Bean解析成Spring内部的BeanDefinition结构
				 *其实就是将Bean的定义信息存储到这个BeanDefinition相应的属性中，
				 *后面对Bean的操作就直接对BeanDefinition进行，
				 *例如拿到这个BeanDefinition后，可以根据里面的类名、构造函数、构造函数参数，使用反射进行对象创建。
				 *BeanDefinition是一个接口，是一个抽象的定义，实际使用的是其实现类，
				 *如 ChildBeanDefinition、RootBeanDefinition、GenericBeanDefinition等。
				 */
				BeanDefinition beanDefinition = beanFactory.getBeanDefinition(dname);
				
				/**
				 * 通过BeanDefinition获取我们的配置文件，这里是applicationContext.xml
				 */
				MutablePropertyValues propertyValues = beanDefinition.getPropertyValues();
				
				/**
				 * 获取到了xml配置文件后，可以修改其中一项
				 */
				if (propertyValues.contains("stuId")) {
					Object value = propertyValues.get("stuId");
					System.out.println("修改前stuId:"+value);
					propertyValues.addPropertyValue("stuId", "zsl66");
					Object value1 = propertyValues.get("stuId");
					System.out.println("修改后stuId:"+value1);
					System.out.println("修改了配置文件里的studentA的stuId");
				}
				
			}
		}
		System.out.println("postProcessBeanFactory执行结束");
	}

}

StuBeanPostProcessor实现了BeanPostProcessor

package com.pojo;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.core.Ordered;

public class StuBeanPostProcessor implements BeanPostProcessor ,Ordered{
	/**
	 * 实例化、依赖注入完毕，
     * 在调用显示的初始化之前完成一些定制的初始化任务
	 */
	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		// TODO Auto-generated method stub
		System.out.println("postProcessBeforeInitialization 实例化、依赖注入完毕,初始化之前执行");
		System.out.println("postProcessBeforeInitialization中bean："+bean+",beanName:"+beanName);
		return bean;
	}

	/**
	 * 实例化、依赖注入、初始化完毕时执行
	 */
	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		// TODO Auto-generated method stub
		System.out.println("postProcessAfterInitialization初始化完毕时执行");
		System.out.println("postProcessAfterInitialization中bean："+bean+",beanName:"+beanName);
		return bean;
	}

	/**
	 * 多个BeanPostProcessor时，可以指定执行顺序
	 * 默认为0优先级最高，值越小，越靠前，优先级越大
	 */
	@Override
	public int getOrder() {
		// TODO Auto-generated method stub
		return 3;
	}
}

ZslInstantiationAwareBeanPostProcessor实现了InstantiationAwareBeanPostProcessor

package com.pojo;

import java.beans.PropertyDescriptor;

import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor;

public class ZslInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor{

	/**
	 * BeanPostProcessor接口的方法，在实例化后，依赖注入后，初始化前执行
	 */
	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		// TODO Auto-generated method stub
		System.out.println("InstantiationAwareBeanPostProcesso中postProcessBeforeInitialization初始化前执行");
		return bean;
	}
	
	/**
	 * BeanPostProcessor接口的方法，在实例化后，依赖注入后，初始化完成后执行
	 */
	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		// TODO Auto-generated method stub
		System.out.println("InstantiationAwareBeanPostProcesso中postProcessAfterInitialization初始化完成后执行");
		return bean;
	}

	/**
	 * InstantiationAwareBeanPostProcessor接口的方法，实例化前执行
	 */
	@Override
	public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
		// TODO Auto-generated method stub
		System.out.println("InstantiationAwareBeanPostProcesso中postProcessBeforeInstantiation实例化前执行");
		return null;
	}

	/**
	 * InstantiationAwareBeanPostProcessor接口的方法，实例化完成后，依赖注入之前执行
	 */
	@Override
	public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
		// TODO Auto-generated method stub
		System.out.println("InstantiationAwareBeanPostProcesso中postProcessAfterInstantiation实例化完成后，依赖注入之前执行");
		return true;
	}

	/**
	 * 如果postProcessAfterInstantiation返回为false则不用执行
	 * 在postProcessPropertyValues中可以对bean的属性进行修改
	 */
	@Override
	public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean,
			String beanName) throws BeansException {
		// TODO Auto-generated method stub
		System.out.println("InstantiationAwareBeanPostProcesso中postProcessPropertyValues对bean的属性进行修改");
		return pvs;
	}

}

StudentA目标类

package com.pojo;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
public class StudentA implements InitializingBean,DisposableBean{
	private String name;
	private String stuId;
	
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
		System.out.println("设值注入Name:"+name);
	}
	
 	public String getStuId() {
		return stuId;
	}
 	
	public void setStuId(String stuId) {
		this.stuId = stuId;
		System.out.println("设值注入stuId:"+stuId);
	}
	
	public StudentA(String name, String stuId) {
		super();
		this.name = name;
		this.stuId = stuId;
	}
	
	public StudentA() {
		super();
		// TODO Auto-generated constructor stub
		System.out.println("通过无参构造...StudentA实例化");
	}
	
	@Override
	public String toString() {
		return "StudentA [name=" + name + ", stuId=" + stuId + "]";
	}
	
	/**
	 * 重写DisposableBean接口里的方法
	 * 在销毁前回调
	 */
	@Override
	public void destroy() throws Exception {
		// TODO Auto-generated method stub
		System.out.println("DisposableBean接口的destroy()");
	}
	
	/**
	 * 重写InitializingBean接口里的方法
	 * 在实例化并设值注入后初始化回调
	 */
	@Override
	public void afterPropertiesSet() throws Exception {
		// TODO Auto-generated method stub
		System.out.println("InitializingBean接口的afterPropertiesSet()");
	}
	
	/**
	 * 自定义初始化后回调
	 * 对应着bean里的init-method="start"
	 */
	public void start() {
		// TODO Auto-generated method stub
		System.err.println("自定义初始化回调...init-method=\"start\"");
	}
	
	/**
	 * 自定义销毁前回调
	 * 对应着bean里的destroy-method="end"
	 */
	public void end() {
		// TODO Auto-generated method stub
		System.out.println("自定义销毁回调...destroy-method=\"end\"");
	}
	
	/**
	 * 通过@PreDestroy注解
	 * 初始化后回调方法
	 */
	@PostConstruct
	public void postConstruct(){
		System.out.println("初始化后回调方法...@postConstruct注解");
	}
	
	
	/**
	 * 通过@PreDestroy注解
	 * 销毁前回调方法
	 */
	@PreDestroy
	public  void preDestory(){
		System.out.println("销毁前回调方法...@preDestory注解");
	}

	
	
}

ApplicationContext.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"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
		
		
		<!-- 如果想使用@ Resource 、@ PostConstruct、@ PreDestroy等注解就必须声明CommonAnnotationBeanPostProcessor -->
	    <context:annotation-config/> 
		
		<!-- 注册studentA对象 -->
	 	<bean class="com.pojo.StudentA" id="studentA" init-method="start" destroy-method="end">
			<!-- 设值注入 -->
			<property name="name" value="zsl"/>
			<property name="stuId" value="zsl33"/>
		</bean>  
<!-- 注册StuBeanPostProcessor，它实现了BeanPostProcessor -->
		  <bean class="com.pojo.StuBeanPostProcessor"/>
<!-- 注册ZslBeanFactoryPostProcessor，实现了BeanFactoryPostProcessor接口 -->
		  <bean class="com.pojo.ZslBeanFactoryPostProcessor" />  
		
		<!-- 注册ZslInstantiationAwareBeanPostProcessor，实现了InstantiationAwareBeanPostProcessor接口 -->
		<bean class="com.pojo.ZslInstantiationAwareBeanPostProcessor"/>	
</beans>

测试：

package com.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.pojo.Cat;
import com.pojo.Dog;
import com.pojo.StudentA;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanNameAware;
public class Test {
	@SuppressWarnings("resource")//去警告，问题不大不要慌
	public static void main(String[] args) {
		ClassPathXmlApplicationContext applicationContext = 
				new ClassPathXmlApplicationContext("applicationContext.xml");
		
		StudentA bean = (StudentA) applicationContext.getBean("studentA");
	System.out.println(bean);
		
		/**
		 * 在非web环境下需要手动关闭IOC容器，则需调用registerShutdownHook()方法
		 * 而web环境下已有相应的配置进行关闭IOC容器
		 */
		applicationContext.registerShutdownHook();
	}
}

结果：

借鉴于大佬：

https://dpb-bobokaoya-sm.blog.csdn.net/article/details/88143169
https://blog.csdn.net/w_linux/article/details/80086950

偷偷学习被我发现
关注
专栏目录
一文读懂 Spring Bean 的生命周期
riemann_的博客
07-18 11万+
欢迎大家关注我的微信公众号【老周聊架构】，Java后端主流技术栈的原理、源码分析、架构以及各种互联网高并发、高性能、高可用的解决方案。 一、前言 今天我们来说一说 Spring Bean 的生命周期，小伙伴们应该在面试中经常遇到，这是正常现象。因为 Spring Bean 的生命周期是除了 IoC、AOP 几个核心概念之外最重要概念，大家务必拿下。可 Spring 源代码又比较复杂，跟着跟着就不知道跟到哪里去了，不太好拿下呀。这倒是真的，而且网上一上来就各种贴流程源码，对初学者来说是真的一脸懵逼，就像字.
Spring Bean的生命周期
qq_52897007的博客
08-01 1871
Spring其实就是一个管理Bean对象的工厂。它负责对象的创建，对象的销毁等。所谓的生命周期就是：对象从创建开始到最终销毁的整个过程。什么时候创建Bean对象？创建Bean对象的前后会调用什么方法？Bean对象什么时候销毁？Bean对象的销毁前后调用什么方法？其实生命周期的本质是：在哪个时间节点上调用了哪个类的哪个方法。我们需要充分的了解在这个生命线上，都有哪些特殊的时间节点。只有我们知道了特殊的时间节点都在哪，到时我们才可以确定代码写到哪。
Spring Bean 生命周期
最新发布
Randy的博客
08-06 1480
生产：加载和创建 Bean 定义和实例。使用：在应用程序中管理和使用 Bean 实例。销毁：适当地销毁和清理 Bean 实例。加载 Bean 定义是 Spring 容器启动的第一步。这一步骤通过各种方式（如 XML 配置、注解扫描等）将项目中定义的所有 Bean 类找到，并放入中。
Spring Bean 生命周期详解
常备不懈
06-22 1583
在 Spring 框架中，Bean 的生命周期由 Spring 容器全权管理。了解和掌握 Bean 的生命周期对于使用 Spring 开发稳定且高效的应用程序至关重要。本文将详细介绍 Spring Bean 生命周期的五个主要阶段：实例化、属性注入、初始化、使用和销毁，并涵盖各个阶段的关键步骤和扩展点。
Spring框架中bean的生命周期
记录各种Bug解决案例及日常学习内容
07-01 1749
1. Spring对bean进行实例化； 2. Spring将值和bean的引用注入到bean对应的属性中； 3. 如果bean实现了`BeanNameAware`接口，Spring将bean的ID传递给`setBean-Name()`方法； 4. 如果bean实现了`BeanFactoryAware`接口，Spring将调用`setBeanFactory()`方法，将`BeanFactory`容器实例传入； 5. 如果bean实现了`ApplicationContextAware`接口，Spring将调用
深度解析 Spring 源码：探寻Bean的生命周期
忆~遂愿的博客
05-04 5771
深度解析 Spring 源码是一项庞大的任务，其中探究 Bean 的生命周期是其中一个重要的方面。在 Spring 框架中，Bean 的生命周期包括创建、初始化、使用和销毁等多个阶段。通过深入研究 Spring 源码，我们可以了解到 Spring 是如何管理这些生命周期的。在 Spring 中，Bean 的生命周期由容器管理，而容器在初始化 Bean 时会遵循一定的流程。这个流程包括实例化 Bean、设置 Bean 的属性、调用 Bean 的初始化方法以及在容器关闭时销毁 Bean。
简述Spring Bean生命周期
沛哥儿的专栏
11-22 2708
如果这个 Bean 的 Spring 配置中配置了 destroy-method 属性，会自动调用其配置的销毁方法。以上就是spring bean的完整生命周期。
Spring Bean 的生命周期
FireFox1997
06-23 1207
Spring Bean 的生命周期是指 Bean 从创建到销毁的过程。Spring 容器负责管理 Bean 的生命周期，确保在适当的时机对 Bean 进行初始化和销毁。了解 Bean 的生命周期对于开发者优化和管理 Spring 应用程序至关重要。为了在 Bean 的生命周期中执行自定义逻辑，Spring 提供了多种方式来定义初始化和销毁方法。Spring Bean 的生命周期管理是 Spring 容器的重要功能之一，通过对 Bean 生命周期的深入了解和合理利用，可以有效优化应用程序的性能和资源管理。
Spring Bean生命周期总结
欢迎来到【战羽】的博客
05-22 4627
1、简要说明 1）本文基于spring5.1.7版本，采用ApplicationContext获取bean对象。 2）BeanFactory和ApplicationContext对于bean后置处理器还有所不同，需要注意，ApplicationContext会自动检测在配置文件中实现了BeanPostProcessor接口的所有bean，并把它们注册为后置处理器，然后在容器创建bean的适当时候调......
Spring之Bean的生命周期
weixin_74352229的博客
08-18 2172
所谓 Bean 的生命周期，就是一个 Bean 从创建到销毁，所经历的各种方法调用。简单的来说，一个Bean的生命周期分为四个阶段实例化(Instantiation)属性设置(populate)初始化(Initialization)销毁(Destruction)。
谈谈我对Spring Bean 生命周期的理解
08-27
Spring Bean 生命周期是 Spring 框架中的一个核心概念，了解 Spring Bean 的生命周期对我们了解整个 Spring 框架会有很大的帮助。本文将详细介绍 Spring Bean 生命周期的概念、生命周期图、生命周期阶段、生命周期...
spring bean的生命周期
01-16
- **XML配置**：在传统的Spring应用中，Bean的定义通常写在XML配置文件中，如`springbean-xml`中的配置。 - **注解配置**：使用`@Component`，`@Service`，`@Repository`和`@Controller`注解标记类，配合`@...
Spring学习笔记之bean生命周期
08-28
《Spring学习笔记之bean生命周期》 在Spring框架中，Bean是核心组件，它们构成了应用程序的主要结构。理解Spring Bean的生命周期对于有效地管理和优化Spring应用程序至关重要。本文将深入探讨Spring Bean的生命周期...
浅尝Spring注解开发_Bean生命周期及执行过程.doc
07-08
ingBean 和 DisposableBean 接口 当不使用注解而是通过实现接口的方式来控制 Bean 的生命周期时，可以实现 ...了解并熟练掌握 Bean 生命周期及其控制方法，对于开发高效、健壮的 Spring 应用程序至关重要。
spring中bean的生命周期详解
08-26
"Spring中Bean的生命周期详解" Spring框架是当前Java EE开发中最流行的框架之一，Spring框架中Bean的生命周期是指从创建到销毁的整个过程。在这个过程中，Spring IOC容器对Bean的生命周期进行管理，使得开发者可以...
对Spring中的IOC与AOP简单理解（简单的理解，通俗易懂）
qq_37432174的博客
07-13 2206
IOC与AOP是Spring中的核心；IOC是控制反转，AOP是面向对象编程，IOC采用了工厂设计模式，AOP采用了代理设计模式。 一、IOC IOC是控制反转，而控制反转是一种思想，而DI是依赖注入，是IOC的实现，DI有构造注入、属性注入（设值注入）（基于注解的方式或者基于XML的方式）。在项目程序中，频繁的去手动创建对象，new对象使得代码间耦合度太大，而Spring提供了容器，通俗的讲：你...
Bean的作用域中prototype原型模式（浅拷贝和深拷贝）
qq_37432174的博客
07-13 1967
在Spring中Bean有五个作用域，其中singleton和prototype分别是单例模式和原型模式。 这里讲一下单例模式和原型模式，进行整理方便我复习。 spring中bean的创建实际就是两种：单例模式和原型模式。（原型模式需要和工厂模式搭配起来） 一、原型模式 原型模式是23种设计模式的其中一种。  在创建对象时通过new关键字创建的对象 (类加载判断，内存分配，初始化等)，在我们需要大...
Spring___多个BeanPostProcessor接口（后置处理器）处理
qq_37432174的博客
07-13 1547
这篇看不懂请看上一篇单独讲BeanPostProcessor接口的 https://www.cnblogs.com/zhangsonglin/p/10939740.html 如果是配置了多个后置处理器，那么它们执行的顺序是由在Spring配置文件定义的顺序决定的，在默认情况下Spring容器会根据后置处理器的定义顺序来依次调用。 我们可以在Spring配置文件中添加多个BeanPostProces...
Bean的五个作用域
qq_37432174的博客
07-13 503
一、Singleton Singleton是单例类型，bean默认就是单例的，就是在创建起容器时就同时自动创建了一个bean的对象，不管你是否使用，他都存在了，每次获取到的对象都是同一个对象。当开发者定义一个Bean的作用域为单例时，Spring IoC容器只会根据Bean定义来创建该Bean的唯一实例。这些唯一的实例会缓存到容器中，后续针对单例Bean的请求和引用，都会从这个缓存中拿到这个唯...
Spring Bean生命周期详解与示例
在Spring框架中，Bean的生命周期管理是至关重要的，它涉及到从Bean的创建、初始化到销毁的整个过程。...对于学习Spring框架或进行Spring项目开发的人员来说，深入理解Bean生命周期是必不可少的知识。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

偷偷学习被我发现

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值