一文看懂 BeanFactoryPostProcessor 与 BeanPostProcessor 接口

最新推荐文章于 2025-05-11 01:22:34 发布
最新推荐文章于 2025-05-11 01:22:34 发布
阅读量898 收藏 17
点赞数 23
文章标签： java spring springboot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_46425661/article/details/144420284
版权

文章目录

BeanFactoryPostProcessor接口

BeanFactoryPostProcessor 接口允许我们在Spring容器加载Bean定义之后、Bean实例化之前修改这些Bean定义。它通常用于动态修改配置元数据（如XML配置文件或注解配置）。

org.springframework.beans.factory.config.BeanFactoryPostProcessor

/**
 * Factory hook that allows for custom modification of an application context's
 * bean definitions, adapting the bean property values of the context's underlying
 * bean factory.
 * Factory 钩子，允许自定义修改应用程序上下文的 bean 定义，调整上下文的基础 bean 工厂的 bean 属性值
 */
@FunctionalInterface
public interface BeanFactoryPostProcessor {

    /**
     * Modify the application context's internal bean factory after its standard
     * initialization. All bean definitions will have been loaded, but no beans
     * will have been instantiated yet. This allows for overriding or adding
     * properties even to eager-initializing beans.
     *
     * 在标准初始化后修改应用程序上下文的内部 Bean 工厂。
     * 所有 bean 定义都已加载，但尚未实例化任何 bean。这允许覆盖或添加属性，甚至允许预先初始化 bean。
     */
    void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;

}

工作原理

当 Spring 容器加载配置文件（如 XML 配置文件或 Java 配置类）时，在所有 Bean 定义被加载后，会调用所有实现了 BeanFactoryPostProcessor 接口的类的postProcessBeanFactory方法。
这个方法接收一个ConfigurableBeanFactory类型的参数，通过这个参数可以访问和修改 Bean 工厂中的 Bean 定义。

使用场景

  • 修改Bean定义属性。
  • 修改Bean之间的依赖关系。
  • 添加或移除某些Bean定义。
  • 解析并处理自定义标签。

代码示例

可以自定义的 BeanFactoryPostProcessor 实现类，对Bean进行处理。

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

/**
 * @author qf
 * @since 2024/10/16 19:58
 */
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        // 获取名为user的Bean定义
        if (beanFactory.containsBeanDefinition("user")) {
            // 修改user的属性值
            beanFactory.getBeanDefinition("user").getPropertyValues().add("id", 10001L);
        }
        // 拿到所有 bean 的名称
        String[] beanNames = beanFactory.getBeanDefinitionNames();
        for (String beanName : beanNames) {
            // 对每个Bean进行处理
            System.out.println("对BeanDefinition: " + beanName +"，进行处理");
        }
    }
}

User实体类

public class User {
    private Long id;
    private String name;
    private Integer age;

    public User() {
    }

    public User(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

beans.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="user" class="com.qf.entity.User">
        <property name="name" value="zhangsan"></property>
        <property name="age" value="1"></property>
    </bean>

    <bean class="com.qf.config.MyBeanFactoryPostProcessor"></bean>
    <bean class="com.qf.config.MyBeanPostProcessor"></bean>
</beans>

测试类

    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        User user = (User) context.getBean("user");
        System.out.println();
    }

BeanPostProcessor接口

BeanPostProcessor 接口允许我们在Spring容器实例化Bean之后但在初始化前后对Bean进行处理。它可以在Bean对象实例化后对其进行增强或修改，例如设置额外的属性、包装Bean等。
org.springframework.beans.factory.config.BeanPostProcessor

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;
    }

}

其中的两个方法

  • postProcessBeforeInitialization：在Bean的初始化方法（如@PostConstruct或InitializingBean的afterPropertiesSet）调用之前执行。
  • postProcessAfterInitialization：在Bean的初始化方法调用之后执行。

工作原理

对于 Spring 容器中的每个 Bean 实例化之后、初始化（调用init - method等）之前。
会先调用BeanPostProcessor接口的postProcessBeforeInitialization方法；
在 Bean 初始化之后，会调用postProcessAfterInitialization方法。这样就可以在 Bean 的生命周期的关键节点进行干预。

使用场景

  • 在Bean初始化前后执行一些预处理和后处理操作。
  • 包装或代理Bean，例如通过AOP实现切面编程。
  • 设置Bean的额外属性或行为。

代码示例

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

/**
 * @author qf
 * @since 2024/10/16 19:58
 */
public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        // 在Bean初始化之前进行处理
        if (beanName.equals("user")) {
            System.out.println(beanName + "bean 初始化之前");
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        // 在Bean初始化之后进行处理
        if (beanName.equals("user")) {
            System.out.println(beanName + "bean 初始化之后");
        }
        return bean;
    }
}

两者在生命周期中的顺序

以下是Spring容器启动时的主要生命周期事件顺序：

  1. 读取配置文件或注解。
  2. 加载Bean定义。
  3. 调用 BeanFactoryPostProcessor.postProcessBeanFactory()。
  4. 创建Bean实例。
  5. 设置Bean属性。
  6. 调用 BeanPostProcessor.postProcessBeforeInitialization()。
  7. 调用Bean的初始化方法（如@PostConstruct或InitializingBean.afterPropertiesSet）。
  8. 调用 BeanPostProcessor.postProcessAfterInitialization()。
  9. 使用Bean。
  10. 销毁Bean（如果容器关闭）。

总结

两者的区别

  • BeanFactoryPostProcessor：
    • 在Bean定义加载之后但在Bean实例化之前工作。
    • 主要用于修改Bean定义或解析自定义标签。
    • 影响的是Bean定义层面，而不是具体的Bean实例。
    • BeanFactoryPostProcessor操作的是BeanFactory(接口)，主要是对 Bean 定义进行操作
  • BeanPostProcessor：
    • 在Bean实例化之后但在初始化前工作。
    • 主要用于对已经实例化的Bean进行增强或修改。
    • 影响的是具体的Bean实例，而不是Bean定义。
    • BeanPostProcessor操作的是Bean(对象)，是在 Bean 实例的生命周期阶段进行操作。

两者的联系

  • 目的相同：
    • 它们都是 Spring 框架提供的扩展点，用于对 Spring 容器的行为进行定制化。
    • 无论是修改 Bean 定义还是在 Bean 生命周期阶段进行干预，都是为了满足应用在特定场景下的需求。
    • 比如自定义配置加载、AOP（Aspect - Oriented - Programming）代理的创建等场景。
  • 在 Spring 容器中的起到协同作用：
    • 在 Spring 容器的启动和 Bean 的生命周期管理过程中，这两个接口的实现类会按照先后顺序协同工作。
    • 首先是 BeanFactoryPostProcessor 对 Bean 定义进行调整，然后 Bean 实例化后，BeanPostProcessor 再对 Bean 实例进行处理。
    • 两者共同完成对 Spring 容器内的 Bean 从定义到实例化、初始化的完整定制化过程。
齐 飞
关注
BeanFactoryPostProcessor和BeanPostProcessor
ruangongtaotao的专栏
01-29 981
从上面的实现可以看出，先调用applyBeanPostProcessorsBeforeInitialization方法，执行每个BeanPostProcessor的postProcessBeforeInitialization，然后调用invokeInitMethods方法，执行bean的初始化方法，最后调用applyBeanPostProcessorsAfterInitialization方法，执行每个BeanPostProcessor的postProcessAfterInitialization方法。
Spring的BeanFactoryPostProcessor和BeanPostProcessor的使用
madman
01-04 6419
BeanFactoryPostProcessor是用来处理修改bean定义信息的后置处理器，这个时候bean还没有初始化，只是定好了BeanDefinition，在BeanFactoryPostProcessor接口的postProcessBeanFactory方法中，我们可以修改bean的定义信息，例如修改属性的值，修改bean的scope为单例或者多例。 BeanPostProcessor则...
BeanFactoryPostProcessor
04stone37
07-17 212
作用 　　在BeanFactory加载完所有bean定义后，对BeanFactory进行逻辑增强； public interface BeanFactoryPostProcessor { /** * Modify the application context's internal bean factory after its standard * initial...
Spring BeanFactoryPostProcessor：机制解读与代码实践
最新发布
qq_45464560的博客
05-11 972
BeanFactoryPostProcessor是Spring框架中的一个关键扩展点（位于org.springframework.beans.factory.config包），其核心功能是在Bean实例化之前修改Bean的配置元数据（即BeanDefinition）。通过该接口，开发者可以在容器启动时动态调整Bean属性（如作用域、懒加载、属性值）、注册新的Bean定义，甚至替换现有Bean的实现类
spring深入学习（二十七）IOC 之 深入分析 BeanFactoryPostProcessor
咖啡的博客
12-16 245
在博客 【死磕 Spring】—– IOC 之 深入分析 BeanPostProcessor 深入介绍了 BeanPostProcessor 的实现机制。在这篇文章中提到 BeanPostProcessor 是 Spring 提供一种扩展机制，该机制允许我们在 Bean 实例化之后初始化之际对 Bean 进行增强处理（前、后置处理）。同样在 Spring 容器启动阶段，Spring 也提供了一种容...
com-spring-ioc-demo:源码主要是学习Spring IOC的原理，以及对Bean的注册及控制，主要运用以下类对Spring进行扩展学习：BeanPostProcessor，BeanFactoryAware，BeanNameAware，ApplicationContextAware，FactoryBean，BeanDefinitionRegistryPostProcessor，BeanFactoryPostProcessor，BeanPostProcessor，ResourceLoaderA
03-22
BeanDefinitionRegistryPostProcessor，BeanFactoryPostProcessor，BeanPostProcessor，ResourceLoaderAware，InvocationHandler。 BeanPostProcessor接口的实现类如何被注册到Spring容器2.更改bean的定义...
Spring BeanPostProcessor接口使用详解
08-28
此外，Spring框架还提供了其他类型的后处理器接口，例如BeanFactoryPostProcessor和BeanValidationPostProcessor等，这些接口也可以用于实现各种Bean处理需求。 BeanPostProcessor接口是一个非常有用的工具，能够...
Spring核心模块—— BeanFactoryPostProcessor&&BeanPostProcessor（后处理器）
左灯右行的爱情
03-05 1453
加油
4-BeanFactoryPostProcessor
weixin_44215154的博客
06-08 193
BeanFactoryPostProcessor BeanFactory 的 后置处理器 bean 创建之前执行 BeanDefinitionRegistryPostProcessor 执行时机，先执行 BeanDefinitionRegistryPostProcessor . postProcessBeanDefinitionRegistry spring 容器的 refresh() 创建刷新 1、prepareRefresh(); 1.initPropertySources(); 初始化属性
Spring Boot之BeanFactoryPostProcessor
诗人不写诗
06-06 675
本章源码基于Spring Boot 2.2.8Spring容器刷新的过程中有一步是执行所有的BeanFactoryPostProcessor，对于用户来说，这是Spring提供的hook，对于Spring来说，这是提供给第三方的SPI。
Spring之BeanFactoryPostProcessor
好记性不如烂笔头
12-02 1299
什么是BeanFactoryPostProcessor,并且举例说明BeanFactoryPostProcessor常用功能,以及BeanFactoryPostProcessor在源码中的执行顺序
【Spring（七）】BeanFactoryPostProcessor
u010900754的专栏
08-18 277
先回顾下spring高级容器中最重要的方法refresh： 先构建一个DefaultListableBeanFactory容器实例，内部会注册一次bean； 再调用postProcessBeanFactory方法及invokeBeanFactoryPostProcessors方法，这里是spring的一个扩展点：BeanFactoryPostProcessor接口。因为之前已经注册过一次bea...
Spring-beans-BeanFactoryPostProcessor
文天大人
10-10 427
喜欢江浙的妹子，热爱湘鄂的妹子
10.BeanFactoryPostProcessor
qq_30635523的博客
05-24 226
highlight: arduino-light BeanFactoryPostProcessor 前几篇我们详细讲解了BeanDefinition的源码，我们知道spring扫描符合规则的业务类后会通过 AnnotatedBeanDefinitionReader和ClassPathBeanDefinitionScanner将业务类封装成BeanDefinition保存在IOC容器中，那么...
BeanFactoryPostProcessor 和 BeanPostProcessor
lhg_55的博客
08-22 1362
这种写法实际上就是一个自定义标签，在这个标签中，会进行一些默认的 Bean 属性的配置，但是，一般来说，这些属性，如果想要自己去配置，也是可以的，比如。后置处理器，在这个后置处理器中，会找到所有的 ${} 格式的 value，并将之替换为真正的值，后面再去创建 bean 的时候，用到的就是真实的值了。这个属性配置的含义表示，对于无法解析的 value，就不解析（默认情况下，如果遇到无法解析的 value，会抛出异常）。创建完毕，Bean 尚未创建的时候，想要去修改 Bean 的属性，那么就可以通过。
Spring核心 - BeanFactoryPostProcessor
u014365523的博客
07-12 280
BeanFactoryPostProcessor 工厂后处理器
bean的生命周期中，BeanFactoryPostProcessor和BeanPostProcessor那个先被注入bean中
06-01
BeanFactoryPostProcessor先于BeanPostProcessor被注入bean中。 BeanFactoryPostProcessor是在Spring容器实例化所有Bean并在执行Bean的生命周期方法之前调用的。它主要用于修改Bean的定义，比如修改Bean的属性值、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值