Spring Bean 生命周期

最新推荐文章于 2024-09-13 22:48:29 发布
最新推荐文章于 2024-09-13 22:48:29 发布
阅读量802 收藏 19
点赞数 23
文章标签： spring java sql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43750771/article/details/120945344
版权

Spring Bean 生命周期

  • Spring Bean 元信息配置阶段
  • Spring Bean 元信息解析阶段
  • Spring Bean 注册阶段
  • Spring BeanDefinition 合并阶段
  • Spring Bean Class 加载阶段
  • Spring Bean 实例化前阶段
  • Spring Bean 实例化阶段
  • Spring Bean 实例化后阶段
  • Spring Bean 属性赋值前阶段
  • Spring Bean Aware接口回调阶段
  • Spring Bean 初始化前阶段
  • Spring Bean 初始化阶段
  • Spring Bean 初始化后阶段
  • Spring Bean 初始化阶段完成阶段
  • Spring Bean 销毁前阶段
  • Spring Bean 销毁阶段
  • Spring Bean 垃圾收集
  • 面试题

Spring Bean元信息配置，解析阶段

BeanDefinition XML,properties配置以及解析

  • 面向资源配置
    • XML配置
    • Properties资源配置
  • 面向注解
  • 面向API
	public static void main(String[] args) {
        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
        /* Xml配置读取 */
//        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);
//        String xmlPath = "";
//        reader.loadBeanDefinitions(xmlPath);
        PropertiesBeanDefinitionReader reader = new PropertiesBeanDefinitionReader(beanFactory);
        String location = "META-INF/user.properties";
        ClassPathResource resource = new ClassPathResource(location);
        EncodedResource encodedResource = new EncodedResource(resource, "UTF-8");
        int i = reader.loadBeanDefinitions(encodedResource);
        System.out.println("已加载数量" + i);

//        String[] beanDefinitionNames = beanFactory.getBeanDefinitionNames();
//        BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanDefinitionNames[0]);
//        System.out.println(beanDefinitionNames);
        System.out.println(beanFactory.getBean( User.class));
    }

如果在properties文件中进行注册Bean，需要注意，注册class的时候需要注意 .(class)

user.(class) = edu.ahau.thinking.in.spring.ioc.overview.domain.User

在properties文件使用中文可能会出现乱码，因此需要使用EncodedResource进行转码；

注解配置以及解析

public class AnnotatedBeanDefinitionParsingDemo {
    public static void main(String[] args) {
        DefaultListableBeanFactory registry = new DefaultListableBeanFactory();

        // 基于java注解的 BeanDefinitionReader
        AnnotatedBeanDefinitionReader reader = new AnnotatedBeanDefinitionReader(registry);
        // 对BeanNameGenerator重新实现，并且重新注入
        MyBeanNameGenerator myBeanNameGenerator = new MyBeanNameGenerator();
        reader.setBeanNameGenerator(myBeanNameGenerator);
        int beanNumberNumsBefore = registry.getBeanDefinitionCount();
        // 注册当前类（非component）
        reader.register(AnnotatedBeanDefinitionParsingDemo.class);
        int beanNumberNumsAfter = registry.getBeanDefinitionCount();
        System.out.println("已加载BeanDefinition数量： "+(beanNumberNumsAfter - beanNumberNumsBefore));
        // 普通的class作为Component注册到SpringIoC容器后，通常Bean名称为小驼峰
        // AnnotationBeanNameGenerator对BeanName的构造


        System.out.println(registry.getBean("haha"));

    }
}

在上面代码自定义实现了BeanNameGenerator，因此没有使用小驼峰BeanName获取Bean，而是自定义的"haha
"

public class MyBeanNameGenerator implements BeanNameGenerator {
    @Override
    public String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {
        return "haha";
    }
}

Spring Bean 注册阶段

注册过程在org.springframework.beans.factory.support.DefaultListableBeanFactory#registerBeanDefinition中；
源码查看，并分析：

	// 存储beanDefinition
	private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);
	// 保证创建Bean的顺序
	private volatile List<String> beanDefinitionNames = new ArrayList<>(256);
	@Override
	public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
			throws BeanDefinitionStoreException {
		/* 对beanName和beanDefinition进行空判断 */
		Assert.hasText(beanName, "Bean name must not be empty");
		Assert.notNull(beanDefinition, "BeanDefinition must not be null");
		/* 校验Bean的定义 */
		if (beanDefinition instanceof AbstractBeanDefinition) {
			try {
				((AbstractBeanDefinition) beanDefinition).validate();
			}
			catch (BeanDefinitionValidationException ex) {
				throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
						"Validation of bean definition failed", ex);
			}
		}
		// 获取已经存在的beanDefinition
		BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
		/* bean的覆盖 */
		if (existingDefinition != null) {
			if (!isAllowBeanDefinitionOverriding()) {
				throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
			}
			else if (existingDefinition.getRole() < beanDefinition.getRole()) {
				// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
				if (logger.isInfoEnabled()) {
					logger.info("Overriding user-defined bean definition for bean '" + beanName +
							"' with a framework-generated bean definition: replacing [" +
							existingDefinition + "] with [" + beanDefinition + "]");
				}
			}
			else if (!beanDefinition.equals(existingDefinition)) {
				if (logger.isDebugEnabled()) {
					logger.debug("Overriding bean definition for bean '" + beanName +
							"' with a different definition: replacing [" + existingDefinition +
							"] with [" + beanDefinition + "]");
				}
			}
			else {
				if (logger.isTraceEnabled()) {
					logger.trace("Overriding bean definition for bean '" + beanName +
							"' with an equivalent definition: replacing [" + existingDefinition +
							"] with [" + beanDefinition + "]");
				}
			}
			this.beanDefinitionMap.put(beanName, beanDefinition);
		}
		/* 创建Bean */
		else {
			if (hasBeanCreationStarted()) {
				// Cannot modify startup-time collection elements anymore (for stable iteration)
				synchronized (this.beanDefinitionMap) {
					this.beanDefinitionMap.put(beanName, beanDefinition);
					List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
					updatedDefinitions.addAll(this.beanDefinitionNames);
					updatedDefinitions.add(beanName);
					this.beanDefinitionNames = updatedDefinitions;
					removeManualSingletonName(beanName);
				}
			}
			else {
				// Still in startup registration phase
				this.beanDefinitionMap.put(beanName, beanDefinition);
				this.beanDefinitionNames.add(beanName);
				removeManualSingletonName(beanName);
			}
			this.frozenBeanDefinitionNames = null;
		}

		if (existingDefinition != null || containsSingleton(beanName)) {
			resetBeanDefinition(beanName);
		}
	}

Spring BeanDefinition 合并阶段

先看xml

 <!-- RootBeanDefinition ,不需要进行合并 -->
<bean id="user" class="edu.ahau.thinking.in.spring.ioc.overview.domain.User">
    <property name="age" value="12"/>
    <property name="workCities" value="BEIJING,HANGZHOU"/>
    <property name="cityList" value="BEIJING,SHANGHAI"/>
  </bean>

<!-- 普通BeanDefinition定义，GenericBeanDefinition -->
  <bean id="superUser" class="edu.ahau.thinking.in.spring.ioc.overview.domain.SuperUser" primary="true" parent="user">
    <property name="address" value="anhui"/>
  </bean>

在BeanDefinition中存在String getParentName();获取的值就是<bean>标签里面的parent;

user是使用RootBeanDefinition进行定义的，所以不存在parent，但是依然需要使用GenericBeanDefinition进行定义

superUser就是使用GenericBeanDefinition进行定义，使用org.springframework.beans.factory.support.BeanDefinitionBuilder#genericBeanDefinition(java.lang.String)构建出一个BeanDefinition;

在<bean>标签里面写上parent，就会把parentBean注入到当前Bean中，就如上述user的信息放入superUser中;

根据依赖查找的Demo

public class MergedBeanDefinitionDemo {

    public static void main(String[] args) {
        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();

        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);

        reader.loadBeanDefinitions("classpath:\\META-INF/dependency-looKup-context.xml");

        User user = beanFactory.getBean("user", User.class);
        System.out.println(user);
        SuperUser superUser = beanFactory.getBean("superUser", SuperUser.class);
        System.out.println(superUser);
    }
}

output: superUser里面包含着user的信息
User{name=‘null’, age=12, beanName=‘user’, workCities=[BEIJING, HANGZHOU], cityList=[BEIJING, SHANGHAI]}
SuperUser{address=‘anhui’}User{name=‘null’, age=12, beanName=‘superUser’, workCities=[BEIJING, HANGZHOU], cityList=[BEIJING, SHANGHAI]}

跟着Debug一步一步的来
User:

  1. org.springframework.beans.factory.support.AbstractBeanFactory#getMergedBeanDefinition(java.lang.String, org.springframework.beans.factory.config.BeanDefinition, org.springframework.beans.factory.config.BeanDefinition)

入的Bean是user，因为Demo里是依赖查找是按照顺序的；在这里插入图片描述
GenericBeanDefinition转换成RootBeanDefinition
在这里插入图片描述

superUser:
如果存在，存在了user这个Bean，通过一系列操作到达这一步，overrideFrom()是对parent里面属性进行覆盖或者添加到superUser这个Bean；最后还是转换成RootBeanDefinition.
在这里插入图片描述

Spring Bean Class 加载阶段

  • ClassLoader类加载
  • Java Security 安全控制
  • ConfigurableBeanFactory临时ClassLoader

String类型的BeanName转换为Class对象的阶段

Spring Bean 实例化前阶段

public static void main(String[] args) {
        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
        beanFactory.addBeanPostProcessor(new MyInstantiationAwareBeanPostProcessor());

        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);

        reader.loadBeanDefinitions("classpath:\\META-INF/dependency-looKup-context.xml");
        System.out.println(beanFactory.getBean("superUser"));  //SuperUser{address='null'}User{name='null', age=0, beanName='null', workCities=null, cityList=null} 被拦截

    }

    static class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
        @Override
        public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
            // 拦截superUser
            if (ObjectUtils.nullSafeEquals("superUser", beanName) && SuperUser.class.equals(beanClass)) {
                return new SuperUser();
            }
            return null;
        }
    }

postProcessBeforeInstantiation —> applyBeanPostProcessorsBeforeInstantiation —> 、

Spring Bean 实例化阶段

  • 传统实例化方式
    • 实例化策略 - InstantiationStrategy
你会散打吗
关注
SpringBean生命周期详解
weixin_43244698的博客
10-28 9534
SpringBean生命周期详解 一、简述： Spring是我们每天都在使用的框架，Bean是被Spring管理的Java对象，是Spring框架最重要的部分之一，那么让我们一起了解一下Spring中Bean的生命周期是怎样的吧 二、流程图 我们先从宏观的角度看一下Spring的生命周期： ![在这里插入图片描述](https://img-blog.csdnimg.cn/20201028174058916.png?x-oss-process=image/watermark,t ype_ZmFuZ3poZW5
Spring Bean生命周期详解
weixin_45723046的博客
04-10 1万+
站在设计者的角度考虑设计IOC容器 加载Bean的配置（比如xml配置） 比如不同类型资源的加载，解析成生成统一Bean的定义 根据Bean的定义加载生成Bean的实例，并放置在Bean容器中 比如Bean的依赖注入，Bean的嵌套，Bean存放（缓存）等 除了基础Bean外，还有常规针对企业级业务的特别Bean 比如国际化Message，事件Event等生成特殊的类结构去支撑 对容器中的Bean提供统一的管理和调用 比如用工厂模式管理，提供方法根据名字/类的类型等从容器中获取Bea
Spring Bean 生命周期详解
常备不懈
06-22 1513
在 Spring 框架中，Bean 的生命周期由 Spring 容器全权管理。了解和掌握 Bean 的生命周期对于使用 Spring 开发稳定且高效的应用程序至关重要。本文将详细介绍 Spring Bean 生命周期的五个主要阶段：实例化、属性注入、初始化、使用和销毁，并涵盖各个阶段的关键步骤和扩展点。
简述Spring Bean生命周期
沛哥儿的专栏
11-22 2690
如果这个 Bean 的 Spring 配置中配置了 destroy-method 属性，会自动调用其配置的销毁方法。以上就是spring bean的完整生命周期。
Spring Bean生命周期源码篇
qq_43649937的博客
04-26 1876
这里先对AOP进行简单的介绍AOP （AspectOrient Programming）,直译过来就是 面向切面编程,AOP 是一种编程思想，是面向对象编程（OOP）的一种补充。面向切面编程，实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术。AOP可以拦截指定的方法并且对方法增强，而且无需侵入到业务代码中，使业务与非业务处理逻辑分离，比如Spring的事务，通过事务的注解配置，Spring会自动在业务方法中开启、提交业务，并且在业务处理失败时，执行相应的回滚策略。
一文读懂 Spring Bean 的生命周期
热门推荐
riemann_的博客
07-18 11万+
欢迎大家关注我的微信公众号【老周聊架构】，Java后端主流技术栈的原理、源码分析、架构以及各种互联网高并发、高性能、高可用的解决方案。 一、前言 今天我们来说一说 Spring Bean 的生命周期，小伙伴们应该在面试中经常遇到，这是正常现象。因为 Spring Bean 的生命周期是除了 IoC、AOP 几个核心概念之外最重要概念，大家务必拿下。可 Spring 源代码又比较复杂，跟着跟着就不知道跟到哪里去了，不太好拿下呀。这倒是真的，而且网上一上来就各种贴流程源码，对初学者来说是真的一脸懵逼，就像字.
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实例化阶
Springbean生命周期详解
qq_64169170的博客
02-21 1万+
在传统的java应用中，JavaBean的生命周期一般都是浅化理解，就是在在Java中使用关键字new把Bean进行实例化，然后Bean就可以使用了，一旦不使用了，Java会自动进行垃圾回收。 如果是在springBean里面，Bean的生命周期就显得非常复杂，我把它详细了解了一下，分为十个步骤： Bean的实例化：spring启动后，会查找和加载需要被spring管理的Bean，并且实例化。 Bean属性注入：Bean被实例化后对将Bean的引入和值注入到Bean的属性中。 调用BeanNameA
springBean生命周期
zhangCheng的博客
12-18 2万+
一、springBean的生命周期 1、 启动spring容器,也就是创建beanFactory(bean工厂), 一般用的是beanFactory的子类applicationcontext, applicationcontext比一般的beanFactory要多很多功能,比如aop、事件等。 通过applicationcontext加载配置文件,或者利用注解的方式扫描将bean 的配置信息加载到spring容器里面。 2、 加载之后,spring容器会将这些
谈谈我对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`注解标记类，配合`@...
第三章 SpringBoot项目构建 - 整合Spring Security入门
想做一个小孩的杨先生的博客
09-11 610
Spring Security 是一个强大的框架，用于保护基于 Spring 的应用程序。它提供了全面的认证和授权功能，使得安全机制与应用逻辑相分离。以下是 Spring Security 的基本使用指南，包括如何集成 Spring Security、定义用户角色和权限、以及自定义安全配置。在 Java 生态中，目前有 Spring Security 和 Apache Shiro 两个安全框架，可以完成认证和授权的功能。
Spring Framework 学习总结博客
2302_80084329的博客
09-13 1052
通过本文的学习，我们从Spring的核心架构入手，逐步理解了IoC和DI的概念，并通过代码示例掌握了如何在实际项目中使用这些技术。Spring通过IoC容器管理bean，依赖注入将bean之间的关系解耦，大大简化了复杂系统的开发过程。这些基本的Spring知识是理解其高级特性（如AOP、事务管理）的基础，掌握这些概念后，我们可以更加自如地使用Spring构建复杂的企业级应用。
基于spring的博客系统（总）
2202_76101487的博客
09-12 1399
本文写了基于spring mvc创建的博客系统；
SpringCloud gateway
c1tenj2的博客
09-11 1102
由此案例，我们可以感受到gateway带给我们的方便。有了gateway，前端就只需要请求8080端口，以模块进行路径的书写，就能访问所有的后端接口了，同时gateway也解决了跨域的问题。
java项目之基于springboot的贸易行业crm系统（源码+文档）
最新发布
sinat_26552841的博客
09-13 460
基于springboot的贸易行业crm系统的主要使用者分为： 管理员功能有个人中心，部门管理，员工管理，产品分类管理，产品信息管理，客户信息管理，市场活动管理，销售订单管理，配送订单管理。员工可以操作自己的个人中心，客户信息，产品信息，销售订单，配送订单，售后回访等。
spring综合性利用工具-SpringBootVul-GUI(五)
siu~
09-12 863
一个半自动化springboot打点工具，内置目前springboot所有漏洞
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值