public ClassPathXmlApplicationContext(
      String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
      throws BeansException {
    //调用父类方法进行初始化
    super(parent);
    //对location文件路径进行解析、替换占位符等工作
    setConfigLocations(configLocations);
    if (refresh) {
      refresh();
    }
  }

  public AbstractApplicationContext(@Nullable ApplicationContext parent) {
    this();
    setParent(parent);
  }

  protected ResourcePatternResolver getResourcePatternResolver() {
    //返回一个返回用于解析占位符的解析器
    return new PathMatchingResourcePatternResolver(this);
  }

    public void setParent(@Nullable ApplicationContext parent) {
    //赋值传进来的父上下文到当前上下文属性中
    this.parent = parent;
    if (parent != null) {
      //获取父容器系统环境属性
      Environment parentEnvironment = parent.getEnvironment();
      if (parentEnvironment instanceof ConfigurableEnvironment) {
        //合并到当前上下文中
        getEnvironment().merge((ConfigurableEnvironment) parentEnvironment);
      }
    }
  }

  @Override
  public String resolveRequiredPlaceholders(String text) throws IllegalArgumentException {
    return this.propertyResolver.resolveRequiredPlaceholders(text);
  }

  protected String parseStringValue(
      String value, PlaceholderResolver placeholderResolver, @Nullable Set<String> visitedPlaceholders) {
    //这里的this.placeholderPrefix 默认值为${
    int startIndex = value.indexOf(this.placeholderPrefix);
    //判断下传进来的路径是否有${开头的占位符
    if (startIndex == -1) {
      return value;
    }
    StringBuilder result = new StringBuilder(value);
    while (startIndex != -1) {
      //查询一下是否有结束占位符下标
      int endIndex = findPlaceholderEndIndex(result, startIndex);
      if (endIndex != -1) {
        //获取占位符内容
        String placeholder = result.substring(startIndex + this.placeholderPrefix.length(), endIndex);
        String originalPlaceholder = placeholder;
        if (visitedPlaceholders == null) {
          visitedPlaceholders = new HashSet<>(4);
        }
        if (!visitedPlaceholders.add(originalPlaceholder)) {
          throw new IllegalArgumentException(
              "Circular placeholder reference '" + originalPlaceholder + "' in property definitions");
        }
        // 递归调用，看占位符内容是否还有包含占位符 ，比如${${user}}
        placeholder = parseStringValue(placeholder, placeholderResolver, visitedPlaceholders);
        // 通过占位符内容名称去查询出，获取具体值，如user从environment中查出当前电脑名称
        String propVal = placeholderResolver.resolvePlaceholder(placeholder);
        if (propVal == null && this.valueSeparator != null) {
          //如果查不到可能是以键值对的形式 如 name:zhangsan
          //这时候我们要解析出KEY跟VALUE
          //获取:符号的下标
          int separatorIndex = placeholder.indexOf(this.valueSeparator);
          if (separatorIndex != -1) {
            //获取出key的值，如name
            String actualPlaceholder = placeholder.substring(0, separatorIndex);
            //获取出value的值,如zhangsan
            String defaultValue = placeholder.substring(separatorIndex + this.valueSeparator.length());
            //通过key值名称去查询，如果查不到则以actualPlaceholder为默认值进行赋值
            propVal = placeholderResolver.resolvePlaceholder(actualPlaceholder);
            if (propVal == null) {
              propVal = defaultValue;
            }
          }
        }
        if (propVal != null) {
          //递归调用，解析包含在以前解析的占位符值中的占位符。
          propVal = parseStringValue(propVal, placeholderResolver, visitedPlaceholders);
          result.replace(startIndex, endIndex + this.placeholderSuffix.length(), propVal);
          if (logger.isTraceEnabled()) {
            logger.trace("Resolved placeholder '" + placeholder + "'");
          }
          startIndex = result.indexOf(this.placeholderPrefix, startIndex + propVal.length());
        }
        else if (this.ignoreUnresolvablePlaceholders) {
          // Proceed with unprocessed value.
          startIndex = result.indexOf(this.placeholderPrefix, endIndex + this.placeholderSuffix.length());
        }
        else {
          throw new IllegalArgumentException("Could not resolve placeholder '" +
              placeholder + "'" + " in value \"" + value + "\"");
        }
        visitedPlaceholders.remove(originalPlaceholder);
      }
      else {
        startIndex = -1;
      }
    }
    return result.toString();
  }