refresh() -＞ registerBeanPostProcessors()

refresh() -> registerBeanPostProcessors()

注册Bean处理器（BeanPostProcessor），这里只是注册功能，真正调用的是getBean()方法

BeanPostProcessor

public interface BeanPostProcessor {
	/**
	 * 初始化方法调用前要进行的处理逻辑
	 */
	@Nullable
	default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}
	/**
	 * 在初始化方法指定后要进行的处理逻辑
	 */
	@Nullable
	default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}
}

常用的4个BeanPostProcessor接口

1.DestructionAwareBeanPostProcessor

在Bean被销毁前都会调用到postProcessBeforeDestruction()

public interface DestructionAwareBeanPostProcessor extends BeanPostProcessor {
	/**
	 * 在bean被销毁前调用
	 */
	void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException;

	/**
	 * 判断是否要进行销毁，一般情况下都需要
	 */
	default boolean requiresDestruction(Object bean) {
		return true;
	}
}

2.MergedBeanDefinitionPostProcessor

合并父类和子类信息

public interface MergedBeanDefinitionPostProcessor extends BeanPostProcessor {
   /**
    *spring通过此方法找出所有需要注入的字段，同时做缓存
    */
   void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName);
   /**
    * 用于在BeanDefinition被修改后，清除容器的缓存
    */
   default void resetBeanDefinition(String beanName) {
   }
}

3.InstantiationAwareBeanPostProcessor

实例化前后的处理工作

public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {
	/**
	 * 在bean实例化之前调用
	 */
	@Nullable
	default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
		return null;
	}
	/**
	 * 在bean实例化之后调用
	 */
	default boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
		return true;
	}
	/**
	 * 当使用注解的时候，通过这个方法来完成属性的注入
	 */
	@Nullable
	default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName)
			throws BeansException {
		return null;
	}
	/**
	 * 属性注入后执行的方法，在5.1版本被废弃
	 */
	@Deprecated
	@Nullable
	default PropertyValues postProcessPropertyValues(
			PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
		return pvs;
	}

}

4.SmartInstantiationAwareBeanPostProcessor

解决循环依赖

public interface SmartInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessor {
	/**
	 * 预测bean的类型，主要是在bean还没有创建前我们需要获取bean的类型
	 */
	@Nullable
	default Class<?> predictBeanType(Class<?> beanClass, String beanName) throws BeansException {
		return null;
	}
	/**
	 * 完成对构造函数的解析和推断
	 */
	@Nullable
	default Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName)
			throws BeansException {

		return null;
	}
	/**
	 * 解决循环依赖问题，通过此方法提前暴露一个合格的对象
	 */
	default Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
		return bean;
	}

}

registerBeanPostProcessors()

实例化并且注册所有的beanPostProcessor

protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
   PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}

PostProcessorRegistrationDelegate.registerBeanPostProcessors()

此方法的实现方式与PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors()方法处理逻辑相似

public static void registerBeanPostProcessors(
  ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

  // 找到所有实现了BeanPostProcessor接口的类
  String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

  // Register BeanPostProcessorChecker that logs an info message when
  // a bean is created during BeanPostProcessor instantiation, i.e. when
  // a bean is not eligible for getting processed by all BeanPostProcessors.
  // 记录下BeanPostProcessor的目标计数
  // 此处为什么要+1呢，原因非常简单，在此方法的最后会添加一个BeanPostProcessorChecker的类
  int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
  // 添加BeanPostProcessorChecker(主要用于记录信息)到beanFactory中
  beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

  // Separate between BeanPostProcessors that implement PriorityOrdered,
  // Ordered, and the rest.
  // 定义存放实现了PriorityOrdered接口的BeanPostProcessor集合
  List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
  // 定义存放spring内部的BeanPostProcessor
  List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
  // 定义存放实现了Ordered接口的BeanPostProcessor的name集合
  List<String> orderedPostProcessorNames = new ArrayList<>();
  // 定义存放普通的BeanPostProcessor的name集合
  List<String> nonOrderedPostProcessorNames = new ArrayList<>();
  // 遍历beanFactory中存在的BeanPostProcessor的集合postProcessorNames，
  for (String ppName : postProcessorNames) {
    // 如果ppName对应的BeanPostProcessor实例实现了PriorityOrdered接口，则获取到ppName对应的BeanPostProcessor的实例添加到priorityOrderedPostProcessors中
    if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
      BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
      priorityOrderedPostProcessors.add(pp);
      // 如果ppName对应的BeanPostProcessor实例也实现了MergedBeanDefinitionPostProcessor接口，那么则将ppName对应的bean实例添加到internalPostProcessors中
      if (pp instanceof MergedBeanDefinitionPostProcessor) {
        internalPostProcessors.add(pp);
      }
    }
    // 如果ppName对应的BeanPostProcessor实例没有实现PriorityOrdered接口，但是实现了Ordered接口，那么将ppName对应的bean实例添加到orderedPostProcessorNames中
    else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
      orderedPostProcessorNames.add(ppName);
    } else {
      // 否则将ppName添加到nonOrderedPostProcessorNames中
      nonOrderedPostProcessorNames.add(ppName);
    }
  }

  // First, register the BeanPostProcessors that implement PriorityOrdered.
  // 首先，对实现了PriorityOrdered接口的BeanPostProcessor实例进行排序操作
  sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
  // 注册实现了PriorityOrdered接口的BeanPostProcessor实例添加到beanFactory中
  registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

  // Next, register the BeanPostProcessors that implement Ordered.
  // 注册所有实现Ordered的beanPostProcessor
  List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
  for (String ppName : orderedPostProcessorNames) {
    // 根据ppName找到对应的BeanPostProcessor实例对象
    BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
    // 将实现了Ordered接口的BeanPostProcessor添加到orderedPostProcessors集合中
    orderedPostProcessors.add(pp);
    // 如果ppName对应的BeanPostProcessor实例也实现了MergedBeanDefinitionPostProcessor接口，那么则将ppName对应的bean实例添加到internalPostProcessors中
    if (pp instanceof MergedBeanDefinitionPostProcessor) {
      internalPostProcessors.add(pp);
    }
  }
  // 对实现了Ordered接口的BeanPostProcessor进行排序操作
  sortPostProcessors(orderedPostProcessors, beanFactory);
  //  注册实现了Ordered接口的BeanPostProcessor实例添加到beanFactory中
  registerBeanPostProcessors(beanFactory, orderedPostProcessors);

  // Now, register all regular BeanPostProcessors.
  // 创建存放没有实现PriorityOrdered和Ordered接口的BeanPostProcessor的集合
  List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
  // 遍历集合
  for (String ppName : nonOrderedPostProcessorNames) {
    // 根据ppName找到对应的BeanPostProcessor实例对象
    BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
    // 将没有实现PriorityOrdered和Ordered接口的BeanPostProcessor添加到nonOrderedPostProcessors集合中
    nonOrderedPostProcessors.add(pp);
    // 如果ppName对应的BeanPostProcessor实例也实现了MergedBeanDefinitionPostProcessor接口，那么则将ppName对应的bean实例添加到internalPostProcessors中
    if (pp instanceof MergedBeanDefinitionPostProcessor) {
      internalPostProcessors.add(pp);
    }
  }
  //  注册没有实现PriorityOrdered和Ordered的BeanPostProcessor实例添加到beanFactory中
  registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

  // Finally, re-register all internal BeanPostProcessors.
  // 将所有实现了MergedBeanDefinitionPostProcessor类型的BeanPostProcessor进行排序操作
  sortPostProcessors(internalPostProcessors, beanFactory);
  // 注册所有实现了MergedBeanDefinitionPostProcessor类型的BeanPostProcessor到beanFactory中
  registerBeanPostProcessors(beanFactory, internalPostProcessors);

  // Re-register post-processor for detecting inner beans as ApplicationListeners,
  // moving it to the end of the processor chain (for picking up proxies etc).
  // 注册ApplicationListenerDetector到beanFactory中
  beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

ApplicationListenerDetector监听器为什么会重新添加一次（prepareBeanFactory()方法中已经注册过一次）

为了能重新使其存在于集合的最后，方便在进行处理的时候来进行相关的一些检测工作