代码编织梦想

后置处理 Bean : BeanPostProcessor的使用

在bean对象初始化之前和之后 (bean从容器中返回给我们之前): 来做某些事情

  • BeanPostProcessor 作用:对 Spring 工厂所创建的对象,进行再加工。(AOP 的底层实现)
  • 后置处理 Bean 原理分析
  • 程序员实现 BeanPostProcessor 接口中规定的两个方法:
// bean初始化之前调用
public Object postProcessBeforeInitialization(Object bean, String beanName) {
    return bean;
}

作用:Spring 创建完对象,并进行注入后,可以运行 Before ⽅法进行加工;

通过方法的参数获得 Spring 创建好的对象,最终通过返回值交给 Spring 框架。

// bean初始化之后调用
public Object postProcessAfterInitialization(Object bean, String beanName) {
    return bean;
}

作⽤:Spring 执行完对象的初始化操作后,可以运行 After ⽅法进行加工;

通过方法的参数获得 Spring 创建好的对象,最终通过返回值交给 Spring 框架。
实战中:很少处理 Spring 的初始化操作,没有必要区分 Before,After。只需要实现其中一个,建议是 After 方法即可。

BeanPostProcessor 开发步骤

类实现 BeanPostProcessor 接口


// 在初始化方法之前和之后执行下面两个方法
//@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return null;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        Category category = (Category) bean;
        category.setName("yusael");
        return category;
    }

}

Spring 配置文件中进行配置

  • <bean id="myBeanPostProcessor" class="com.yusael.beanpost.MyBeanPostProcessor"/>
  • 细节:BeanPostProcessor 会对 Spring 工厂创建的所有对象进行加工。如果工厂创建了多个不同的对象,要注意区别传入的对象:
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    if (bean instanceof  Category) {
        Category category = (Category) bean;
        category.setName("yusael");
        return category;
    }
    return bean;
}

在这里插入图片描述

在这里插入图片描述

BeanPostProcessor原理

下面代码可以证明:BeanPostProcessor是在bean初始化前后来做事情

这块代码在initializeBean方法内
在这里插入图片描述

  • 在applyBeanProcessorsBeforeInitialization方法中遍历所有的BeanPostProcessor(包括实现类); 如果返回null, 表示不会执行后面的BeanPostProcessor了; 把所有的BPP在bean初始化之前的操作都执行完
    在这里插入图片描述
  • 执行自定义初始化操作 invokeInitMethods方法
  • 在applyBeanProcessorsAfternitialization方法中遍历所有的BeanPostProcessor(包括实现类); 如果返回null, 表示不会执行后面的BeanPostProcessor了; 把所有的BPP在bean初始化之后的操作都执行完

BeanPostProcessor原理
在这里插入图片描述

BeanPostProcessor在Spring底层的使用

在这里插入图片描述

ApplicationContextAwareProcessor

  • class ApplicationContextAwareProcessor implements BeanPostProcessor

该processor给ApplicationContextAware接口导入了Spring中所有的bean; 我们实现ApplicationContextAware就可以拿到Spring容器中所有的bean

ApplicationContextAwareProcessor会在

class ApplicationContextAwareProcessor implements BeanPostProcessor {

	private final ConfigurableApplicationContext applicationContext;

	private final StringValueResolver embeddedValueResolver;


	/**
	 * Create a new ApplicationContextAwareProcessor for the given context.
	 */
	public ApplicationContextAwareProcessor(ConfigurableApplicationContext applicationContext) {
		this.applicationContext = applicationContext;
		this.embeddedValueResolver = new EmbeddedValueResolver(applicationContext.getBeanFactory());
	}


	@Override
	@Nullable // 在bean初始化之前来执行
	public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException {
		AccessControlContext acc = null;

		if (System.getSecurityManager() != null &&
				(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
						bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
						// 首先判断bean是否实现了ApplicationContextAware
						bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)) {
			acc = this.applicationContext.getBeanFactory().getAccessControlContext();
		}

		if (acc != null) {
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				invokeAwareInterfaces(bean);
				return null;
			}, acc);
		}
		else {
			invokeAwareInterfaces(bean);
		}

		return bean;
	}

	private void invokeAwareInterfaces(Object bean) {
		if (bean instanceof Aware) {
			// ... 省略
			if (bean instanceof MessageSourceAware) {
				((MessageSourceAware) bean).setMessageSource(this.applicationContext);
			}
			// 然后把这个bean转换为ApplicationContextAware, 将IoC容器
//			(this.applicationContext)设置到setApplicationContext()中
			// 所以在我们类实现ApplicationContextAware接口的实现方法中,拿到IoC容器
			if (bean instanceof ApplicationContextAware) {
				((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
			}
		}
	}

	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) {
		return bean;
	}
}

测试

@Component
public class User implements ApplicationContextAware {
    private ApplicationContext ac;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.ac = applicationContext;
    }

    public ApplicationContext getContext() {
        return ac;
    }

    public <Y> Y getBean(Class<Y> clazz) {
        return ac.getBean(clazz);
    }
}
    @Test
    public void test() {
        AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(AppConfig6.class);
//        String[] beanDefinitionNames = ac.getBeanDefinitionNames();
//        for (String name : beanDefinitionNames) {
//            System.out.println(name);
//        }
//        System.out.println(ac.getBean("rainBow"));

        User user = ac.getBean(User.class);
        ApplicationContext context = user.getContext();
        for (String beanDefinitionName : context.getBeanDefinitionNames()) {
            System.out.println(beanDefinitionName);
        }

        System.out.println("-----------------------------");
        Red bean = user.getBean(Red.class);
        System.out.println(bean);
    }


org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
appConfig6
customer
user
red
blue
rainBow
-----------------------------
com.baizhiedu.bean.Red@6c4980d3

除了上面的ApplicationContextAwareProcessor; 还有给bean赋值, 注入其他组件, @Autowird, 生命周期注解, @Async 等 实现的原理; 都是采用xxxBeanPostProcessor来实现的

实现XxxAware, 使用Spring容器底层的一些组件

自定义的组件(bean) 想要使用Spring容器底层的一些组件(ApplicationContext, BeanFactory…等);

  • 我们自定义的组件 实现XxxAware; 实现他们的一些接口方法,
    在创建自定义组件对象的时候, 会调用接口规定的方法注入相关组件

实现XxxAware, 把Spring底层的一些组件注入到自定义的Bean中

@Component
public class TestAware implements ApplicationContextAware, BeanNameAware, EmbeddedValueResolverAware {

    private ApplicationContext applicationContext;

    // 将当前bean的名字返回
    @Override
    public void setBeanName(String s) {
        System.out.printf("当前bean的名字:%s%n", s);
    }

    // 返回IoC容器
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
        System.out.println("IoC容器:" + this.applicationContext);
    }

    // 用来解析Spring中表达式的
    @Override
    public void setEmbeddedValueResolver(StringValueResolver resolver) {
        System.out.println(resolver.resolveStringValue("你好, ${os.name}, my age is #{2 * 12}"));
    }
}
@Test
public void test02() {
    AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(AppConfig7.class);
    TestAware bean = ac.getBean(TestAware.class);
    System.out.println(bean);
}
当前bean的名字:testAware
你好, Mac OS X, my age is 24
IoC容器:org.springframework.context.annotation.AnnotationConfigApplicationContext@7714e963, started on Fri Apr 15 17:49:02 CST 2022

从下面图可以看出, 在bean返回之前就做了对应的处理工作
在这里插入图片描述

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/m0_37989980/article/details/124197936

spring beanpostprocessor后置处理器_一笑而过者也的博客-爱代码爱编程

这个接口有两个方法: public interface BeanPostProcessor { @Nullable default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { return bean;

spring beanpostprocessor 后置处理器学习_tom有了cat的博客-爱代码爱编程

基础概念: 1、实例化—-实例化的过程是一个创建Bean的过程,即调用Bean的构造函数,单例的Bean放入单例池中 2、初始化—-初始化的过程是一个赋值的过程,即调用Bean的setter,设置Bean的属性 sprig  beanPostProcessor 后置处理器主要用于对在对象初始化之前或者在对象初始化之后在这期间可以对对象做一些其他事情,

后置处理器beanpostprocessor_会走的桃子的博客-爱代码爱编程

文章目录 spring-bean生命周期BeanPostProcessorInstantiationAwareBeanPostProcessorSmartInstantiationAwareBeanPostProce

beanpostprocessor后置处理器原理以及applicationlistener原理_码莎拉蒂的博客-爱代码爱编程

BeanPostProcessor:bean后置处理器,bean创建对象初始化前后进行拦截工作的 1、BeanFactoryPostProcessor:BeanFactory的后置处理器;             在BeanFactory标准初始化之后调用;所有的bean定义已经保存加载到BeanFactory,但是bean的实例还没创建;     Be

spring注解---BeanPostProcessor后置处理器-爱代码爱编程

.BeanPostProcessor :bean的后置处理器。         postProcessBeforeInitialization:bean实例被创建之后,初始化方法执行之前被执行         postProcessAfterInitialization:初始化方法执行之后被执行         参数:Object bean:当前实例

09-Spring生命周期-BeanPostProcessor后置处理器-爱代码爱编程

BeanPostProcessor 后置处理器 在 bean 初始化前后做处理,对 bean 初始化方法做了拦截,使用也很简单,新建一个组件实现 BeanPostProcessor 并加入到容器中. BeanPostProcessor 提供了两个方法,实现这两个方法即可: postProcessBeforeInitialization: 在初始化之前

spring--bean后置处理器(BeanPostProcessor)原理解析-爱代码爱编程

文章目录 功能描述:如何使用:定义要处理的接口类型添加实际需要处理的类定义后置处理器编写测试类执行日志后置处理器加载解析registerBeanPostProcessors注册拦截bean创建的后置处理器后置处理器的调用bean实例化前、后的处理调用过程举例谈谈spring内部实现了BeanPostProcessor接口的类BeanPostProc

(十三)生命周期-BeanPostProcessor后置处理器-爱代码爱编程

文章目录 结论先行BeanPostProcessor实现类定义配置类启动类结果原理BeanValidationPostProcessorInitDestroyAnnotationBeanPostProcessorAutowiredAnnotationBeanPostProcessor 结论先行 通过实现BeanPostProcessor接口,

BeanPostProcessor 后置处理器-爱代码爱编程

BeanPostProcessor【interface】:bean的后置处理器; 在bean初始化前后进行一些处理工作;spring底层大量使用; postProcessBeforeInitialization:在初始化之前工作 postProcessAfterInitialization:在初始化之后工作 可以作为Bean初始化前后的回调方法;

BeanPostProcessor后置处理器原理与应用-爱代码爱编程

BeanPostProcessor后置处理器原理与应用 BeanPostProcessor又叫后置处理器,是spring框架极其重要的概念。本身是个接口,接口里面定义了两个方法。许多扩展功能都是基于这种后置处理器的方式来实现的。spring框架会自动识别所有实现BeanPostProcessor接口的实现类,加载到容器中。当容器实例化完具体的一个bean

【SpringBoot_ANNOTATIONS】生命周期 04 BeanPostProcessor 后置处理器-爱代码爱编程

生命周期 04 BeanPostProcessor 后置处理器 BeanPostProcessor是一个接口:bean的后置处理器 在bean初始化前后进行一些处理工作postProcessBeforeInitialization:初始化之前调用postProcessAfterInitialization:初始化之后调用 自定义后置处理器 packa

Spring注解09——BeanPostProcessor后置处理器深度剖析-爱代码爱编程

该系列文章主要学习 雷丰阳老师的《Spring注解驱动》课程总结。 原课程地址:课程地址 包括了自己阅读其他书籍《Spring揭秘》《Spring Boot 实战》等课程。 该系列文档会不断的完善,欢迎大家留言及提意见。 文章目录 1. 写在之前2. BeanPostProcessor 是什么3. xxxBeanPostProc

BeanPostProcessor后置处理器的快速(初级)入门 详细例子说明如何使用-爱代码爱编程

BeanPostProcessor后置处理器,可以在bean实例化的时候执行自己加上的逻辑。 BeanPostProcessor 是接口: public interface BeanPostProcessor { @Nullable // 在bean实例化,执行特定init方法之前被执行 default Object post