ApplicationContext是对容器的功能拓展，内置BeanFactory，并添加对SPEL，BeanPostPorcess自动注册等功能的支持

核心方法

public abstract class AbstractApplicationContext extends DefaultResourceLoader
        implements ConfigurableApplicationContext {
    public void refresh() throws BeansException, IllegalStateException {

        StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");

        // 准备、验证环境变量
        prepareRefresh();

        // 初始化BeanFactory，读取XML文件
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // 功能填充，主要包括添加SPEL解析器、对AspectJ的支持
        prepareBeanFactory(beanFactory);

        // 实例化并调用所有注册的BeanFactoryPostProcessor
        invokeBeanFactoryPostProcessors(beanFactory);

        // 注册Bean处理器
        registerBeanPostProcessors(beanFactory);

        // 初始化应用消息广播器
        initApplicationEventMulticaster();

        // 模板方法 子类实现
        onRefresh();

        // 注册时间监听器
        registerListeners();

        // 实例化非延迟加载Bean
        finishBeanFactoryInitialization(beanFactory);

        // 完成，通过lifeCycleProcessor发布事件
        finishRefresh();

    }
}

BeanFactoryPostProcessors

public interface BeanFactoryPostProcessor {

   void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;

}

实例化Bean前对Beandefine进行操作

自动注册BeanPostProcess 以及 对注解的支持

部分转载自binarylei - 博客园 (cnblogs.com)的文章

注解实现

核心接口

public interface MergedBeanDefinitionPostProcessor extends BeanPostProcessor {

//postProcessMergedBeanDefinition只在doCreateBean中，通过构造函数构造Bean实例后紧接着调用过一
//次，主要用于对Bean属性、方法进行解析，收集标记了某些注解的字段或者方法
	void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition,
        Class<?> beanType, String beanName);

	default void resetBeanDefinition(String beanName) {
	}

}

public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {

   //在属性应用到Bean前对其进行处理，仅在doCreateBean调用的populateBean中按类注入与按名注入完成后，
   //调用postProcessPropertyValues前，调用过一次，对PVS修改，然后再应用到Bean实例中
    default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName)
      throws BeansException {

   return null;
}
   //在属性应用到Bean前对其进行处理，仅在doCreateBean调用的populateBean中中按类注入与按名注入完成后，
   //将结果PVS应用到Bean实例前，调用过一次，对PVS修改，然后再应用到Bean实例中
   default PropertyValues postProcessPropertyValues(
         PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) 
         throws BeansException {
      return pvs;
   }

}

通常注解解析类实现这两个接口，进行属性解析，填充

对注解解析组件的注册

Spring 注解原理（一）组件注册 - binarylei - 博客园 (cnblogs.com)
Spring 注解原理（二）AutowiredAnnotationBeanPostProcessor：@Autowired @Value @Inject @Lookup - binarylei - 博客园 (cnblogs.com)
Spring 注解原理（三）AutowireCandidateResolver：@Qualifier @Value @Autowire @Lazy - binarylei - 博客园 (cnblogs.com)
SSM项目中开启注解的支持需要手动在配置文件中注册对应BeanPostProcessor组件，也可以通过配置 <context:annotation-config/>来调用registerAnnotationConfigProcessors自动注册。

public abstract class AnnotationConfigUtils {
    public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
            BeanDefinitionRegistry registry, Object source) {

        DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
        if (beanFactory != null) {
            // 1. 排序用，解析 @Order @Priority 注解或 PriorityOrdered Ordered 接口
            if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
                beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
            }
            // 2. 注入ContextAnnotationAutowireCandidateResolver，用于解析@Qualifier @Value，判断一个给定的对象是否可以使用@Autowire 
            if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
                beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
            }
        }

        Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<BeanDefinitionHolder>(4);

        // 3. @Configuration -> ConfigurationClassPostProcessor
        if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
            RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
        }
        // 4. @Autowired -> AutowiredAnnotationBeanPostProcessor
        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));
        }
        // 5. @Required -> RequiredAnnotationBeanPostProcessor
        if (!registry.containsBeanDefinition(REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
            RootBeanDefinition def = new RootBeanDefinition(RequiredAnnotationBeanPostProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
        }

        // 6. @Resource、@PostConstruct、@PreDestroy -> 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));
        }

        // 7. @Persistence -> 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(ex);
            }
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
        }

        // 8. @Persistence -> EventListenerMethodProcessor
        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));
        }
        // 9. @EventListener -> DefaultEventListenerFactory
        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;
    }

}

上文中registerPostProcessor方法没有把PostProcessor注册到beanPostProcessors中，而是注册到了beanDefinitionMap中，ApplicationContaxt的registerBeanPostProcessors会真正注册到beanPostProcessors中。

private static BeanDefinitionHolder registerPostProcessor(
      BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName) {

   definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
   registry.registerBeanDefinition(beanName, definition);
   return new BeanDefinitionHolder(definition, beanName);
}

registerBeanPostProcessors

public static void registerBeanPostProcessors(
        ConfigurableListableBeanFactory beanFactory, org.springframework.context.support.AbstractApplicationContext applicationContext) {
    String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
    
    // 使用Order保证顺序

    //首先，注册实现PriorityOrdered的BeanPostProcessor
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

    //然后，注册实现Ordered的BeanPostProcessor
    List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
    for (String ppName : orderedPostProcessorNames) {
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        orderedPostProcessors.add(pp);
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
        }
    }
    sortPostProcessors(orderedPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, orderedPostProcessors);

    //注册所有无序BeanPostProcessors，过程和上一步类似

    //最后，单独注册所有MergedBeanDefinePostProcessor类型的BeanPostProcessor
    sortPostProcessors(internalPostProcessors, 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).
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

注册过程中不会出现重复注册，注册时调用下段代码

public void addBeanPostProcessors(Collection<? extends BeanPostProcessor> beanPostProcessors) {
   this.beanPostProcessors.removeAll(beanPostProcessors);
   this.beanPostProcessors.addAll(beanPostProcessors);
}