BeanFactoryPostProcessor

最新推荐文章于 2024-11-10 08:43:33 发布
最新推荐文章于 2024-11-10 08:43:33 发布
阅读量107 收藏
点赞数
文章标签： java
原文链接：http://www.cnblogs.com/wolfdriver/p/10573395.html
版权

目录

1 使用

示例：去除Spring容器中潜在的敏感词信息，例如bean定义中过滤"zxt"、"sb"等词。

1.1 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="customBeanFactoryPost" class="com.test.CustomBeanFactoryPostProcessor">
        <property name="obs">
            <set>
                <value>zxt</value>
                <value>sb</value>
            </set>
        </property>
    </bean>
    <bean id="u1" class="com.test.UserPO" >
        <property name="userName" value="sb" />
        <property name="email" value="zxt@163.com" />
        <property name="address" ref="testAddr" />
    </bean>
    <bean id="testAddr" class="com.test.Address" >
        <property name="desc" value="testDesc" />
        <property name="detail" value="testDetail" />
    </bean>
</beans>

1.2 POJO：UserPo

public class UserPO {
    private String userName;
    private String email;
    private Address address;
    // setter, getter
}

public class Address {
    private String desc;
    private String detail;
    // setter, getter
}

1.3 BeanFactoryPostProcessor

public class CustomBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    private Set<String> obs;
    public CustomBeanFactoryPostProcessor() {
        obs = new HashSet<>();
    }

    /// 数据解析
    private StringValueResolver valueResolver = (strVal) -> {
        if (obsContainValue(strVal)) {
            return "******";
        }
        return strVal;
    };

    //将所有bean 的参数中含有 obs 集合中的值进行屏蔽
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {


        String[] beanNames = beanFactory.getBeanDefinitionNames();
        for (String beanName : beanNames) {
            BeanDefinition bd = beanFactory.getBeanDefinition(beanName);
            BeanDefinitionVisitor visitor = new BeanDefinitionVisitor(valueResolver);
            visitor.visitBeanDefinition(bd);
        }

    }
    private boolean obsContainValue(String value) {
        String strValue = value.toLowerCase();
        return this.obs.contains(strValue);
    }
    public void setObs(Set<String> obs) {
        this.obs.clear();
        for (String ob : obs) {
            this.obs.add(ob.toLowerCase());
        }
    }
}

1.4 测试

public static void main(String[] args) {
    ApplicationContext ac = new ClassPathXmlApplicationContext("custom-post.xml");
    UserPO userPO = (UserPO) ac.getBean("u1");
    System.out.println(userPO);
}

2 源码分析

2.1 简介

BeanFactoryPostProcessor是在AbstractApplicationContext扩展中实现的。在Spring容器实例化Bean之前的操作，是一个容器级别的处理器。

在Spring中使用的${userName}的引用变量就是通过BeanFactoryPostProcessor实现的，即PropertyPlaceholderConfigurer。

2.2 源码

AbstractApplicationContext#refresh()方法中，会获取beanFactory的所有BeanFactoryPostProcessor并进行调用

public void refresh() throws BeansException, IllegalStateException {
    // 执行BeanFactory中的所有BeanFactoryPostProcessor
    invokeBeanFactoryPostProcessors(beanFactory);
}

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
    // Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
    // (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
    if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }
}

执行BeanFactoryPostProcessor委托给了PostProcessorRegistrationDelegate类来实现。
对于BeanFactoryPostProcessor的处理分为2种情况：

  • 特殊的BeanDefinitionRegistryPostProcessor
  • 常规的BeanFactoryPostProcessor

无论是哪种情况，都需要考虑两种情况：

  • 硬编码注册后置处理器

    硬编码注册的后处理器主要通过：AbstractApplicationContext#addBeanFactoryPostProcessor()

  • 通过配置注入的后置处理器
public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

    Set<String> processedBeans = new HashSet<String>();
    if (beanFactory instanceof BeanDefinitionRegistry) {
        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
        // 记录通过硬编码方式注册的BeanFactoryPostProcessor
        List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>();
        // 记录通过硬编码方式注册的BeanDefinitionRegistryPostProcessor
        List<BeanDefinitionRegistryPostProcessor> registryPostProcessors = new LinkedList<BeanDefinitionRegistryPostProcessor>();
        for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
            if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                BeanDefinitionRegistryPostProcessor registryPostProcessor = (BeanDefinitionRegistryPostProcessor) postProcessor;
                registryPostProcessor.postProcessBeanDefinitionRegistry(registry);
                registryPostProcessors.add(registryPostProcessor);
            } else {
                regularPostProcessors.add(postProcessor);
            }
        }
        // 获取所有通过配置文件注入的BeanDefinitionRegistryPostProcessor类
        String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        
        // 1.执行实现PriorityOrdered的所有BeanDefinitionRegistryPostProcessor
        List<BeanDefinitionRegistryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();
        for (String ppName : postProcessorNames) {
            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                processedBeans.add(ppName);
            }
        }
        sortPostProcessors(beanFactory, priorityOrderedPostProcessors);
        registryPostProcessors.addAll(priorityOrderedPostProcessors);
        invokeBeanDefinitionRegistryPostProcessors(priorityOrderedPostProcessors, registry);
        // 2.执行实现Ordered的所有BeanDefinitionRegistryPostProcessor
        postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        List<BeanDefinitionRegistryPostProcessor> orderedPostProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();
        for (String ppName : postProcessorNames) {
            if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
                orderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                processedBeans.add(ppName);
            }
        }
        sortPostProcessors(beanFactory, orderedPostProcessors);
        registryPostProcessors.addAll(orderedPostProcessors);
        invokeBeanDefinitionRegistryPostProcessors(orderedPostProcessors, registry);
        // 3.执行其他所有的BeanDefinitionRegistryPostProcessor
        boolean reiterate = true;
        while (reiterate) {
            reiterate = false;
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            for (String ppName : postProcessorNames) {
                if (!processedBeans.contains(ppName)) {
                    BeanDefinitionRegistryPostProcessor pp = beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class);
                    registryPostProcessors.add(pp);
                    processedBeans.add(ppName);
                    pp.postProcessBeanDefinitionRegistry(registry);
                    reiterate = true;
                }
            }
        }
        invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory);
        invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
    } else {
        invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
    }

    // 获取所有配置注入的BeanFactoryPostProcessor，并执行
    String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
    List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
    List<String> orderedPostProcessorNames = new ArrayList<String>();
    List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
    for (String ppName : postProcessorNames) {
        if (processedBeans.contains(ppName)) {
            // skip - already processed in first phase above
        } else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
        } else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            orderedPostProcessorNames.add(ppName);
        } else {
            nonOrderedPostProcessorNames.add(ppName);
        }
    }
    sortPostProcessors(beanFactory, priorityOrderedPostProcessors);
    invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
    List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
    for (String postProcessorName : orderedPostProcessorNames) {
        orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    sortPostProcessors(beanFactory, orderedPostProcessors);
    invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
    List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
    for (String postProcessorName : nonOrderedPostProcessorNames) {
        nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

    beanFactory.clearMetadataCache();
}

转载于:https://www.cnblogs.com/wolfdriver/p/10573395.html

dehubiao4740
关注
Spring注解驱动扩展原理BeanFactoryPostProcessor
08-19
Spring注解驱动扩展原理BeanFactoryPostProcessor Spring框架中的BeanFactoryPostProcessor是一个非常重要的扩展点，它允许开发者在BeanFactory标准初始化之后对其进行定制和修改。下面我们将详细介绍...
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源码阅读(三)-AbstractApplicationContext#invokeBeanFactoryPostProcessors
Java部落格
01-11 146
一、BeanFactoryPostProcessor 1、BeanFactoryPostProcessor 接口是 Spring 初始化 BeanFactory 时对外暴露的扩展点，Spring IoC 容器允许 BeanFactoryPostProcessor 在容器实例化任何 bean 之前读取 bean 的定义，并可以修改它。 2、BeanDefinitionRegistryPostProcessor 继承自 BeanFactoryPostProcessor，比 BeanFactoryPostP
BeanFactoryPostProcessor类的运用
做互联网行业中的顶梁柱，认真学习，虚心求教
09-07 206
package com.spring.ch04; import org.springframework.beans.factory.config.BeanFactoryPostProcessor; import org.springframework.beans.factory.config.ConfigurableListableBeanFactory; import org.spri...
spring4.1.8扩展实战之五：改变bean的定义(BeanFactoryPostProcessor接口)
程序员欣宸的博客
08-29 1万+
本章我们继续实战spring的扩展能力，通过自定义BeanFactoryPostProcessor接口的实现类，来对控制bean实例做一些控制； 原文地址：https://blog.csdn.net/boling_cavalry/article/details/82083889 BeanFactoryPostProcessor接口简介 spring容器初始化时，从资源中读取到bean的相...
Spring经典扩展接口应用：BeanFactoryPostProcessor
热门推荐
张彦峰的博客
04-17 1万+
对BeanFactoryPostProcessor基本知识总结，并给出框架中的应用举例分析，再次给出扩展应用代码举例和一些建议，最后简单分析对应的源码分析
BeanFactoryPostProcessor 和 BeanPostProcessor
lhg_55的博客
08-22 1116
这种写法实际上就是一个自定义标签，在这个标签中，会进行一些默认的 Bean 属性的配置，但是，一般来说，这些属性，如果想要自己去配置，也是可以的，比如。后置处理器，在这个后置处理器中，会找到所有的 ${} 格式的 value，并将之替换为真正的值，后面再去创建 bean 的时候，用到的就是真实的值了。这个属性配置的含义表示，对于无法解析的 value，就不解析（默认情况下，如果遇到无法解析的 value，会抛出异常）。创建完毕，Bean 尚未创建的时候，想要去修改 Bean 的属性，那么就可以通过。
BeanFactoryPostProcessor接口
~
05-27 654
在容器初始化过程中，当所有的BeanDefinition都已经加载到BeanFactory中后，Spring容器会回调所有实现了BeanFactoryPostProcessor接口的实例的postProcessBeanFactory方法。在上面的示例中，我们定义了一个名为MyBeanFactoryPostProcessor的类，实现了BeanFactoryPostProcessor接口，并将其声明为一个@Component（或者使用@Bean）。方法修改现有属性的值为"newValue"。
BeanFactoryPostProcessor作用
lp1302190871的博客
05-24 650
BeanFactoryPostProcessor是spring中一个很重要的接口，位于spring流程中的获取BeanDefinition之后，实例化之前(点击spring流程)，我们可以实现该接口并注入spring容器中进行拓展（对BeanDefinition进行自定义修改），我们知道容器中的Bean都是根据BeanDefinition信息去是实例化的，BeanDefinition中存储了bean的信息，我们这儿可以修改BeanDefinition，所以相当于修改bean。
BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor机制
熊诗言的博客
05-05 841
一、前言 在Spring中BeanFactoryPostProcessor的执行是非常重要的一部分，无论是扫描的实现还是拓展spring都需要涉及到这部分。BeanFactoryPostProcessor的执行时机是在BeanFactory实例化之后，其他Bean还未被创建的时候，可以修改beanFactory（主要是修改BeanDefinition）。 1、BeanFactoryPostProcessor介绍 BeanFactoryPostProcessor是spring提供的一个接口，其内部只有一个方法
JAVA-01-变量
LJH_laura_li的博客
11-08 440
在方法、构造函数或块内部定义的变量。
Java基于小程序公考学习平台的设计与实现（附源码，文档）
chusheng1840的博客
11-09 1052
Java基于小程序公考学习平台的设计与实现，小程序公考学习平台使用Java语言进行编码，使用Mysql创建数据表保存本系统产生的数据。系统可以提供信息显示和相应服务，其管理小程序公考学习平台信息，查看小程序公考学习平台信息，管理小程序公考学习平台。总之，小程序公考学习平台集中管理信息，有着保密性强，效率高，存储空间大，成本低等诸多优点。它可以降低信息管理成本，实现信息管理计算机化。关键词：小程序公考学习平台；Java语言；Mysql。
基于 SpringBoot 实现QQ邮箱验证码注册功能
2301_79201049的博客
11-06 660
找到并开通以下的邮件协议服务，而且服务开启也较为简单，需要我们发送一个短信到指定的号码，开启后平台会提供一个授权码，一定要记住这个授权码，发邮件的时候需要这个。host 是根据服务主机区分，网易邮箱是 smtp.163.com, qq邮箱是 smtp.qq.com。其中的 username 是你第一步中操作的邮箱账号，nickname 是接收者收到邮件中显示的发件人。发送邮件的核心依赖是 mail ，由于该项目还涉及其他依赖就全都导进来了。（1）首先打开QQ邮箱，点击设置并来到账号页面。
java_方法重写/覆盖(override)
HHppGo的博客
11-07 337
方法覆盖（重写）就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法覆盖了父类的方法。
在 C# 中，如何实现观察者模式？
Leo的博客
11-06 503
观察者模式是一种设计模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。当该主题对象的状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。这个模式常用于事件处理系统、通知系统等场景。
并发编程的基础：深入理解内存屏障（Memory Barriers）
2401_86353562的博客
11-06 1007
内存屏障是一种基础语言，在不同的计算机架构下有不同的实现细节。本文主要在x86_64处理器下，通过Linux及其内核代码来分析和使用内存屏障对大多数应用层开发者来说，“内存屏障”（memory Barrier）是一种陌生，甚至有些诡异的技术。实际上，他机制常被用在操作系统内核中，用于实现同步、驱动程序利用它，能够实现高效的无锁数据结构，提高多线程程序的性能表现。本文首先探讨了内存屏障的必要性，之后介绍如何利用内存屏障实现一个无锁唤醒振荡器（队列），用于在多个线程间进行高效的数据交换。
ArkTS--应用状态
最新发布
qq_63946637的博客
11-10 538
本文旨在帮助大家学习鸿蒙中的LocalStorage和AppStorage
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值