Spring框架总结五---bean生命周期后置处理器

最新推荐文章于 2022-12-12 11:39:22 发布
最新推荐文章于 2022-12-12 11:39:22 发布
阅读量396 收藏
点赞数
分类专栏： Spring框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CarryJoe/article/details/106195834
版权

文章目录

一.生命周期

1.创建bean实例

	public Emp() {
		super();
		System.out.println("One：创建对象Emp");
		// TODO Auto-generated constructor stub
	}

2.设置属性值

	public void setEname(String ename) {
		System.out.println("Two：依赖注入Emp");
		this.ename = ename;
	}

3.调用初始化方法

在xml配置文件中需要申明初始化方法名

	<bean id="person" class="com.atguigu.ioc.life.Person" init-method="init" destroy-method="destory">
		<property name="id" value="1001"></property>
		<property name="sex" value="男"></property>
	</bean>

	public void init() {
		System.out.println("Three:初始化Emp");
	}

4.使用bean（调用一个toString方法吧）

	@Override
	public String toString() {
		return "Four:Emp [ename=" + ename + "]";
	}

5.容器关闭调用销毁方法

	public void destory() {
		System.out.println("Five:销毁Emp");
	}

6.运行效果

在这里插入图片描述

7.总结(删除线部分为后置处理器部分)

i.通过构造器或工厂方法创建bean实例
ii.为bean的属性设置值和对其他bean的引用
iii.将bean实例传递给bean后置处理器的postProcessBeforeInitialization()方法
iv.调用bean的初始化方法
v.将bean实例传递给bean后置处理器的postProcessAfterInitialization()方法
vi.bean可以使用了
vii.当容器关闭时调用bean的销毁方法

二.后置处理器

1.什么时候起作用？

在调用初始化方法（ Init() ）前后对bean进行额外的处理

2.如何处理？

对IOC容器里的所有bean实例逐一处理，而非单一实例。其典型应用是：检查bean属性的正确性或根据特定的标准更改bean的属性
例：

@Override
	public Object postProcessAfterInitialization(Object bean, String beanId) throws BeansException {
		System.out.println("我是后置处理器初始化前执行的方法，处理的beanId为："+beanId);
		// 后置处理器会对配置文件中的bean采取顺序遍历的方式进行处理
		if(beanId.equals("emp")) {
			Emp emp=(Emp)bean;
			System.out.println(emp);
		}
		else if(beanId.equals("person"))
		{
			Person person=(Person)bean;
			System.out.println(person);
			return person;
		}
		return null;
	}

3.使用条件？

实现BeanPostProcessor接口，重写postProcessBeforeInitialization()、postProcessAfterInitialization两个方法做出处理；

package com.life;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
public class PostProcessor implements BeanPostProcessor {
	@Override
	public Object postProcessAfterInitialization(Object bean, String beanId) throws BeansException {
		System.out.println("我是后置处理器初始化前执行的方法，处理的beanId为："+beanId);
		// 后置处理器会对配置文件中的bean采取顺序遍历的方式进行处理
		if(beanId.equals("emp")) {
			Emp emp=(Emp)bean;
			System.out.println(emp);
		}
		else if(beanId.equals("person"))
		{
			Person person=(Person)bean;
			System.out.println(person);
			return person;
		}
		return null;
	}
	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanId) throws BeansException {
		// TODO Auto-generated method stub
		System.out.println("我是后置处理器初始化后执行的方法，处理的beanId为："+beanId);
		return null;
	}
}

三.实现代码

1.Emp类

package com.life;

public class Emp {
	private Integer eid;
	private String ename;
	private String gender;

	public Integer getEid() {
		return eid;
	}

	public void setEid(Integer eid) {
		this.eid = eid;
	}

	public String getEname() {
		return ename;
	}

	public void setEname(String ename) {
		this.ename = ename;
	}

	public String getGender() {
		return gender;
	}

	public void setGender(String gender) {
		this.gender = gender;
		System.out.println("two:Emp为bean的属性设置值和对其他bean的引用");
	}

	public Emp() {
		super();
		System.out.println("one:Emp通过构造器或工厂方法创建bean实例");
		// TODO Auto-generated constructor stub
	}

	public Emp(Integer eid, String ename, String gender) {
		super();
		this.eid = eid;
		this.ename = ename;
		this.gender = gender;
	}

	public void init() {
		System.out.println("Three:Emp调用bean的初始化方法");
	}

	public void destroy() {
		System.out.println("Five:Emp容器关闭时，调用bean的销毁方法");
	}

	@Override
	public String toString() {
//		System.out.println("Four: bean可以使用了");
		return "Four:Emp [eid=" + eid + ", ename=" + ename + ", gender=" + gender + "]";
	}

}

2.Person类

package com.life;

public class Person {
	private String pname;

	public String getPname() {
		return pname;
	}

	public void setPname(String pname) {
		this.pname = pname;
		System.out.println("two:Person为bean的属性设置值和对其他bean的引用");
	}

	public Person() {
		super();
		System.out.println("one:Person通过构造器或工厂方法创建bean实例");
		// TODO Auto-generated constructor stub
	}
	
	public Person(String pname) {
		super();
		this.pname = pname;
		
	}
	public void init() {
		System.out.println("Three:Person调用bean的初始化方法");
	}

	public void destroy() {
		System.out.println("Five:Person容器关闭时，调用bean的销毁方法");
	}
	@Override
	public String toString() {
		return "Four:Person [pname=" + pname + "]";
	}
}

3.后置处理器类

注意postProcessAfterInitialization、postProcessBeforeInitialization两个方法的顺序，返回对象要明确

package com.life;

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

public class PostProcessor implements BeanPostProcessor {
	@Override
	public Object postProcessAfterInitialization(Object bean, String beanId) throws BeansException {
		// TODO Auto-generated method stub
		System.out.println("我是后置处理器初始化后执行的方法，处理的beanId为：" + beanId);
		return bean;
	}

	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanId) throws BeansException {

		System.out.println("我是后置处理器初始化前执行的方法，处理的beanId为：" + beanId);
		// 后置处理器会对配置文件中的bean采取顺序遍历的方式进行处理
		if (beanId.equals("emp01")) {
			Emp emp = (Emp) bean;
//			System.out.println(emp);
			return emp;
		} else if (beanId.equals("person")) {
			Person person = (Person) bean;
			System.out.println(person);
			return person;
		} else
			return null;
	}
}

4.配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:p="http://www.springframework.org/schema/p"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:util="http://www.springframework.org/schema/util"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util
       http://www.springframework.org/schema/util/spring-util.xsd">
    <bean id="emp01" class="com.life.Emp" init-method="init" destroy-method="destroy">
        <property name="eid" value="15145101"></property>
        <property name="ename" value="Bao Anyin"></property>
        <property name="gender" value="nv"></property>
    </bean>
    
     <bean id="person" class="com.life.Person" init-method="init" destroy-method="destroy">
        <property name="pname" value="Zhang San"></property>
    </bean>
    
    <bean class="com.life.PostProcessor"></bean>
</beans>

5.运行效果

在这里插入图片描述

6.总结

注意多个bean之间one、two、three等的前后顺序
i.通过构造器或工厂方法创建bean实例
ii.为bean的属性设置值和对其他bean的引用
iii.将bean实例传递给bean后置处理器的postProcessBeforeInitialization()方法
iv.调用bean的初始化方法
v.将bean实例传递给bean后置处理器的postProcessAfterInitialization()方法
vi.bean可以使用了
vii.当容器关闭时调用bean的销毁方法

周小敬
关注
专栏目录
Spring5源码5-Bean生命周期后置处理器
java_lujj的博客
08-30 308
BeanPostProcessor 是Spring提供给我们的一个非常重要的扩展接口，并且Spring内部的很多功能也是通过 BeanPostProcessor 来完成的(目前看到最典型的就是 AnnotationAwareAspectJAutoProxyCreator 的 注入)。
Spring IOC容器管理Bean的生命周期以及bean的后置处理器
u010512429的博客
05-27 1541
bean的后置处理器Spring IOC容器可以管理Bean的生命周期，Spring允许在Bean生命周期的特定点执行定制的任务。Spring IOC容器对Bean的生命周期进行管理的过程如下：通过构造器或工厂方法创建Bean实例为Bean的属性设置值和对其他Bean的引用调用Bean的初始化方法(init-method)Bean可以使用了当容器关闭时，调用Bean的销毁方法(destory-me...
Spring之Bean的生命周期以及Bean后置处理器
qq_38409944的博客
09-13 423
注意： 在Bean的声明离设置init-method和destroy-method属性，为Bean指定初始化和销毁方法。 1. 通过构造器或者工厂方法创建Bean实例 2. 为Bean的属性设置值和对其他Bean的引用 3. 调用Bean的初始化方法 4. 使用Bean 5. 关闭容器的时候 调用Bean的销毁方法 举例： &lt;bean id="getHello" cla...
Spring后置处理器总结
zealon的博客
05-24 548
1、BeanFactoryPostProcessor 用来处理BeanFactory中Bean属性的后置处理器，也就是说在Bean初始化之前，Spirng提供了一个钩子可以让你根据自己的实际情况修改Bean的属性，最常见的应用就是我们的Bean中会有一些占位符，那么在Bean实例化之前这些占位符肯定是要被实际的配置参数填充的，这个填充的过程就是通过BeanFactoryPostProcessor的后置处理完成的 @FunctionalInterface public interface BeanFac
Bean生命周期+后置处理器
懒人记录处
12-06 513
生命周期 详细：https://blog.csdn.net/w_linux/article/details/80086950 摘要： 1.实例化bean对象(通过构造方法或者工厂方法) 2.设置对象属性(setter等)（依赖注入） 3.如果Bean实现了BeanNameAware接口，工厂调用Bean的setBeanName()方法传递Bean的ID。（和下面的一条均属于检查Awa...
Spring源码学习之Spring Bean的生命周期以及Spring后置处理器
小宝-的博客
01-05 190
最近在学习Spring源码，整理一些学习笔记，希望能够帮助自己结构化的梳理知识，如果凑巧能帮助到大家，无上荣幸。当然笔记中会有我自己一些理解性的内容，可能出现不全面甚至错误的东西，大家甄别后谨慎参考哈。 既然是Spring Bean的生命周期管理先说明下什么是Spring Bean，他和普通的java类有什么区别，我的理解是Spring Bean是通过Spring容器在保留我们自己写的业务代码原有...
spring中bean的生命周期详解
08-26
Spring框架是当前Java EE开发中最流行的框架之一，Spring框架中Bean的生命周期是指从创建到销毁的整个过程。在这个过程中，Spring IOC容器对Bean的生命周期进行管理，使得开发者可以在特定的时间点执行指定的任务。...
spring源码-bean的后置处理器
路漫漫其修远兮，吾将上下而求索。
12-12 747
bean的后置处理器
Spring(七)——Bean的生命周期和后置处理器
flunggg的博客
07-16 836
1.Bean的生命周期 Spring IOC 容器可以管理 Bean 的生命周期, Spring 允许在 Bean 生命周期的特定点执行定制的任务. Spring IOC 容器对 Bean 的生命周期进行管理的过程: 通过构造器或工厂方法创建 Bean 实例 为 Bean 的属性设置值和对其他 Bean 的引用 调用 Bean 的初始化...
Spring的Bean的生命周期和Bean的后置处理器
qq_43687990的博客
10-11 168
1.Spring IOC容器可以管理Bean的声明周期，Spring允许在Bean的生命周期的特定点执行定制的任务。 2.Spring IOC容器对Bean的生命周期进行管理的过程： (1)通过构造器或工厂方法创建Bean的实例 (2)为Bean的属性设置值和对其他Bean的引用 (3)调用Bean的初始化方法 (4)Bean可以使用 (5)当容器关闭时，调用Bean的销毁方法 3.在Bean的声...
Bean生命周期及后处理器
qq_40102411的博客
04-09 328
Bean生命周期及后处理器 SpringBean生命周期 我们先手写一个Bean @Component public class UserBean { public UserBean() { System.out.println("1.执行了构造方法"); } @Autowired public void autowire(@Value("by www.dazuizui.com")String home){ System.out.printl
bean的生命周期（含后置处理器）
qq_42388853的博客
08-30 251
bean的生命周期 我们先讲不含后置处理器的： (1）通过构造器创建bean实例（无参数构造） (2）为bean的属性设置值和对其他bean引用（调用set方法） (3）调用bean的初始化的方法（需要进行配置初始化的方法）。 (4) bean可以使用了对象获取到了). (5）当容器关闭时候，调用bean的销毁的方法（需要进行配置销毁的方法） 先创建一个我们要调用的bean 然后我会在各个步骤上进行输出。 package cn.zsp.spring5.bean; public class Order {
学习Spring-生命周期&bean的后置处理器
foldingairplane的博客
09-30 120
Spring IOC 容器可以管理 Bean 的生命周期, Spring 允许在 Bean 生命周期的特定点执行定制的任务。举一个简单的例子 Bean 的生命周期 1）你需要创建Person.java和Main.java 首先是是Person.java，注意 init（）与destory（） package com.spring.day03; public class Person {...
spring中Bean后置处理器实现总结
weixin_34247155的博客
01-09 111
BeanPostProcessor接口 bean的后置处理器实现功能主要是 可以在bean初始化之前和之后做增强处理。自定义MyBeanProcessor实现BeanPostProcessor接口，重写里面的postProcessBeforeInitialization和postProcessAfterInitialization方法，这里两个方法的主要是用来bean初始化（init方法）之前和之...
总结Spring中工厂后处理器
chyohn的博客
02-14 2243
工厂处理器是一种特殊的Bean，这种Bean并不对外提供服务，它甚至可以无需id属性，它主要负责对容器本身进行某些特殊的处理。Spring中有两类工厂后处理器，一个是BeanFactoryPostProcessor，它是所有工厂后处理器的顶层接口；另一个是BeanDefinitionRegistryPostProcessor，它继承自BeanFactoryPostProcessor，设计它的目的是使
Spring 学习之扩展点总结之后置处理器（一）
qq_19283249的博客
09-26 1708
本文用 Spring-framework-5.x 版本，Spring 源码用的是 Gradle 管理的，下载源码用 Gradle 进行编译即可在开发工具（idea）里面进行测试。我们平时使用 new 关键字来实例化一个 Class，得到的就是一个实例对象。
spring基础再学习-----------Bean的后置处理器概念
weixin_41762316的博客
08-26 207
Sping每次在创建一个bean的时候都会进行初始化 （init），在传统的老的SSH或者SSM的框架下，一般常见的有两种方法来进行初始化和销毁的重写。这两个方法类似于Servlet的方法。 我们必须明确bean的后置处理器其实跟【销毁】的方法可没多大的关系。它的作用域只是限于每一个bean的初始化【前后】进行程序设定。 来看一下简单的demo结构： Bean1.xml <?x...
Spring学习笔记--高级特性之后置处理器(SpringBean的生命周期)
qq_40977467的博客
05-19 250
Spring学习笔记–高级特性之后置处理器 Spring提供了两种后处理bean的扩展接⼝，分别为 BeanPostProcessor 和BeanFactoryPostProcessor，两者在使⽤上是有所区别的。 工厂初始化（BeanFactory）—> Bean对象 在BeanFactory初始化之后可以使⽤BeanFactoryPostProcessor进⾏后置处理做⼀些事情 在Bean对象实例化（并不是Bean的整个⽣命周期完成）之后可以使⽤BeanPostProcessor进⾏后置处理做⼀些
spring bean生命周期前置后置
最新发布
09-08
总结起来，Spring提供了多种方式来管理Bean的生命周期，包括前置处理和后置处理。通过实现InitializingBean和DisposableBean接口、使用注解@PostConstruct和@PreDestroy、以及使用BeanFactoryPostProcessor和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值