IoC之解析Bean：解析import标签

private void parseDefaultElement(Element ele, 
                                 BeanDefinitionParserDelegate delegate) {
	// 对 import 标签的解析
  if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
    importBeanDefinitionResource(ele);
  }
  	// 对 alias 标签的解析
  else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
    processAliasRegistration(ele);
  }
  	// 对 bean 标签的解析
  else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
    processBeanDefinition(ele, delegate);
  }
  	// 对 beans 标签的解析
  else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
  	// recurse
    doRegisterBeanDefinitions(ele);
  }
}

protected void importBeanDefinitionResource(Element ele) {
  // 获取 resource 的属性值 
  String location = ele.getAttribute(RESOURCE_ATTRIBUTE);
  // 为空，直接退出
  if (!StringUtils.hasText(location)) {
    getReaderContext().error("Resource location must not be empty", ele);
    return;
  }

  // 解析系统属性，格式如 ："${user.dir}"
  location = getReaderContext().getEnvironment().resolveRequiredPlaceholders(location);

  Set<Resource> actualResources = new LinkedHashSet<>(4);

  // 判断 location 是相对路径还是绝对路径
  boolean absoluteLocation = false;
  try {
    absoluteLocation = ResourcePatternUtils.isUrl(location) || ResourceUtils.toURI(location).isAbsolute();
  }
  catch (URISyntaxException ex) {
    // cannot convert to an URI, considering the location relative
    // unless it is the well-known Spring prefix "classpath*:"
  }

  // 绝对路径
  if (absoluteLocation) {
    try {
      // 直接根据地质加载相应的配置文件
      int importCount = getReaderContext()
        .getReader().loadBeanDefinitions(location, actualResources);
      if (logger.isDebugEnabled()) {
        logger.debug("Imported " 
                     + importCount 
                     + " bean definitions from URL location [" 
                     + location + "]");
      }
    }
    catch (BeanDefinitionStoreException ex) {
      getReaderContext().error(
        "Failed to import bean definitions from URL location [" 
        + location + "]", ele, ex);
    }
  }
  else {
    // 相对路径则根据相应的地质计算出绝对路径地址
    try {
      int importCount;
      Resource relativeResource = getReaderContext()
        .getResource().createRelative(location);
      if (relativeResource.exists()) {
        importCount = getReaderContext()
          .getReader().loadBeanDefinitions(relativeResource);
        actualResources.add(relativeResource);
      }
      else {
        String baseLocation = getReaderContext()
          .getResource().getURL().toString();
        importCount = getReaderContext().getReader()
          .loadBeanDefinitions(
          StringUtils.applyRelativePath(baseLocation, location), 
          actualResources);
      }
      if (logger.isDebugEnabled()) {
        logger.debug("Imported " + importCount 
                     + " bean definitions from relative location [" 
                     + location + "]");
      }
    }
    catch (IOException ex) {
      getReaderContext().error("Failed to resolve current resource location", ele, ex);
    }
    catch (BeanDefinitionStoreException ex) {
      getReaderContext()
        .error("Failed to import bean definitions from relative location [" 
               + location + "]",
                               ele, ex);
    }
  }
  // 解析成功后，进行监听器激活处理
  Resource[] actResArray = actualResources.toArray(new Resource[0]);
  getReaderContext().fireImportProcessed(location, actResArray, extractSource(ele));
}

absoluteLocation = ResourcePatternUtils.isUrl(location) || 
ResourceUtils.toURI(location).isAbsolute();

public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) 
  throws BeanDefinitionStoreException {
  ResourceLoader resourceLoader = getResourceLoader();
  if (resourceLoader == null) {
    throw new BeanDefinitionStoreException(
      "Cannot import bean definitions from location [" 
      + location + "]: no ResourceLoader available");
  }

  if (resourceLoader instanceof ResourcePatternResolver) {
    // Resource pattern matching available.
    try {
      Resource[] resources = ((ResourcePatternResolver) resourceLoader)
        .getResources(location);
      int loadCount = loadBeanDefinitions(resources);
      if (actualResources != null) {
        for (Resource resource : resources) {
          actualResources.add(resource);
        }
      }
      if (logger.isDebugEnabled()) {
        logger.debug("Loaded " + loadCount 
                     + " bean definitions from location pattern [" 
                     + location + "]");
      }
      return loadCount;
    }
    catch (IOException ex) {
      throw new BeanDefinitionStoreException(
        "Could not resolve bean definition resource pattern [" 
        + location + "]", ex);
    }
  }
  else {
    // Can only load single resources by absolute URL.
    Resource resource = resourceLoader.getResource(location);
    int loadCount = loadBeanDefinitions(resource);
    if (actualResources != null) {
      actualResources.add(resource);
    }
    if (logger.isDebugEnabled()) {
      logger.debug("Loaded " 
                   + loadCount 
                   + " bean definitions from location [" 
                   + location + "]");
    }
    return loadCount;
  }
}