BeanFactoryPostProcessor

BeanFactory是Spring中容器功能的基础,用于存放所有已经加载的bean,为了保证程序上的高可扩展性,Spring针对BeanFactory做了大量的扩展.

激活注册BeanFactoryPostProcessor

BeanFactoryPostProcessor和BeanPostProcessor类似,可以对beanDefinition进行处理,也就是说SpringIOC容器允许BeanFactoryPostProcessor在容器实际实例化任何bean之前读取beanDefinition,并有可能修改他.并且我们还可以配置自定义的BeanFactoryPostProcessor.如果想改变bean,那么使用beanPostProcessor.

并通过order属性来控制BeanFactoryPostProcessor的执行次序.因为只有实现了Ordered接口时,才可以设置这个属性,所以在实现BeanFactoryPostProcessor的时候,就应该考虑实现Ordered接口.

BeanFactoryPostProcessor的作用域是容器级的,只和你使用的容器有关,如果在一个容器中定义了一个BeanFactoryPostProcessor,他仅仅对此容器中的beanDefinition进行后处理.BeanFactoryPostProcessor不会对定义在另一个容器中的bean进行后处理,即便这两个容器都在同一个层次上.

1、BeanFactoryPostProcessor的典型应用:PropertyPlaceholderConfigurer
有时候我们在Spring的bean的描述文件中需要引入像properties配置文件中数据举个例子:

<bean id="black" class="com.ipluto.demo.BlackCat">
    <property name="name">
        <value>${cat.name}</value>
    </property>
</bean>

注意上面使用了一个${cat.name},这就是Spring的分散配置,可以在另外的配置文件中为cat.name指定值,比如在cat.properties配置文件中配置:

cat.name = 火锅

在访问BlackCat的时候,name属性就会被替换为“火锅”,这就是PropertyPlaceholderConfigurer的功能.

<bean id="nameHandler" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="locations">
        <list>
            <value>config/cat.properties</value>
        </list>
    </property>
</bean>

把PropertyPlaceholderConfigurer这个类间接继承了BeanFactoryPostProcessor接口,当Spring加载任何实现了这个接口的bean的配置时,都会在beanDefinition载入之后执行postProcessorBeanFactory方法.在PropertyPlaceholderConfigurer中实现了postProcessorBeanFactory方法,在方法中调用了mergeProperties(得到配置)、convertProperties(得到的配置转化为合适的类型)、processProperties(将配置内容告知BeanFactory)这3个方法.

2、使用自定义BeanFactoryPostProcessor
比如我们以实现一个BeanFactoryPostProcessor,去除潜在的“流氓”属性值的功能展示自定义BeanFactoryPostProcessor的创建及使用:

• 自定义一个postProcessor

public class ObscenityRemovingBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

    private Set<String> obscenity;


    public ObscenityRemovingBeanFactoryPostProcessor(Set<String> obscenity) {
        this.obscenity = obscenity;
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        String[] beanDefinitionNames = beanFactory.getBeanDefinitionNames();
        for (String beanDefinitionName : beanDefinitionNames) {
            BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanDefinitionName);
            // 创建了一个string类型的解析器
            StringValueResolver stringValueResolver = new StringValueResolver() {
                @Override
                public String resolveStringValue(String strVal) {
                    if (isObscene(strVal))
                        return "*****";
                    return strVal;
                }
            };
            // 构建beanDefinition解析器
            BeanDefinitionVisitor beanDefinitionVisitor = new BeanDefinitionVisitor(stringValueResolver);
            // 使用beanDefinition解析器
            beanDefinitionVisitor.visitBeanDefinition(beanDefinition);
        }

    }

    private boolean isObscene(String strVal) {
        String s = strVal.toString().toUpperCase();
        return obscenity.contains(s);
    }
}

• 添加到Spring中

<bean id="bfpp" class="com.ipluto.demo.ObscenityRemovingBeanFactoryPostProcessor">
    <constructor-arg>
        <set>
            <value>bollockes</value>
            <value>winky</value>
            <value>bum</value>
            <value>Microsoft</value>
        </set>
    </constructor-arg>
</bean>

• 定义一个pojo

package com.ipluto.demo;

public class SimplePO {

    private String connectionString;

    private String password;

    private String userName;

    public String getConnectionString() {
        return connectionString;
    }

    public void setConnectionString(String connectionString) {
        this.connectionString = connectionString;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }
}

• 添加到Spring中

<bean id="simpleBean" class="com.ipluto.demo.SimplePO">
    <property name="connectionString" value="bollockes"/>
    <property name="password" value="guest"/>
    <property name="userName" value="Microsoft"/>
</bean>

• 测试

public static void main(String[] args) {
        ConfigurableListableBeanFactory bf = new XmlBeanFactory(new ClassPathResource("META-INF/beanFactory.xml"));
        BeanFactoryPostProcessor bfpp =(BeanFactoryPostProcessor) bf.getBean("bfpp");
        bfpp.postProcessBeanFactory(bf);
        System.out.println(bf.getBean("simpleBean"));
    }

• 结果
  SimplePO{connectionString=,userName=,password=guest}

使用后处理器,很好的屏蔽掉了obscenties定义的不应该出现的属性

3、激活BeanFactoryPostProcessor

    protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
        // 激活的核心代码
        PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, 
        // 硬编码注册的后处理器
        this.getBeanFactoryPostProcessors());
        if (!NativeDetector.inNativeImage() && beanFactory.getTempClassLoader() == null && beanFactory.containsBean("loadTimeWeaver")) {
            beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
            beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
        }

    }

public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
        Set<String> processedBeans = new HashSet();
        ArrayList regularPostProcessors;
        ArrayList registryProcessors;
        int var9;
        ArrayList currentRegistryProcessors;
        String[] postProcessorNames;
        // 对BeanDefinitionRegistry类型的处理
        if (beanFactory instanceof BeanDefinitionRegistry) {
            BeanDefinitionRegistry registry = (BeanDefinitionRegistry)beanFactory;
            regularPostProcessors = new ArrayList();
            registryProcessors = new ArrayList();
            Iterator var6 = beanFactoryPostProcessors.iterator();

            while(var6.hasNext()) {
                BeanFactoryPostProcessor postProcessor = (BeanFactoryPostProcessor)var6.next();
                if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                    BeanDefinitionRegistryPostProcessor registryProcessor = (BeanDefinitionRegistryPostProcessor)postProcessor;
                    // 对于BeanDefinitionRegistryPostProcessor类型,在beanFactoryPostProcessor的基础上还有自定义的方法:postProcessBeanDefinitionRegistry,需要先调用
                    registryProcessor.postProcessBeanDefinitionRegistry(registry);
                    registryProcessors.add(registryProcessor);
                } else {
                	// 常规的beanFactoryPostProcessor
                    regularPostProcessors.add(postProcessor);
                }
            }

            currentRegistryProcessors = new ArrayList();
            // 配置注册的后处理器
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            String[] var16 = postProcessorNames;
            var9 = postProcessorNames.length;

            int var10;
            String ppName;
            for(var10 = 0; var10 < var9; ++var10) {
                ppName = var16[var10];
                // 是PriorityOrdered.class类型的
                if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                    // 收集BeanDefinitionRegistryPostProcessor类型的postProcessor
                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    processedBeans.add(ppName);
                }
            }
			// 排序,根据上面的判断条件:beanFactory.isTypeMatch(ppName, PriorityOrdered.class
			// 可知是根据PriorityOrdered.class排序
            sortPostProcessors(currentRegistryProcessors, beanFactory);
            registryProcessors.addAll(currentRegistryProcessors);
            // 激活,其实就是上面提到的BeanDefinitionRegistryPostProcessor类型的postProcessor,
            // 并且会执行他的自定义方法postProcessBeanDefinitionRegistry
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
            currentRegistryProcessors.clear();
            // 基本同上,只是下面排序和获取的类型不一样
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            var16 = postProcessorNames;
            var9 = postProcessorNames.length;

            for(var10 = 0; var10 < var9; ++var10) {
                ppName = var16[var10];
                // 排除上面的,并且Ordered.class类型的
                if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    processedBeans.add(ppName);
                }
            }
			// 根据beanFactory.isTypeMatch(ppName, Ordered.class:
			// 可以排序时根据order进行的
            sortPostProcessors(currentRegistryProcessors, beanFactory);
            registryProcessors.addAll(currentRegistryProcessors);
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
            currentRegistryProcessors.clear();
            boolean reiterate = true;

            while(reiterate) {
                reiterate = false;
                postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
                String[] var19 = postProcessorNames;
                var10 = postProcessorNames.length;

                for(int var26 = 0; var26 < var10; ++var26) {
                    String ppName = var19[var26];
                    // 排除上面两种类型,剩余的PostProcessor
                    if (!processedBeans.contains(ppName)) {
                        currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                        processedBeans.add(ppName);
                        reiterate = true;
                    }
                }
				// 进行排序
                sortPostProcessors(currentRegistryProcessors, beanFactory);
                registryProcessors.addAll(currentRegistryProcessors);
                invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
                currentRegistryProcessors.clear();
            }
			// 最后分别调用两种类型的postProcessBeanFactory方法
            invokeBeanFactoryPostProcessors((Collection)registryProcessors, (ConfigurableListableBeanFactory)beanFactory);
            invokeBeanFactoryPostProcessors((Collection)regularPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
        } else {
            invokeBeanFactoryPostProcessors((Collection)beanFactoryPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
        }
		// 获取到所有的配置的BeanFactoryPostProcessor
        String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
        regularPostProcessors = new ArrayList();
        registryProcessors = new ArrayList();
        currentRegistryProcessors = new ArrayList();
        postProcessorNames = postProcessorNames;
        int var20 = postProcessorNames.length;

        String ppName;
        for(var9 = 0; var9 < var20; ++var9) {
            ppName = postProcessorNames[var9];
            	// 排除上面已经处理过的
            if (!processedBeans.contains(ppName)) {
            	// 对于PriorityOrdered类型的
                if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                    regularPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
                } else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
                	// 对于Ordered类型的
                    registryProcessors.add(ppName);
                } else {
                	// 除了上面两种类型之外的
                    currentRegistryProcessors.add(ppName);
                }
            }
        }
		// 排序
        sortPostProcessors(regularPostProcessors, beanFactory);
        // 执行ostProcessBeanFactory方法
        invokeBeanFactoryPostProcessors((Collection)regularPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
        List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList(registryProcessors.size());
        Iterator var21 = registryProcessors.iterator();

        while(var21.hasNext()) {
            String postProcessorName = (String)var21.next();
            orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
        }

        sortPostProcessors(orderedPostProcessors, beanFactory);
        invokeBeanFactoryPostProcessors((Collection)orderedPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
        List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList(currentRegistryProcessors.size());
        Iterator var24 = currentRegistryProcessors.iterator();

        while(var24.hasNext()) {
            ppName = (String)var24.next();
            nonOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
        }

        invokeBeanFactoryPostProcessors((Collection)nonOrderedPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
        beanFactory.clearMetadataCache();
    }

总结一下上面的代码:
对于BeanFactoryPostProcessor的处理主要分为两种情况,一个是对BeanDefinitionRegistry类的处理,另一个是对普通的BeanFactoryPostProcessor的处理.对于这两种情况都要考虑硬编码注入和配置注入的后处理器.
对于硬编码注册的后处理器的处理,主要是通过ApplicationContext中的添加处理器方法addBeanFactoryPostProcessor进行添加.

    public void addBeanFactoryPostProcessor(BeanFactoryPostProcessor postProcessor) {
        Assert.notNull(postProcessor, "BeanFactoryPostProcessor must not be null");
        this.beanFactoryPostProcessors.add(postProcessor);
    }

添加的后处理器会存放在beanFactoryPostProcessors中,而在处理器激活的时候会首先检测beanFactoryPostProcessors中是否有数据.
BeanDefinitionRegistryPostProcessor继承了BeanFactoryPostProcessors,不但有BeanFactoryPostProcessor的特性,还有自己定义的方法,也是需要在这里调用的,所以需要从beanFactoryPostProcessors挑出来,然后执行他的postProcessBeanDefinitionRegistry方法的激活.
if (beanFactory instanceof BeanDefinitionRegistry):
这个判断是因为,BeanDefinitionRegistryPostProcessor只对BeanDefinitionRegistry类型的ConfigurableListableBeanFactory有效,如果beanFactory不是BeanDefinitionRegistry,那么就可以忽略BeanDefinitionRegistryPostProcessor.

强调一个点,对于硬编码方式的后处理器是不需要进行排序的,但是配置文件中读取的处理器,Spring并不能保证他的读取顺序,所以为了保证用户的调用顺序的要求,Spring对于后处理器的排序支持PriorityOrdered或者Ordered的顺序调用