Spring--BeanFactoryPostProcessor学习笔记

总而言之，beanFactoryPostprocessor的作用是在beanFactory初始化之后提供一个修改的机会

第一篇学习笔记，深感智商不足，看spring看不明白，所以把比较疑惑的地方写下来

还是从refresh方法进去，在obtainFreshBeanFactory方法中，就已经loadBeanDefinitons()了，容器做了一些准备工作后，调用了invokeBeanFactoryPostProcessors(beanFactory)方法。这里把beanFactoryPostprocessor都调用了一遍

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);
				// 在这里
				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) {
				// Destroy already created singletons to avoid dangling resources.
				destroyBeans();
				// Reset 'active' flag.
				cancelRefresh(ex);
				// Propagate exception to caller.
				throw ex;
			}
		}
	}
public interface BeanFactoryPostProcessor {

	/**
	 * 这里提供了修改beanFacotry的机会
         */
	void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;

}
public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {

	/**
	 * 这个接口继承了postprocessor 并且将beanFactory转成了registry能够访问到beanDefinition。
	 */
	void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;

}

Order是spring的接口，实现了该接口的Spring都可以对对象集合排序。

这个方法的具体内容如下

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		// 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 : getBeanFactoryPostProcessors()) {
				if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
					BeanDefinitionRegistryPostProcessor registryPostProcessor =
							(BeanDefinitionRegistryPostProcessor) postProcessor;
					registryPostProcessor.postProcessBeanDefinitionRegistry(registry);
					registryPostProcessors.add(registryPostProcessor);
				}
				else {
					regularPostProcessors.add(postProcessor);
				}
			}
			Map<String, BeanDefinitionRegistryPostProcessor> beanMap =
					beanFactory.getBeansOfType(BeanDefinitionRegistryPostProcessor.class, true, false);
			List<BeanDefinitionRegistryPostProcessor> registryPostProcessorBeans =
					new ArrayList<BeanDefinitionRegistryPostProcessor>(beanMap.values());
			OrderComparator.sort(registryPostProcessorBeans);
			for (BeanDefinitionRegistryPostProcessor postProcessor : registryPostProcessorBeans) {
				postProcessor.postProcessBeanDefinitionRegistry(registry);
			}
			invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory);
			invokeBeanFactoryPostProcessors(registryPostProcessorBeans, beanFactory);
			invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
			processedBeans.addAll(beanMap.keySet());
		}
		else {
			// Invoke factory processors registered with the context instance.
			invokeBeanFactoryPostProcessors(getBeanFactoryPostProcessors(), 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 (isTypeMatch(ppName, PriorityOrdered.class)) {
				priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
			}
			else if (isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

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

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

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

方法可以看做上下两部分。上半部分 建了三个集合分别存了三种postprocessor 然后调用了其方法修改了beanFactory。下半部分就不太懂了，因为我觉得上半部分明明已经调用过一次了，下面的除了排序之外岂不是又重复了一次。

总而言之，beanFactoryPostprocessor的作用是在beanFactory初始化之后提供一个修改的机会。spring已经提供了不少实现，我们自己也可以写一些实现配置在xml中 或者手动调用。

比如自己写代码使用

ConfigurableListableBeanFactory beanFactory = new XmlBeanFactory(  
                new ClassPathResource("xxxx.xml")  
        );  
        BeanFactoryPostProcessor myBfpp = (BeanFactoryPostProcessor)beanFactory.getBean("mypostprocessor");  
        myBfpp.postProcessBeanFactory(beanFactory);  
        System.out.println(beanFactory.getBean("test"));

spring也提供了不少实现，我们最常用的三个：  propertyPlaceholerConfigurer、CustomerEditorConfigurer、propertyOverrideConfigurer等。

propertyPlaceholerConfigurer：从.properties文件中读数据替换xml中的值

<bean id="propertyConfigurer"class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
  <property name="locations">//也可以写location只配置一个
   <list>
    <value>/WEB-INF/mail.properties</value> 
    <value>classpath: conf/sqlmap/jdbc.properties</value>//注意这两种value值的写法
   </list>
  </property>
</bean><bean id="A" class="com.xx.xx">   
    <property name="password" value="${A.password}"/>  
    <property name="username" value="$(A.username}"/>  
 </bean>

propertyOverrideConfigurer:从.properties文件中读数据替换xml的值，和上面的有点类似，但这个智能一点，而且可以有默认值，如果properties文件中没有定义，不会报错。对于<bean name="A"><property name="B"></p></b>。他会去properties文件里找A.B的值。如果没找到就使用xml里的默认值

<bean id="bfpp" class="org.springframework.beans.factory.config.propertyOverrideConfigurerfigurer">  
    <property name="location" value="classpath:/META-INF/xxxx.properties"/>  
 </bean>  
  
<bean id="A" class="com.xx.xx">   
    <property name="password" value=""/>  
    <property name="username" value=""/>  
 </bean>
properties文件中写A.password、A.username

CustomerEditorConfigurer。这个是用来向容器注册propertyEditor的。propertyEditor是一个接口有里面主要有两个方法：setAsText(),getAsText().顾名思义，把字符串解析成值。xml文件里我们填的都是字符串，而转成bean的属性，需要一个editor。spring 默认有一些可以处理基础数据类型和byteArray.File.url.uuid什么的，如果想要自己拓展,需要自己写一个类继承PropertyEditorSupport,他实现了PropertyEditor接口，我们继承更方便，写好自己的editer之后需要配置CustomerEditorConfigurer

<bean id="bfpp" class="org.springframework.beans.factory.config.propertyOverrideConfigurerfigurer">  
    <property name="location" value="classpath:/META-INF/xxxx.properties"/>  
 </bean>  
  
<bean id="A" class="com.xx.xx">   
    <property name="password" value=""/>  
    <property name="username" value=""/>  
 </bean>
properties文件中写A.password、A.username

    实现：CustomerEditorConfigurer里有一个map ，key是要转的目标类型，value是实现了PropertyEditor的类。当上面容器调用到这个postProcessor的时候，他将map里的成员注册到beanFactory里

    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
            if (this.customEditors != null) {
                for (Iterator it = this.customEditors.keySet().iterator(); it.hasNext();) {
                    Object key = it.next();
                    Class requiredType = null;
                    if (key instanceof Class) {
                        requiredType = (Class) key;
                    }
                    else if (key instanceof String) {
                        String className = (String) key;
                        try {
                            requiredType = ClassUtils.forName(className);
                        }
                        catch (ClassNotFoundException ex) {
                            throw new BeanInitializationException(
                                    "Could not load required type [" + className + "] for custom editor", ex);
                        }
                    }
                    else {
                        throw new BeanInitializationException(
                                "Invalid key [" + key + "] for custom editor - needs to be Class or String");
                    }
                    Object value = this.customEditors.get(key);
                    if (!(value instanceof PropertyEditor)) {
                        throw new BeanInitializationException("Mapped value [" + value + "] for custom editor key [" +
                                key + "] is not of required type [" + PropertyEditor.class.getName() + "]");
                    }
                    beanFactory.registerCustomEditor(requiredType, (PropertyEditor) value);
                }
            }
        }
    }

当Spring createBean的时候，就是在instantiateBean方法中会先创建BeanWrapper 然后initBeanWrapper()。在这个方法中beanWrapper又会将这些以及spring提供的公共的Editor注册给自己。然后在接下来的populate()方法中，会调用 Object resolvedValue =valueResolver.resolveValueIfNecessary( "bean property '"  + pv.getName() +  "'" , pv.getValue()); 这个方法再重载一下，最终就会用到Editor将beanDefinition中存的信息转成相应的类型，返回，然后注入给bean

转自http://blog.youkuaiyun.com/xiao_jun_0820/article/details/7242379