Spring核心扩展点BeanDefinitionRegistryPostProcessor源码分析

        我们知道，只要在一个Java类上加上@Component、@Service、@Controller等注解，就可以被加载到Spring容器中，除了以上方式，加了@Bean和@Import好像也可以将对象添加到Spring容器中，究竟Spring是如何实现这些功能的呢？让我们一起来一探究竟。

一、BeanFactoryPostProcessor后置处理器

        Spring IOC在实例化Bean对象之前，需要先读取Bean的相关属性，保存到BeanDefinition对象中，然后通过BeanDefinition对象，实例化Bean对象。

        如果想修改BeanDefinition对象中的属性，该怎么办呢？

        我们可以通过实现BeanFactoryPostProcessor接口实现。

//可以修改bean信息，但必须在bean实例化之前修改
@FunctionalInterface
public interface BeanFactoryPostProcessor {

	/**
	 * Spring自动加载的某个BeanFactoryPostProcessor用于执行cglib动态代理
	 */
	void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;

}

（1）BeanFactoryPostProcessor的执行时机

        所有的BeanDefinitionPostProcessor后置处理器都是在spring的核心方法refresh()的invokeBeanFactoryPostProcessors(beanFactory);方法中执行的，主要用于修改BeanDefinition的属性信息。

//spring最主要的方法，context(上下文刷新)
	@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");

			/**
			 * context刷新前的准备工作：主要是一些初始状态的赋值，环境配置的获取等
			 *
			 */
			// Prepare this context for refreshing.
			prepareRefresh();

			/**
			 * 获取一个新的BeanFactory：如果已经context中存在BeanFactory，关闭该BeanFactory（先销毁工厂中的bean），再
			 * 重新创建一个BeanFactory(DefaultListableBeanFactory类型)
			 *
			 */
			// Tell the subclass to refresh the internal bean factory.
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			/**
			 * beanFactory的准备工作，创将一个标准的工厂(设置一些初始状态和初始值)
			 */
			// Prepare the bean factory for use in this context.
			prepareBeanFactory(beanFactory);

			try {
				/**
				 * 添加BeanFactory的增强器,留给用户扩展
				 */
				// Allows post-processing of the bean factory in context subclasses.
				postProcessBeanFactory(beanFactory);

				StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
				/**
				 * 执行BeanFactory中注册的BeanFactoryPostProcessor的相关逻辑
				 */
				// Invoke factory processors registered as beans in the context.
				//完成所谓的扫描和parse(解析，将类变成beanDefinition)
				// springboot的自动装配是在该方法执行的
				invokeBeanFactoryPostProcessors(beanFactory);

				/**
				 * 注册bean的增强器(BeanPostProcessor)
				 */
				// Register bean processors that intercept bean creation.
				registerBeanPostProcessors(beanFactory);
				beanPostProcess.end();

				/**
				 * 国际化处理
				 */
				// Initialize message source for this context.
				initMessageSource();

				/**
				 * 初始化应用事件广播器
				 */
				// Initialize event multicaster for this context.
				initApplicationEventMulticaster();

				/**
				 *在特定的上下文子类中初始化其他特殊bean，留给用户实现
				 */
				// Initialize other special beans in specific context subclasses.
				onRefresh();

				/**
				 * 往广播器中注册监听器
				 */
				// Check for listener beans and register them.
				registerListeners();

				/**
				 * 完成单例bean的初始化，同时也会执行registerBeanPostProcessors()时注册的beanPostProcessor
				 */
				// Instantiate all remaining (non-lazy-init) singletons.
				//开始实例化单例的类（需要validate和life）
				finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
				// springboot启动Tomcat
				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();
				contextRefresh.end();
			}
		}
	}

（2）代码实现

public class SupplierObj{

	private String version;

	private int num;


	public SupplierObj() {
	}

	public String getVersion() {
		return version;
	}

	public void setVersion(String version) {
		this.version = version;
	}

	public int getNum() {
		return num;
	}

	public void setNum(int num) {
		this.num = num;
	}

	@Override
	public String toString() {
		return "SupplierObj{" +
				"version='" + version + '\'' +
				", num=" + num +
				'}';
	}
}

           这里设置属性version的值为”1.0.0“。

        在这个接口里我们可以修改BeanDefinition的所有属性值，从而间接达到修改bean的信息的效果。

public class MyPostProcessor implements BeanFactoryPostProcessor {

	@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
		GenericBeanDefinition beanDefinition = (GenericBeanDefinition)beanFactory.getBeanDefinition("supplierObj");

		//beanDefinition.getConstructorArgumentValues().addIndexedArgumentValue();
        // 通过Supplier实现对象的实例化
		beanDefinition.setInstanceSupplier(() -> {
			SupplierObj supplierObj1 = new SupplierObj();
			return supplierObj1;
		});
		beanDefinition.getPropertyValues().addPropertyValue("version","通过BeanFactoryPostProcessor修订的版本0.0.2");


	}
}

控制台输出：

supplierObj = SupplierObj{version='通过BeanFactoryPostProcessor修订的版本0.0.2',  num=12}

（二）核心接口BeanDefinitionRegistryPostProcessor

        见名知义，这个后置处理器可以手动控制BeanDefinition的创建和注册。BeanDefinitionRegistryPostProcessor接口继承了BeanFactoryPostProcessor接口。

// BeanDefinitionRegistryPostProcessor可以注册更多的beanDefinition
public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {

	/**
	 * 在其标准初始化之后修改应用程序上下文的内部beanDefinition定义注册表
	 */
	void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;

}

        查看Spring源码中关于BeanDefinitionRegistryPostProcessor 的实现类，其中ConfigurationClassPostProcessor是很重要的实现类。

        我们直接通过refresh()的invokeBeanFactoryPostProcessors(beanFactory)方法进入，查看所有BeanFactoryPostProcessor的执行。

// 实例化并调用所有已注册的BeanFactoryPostProcessorBean;
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		//getBeanFactoryPostProcessors()默认为空，可以通过context.addBeanFactoryPostProcessor();设置值
        // 代码块一：
		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 (!IN_NATIVE_IMAGE && beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}
	}

（1）代码块一：invokeBeanFactoryPostProcessors()，执行所有的BeanFactoryPostProcessors接口。

        其中这个方法有一个参数是通过getBeanFactoryPostProcessors()传入的，其默认为空，可以通过context.addBeanFactoryPostProcessor();设置值。

        这个方法也有很多中间变量，我们先把这些变量的作用简单说明下。

• Set processedBeans ：存放所有满足条件的BeanDefinitionRegistryPostProcessor实现类的名称。
• List regularPostProcessors ：存放标准的BeanFactoryPostProcessor实现类的集合(只实现了BeanFactoryPostProcessor接口的实现类)。
• List registryProcessors：存放BeanDefinitionRegistryPostProcessor实现类的集合。
• List currentRegistryProcessors：存放当前策略下执行的BeanDefinitionRegistryPostProcessor的集合。
• String[] postProcessorNames：Spring容器中所有BeanDefinitionRegistryPostProcessor类型的postProcessor对应的名字（beanName）。
• boolean reiterate：重复标识，初始值为true，因为BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法可能注册了BeanDefinitionRegistryPostProcessor类型的bd，直到调用完所有BeanDefinitionRegistryPostProcessors，不会出现新的BeanDefinitionRegistryPostProcessors时，设置为false。
• List priorityOrderedPostProcessors：存放实现了PriorityOrdered接口的BeanFactoryPostProcessor。
• List orderedPostProcessorNames ：存放实现了Ordered接口的BeanFactoryPostProcessor。
• List nonOrderedPostProcessorNames：存放即没有实现PriorityOrdered接口也没有实现Ordered接口的BeanFactoryPostProcessor。

        这个方法大致总结为：

        1）如果方法参数中beanFactoryPostProcessors不为null，遍历beanFactoryPostProcessors。

        a. 如果其中的processor是BeanDefinitionRegistryPostProcessor类型。

        向上转型为BeanDefinitionRegistryPostProcessor类型，并执行其接口方法postProcessBeanDefinitionRegistry，同时将该processor加入registryProcessors集合。

        b. 如果其中的processor不是BeanDefinitionRegistryPostProcessor类型。

        将该processor加入regularPostProcessors集合。

        beanFactoryPostProcessors默认为空，可以通过context.addBeanFactoryPostProcessor();设置值。

        2）找到Spring容器中所有BeanDefinitionRegistryPostProcessor类型的postProcessor对应的名字,保存到字符串数组postProcessorNames中，遍历这个数组（这时只会找到Spring自己添加的）

        3）如果其中的processor是PriorityOrdered接口的实现类，从容器中getBean(postProcessorName)获取对应的BeanDefinitionRegistryPostProcessor，并将其放入currentRegistryProcessors * 同时将postProcessorName放入processedBeans集合。（这里不用担心会重复执行beanFactoryPostProcessors的processor，它是直接传入的值，并没有注册到容器中）遍历完成后，对currentRegistryProcessors进行排序，将currentRegistryProcessors中的元素全部加入registryProcessors集合中。遍历执行currentRegistryProcessors元素的postProcessBeanDefinitionRegistry(), *然后清空currentRegistryProcessors集合。

        4）重复步骤2，这是因为步骤3中的processor执行postProcessBeanDefinitionRegistry()方法时可能往容器中注册了BeanDefinitionRegistryPostProcessor类型的beanDefinition。

        5）如果其中的processor对应的name在processedBeans中不存在，且是Ordered接口的实现类，后续逻辑与步骤3一致。

        6）维护一个reiterate重复标识，初始值为true，进入while(reiterate)，循环内容为执行步骤7

        7）将reiterate设置为false，重复步骤2，如果其中的processor对应的name在processedBeans中不存在，设置reiterate为true,后续逻辑与步骤3一致，进入下一轮循环，直到所有的beanName都在processedBeans中（没有找到新的BeanDefinitionRegistryPostProcessor类型的beanDefinition），结束while循环。

        8）遍历registryProcessors集合，执行BeanDefinitionRegistryPostProcessor类型的postProcessor的postProcessBeanFactory()方法。

         9）遍历regularPostProcessors集合，执行不是BeanDefinitionRegistryPostProcessor类型的postProcessor的postProcessBeanFactory()方法。

        10）找到Spring容器中所有BeanFactoryPostProcessor类型的postProcessor对应的名字,保存到字符串数组postProcessorNames中，遍历这个数组。(这里也是我们扩展的BeanFactoryPostProcessor的执行时机)

……

 BeanFactoryPostProcessor的处理逻辑与上述处理BeanDefinitionRegistryPostProcessor时类似，就不过多描述了。 也是先找PriorityOrdered接口的实现类，再找Ordered接口的实现类，最后找不是前面两种的普通实现类，放入对应的集合，排序，遍历执行接口方法

……

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

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

		
		if (beanFactory instanceof BeanDefinitionRegistry) {
			BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
			//存放标准的BeanFactoryPostProcessor的集合(只实现了BeanFactoryPostProcessor接口的实现类)
			List regularPostProcessors = new ArrayList<>();
			//存放BeanDefinitionRegistryPostProcessor的集合
			List registryProcessors = new ArrayList<>();
            //beanFactoryPostProcessors默认为空，可自己扩展
			for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
				//先执行实现了BeanDefinitionRegistryPostProcessor接口的实现类中的postProcessBeanDefinitionRegistry()方法
				if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
					//向上转型
					BeanDefinitionRegistryPostProcessor registryProcessor =
							(BeanDefinitionRegistryPostProcessor) postProcessor;
					registryProcessor.postProcessBeanDefinitionRegistry(registry);
					registryProcessors.add(registryProcessor);
				}
				else {
					//不是BeanDefinitionRegistryPostProcessor类型的postProcessor
					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.
			// 存放当前执行的BeanDefinitionRegistryPostProcessor
			List currentRegistryProcessors = new ArrayList<>();

			// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
			//找到spring容器中所有BeanDefinitionRegistryPostProcessor类型的postProcessor对应的名字
            // 代码块二：默认的BeanDefinitionRegistryPostProcessors的注入时机
			//为什么只有一个？怎么来的？Spring在容器初始化时会自动注入一些必要的bean
			String[] postProcessorNames =
					beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				//找实现了PriorityOrdered接口的实现类
				if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
					//当前需要执行BeanDefinitionRegistryPostProcessor，执行完就会被清空
					//为什么能beanFactory.getBean()?虽然spring还没有实例化系统中bean，但是spring会提前实例化必须的bean（）
					//为什么不直接new，而是选择getBean?有时可能程序员不使用系统默认的实现，可以自己指定实现
					/**
					 * * @see AnnotatedBeanDefinitionReader#AnnotatedBeanDefinitionReader(BeanDefinitionRegistry, Environment)
					 */

					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					//将找到的Processor对应的名字放入processedBeans，方便后续根据名字判断
					processedBeans.add(ppName);
				}
			}
            // 代码块三：对后置处理器进行排序
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			//将满足条件的Processors对象放入registryProcessors
			registryProcessors.addAll(currentRegistryProcessors);
			// Spring默认的后置处理器在这个方法里完成扫描
            // 代码块四：执行实现了PriorityOrdered接口的后置处理器的接口方法
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
			currentRegistryProcessors.clear();

			// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				//找实现了Ordered接口的实现类
				if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
				}
			}
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			registryProcessors.addAll(currentRegistryProcessors);
            // 执行实现了
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
			currentRegistryProcessors.clear();

			// 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) {
					//找非PriorityOrdered及非Ordered实现类对应BeanDefinitionRegistryPostProcessor
					if (!processedBeans.contains(ppName)) {
						currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
						processedBeans.add(ppName);
						//为什么设置为true
						//因为BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法可能注册了BeanDefinitionRegistryPostProcessor类型的bd
						reiterate = true;
					}
				}
				sortPostProcessors(currentRegistryProcessors, beanFactory);
				registryProcessors.addAll(currentRegistryProcessors);
				invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
				currentRegistryProcessors.clear();
			}

			// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
			//执行BeanDefinitionRegistryPostProcessor类型的postProcessor的postProcessBeanFactory()方法
			invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
			//执行不是BeanDefinitionRegistryPostProcessor类型的postProcessor的postProcessBeanFactory()方法
			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!
		//通过扫描找到的BeanFactoryPostProcessor，加了注解（@Component）的后置处理器
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

		// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
		// Ordered, and the rest.
		List priorityOrderedPostProcessors = new ArrayList<>();
		List orderedPostProcessorNames = new ArrayList<>();
		List nonOrderedPostProcessorNames = new ArrayList<>();
		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(priorityOrderedPostProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

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

		// Finally, invoke all other BeanFactoryPostProcessors.
		List nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
		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();
	}

（2）代码块二：默认的BeanDefinitionRegistryPostProcessors的注入时机。

        Spring默认注入的BeanDefinitionRegistryPostProcessors实现类是ConfigurationClassPostProcessor。在创建Spring容器中有一行代码new AnnotatedBeanDefinitionReader(this);Spring会在容器创建的时候自动注入一些必要的组件。

public AnnotationConfigApplicationContext(Class... componentClasses) {
		//调用构造函数，完成一些必须bd的注入
		this();
		//注册配置类，因为配置需要解析，一般不需要自己扫描
		//aliasMap.put
		//注册一些spring自身的bean，因为有些bean是无法通过扫描得到的
		//registerBeanDefinition(String beanName, BeanDefinition beanDefinition) --- this.beanDefinitionMap.put(beanName, beanDefinition);
		register(componentClasses);
		refresh();
	}

public AnnotationConfigApplicationContext() {
		StartupStep createAnnotatedBeanDefReader = this.getApplicationStartup().start("spring.context.annotated-bean-reader.create");
		// spring会自动注入一些必须的组件
		this.reader = new AnnotatedBeanDefinitionReader(this);
		createAnnotatedBeanDefReader.end();
		//spring提供api用来动态扫描注解
		//一般供扩展spring的时候用的
		this.scanner = new ClassPathBeanDefinitionScanner(this);
	}

        省略中间的一些代码，最终我们可以找到下面这个方法，registerAnnotationConfigProcessors()，在这个方法中往Spring容器中注入了一些BD。

public static Set registerAnnotationConfigProcessors(
			BeanDefinitionRegistry registry, @Nullable Object source) {

		DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
		if (beanFactory != null) {
			if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
				beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
			}
			if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
				beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
			}
		}

		Set beanDefs = new LinkedHashSet<>(8);

		//初始化一些必要的bd
		if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
            // 注入ConfigurationClassPostProcessor.class的地方
			RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		// Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
		if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		// Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
		if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition();
			try {
				def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
						AnnotationConfigUtils.class.getClassLoader()));
			}
			catch (ClassNotFoundException ex) {
				throw new IllegalStateException(
						"Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
			}
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
		}

		if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
		}

		return beanDefs;
	}

 （3）代码块三：sortPostProcessors()，对后置处理器进行排序

        通过排序比较器进行排序。

private static void sortPostProcessors(List postProcessors, ConfigurableListableBeanFactory beanFactory) {
		// Nothing to sort?
		if (postProcessors.size() <= 1) {
			return;
		}
		Comparator