【小家Spring】Spring IOC容器启动流程 AbstractApplicationContext#refresh()方法源码分析（一）(中)-阿里云开发者社区

request上下文是如何跟线程上下文绑定的，参考原理：【小家Spring】Spring MVC执行流程 FrameworkServlet、DispatcherServlet源码分析（processRequest、doDispatch）

小伙伴们以后要使用Servlet源生对象，不要只知道从方法入参里注入，看起来很不优雅，很不Spring MVC化，懂了这些原理来龙去脉后，相信可以放心的、安全的使用了~

从这方面可以看出，我们不得不佩服Spring的考虑周到。一个优秀的框架，绝对不仅仅是实现了某个功能而已，而是能让你用得舒服，用得爽，可扩展性非常强等一些附加属性~~~~比如下面的web容器AbstractRefreshableWebApplicationContext就会设置一些初始值：

  @Override
  protected void initPropertySources() {
    ConfigurableEnvironment env = getEnvironment();
    // 初始化web环境中的初始值（比如init等，这个后续会说）
    if (env instanceof ConfigurableWebEnvironment) {
      ((ConfigurableWebEnvironment) env).initPropertySources(this.servletContext, null);
    }
  }
    @Override
  public ConfigurableEnvironment getEnvironment() {
    if (this.environment == null) {
      this.environment = createEnvironment();
    }
    return this.environment;
  }
  // 这个方法需要注意一下，默认是StandardEnvironment，但是它是protected方法设计，所以之类可以重写（如下图）
  protected ConfigurableEnvironment createEnvironment() {
    return new StandardEnvironment();
  }
//StandardServletEnvironment.initPropertySources(this.servletContext, null)
  @Override
  public void initPropertySources(@Nullable ServletContext servletContext, @Nullable ServletConfig servletConfig) {
  // 将 servletContext、servletConfig 添加到 propertySources里(ServletConfigPropertySource)
  //ServletConfigPropertySource作用：reads init parameters from ServletConfig
    WebApplicationContextUtils.initServletPropertySources(getPropertySources(), servletContext, servletConfig);
  }

它们都是web环境下的上下文，因此重写的方式也是一模一样：

  //StandardServletEnvironment是web环境上下文里的Enviroment
  @Override
  protected ConfigurableEnvironment createEnvironment() {
    return new StandardServletEnvironment();
  }

refresh() 第二步：ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory()

实际上就是重新创建一个bean工厂，并销毁原工厂。主要工作是创建DefaultListableBeanFactory实例，解析配置文件，注册Bean的定义信息

  protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    refreshBeanFactory();
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    if (logger.isDebugEnabled()) {
      logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
    }
    return beanFactory;
  }

在spring中，基本上各司其职，每个类都有每个类的作用。其中refreshBeanFactory()是具体的刷新BeanFactory,负责这个工作做在类AbstractRefreshableApplicationContext#refreshBeanFactory中，顾名思义这是专门用来刷新的：

  @Override
  protected final void refreshBeanFactory() throws BeansException {
    // 判断是否已经存在BeanFactory，存在则销毁所有Beans，并且关闭BeanFactory
    // 避免重复加载BeanFactory
    if (hasBeanFactory()) {
      destroyBeans();
      closeBeanFactory();
    }
    try {
      // 创建具体的beanFactory，这里创建的是DefaultListableBeanFactory，最重要的beanFactory spring注册及加载bean就靠它
      // createBeanFactory()这个方法，看下面，还有得说的
      DefaultListableBeanFactory beanFactory = createBeanFactory();
      beanFactory.setSerializationId(getId());
      // 这句比较简单，就是把当前旧容器的一些配置值复制给新容器 
      // allowBeanDefinitionOverriding属性是指是否允对一个名字相同但definition不同进行重新注册，默认是true。
      // allowCircularReferences属性是指是否允许Bean之间循环引用，默认是true.
      // 这两个属性值初始值为空：复写此方法即可customizeBeanFactory
      customizeBeanFactory(beanFactory);
      // 这个就是最重要的了，加载所有的Bean配置信息，具体如下详细解释
      // 它属于模版方法，由子类去实现加载的方式
      loadBeanDefinitions(beanFactory);
      synchronized (this.beanFactoryMonitor) {
        this.beanFactory = beanFactory;
      }
    }
    catch (IOException ex) {
      throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
    }
  }

createBeanFactory()

  // 创建的时候就是new了一个工厂：DefaultListableBeanFactory   这个时候工厂里面所有东西都是默认值，很多还没有完成初始化属性的设置呢
  protected DefaultListableBeanFactory createBeanFactory() {
    return new DefaultListableBeanFactory(getInternalParentBeanFactory());
  }
  // 给设置父的BeanFactory，若存在的话
  public AbstractAutowireCapableBeanFactory(@Nullable BeanFactory parentBeanFactory) {
    this();
    setParentBeanFactory(parentBeanFactory);
  }
  // 父类空构造器有这么些语句
  public AbstractAutowireCapableBeanFactory() {
    super();
    // 这里是重点。忽略自动装配。这里指定的都是接口。什么意思呢？
    // ignoreDependencyInterface的真正意思是在自动装配时忽略指定接口的实现类中，对外的依赖。（这里面注意：@Autowired和它的关系，其实是有坑的，后续会专门讲解这个坑）
    ignoreDependencyInterface(BeanNameAware.class);
    ignoreDependencyInterface(BeanFactoryAware.class);
    ignoreDependencyInterface(BeanClassLoaderAware.class);
  }
  //找到父的，若存在就返回 若存在父容器就存在父的BeanFactory
  @Nullable
  protected BeanFactory getInternalParentBeanFactory() {
    return (getParent() instanceof ConfigurableApplicationContext) ?
        ((ConfigurableApplicationContext) getParent()).getBeanFactory() : getParent();
  }

AnnotationConfigWebApplicationContext#loadBeanDefinitions()方法，加载Bean的定义（XmlWebApplicationContext的实现不一样，因为它是加载xml配置文件）

  @Override
  protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) {
    // 初始化这个脚手架 其实就是直接new出实例。具体做的工作，下面有相关博文链接
    AnnotatedBeanDefinitionReader reader = getAnnotatedBeanDefinitionReader(beanFactory);
    ClassPathBeanDefinitionScanner scanner = getClassPathBeanDefinitionScanner(beanFactory);
    // 生成Bean的名称的生成器，如果自己没有setBeanNameGenerator（可以自定义）,这里目前为null
    BeanNameGenerator beanNameGenerator = getBeanNameGenerator();
    if (beanNameGenerator != null) {
      reader.setBeanNameGenerator(beanNameGenerator);
      scanner.setBeanNameGenerator(beanNameGenerator);
      //若我们注册了beanName生成器，那么就会注册进容器里面
      beanFactory.registerSingleton(AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR, beanNameGenerator);
    }
    //这是给reader和scanner注册scope的解析器  此处为null
    ScopeMetadataResolver scopeMetadataResolver = getScopeMetadataResolver();
    if (scopeMetadataResolver != null) {
      reader.setScopeMetadataResolver(scopeMetadataResolver);
      scanner.setScopeMetadataResolver(scopeMetadataResolver);
    }
    // 此处注意了：annotatedClasses和basePackages一般是选其一（当然看到此处，他们是可以并存的）
    //我们可以自己指定annotatedClasses 配置文件,同时也可以交给下面扫描
    if (!this.annotatedClasses.isEmpty()) {
      // 这里会把所有的配置文件输出=======info日志  请注意观察控制台
      if (logger.isInfoEnabled()) {
        logger.info("Registering annotated classes: [" +
            StringUtils.collectionToCommaDelimitedString(this.annotatedClasses) + "]");
      }
      // 若是指明的Bean，就交给reader去处理，至于怎么处理，见上篇博文的doRegisterBean去怎么解析每一个Config Bean的
      reader.register(ClassUtils.toClassArray(this.annotatedClasses));
    }
    // 也可以是包扫描的方式，扫描配置文件的Bean
    if (!this.basePackages.isEmpty()) {
      // 输出对应的info日志
      if (logger.isInfoEnabled()) {
        logger.info("Scanning base packages: [" +
            StringUtils.collectionToCommaDelimitedString(this.basePackages) + "]");
      }
      // 这里重要了，scan方法具体做了什么事，上篇博文也有详细的介绍，请参阅
      scanner.scan(StringUtils.toStringArray(this.basePackages));
    }
    // 此处的意思是，也可以以全类名的形式注册。比如可以调用setConfigLocations设置（这在xml配置中使用较多）  可以是全类名，也可以是包路径
    String[] configLocations = getConfigLocations();
    if (configLocations != null) {
      for (String configLocation : configLocations) {
        try {
          Class<?> clazz = ClassUtils.forName(configLocation, getClassLoader());
          reader.register(clazz);
        } catch (ClassNotFoundException ex) {
          // 发现不是全类名，那就当作包扫描吧
          int count = scanner.scan(configLocation);
        }
      }
    }
  }

最开始涉及到两个类的初始化，请参考博文：

【小家Spring】Spring容器加载Bean定义信息的两员大将：AnnotatedBeanDefinitionReader和ClassPathBeanDefinitionScanner

有了这篇博文解释这两个类先行，理解上面loadBeanDefinitions就简单太多了。至此，整个ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();这个步骤全部结束。

现在BeanFactory已经创建了，并且Config配置文件的Bean定义已经注册完成了**（备注：其它单例Bean是还没有解析的~~~~）**

显然，下面的步骤大都把BeanFactory传进去了，都是基于此Bean工厂的了~~~

refresh() 第三步：prepareBeanFactory(beanFactory)

这个方法是配置工厂的标准上下文特征

  protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    // 设置beanFactory的classLoader为当前context的classLoader
    beanFactory.setBeanClassLoader(getClassLoader());
    // 设置EL表达式解析器（Bean初始化完成后填充属性时会用到）
    // spring3增加了表达式语言的支持，默认可以使用#{bean.xxx}的形式来调用相关属性值
    beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
    // 设置属性注册解析器PropertyEditor 这个主要是对bean的属性等设置管理的一个工具
    beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
    // 将当前的ApplicationContext对象交给ApplicationContextAwareProcessor类来处理，从而在Aware接口实现类中的注入applicationContext等等
    // 添加了一个处理aware相关接口的beanPostProcessor扩展，主要是使用beanPostProcessor的postProcessBeforeInitialization()前置处理方法实现aware相关接口的功能
    // 类似的还有ResourceLoaderAware、ServletContextAware等等等等
    beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
    // 下面是忽略的自动装配（也就是实现了这些接口的Bean，不要Autowired自动装配了）
    // 默认只有BeanFactoryAware被忽略,所以其它的需要自行设置
    // 因为ApplicationContextAwareProcessor把这5个接口的实现工作做了（具体你可参见源码） 所以这里就直接忽略掉
    beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
    beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
    beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
    beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
    // 设置几个"自动装配"规则======如下：
    // 如果是BeanFactory的类，就注册beanFactory
    //  如果是ResourceLoader、ApplicationEventPublisher、ApplicationContext等等就注入当前对象this(applicationContext对象)
    // 此处registerResolvableDependency()方法注意：它会把他们加入到DefaultListableBeanFactory的resolvableDependencies字段里面缓存这，供后面处理依赖注入的时候使用 DefaultListableBeanFactory#resolveDependency处理依赖关系
    // 这也是为什么我们可以通过依赖注入的方式，直接注入这几个对象比如ApplicationContext可以直接依赖注入
    // 但是需要注意的是：这些Bean，Spring的IOC容器里其实是没有的。beanFactory.getBeanDefinitionNames()和beanFactory.getSingletonNames()都是找不到他们的，所以特别需要理解这一点
    // 至于容器中没有，但是我们还是可以@Autowired直接注入的有哪些，请看下图：
    beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
    beanFactory.registerResolvableDependency(ResourceLoader.class, this);
    beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
    beanFactory.registerResolvableDependency(ApplicationContext.class, this);
    // 注册这个Bean的后置处理器：在Bean初始化后检查是否实现了ApplicationListener接口
    // 是则加入当前的applicationContext的applicationListeners列表 这样后面广播事件也就方便了
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
    // 检查容器中是否包含名称为loadTimeWeaver的bean，实际上是增加Aspectj的支持
    // AspectJ采用编译期织入、类加载期织入两种方式进行切面的织入
    // 类加载期织入简称为LTW（Load Time Weaving）,通过特殊的类加载器来代理JVM默认的类加载器实现
    if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
      // 添加BEAN后置处理器：LoadTimeWeaverAwareProcessor
          // 在BEAN初始化之前检查BEAN是否实现了LoadTimeWeaverAware接口，
          // 如果是，则进行加载时织入，即静态代理。
      beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
      // Set a temporary ClassLoader for type matching.
      beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }
    // 注入一些其它信息的bean，比如environment、systemProperties、SystemEnvironment等
    if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
      beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
    }
    if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
      beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
    }
    if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
      beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
    }
  }