【Spring注解驱动开发】BeanPostProcessor在Spring底层是如何使用的？看完这篇我懂了！！

最新推荐文章于 2024-09-27 20:07:43 发布

weixin_Vip1104z

最新推荐文章于 2024-09-27 20:07:43 发布

阅读量339

点赞数 4

分类专栏：程序员文章标签： spring java 后端

本文链接：https://blog.csdn.net/weixin_42179304/article/details/137910955

版权

程序员专栏收录该内容

484 篇文章 0 订阅

订阅专栏

==========================================================

项目工程源码已经提交到GitHub：https://github.com/sunshinelyz/spring-annotation

BeanPostProcessor接口

我们先来看下BeanPostProcessor接口的源码，如下所示。

package org.springframework.beans.factory.config;

import org.springframework.beans.BeansException;

import org.springframework.lang.Nullable;

public interface BeanPostProcessor {

@Nullable

default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {

return bean;

}

@Nullable

default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {

return bean;

}

可以看到，在BeanPostProcessor接口中，提供了两个方法：postProcessBeforeInitialization()方法和postProcessAfterInitialization()方法。postProcessBeforeInitialization()方法会在bean初始化之前调用，postProcessAfterInitialization()方法会在bean初始化之后调用。接下来，我们就分析下BeanPostProcessor接口在Spring中的实现。

注意：这里，我列举几个BeanPostProcessor接口在Spring中的实现类，来让大家更加清晰的理解BeanPostProcessor接口在Spring底层的应用。

ApplicationContextAwareProcessor类

org.springframework.context.support.ApplicationContextAwareProcessor是BeanPostProcessor接口的实现类，这个类的作用是可以向组件中注入IOC容器，大致的源码如下所示。

package org.springframework.context.support;

import java.security.AccessControlContext;

import java.security.AccessController;

import java.security.PrivilegedAction;

import org.springframework.beans.BeansException;

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

import org.springframework.beans.factory.config.EmbeddedValueResolver;

import org.springframework.context.ApplicationContextAware;

import org.springframework.context.ApplicationEventPublisherAware;

import org.springframework.context.ConfigurableApplicationContext;

import org.springframework.context.EmbeddedValueResolverAware;

import org.springframework.context.EnvironmentAware;

import org.springframework.context.MessageSourceAware;

import org.springframework.context.ResourceLoaderAware;

import org.springframework.lang.Nullable;

import org.springframework.util.StringValueResolver;

class ApplicationContextAwareProcessor implements BeanPostProcessor {

/****省略N多行代码/

}

这里，省略了源码的细节，只给出了类结构，感兴趣的小伙伴们可自行翻阅Spring源码进行查看，我这里的Spring版本为5.2.6.RELEASE。

那具体如何使用ApplicationContextAwareProcessor类向组件中注入IOC容器呢？别急，我用一个例子来说明下，相信小伙伴们看完后会有一种豁然开朗的感觉——哦，原来是它啊，我之前在项目中使用过的！

要想使用ApplicationContextAwareProcessor类向组件中注入IOC容器，我们就不得不提Spring中的另一个接口：ApplicationContextAware，如果需要向组件中注入IOC容器，可以使组件实现ApplicationContextAware接口。

例如，我们创建一个Employee类，使其实现ApplicationContextAware接口，此时，我们需要实现ApplicationContextAware接口的setApplicationContext()方法，在setApplicationContext()方法中有一个ApplicationContext类型的参数，这个就是IOC容器对象，我们可以在Employee类中定义一个ApplicationContext类型的成员变量，然后在setApplicationContext()方法中为这个成员变量赋值，此时就可以在Employee中的其他方法中使用ApplicationContext对象了，如下所示。

package io.mykit.spring.plugins.register.bean;

import org.springframework.beans.BeansException;

import org.springframework.context.ApplicationContext;

import org.springframework.context.ApplicationContextAware;

import org.springframework.stereotype.Component;

/**

@author binghe
@version 1.0.0
@description 测试ApplicationContextAware

@Component

public class Employee implements ApplicationContextAware {

private ApplicationContext applicationContext;

@Override

public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {

this.applicationContext = applicationContext;

}

看到这里，相信不少小伙伴们都有一种很熟悉的感觉：没错，我之前也在项目中使用过！是的，这就是BeanPostProcessor在Spring底层的一种使用场景。至于上面的案例代码为何会在setApplicationContext()方法中获取到ApplicationContext对象，这就是ApplicationContextAwareProcessor类的功劳了！

接下来，我们就深入分析下ApplicationContextAwareProcessor类。

我们先来看下ApplicationContextAwareProcessor类中对于postProcessBeforeInitialization()方法的实现，如下所示。

@Override

@Nullable

public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {

if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||

bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||

bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)){

return bean;

}

AccessControlContext acc = null;

if (System.getSecurityManager() != null) {

acc = this.applicationContext.getBeanFactory().getAccessControlContext();

}

if (acc != null) {

AccessController.doPrivileged((PrivilegedAction) () -> {

invokeAwareInterfaces(bean);

return null;

}, acc);

}

else {

invokeAwareInterfaces(bean);

}

return bean;

}

在bean初始化之前，首先对当前bean的类型进行判断，如果当前bean的类型不是EnvironmentAware，不是EmbeddedValueResolverAware，不是ResourceLoaderAware，不是ApplicationEventPublisherAware，不是MessageSourceAware，也不是ApplicationContextAware，则直接返回bean。如果是上面类型中的一种类型，则最终会调用invokeAwareInterfaces()方法，并将bean传递给invokeAwareInterfaces()方法。invokeAwareInterfaces()方法又是个什么鬼呢？我们继续看invokeAwareInterfaces()方法的源码，如下所示。

private void invokeAwareInterfaces(Object bean) {

if (bean instanceof EnvironmentAware) {

((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());

}

if (bean instanceof EmbeddedValueResolverAware) {

((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);

}

if (bean instanceof ResourceLoaderAware) {

((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);

}

if (bean instanceof ApplicationEventPublisherAware) {

((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);

}

if (bean instanceof MessageSourceAware) {

((MessageSourceAware) bean).setMessageSource(this.applicationContext);

}

if (bean instanceof ApplicationContextAware) {

((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);

}

可以看到invokeAwareInterfaces()方法的源码比较简单，就是判断当前bean属于哪种接口类型，则将bean强转为哪种接口类型的对象，然后调用接口的方法，将相应的参数传递到接口的方法中。这里，我们在创建Employee类时，实现的是ApplicationContextAware接口，所以，在invokeAwareInterfaces()方法中，会执行如下的逻辑代码。

if (bean instanceof ApplicationContextAware) {

((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);

}

我们可以看到，此时会将this.applicationContext传递到ApplicationContextAware接口的setApplicationContext()方法中。所以，我们在Employee类中的setApplicationContext()方法中就可以直接接收到ApplicationContext对象了。

我们也可以在IDEA中通过Debug的形式来看一下程序的执行过程，此时我们在Employee类的setApplicationContext()方法上设置断点，如下所示。

在这里插入图片描述

接下来，我们以Debug的方式来运行SpringBeanTest类的testAnnotationConfig2()方法，运行后的效果如下图所示。

在这里插入图片描述

在IDEA的左下角可以看到方法的调用堆栈，通过对方法调用栈的分析，我们看到在执行Employee类中的setApplicationContext()方法之前，执行了ApplicationContextAwareProcessor类的invokeAwareInterfaces方法，如下所示。

在这里插入图片描述

当我们点击方法调用栈中的invokeAwareInterfaces()方法时，代码的执行定位到如下一行代码。

((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);

和我们之前分析的逻辑一致。

BeanValidationPostProcessor类

org.springframework.validation.beanvalidation.BeanValidationPostProcessor类主要是用来为bean进行校验操作，当我们创建bean，并为bean赋值后，我们可以通过BeanValidationPostProcessor类为bean进行校验操作。BeanValidationPostProcessor类的结构如下所示。

package org.springframework.validation.beanvalidation;

import java.util.Iterator;

import java.util.Set;

import javax.validation.ConstraintViolation;

import javax.validation.Validation;

import javax.validation.Validator;

import javax.validation.ValidatorFactory;

import org.springframework.aop.framework.AopProxyUtils;

import org.springframework.beans.BeansException;

import org.springframework.beans.factory.BeanInitializationException;

import org.springframework.beans.factory.InitializingBean;

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