ApplicationContext和BeanFactory两者都是加载bean的。但是相比之下，前者提供了更多的功能。

  1. public ClassPathXmlApplicationContext(
  2.     String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
  3.     throws BeansException {
  5.     super(parent);
  6.     setConfigLocations(configLocations);
  7.     if (refresh) {
  8.         refresh();
  9.     }
  10. }

ClassPathXmlApplicationContext可以对数组进行解析并进行加载，而对于解析以及功能实现都在refresh中。

6.2 扩展功能

AbstractApplicationContext

  1.     public void refresh() throws BeansException, IllegalStateException {
  2.         synchronized (this.startupShutdownMonitor) {
  3.             // Prepare this context for refreshing.
  4.             //刷新上下文环境
  5.             prepareRefresh();
  7.             // Tell the subclass to refresh the internal bean factory.
  8.             // 初始化BeanFactory，并进行XML文件读取
  9.             ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
  11.             // Prepare the bean factory for use in this context.
  12.             // 对beanFactory进行各种填充
  13.             prepareBeanFactory(beanFactory);
  15.             try {
  16.                 // Allows post-processing of the bean factory in context subclasses.
  17.                 //子类覆盖方法做额外的处理
  18.                 postProcessBeanFactory(beanFactory);
  20.                 // Invoke factory processors registered as beans in the context.
  21.                 // 激活各种BeanFactory处理器
  22.                 invokeBeanFactoryPostProcessors(beanFactory);
  24.                 // Register bean processors that intercept bean creation.
  25.                 //注册拦截Bean创建的Bean处理器，这里只是注册，真正的调用在getBean时候
  26.                 registerBeanPostProcessors(beanFactory);
  28.                 // Initialize message source for this context.
  29.                 // 为上下文初始化Message源，国际化处理。
  30.                 initMessageSource();
  32.                 // Initialize event multicaster for this context.
  33.                 initApplicationEventMulticaster();
  35.                 // Initialize other special beans in specific context subclasses.
  36.                 //留给子类来初始化其他bean
  37.                 onRefresh();
  39.                 // Check for listener beans and register them.
  40.                 //在所有注册的bean中查找Listener bean ,并注册到消息广播器中
  41.                 registerListeners();
  43.                 // Instantiate all remaining (non-lazy-init) singletons.
  44.                 // 初始化剩下的单实例(非惰性的)
  45.                 finishBeanFactoryInitialization(beanFactory);
  47.                 // Last step: publish corresponding event.
  48.                 // 完成刷新过程，通知生命周期LifecycleProcessor刷新过程，同时发出ContextRefreshEvent通知别人
  49.                 finishRefresh();
  50.             }
  52.             catch (BeansException ex) {
  53.                 if (logger.isWarnEnabled()) {
  54.                     logger.warn("Exception encountered during context initialization - " +
  55.                             "cancelling refresh attempt: " + ex);
  56.                 }
  58.                 // Destroy already created singletons to avoid dangling resources.
  59.                 destroyBeans();
  61.                 // Reset 'active' flag.
  62.                 cancelRefresh(ex);
  64.                 // Propagate exception to caller.
  65.                 throw ex;
  66.             }
  68.             finally {
  69.                 // Reset common introspection caches in Spring's core, since we
  70.                 // might not ever need metadata for singleton beans anymore...
  71.                 resetCommonCaches();
  72.             }
  73.         }
  74.     }


/

6.4 加载BeanFactory

AbstractApplicationContext.refresh()->``obtainFreshBeanFactory

经过obtainFreshBeanFactory 这个函数之后，ApplicationContext就已经拥有了BeanFactory的全部功能。

AbstractRefreshableApplicationContext.refreshBeanFactory

  1.     protected final void refreshBeanFactory() throws BeansException {
  2.         if (hasBeanFactory()) {
  3.             destroyBeans();
  4.             closeBeanFactory();
  5.         }
  6.         try {
  7.             DefaultListableBeanFactory beanFactory = createBeanFactory();
  8.             beanFactory.setSerializationId(getId());
  9.             //定制beanFactory，设置相关属性，包括是运行覆盖同名称的不同定义的对象以及循环依赖以及
  10.             //设置@Autowrited 和@Qualifier注解解析器
  11.             customizeBeanFactory(beanFactory);
  12.             //初始化DoumentReader ，并进行XML文件读取及解析
  13.             loadBeanDefinitions(beanFactory);
  14.             this.beanFactory = beanFactory;
  15.         }
  16.         catch (IOException ex) {
  17.             throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
  18.         }
  19.     }

6.5 功能扩展

进入prepareBeanFactory前，Spring已经完成了对配置的解析，而ApplicationContext在功能上的扩展也由此展开。

  1.     protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
  2.         // Tell the internal bean factory to use the context's class loader etc.
  3.         beanFactory.setBeanClassLoader(getClassLoader());
  4.         beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
  5.         //为beanFactory增加一个默认的propertyEditor ，这个主要是对bean属性等设置管理的一个工具
  6.         beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
  8.         // Configure the bean factory with context callbacks.
  9.         //忽略几个自动装配的接口
  10.         beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
  11.         beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
  12.         beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
  13.         beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
  14.         beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
  15.         beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
  16.         beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
  18.         // BeanFactory interface not registered as resolvable type in a plain factory.
  19.         // MessageSource registered (and found for autowiring) as a bean.
  20.         beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
  21.         beanFactory.registerResolvableDependency(ResourceLoader.class, this);
  22.         beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
  23.         beanFactory.registerResolvableDependency(ApplicationContext.class, this);
  25.         // Register early post-processor for detecting inner beans as ApplicationListeners.
  26.         beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
  28.         // Detect a LoadTimeWeaver and prepare for weaving, if found.
  29.         // 增加对AspectJ的支持
  30.         if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
  31.             beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
  32.             // Set a temporary ClassLoader for type matching.
  33.             beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
  34.         }
  36.         // Register default environment beans.
  37.         //添加默认的系统环境bean
  38.         if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
  39.             beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
  40.         }
  41.         if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
  42.             beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
  43.         }
  44.         if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
  45.             beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
  46.         }
  47.     }

上述主要进行了几个方面的扩展。

  • 增加对SpEL语言的支持
  • 增加对属性编辑器的支持
  • 增加一些内置类，
  • 设置了依赖功能可忽略的接口
  • 注册一些固定依赖的属性
  • 增加AspectJ的支持
  • 将相关环境变量及属性注册以单例模糊注册

6.6 BeanFactory的后处理

BeanFactory作为Spring中容器功能的基础，用于存放所有已经加载的bean，为了保证程序上的高可扩展性，Spring针对BeanFactory做了大量的扩展，比如我们熟知的PostProcessor。

6.6.1 激活注册的BeanFactoryPostProcessor

spring对BeanFactoryPostProcessor的典型应用是PropertyResourceConfigurer

2 使用自定义的 BeanFactoryPostProcessor