protected void prepareRefresh() {
    //设置当前上下文状态
    this.startupDate = System.currentTimeMillis();
    this.closed.set(false);
    this.active.set(true);
    if (logger.isDebugEnabled()) {
      if (logger.isTraceEnabled()) {
        logger.trace("Refreshing " + this);
      }
      else {
        logger.debug("Refreshing " + getDisplayName());
      }
    }
    //初始化当前上下文属性的上下文，该方法内容为空，主要提供给子类进行实现
    initPropertySources();
    //验证所有标记为必需的属性都是可解析的
    getEnvironment().validateRequiredProperties();
    //下面是初始化监听器和事件源集合
    // Store pre-refresh ApplicationListeners...
    if (this.earlyApplicationListeners == null) {
      this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
    }
    else {
      // Reset local application listeners to pre-refresh state.
      this.applicationListeners.clear();
      this.applicationListeners.addAll(this.earlyApplicationListeners);
    }
    // Allow for the collection of early ApplicationEvents,
    // to be published once the multicaster is available...
    this.earlyApplicationEvents = new LinkedHashSet<>();
  }

    @Override
    protected void initPropertySources() {
        System.out.println("扩展initPropertySource");
        //这里添加了一个name属性到Environment里面，以方便我们在后面用到
        getEnvironment().getSystemProperties().put("name","bobo");
        //这里要求Environment中必须包含username属性，如果不包含，则抛出异常
        getEnvironment().setRequiredProperties("username");
    }

  protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    refreshBeanFactory();
    return getBeanFactory();
  }

  protected final void refreshBeanFactory() throws BeansException {
    //判断一下当前上下文是否有实例化beanFactory，存在则销毁，后面会重新构建
    if (hasBeanFactory()) {
      destroyBeans();
      closeBeanFactory();
    }
    try {
      //实例化一个beanFactory
      DefaultListableBeanFactory beanFactory = createBeanFactory();
      //设置ID
      beanFactory.setSerializationId(getId());
      // 定制beanFactory，设置相关属性，包括是否允许覆盖同名称的不同定义的对象以及循环依赖.属于拓展方法
      customizeBeanFactory(beanFactory);
      // 初始化documentReader,并进行XML文件读取及解析,默认命名空间的解析，自定义标签的解析
      //封装BeanDefinition对象用于后续实例化初始化等工作做准备
      loadBeanDefinitions(beanFactory);
      synchronized (this.beanFactoryMonitor) {
        this.beanFactory = beanFactory;
      }
    }
    catch (IOException ex) {
      throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
    }
  }

  protected DefaultListableBeanFactory createBeanFactory() {
    return new DefaultListableBeanFactory(getInternalParentBeanFactory());
  }

  public AbstractAutowireCapableBeanFactory() {
    super();
    //忽略属性注入时，不设置该值。一般是通过postProcessor进行注入的
    ignoreDependencyInterface(BeanNameAware.class);
    ignoreDependencyInterface(BeanFactoryAware.class);
    ignoreDependencyInterface(BeanClassLoaderAware.class);
  }

    @Override
    protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
        super.setAllowBeanDefinitionOverriding(false);
        super.setAllowCircularReferences(false);
        super.customizeBeanFactory(beanFactory);
    }

  protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
    // 将BeanDefinition封装成XmlBeanDefinitionReader，后续对其操作都是使用XmlBeanDefinitionReader
    XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
    //给其设置些属性
    beanDefinitionReader.setEnvironment(this.getEnvironment());
    beanDefinitionReader.setResourceLoader(this);
    beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
    //提供拓展方法，供子类进行拓展，可以对beanDefinitionReader进行一些初始化操作
    initBeanDefinitionReader(beanDefinitionReader);
    //解析配置
    loadBeanDefinitions(beanDefinitionReader);
  }

  public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {
    Assert.notNull(locations, "Location array must not be null");
    int count = 0;
    for (String location : locations) {
      count += loadBeanDefinitions(location);
    }
    return count;
  }

  public int loadBeanDefinitions(String location) throws BeanDefinitionStoreException {
    return loadBeanDefinitions(location, null);
  }

  public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException {
    //获取上下文的资源加载器
    ResourceLoader resourceLoader = getResourceLoader();
    if (resourceLoader == null) {
      throw new BeanDefinitionStoreException(
          "Cannot load bean definitions from location [" + location + "]: no ResourceLoader available");
    }
    //判断加载器类型
    if (resourceLoader instanceof ResourcePatternResolver) {
      // Resource pattern matching available.
      try {
        //将传进来的配置文件路径进行解析，判断路径中是否含有classPath*: 或war:等，对其解析成多个Resource
        Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
        //解析处理
        int count = loadBeanDefinitions(resources);
        if (actualResources != null) {
          Collections.addAll(actualResources, resources);
        }
        if (logger.isTraceEnabled()) {
          logger.trace("Loaded " + count + " bean definitions from location pattern [" + location + "]");
        }
        return count;
      }
      catch (IOException ex) {
        throw new BeanDefinitionStoreException(
            "Could not resolve bean definition resource pattern [" + location + "]", ex);
      }
    }
    else {
      // 通过路径封装成一个Resource 
      Resource resource = resourceLoader.getResource(location);
      int count = loadBeanDefinitions(resource);
      if (actualResources != null) {
        actualResources.add(resource);
      }
      if (logger.isTraceEnabled()) {
        logger.trace("Loaded " + count + " bean definitions from location [" + location + "]");
      }
      return count;
    }
  }

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
      throws BeanDefinitionStoreException {
    try {
      //根据inputSource和resource加载XML文件，并封装成Document
      Document doc = doLoadDocument(inputSource, resource);
      //解析并封装和注册成BeanDefinition
      int count = registerBeanDefinitions(doc, resource);
      if (logger.isDebugEnabled()) {
        logger.debug("Loaded " + count + " bean definitions from " + resource);
      }
      return count;
    }
    catch (BeanDefinitionStoreException ex) {
      throw ex;
    }
    catch (SAXParseException ex) {
      throw new XmlBeanDefinitionStoreException(resource.getDescription(),
          "Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);
    }
    catch (SAXException ex) {
      throw new XmlBeanDefinitionStoreException(resource.getDescription(),
          "XML document from " + resource + " is invalid", ex);
    }
    catch (ParserConfigurationException ex) {
      throw new BeanDefinitionStoreException(resource.getDescription(),
          "Parser configuration exception parsing XML from " + resource, ex);
    }
    catch (IOException ex) {
      throw new BeanDefinitionStoreException(resource.getDescription(),
          "IOException parsing XML document from " + resource, ex);
    }
    catch (Throwable ex) {
      throw new BeanDefinitionStoreException(resource.getDescription(),
          "Unexpected exception parsing XML document from " + resource, ex);
    }
  }

  protected Document doLoadDocument(InputSource inputSource, Resource resource) throws Exception {
     // getValidationModeForResource(resource): 获取XML配置文件的验证模式
     // documentLoader.loadDocument: 加载XML文件，解析封装成 Document
    return this.documentLoader.loadDocument(inputSource, getEntityResolver(), this.errorHandler,
        getValidationModeForResource(resource), isNamespaceAware());
  }
  protected int getValidationModeForResource(Resource resource) {
    //获取当前的验证模式标识
    int validationModeToUse = getValidationMode();
    //如果为指定则返回指定的
    if (validationModeToUse != VALIDATION_AUTO) {
      return validationModeToUse;
    }
    //解析出配置文件的验证模式
    int detectedMode = detectValidationMode(resource);
    //如果检测出的验证模式不为 VALIDATION_AUTO, 则返回检测出来的验证模式
    if (detectedMode != VALIDATION_AUTO) {
      return detectedMode;
    }
    // Hmm, we didn't get a clear indication... Let's assume XSD,
    // since apparently no DTD declaration has been found up until
    // detection stopped (before finding the document's root tag).
    return VALIDATION_XSD;
  }
  public int getValidationMode() {
    return this.validationMode;
  }
  protected int detectValidationMode(Resource resource) {
    if (resource.isOpen()) {
      throw new BeanDefinitionStoreException(
          "Passed-in Resource [" + resource + "] contains an open stream: " +
          "cannot determine validation mode automatically. Either pass in a Resource " +
          "that is able to create fresh streams, or explicitly specify the validationMode " +
          "on your XmlBeanDefinitionReader instance.");
    }
    InputStream inputStream;
    try {
      inputStream = resource.getInputStream();
    }
    catch (IOException ex) {
      throw new BeanDefinitionStoreException(
          "Unable to determine validation mode for [" + resource + "]: cannot open InputStream. " +
          "Did you attempt to load directly from a SAX InputSource without specifying the " +
          "validationMode on your XmlBeanDefinitionReader instance?", ex);
    }
    try {
      //解析检查出当前的验证标识
      return this.validationModeDetector.detectValidationMode(inputStream);
    }
    catch (IOException ex) {
      throw new BeanDefinitionStoreException("Unable to determine validation mode for [" +
          resource + "]: an error occurred whilst reading from the InputStream.", ex);
    }
  }

  public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
    //通过反射创建默认的DefaultBeanDefinitionDocumentReader，其为BeanDefinitionDocumentReader的子类
    BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
    //记录统计前BeanDefinition的加载个数
    int countBefore = getRegistry().getBeanDefinitionCount();
    //封装BeanDefinition对象，并加入缓存集合中
    documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
    return getRegistry().getBeanDefinitionCount() - countBefore;
  }

  protected void doRegisterBeanDefinitions(Element root) {
    BeanDefinitionParserDelegate parent = this.delegate;
    this.delegate = createDelegate(getReaderContext(), root, parent);
    //校验root节点的命名空间是否为默认的命名空间（默认命名空间http://www.springframework.org/schema/beans）
    if (this.delegate.isDefaultNamespace(root)) {
      //获取profile属性
      String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
      if (StringUtils.hasText(profileSpec)) {
        String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
            profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
        // We cannot use Profiles.of(...) since profile expressions are not supported
        // in XML config. See SPR-12458 for details.
        if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
          if (logger.isDebugEnabled()) {
            logger.debug("Skipped XML bean definition file due to specified profiles [" + profileSpec +
                "] not matching: " + getReaderContext().getResource());
          }
          return;
        }
      }
    }
    //拓展方法，没有实现，主要留给子类拓展使用
    preProcessXml(root);
    parseBeanDefinitions(root, this.delegate);
    //拓展方法，没有实现，主要留给子类拓展使用
    postProcessXml(root);
    this.delegate = parent;
  }