protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
  /**
	 * 1.getBeanFactoryPostProcessors(): 拿到当前应用上下文beanFactoryPostProcessors变量中的值
	 * 2.invokeBeanFactoryPostProcessors: 实例化并调用所有已注册的BeanFactoryPostProcessor
	 */
  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()));
  }
}

PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

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

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

	/** 判断beanFactory 是不是BeanDefinitionRegistry 如果是则直接调用invokeBeanFactoryPostProcessors,
	 * 否则将 beanDefinitionRegistry转化为BeanFactoryPostProcessor 然后在执行如果是则直接调用invokeBeanFactoryPostProcessors
	 * beanFactory是DefaultListableBeanFactory，是BeanDefinitionRegistry的实现类，所以肯定满足if条件
	 */
	if (beanFactory instanceof BeanDefinitionRegistry) {
		BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
		/**
		 * regularPostProcessors用来存放BeanFactoryPostProcessor
		 */
		List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
		/**
		 * registryProcessors用来存放BeanDefinitionRegistryProcessors
		 * BeanDefinitionRegistryProcessors扩展了BeanFactoryPostProcessor
		 */
		List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

		/**
		 * 循环进来的beanFactoryPostProcessors,正常情况下，beanFactoryPostProcessors肯定是没有数据的
		 * 因为beanFactoryPostProcessors是获得手动添加的，而不是spring扫描的，
		 * 只有手动调用annotationConfigApplicationContext.addBeanFactoryPostProcessor(...)才会有数据
		 */
		for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
			/**
			 * 判断postProcessor是不是BeanDefinitionRegistryPostProcessor,因为BeanDefinitionRegistryPostProcessor
			 * 扩展了BeanFactoryPostProcessor，所以这里首先判断是不是BeanDefinitionRegistryPostProcessor
			 * 如果是的话，直接就执行postProcessBeanDefinitionRegistry(...)方法，然后把对象装到registryProcessors中
			 */
			if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
				BeanDefinitionRegistryPostProcessor registryProcessor =
						(BeanDefinitionRegistryPostProcessor) postProcessor;
				/** 注册bean定义后置处理器 */
				registryProcessor.postProcessBeanDefinitionRegistry(registry);
				registryProcessors.add(registryProcessor);
			}
			else {
				/**
				 * 如果不是就装到regularPostProcessors中
				 */
				regularPostProcessors.add(postProcessor);
			}
		}

		/** 这里不会初始化FactoryBeans，会让bean工厂后置处理器去初始化这些常规bean
		 * 并且将这些bean分离出来按照 BeanDefinitionRegistryPostProcessors实现的接口*/
		List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

		// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
		/**
		 * 1、调用 实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessors后置处理器
		 * 获得实现BeanDefinitionRegistryPostProcessors接口类的BeanName： org.springframework.context.annotation.internalConfigurationAnnotationProcessor
		 * 并且装入数组postProcessorNames中，如果自定义了实现了BeanDefinitionRegistryPostProcessor接口的类，并且也在自定义的类上打上了@Component注解
		 * 在这一步还是拿不到自定义的这个类，因为spring还没有进行扫描。
		 * 扫描是在ConfigurationPostProcessor类中完成的也就是下面的invokeBeanDefinitionRegistryPostProcessors(...)方法
		 */
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
		for (String ppName : postProcessorNames) {
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				/**
				 * 获得ConfigurationClassPostProcessor并且放到currentRegistryProcessors
				 * ConfigurationClassPostProcessor是很重要的一个类，他实现了BeanDefinitionRegistryPostProcessor接口
				 * BeanDefinitionRegistryPostProcessor又实现了BeanFactoryPostProcessor接口
				 * ConfigurationClassPostProcessor里面执行了扫描Bean，Import，ImportResource等各种操作
				 * 用来处理配置类的各种逻辑
				 */
				currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
				/**
				 * 把name放到processedBeans,后续会根据这个集合来判断处理器是否已经被执行过了
				 */
				processedBeans.add(ppName);
			}
		}
		/**
		 * 排序处理
		 */
		sortPostProcessors(currentRegistryProcessors, beanFactory);
		/**
		 * 合并currentRegistryProcessors，这里为什么要这么做呢？因为registryProcessors是装载BeanDefinitionRegistryPostProcessor的
		 * 一开始的时候，spring只会执行BeanDefinitionRegistryPostProcessor独有的方法，而不会执行BeanDefinitionRegistryPostProcessor
		 * 父类的方法，即BeanFactoryProcessor的方法，所以这里把处理器统一放在集合中，后期统一执行父类方法
		 */
		registryProcessors.addAll(currentRegistryProcessors);
		/**
		 * 第一次调用bean定义后置处理器,这个方法比较重要，需要我们点进去详细研究一下
		 * 可以理解为执行ConfigurationClassPostProcessor的postProcessorBeanDefinitionRegistry()方法
		 * spring热插拔的体现，向ConfigurationClassPostProcessor就相当于一个组件，spring很多的事情就是交给
		 * 组件去管理的，如果不想用这个组件，直接吧注册组件的那一步去掉就可以
		 * 注册@Import等注解也是在这个方法中调用
		 */
		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
		/**
		 * 因为currentRegistryProcessors是一个临时变量，所以需要清除掉
		 */
		currentRegistryProcessors.clear();

		// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
		/**
		 * 2、调用实现Ordered接口的BeanDefinitionRegistryPostProcessors后置处理器
		 * 再次根据BeanDefinitionRegistryPostProcessor获取BeanName，看这个BeanName是否已经被执行过了，有没有实现Ordered接口
		 * 如果没有执行过，也实现了Ordered接口的话，把对象推送到currentRegistryProcessors，名称推送到processedBeans
		 * 如果没有实现Order接口的话，这里不把数据加到currentRegistryProcessors、processedBeans中，后续再做处理
		 * 这里才可以获取我们自定义的实现了BeanDefinitionRegistryPostProcessor的Bean
		 */
		postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
		for (String ppName : postProcessorNames) {
			if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
				currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
				processedBeans.add(ppName);
			}
		}
		/**
		 * 排序处理
		 */
		sortPostProcessors(currentRegistryProcessors, beanFactory);
		/**
		 * 合并processors
		 */
		registryProcessors.addAll(currentRegistryProcessors);
		/**
		 * 执行我们自定义的BeanDefinitionRegistryPostProcessor
		 */
		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
		/**
		 * 清空临时变量
		 */
		currentRegistryProcessors.clear();

		// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
		/**
		 * 3、调用其他所有的BeanDefinitionRegistryPostProcessors后置处理器
		 * 上面的代码是执行了实现了Ordered接口的BeanDefinitionRegistryPostProcessor，
		 * 下面的代码是执行没有实现Ordered接口的BeanDefinitionRegistryPostProcessor
		 */
		boolean reiterate = true;
		while (reiterate) {
			reiterate = false;
			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				if (!processedBeans.contains(ppName)) {
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
					reiterate = true;
				}
			}
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			registryProcessors.addAll(currentRegistryProcessors);
			/** 第三次调用bean定义后置处理器 */
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			currentRegistryProcessors.clear();
		}

		// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
		/**
		 * 调用目前处理的所有后置处理器的回调函数
		 * registryProcessors装的是BeanDefinitionRegistryPostProcessor
		 * 上面的代码是执行子类独有的方法，这里需要再把父类的方法也执行一次
		 */
		invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
		/**
		 * regularPostProcessors装的是BeanFactoryPostProcessor，执行BeanFactoryPostProcessor的方法
		 * 但是regularPostProcessors一般情况下，是不会有数据的，只有在外面手动添加BeanFactoryPostProcessor，才会有数据
		 */
		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!
	/** 这里不进行初始化FactoryBeans，而是让bean工厂后置处理器去初始化这些常规的bean */
	String[] postProcessorNames =
			beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

	// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,Ordered, and the rest.
	/** 分离出 orderedPostProcessorNames 和nonOrderedPostProcessorNames */
	List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
	List<String> orderedPostProcessorNames = new ArrayList<>();
	List<String> nonOrderedPostProcessorNames = new ArrayList<>();
	/**
	 * 循环BeanNames
	 */
	for (String ppName : postProcessorNames) {
		/**
		 * 如果这个bean被执行过了，则跳过不执行
		 */
		if (processedBeans.contains(ppName)) {
			// skip - already processed in first phase above
		}
		/**
		 * 如果bean实现了PriorityOrdered接口，则加入到priorityOrderedPostProcessors
		 */
		else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
			priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
		}
		/**
		 * 如果bean实现了Ordered接口，则加入到orderedPostProcessorNames
		 */
		else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
			orderedPostProcessorNames.add(ppName);
		}
		/**
		 * 既没有实现PriorityOrdered接口，也没有实现Ordered接口，则加入到nonOrderedPostProcessorNames
		 */
		else {
			nonOrderedPostProcessorNames.add(ppName);
		}
	}

	// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
	/**
	 * 1、调用实现PriorityOrdered接口的bean工厂后置处理器
	 * 排序处理priorityOrderedPostProcessors,即实现了PriorityOrdered接口的BeanFactoryPostProcessor
	 */
	sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
	/**
	 * 执行priorityOrderedPostProcessor
	 */
	invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

	// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
	/**
	 * 2、调用实现Ordered接口实现的bean后置处理器
	 * 执行实现了Ordered接口的BeanFactoryPostProcessor
	 */
	List<BeanFactoryPostProcessor> 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.
	/**
	 * 3、调用其他所有的bean后置处理器
	 * 执行既没有实现PriorityOrdered接口也没有实现Ordered接口的BeanFactoryPostProcessor
	 */
	List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
	for (String postProcessorName : nonOrderedPostProcessorNames) {
		nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
	}
	/** 这里会调用EventListenerMethodProcessor.postProcessBeanFactory(),注册事件监听器后置处理器 */
	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();
}