Spring BeanPostFactoryProcessor研究

在實際開發(fā)中,我們可能會遇到這樣的場景,數(shù)據(jù)庫的用戶名和密碼明文存儲非常不安全,一種可行的方法是:運(yùn)行時候通過訪問一個安全性高的內(nèi)部服務(wù)去獲取用戶名和密碼.

配置如下:
application-Context.xml

<!--配置PropertyPlaceholderConfigurer -->
<bean class="xxxx.DBConnectionConfigurer">
        <property name="fetcher" ref="fetcher"></property>
        <property name="locations">
            <list>
                <value>classpath:db.properties</value>
            </list>
        </property>
    </bean>

<!-- 配置數(shù)據(jù)源 -->
<bean id="dataSource.master"
          class="org.apache.commons.dbcp.BasicDataSource"
          destroy-method="close">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="${master_jdbc_url}"></property>
        <property name="username" value="${master_jdbc_username}"></property>
        ...............
    </bean>

db.properties

master_jdbc_url=database_master_jdbc_url
master_jdbc_username=database_master_jdbc_username

  1. 原理
    通過DBConnectionConfigurer來獲取指定的key的value, 然后注入給數(shù)據(jù)源<bean id="dataSource.master". DBConnectionConfigurer繼承自PropertyPlaceholderConfigurer, PropertyPlaceholderConfigurer向上追溯發(fā)現(xiàn)實現(xiàn)接口BeanFactoryPostProcessor,這個接口在Spring中有特殊的作用

  2. 分析Spring代碼
    首先看AbstractApplicationContext, 這個類實現(xiàn)代碼如下

    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // Prepare this context for refreshing.
            prepareRefresh();

            // Tell the subclass to refresh the internal bean factory.
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            // Prepare the bean factory for use in this context.
            prepareBeanFactory(beanFactory);

            try {
                // Allows post-processing of the bean factory in context subclasses.
                postProcessBeanFactory(beanFactory);

                // Invoke factory processors registered as beans in the context.
                invokeBeanFactoryPostProcessors(beanFactory);

                // Register bean processors that intercept bean creation.
                registerBeanPostProcessors(beanFactory);

                // Initialize message source for this context.
                initMessageSource();

                // Initialize event multicaster for this context.
                initApplicationEventMulticaster();

                // Initialize other special beans in specific context subclasses.
                onRefresh();

                // Check for listener beans and register them.
                registerListeners();

                // Instantiate all remaining (non-lazy-init) singletons.
                finishBeanFactoryInitialization(beanFactory);

                // Last step: publish corresponding event.
                finishRefresh();
            }

            catch (BeansException ex) {
                if (logger.isWarnEnabled()) {
                    logger.warn("Exception encountered during context initialization - " +
                            "cancelling refresh attempt: " + ex);
                }

                // Destroy already created singletons to avoid dangling resources.
                destroyBeans();

                // Reset 'active' flag.
                cancelRefresh(ex);

                // Propagate exception to caller.
                throw ex;
            }

            finally {
                // Reset common introspection caches in Spring's core, since we
                // might not ever need metadata for singleton beans anymore...
                resetCommonCaches();
            }
        }
    }

在refresh函數(shù)中調(diào)用了函數(shù)invokeBeanFactoryPostProcessors, 這個函數(shù)會調(diào)用PostProcessorRegistrationDelegate類的invokeBeanFactoryPostProcessors函數(shù)

public static void invokeBeanFactoryPostProcessors(
            ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

        // Invoke BeanDefinitionRegistryPostProcessors first, if any.
        Set<String> processedBeans = new HashSet<String>();

        if (beanFactory instanceof BeanDefinitionRegistry) {
            BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
            List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>();
            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);
                }
            }

                         // 配置注冊的后處理器
            // Do not initialize FactoryBeans here: We need to leave all regular beans
            // uninitialized to let the bean factory post-processors apply to them!
            // Separate between BeanDefinitionRegistryPostProcessors that implement
            // PriorityOrdered, Ordered, and the rest.
            String[] postProcessorNames =
                    beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);

            // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
            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);

            // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
            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);

            // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
            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;
                    }
                }
            }

            // Now, invoke the postProcessBeanFactory callback of all processors handled so far.
            invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory);
            invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
        }

        else {
            // Invoke factory processors registered with the context instance.
            invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
        }

        // Do not initialize FactoryBeans here: We need to leave all regular beans
        // uninitialized to let the bean factory post-processors apply to them!
        String[] postProcessorNames =
                beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

        // Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
        // Ordered, and the rest.
        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);
            }
        }

        // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
        sortPostProcessors(beanFactory, priorityOrderedPostProcessors);
        invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

        // Next, invoke the BeanFactoryPostProcessors that implement Ordered.
        List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
        for (String postProcessorName : orderedPostProcessorNames) {
            orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
        }
        sortPostProcessors(beanFactory, orderedPostProcessors);
        invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

        // Finally, invoke all other BeanFactoryPostProcessors.
        List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
        for (String postProcessorName : nonOrderedPostProcessorNames) {
            nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
        }
        invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

        // Clear cached merged bean definitions since the post-processors might have
        // modified the original metadata, e.g. replacing placeholders in values...
        beanFactory.clearMetadataCache();
    }

注意, 下文中的"后處理器"都是表示BeanFactoryPostProcessor

  1. 流程分析:

  • 處理硬編碼的后處理器,

    • 判斷硬編碼的后處理器類型
      • 如果是BeanDefinitionRegistryPostProcessor類型則加入到registryPostProcessors中,并且同時處理這個registryPostProcessor
      • 否則加入到regularPostProcessors中

  • 從beanFactory中獲取(不是硬編碼的)所有類型為BeanDefinitionRegistryPostProcessor的bean, 并進(jìn)行處理

    • 1.獲得這些bean中具有PriorityOrdered屬性的bean, 然后將這些bean添加到priorityOrderedPostProcessors中, 進(jìn)行排序, 記錄在processedBeans中, 并批量執(zhí)行這些后處理器.

    • 2.獲得這些bean中具有Ordered屬性的bean, 記錄在processedBeans中, 然后將這些bean記錄到orderedPostProcessors中, 排序并執(zhí)行.

    • 3.獲得這些bean中不滿足上述條件的bean, 記錄在processedBeans中, 并依次執(zhí)行

    • 4.批量處理invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory); invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);

    • 值得注意的是: 上述每個小步驟都會重新獲得所有滿足條件的bean集合, 即調(diào)用beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);,我的理解是在后處理器處理過程中,可能會生成新的BeanDefinitionRegistryPostProcessor類型的后處理器, 所以需要重新加載, 此外, BeanDefinitionRegistryPostProcessor是特殊的后處理器, 在該階段只執(zhí)行特殊邏輯, 通用的邏輯在4中批量處理.

  • 接下里處理bean容器中的BeanFactoryPostProcessor.

    • 對于獲得的所有的BeanFactoryPostProcessor也同樣按照級別去劃分為priorityOrderedPostProcessors, orderedPostProcessorNames, nonOrderedPostProcessorNames
      • 執(zhí)行每個列表的時候都挨個去查找實際的class,然后遍歷每個列表并執(zhí)行

  • 一些特殊的操作

    • PropertyPlaceholderConfigurer的執(zhí)行過程如下
        Properties mergedProps = mergeProperties();
       // Convert the merged properties, if necessary.
        convertProperties(mergedProps);
      // Let the subclass process the properties.
        processProperties(beanFactory, mergedProps);

首先是從locations指定的properties文件中讀取內(nèi)容, 然后獲得調(diào)用convertProperties, 最終執(zhí)行processProperties, convertProperties函數(shù)一般由自己完成邏輯,在processProperties中, 會調(diào)用BeanDefinitionVisitor, 遍歷bean的各個屬性用properties填充, BeanDefinitionVisitor會將替換的操作委托給內(nèi)部的一個StringValueResolver來執(zhí)行(PlaceholderResolvingStringValueResolver), 而這個StringValueResolver又會將操作委托給PropertyPlaceholderHelper, 這個helper(PropertyPlaceholderHelper)在實際執(zhí)行的時候會執(zhí)行內(nèi)部的parseStringValue函數(shù),解析過程可以參考源代碼, 值得注意的是可能會在key里面嵌套新的key,例如${ty${key}}之類的,這種情況也處理了

此外,有一個特殊處理

if (propVal != null) {
                    // Recursive invocation, parsing placeholders contained in the
                    // previously resolved placeholder value.
                    propVal = parseStringValue(propVal, placeholderResolver, visitedPlaceholders);
                    result.replace(startIndex, endIndex + this.placeholderSuffix.length(), propVal);
                    if (logger.isTraceEnabled()) {
                        logger.trace("Resolved placeholder '" + placeholder + "'");
                    }
                    startIndex = result.indexOf(this.placeholderPrefix, startIndex + propVal.length());
                }
                else if (this.ignoreUnresolvablePlaceholders) {
                    // Proceed with unprocessed value.
                    startIndex = result.indexOf(this.placeholderPrefix, endIndex + this.placeholderSuffix.length());
                }
                else {
                    throw new IllegalArgumentException("Could not resolve placeholder '" +
                            placeholder + "'" + " in string value \"" + strVal + "\"");
                }
                visitedPlaceholders.remove(originalPlaceholder);
            }

可見ignoreUnresolvablePlaceholders這個參數(shù)有特殊的用途, 當(dāng)我們定義多個PropertyPlaceholderConfigurer時候, 可能是希望各自解析不同的內(nèi)容,但是, 如果不指定ignoreUnresolvablePlaceholders的時候,在執(zhí)行第一個PropertyPlaceholderConfigurer的時候,就會一直使用這個PropertyPlaceholderConfigurer, 遇到不能解析的內(nèi)容就會報錯.這個需要特別注意一下

最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

推薦閱讀更多精彩內(nèi)容

  • Spring Cloud為開發(fā)人員提供了快速構(gòu)建分布式系統(tǒng)中一些常見模式的工具（例如配置管理，服務(wù)發(fā)現(xiàn)，斷路器，智...
    卡卡羅2017閱讀 134,991評論 19贊 139
  • 1. Java基礎(chǔ)部分 基礎(chǔ)部分的順序：基本語法，類相關(guān)的語法，內(nèi)部類的語法，繼承相關(guān)的語法，異常的語法，線程的語...
    子非魚_t_閱讀 31,769評論 18贊 399
  • Spring容器高層視圖 Spring 啟動時讀取應(yīng)用程序提供的Bean配置信息，并在Spring容器中生成一份相...
    Theriseof閱讀 2,853評論 1贊 24
  • 今天中午澆花，發(fā)現(xiàn)有個口笛鉆出花了。這實在令我喜悅，畢竟養(yǎng)了三年，從一個單頭到三頭，再到今年的九頭，眼看著又要爆出...
    一念見花開閱讀 679評論 3贊 7
  • 那一刻，我突然覺得不會再有一個他，沒有人像他 沒有擁有，只是錯過 不管后來我遇見多少人 不管這個世界有多奇妙，都沒...
    豌豆公主呀閱讀 152評論 0贊 0