【Spring源码分析】09-PropertySourcesPropertyResolver

扫码关注公众号:Java 技术驿站

发送:vip
将链接复制到本浏览器,永久解锁本站全部文章

【公众号:Java 技术驿站】 【加作者微信交流技术,拉技术群】

PropertySourcesPropertyResolver用来将PropertySource的占位符文本解析,PropertyResolver是 Environment的顶层接口,主要提供属性检索和解析带占位符的文本。

20191017100335\_1.png

    public interface PropertyResolver {
       boolean containsProperty(String key);
       @Nullable
       String getProperty(String key);
       String getProperty(String key, String defaultValue);
       @Nullable
       <T> T getProperty(String key, Class<T> targetType);
       <T> T getProperty(String key, Class<T> targetType, T defaultValue);
       String getRequiredProperty(String key) throws IllegalStateException;
       <T> T getRequiredProperty(String key, Class<T> targetType) throws IllegalStateException;
       String resolvePlaceholders(String text);
       String resolveRequiredPlaceholders(String text) throws IllegalArgumentException;
    }

ConfigurablePropertyResolver定了解析占位符的一些配置方法。

    public interface ConfigurablePropertyResolver extends PropertyResolver {
       ConfigurableConversionService getConversionService();
       void setConversionService(ConfigurableConversionService conversionService);
       void setPlaceholderPrefix(String placeholderPrefix);
       void setPlaceholderSuffix(String placeholderSuffix);
       void setValueSeparator(@Nullable String valueSeparator);
       void setIgnoreUnresolvableNestedPlaceholders(boolean ignoreUnresolvableNestedPlaceholders);
       void setRequiredProperties(String... requiredProperties);
       void validateRequiredProperties() throws MissingRequiredPropertiesException;
    }

AbstractPropertyResolver封装了解析占位符的具体实现,而PropertySourcesPropertyResolver主要是负责提供数据源。AbstractPropertyResolver中有两个成员变量都是PropertyPlaceholderHelper对象,区别在于构造参数不同。

    public PropertyPlaceholderHelper(String placeholderPrefix, String placeholderSuffix,
          @Nullable String valueSeparator, boolean ignoreUnresolvablePlaceholders) {

       Assert.notNull(placeholderPrefix, "'placeholderPrefix' must not be null");
       Assert.notNull(placeholderSuffix, "'placeholderSuffix' must not be null");
       this.placeholderPrefix = placeholderPrefix;
       this.placeholderSuffix = placeholderSuffix;
       String simplePrefixForSuffix = wellKnownSimplePrefixes.get(this.placeholderSuffix);
       if (simplePrefixForSuffix != null && this.placeholderPrefix.endsWith(simplePrefixForSuffix)) {
          this.simplePrefix = simplePrefixForSuffix;
       }
       else {
          this.simplePrefix = this.placeholderPrefix;
       }
       this.valueSeparator = valueSeparator;
       this.ignoreUnresolvablePlaceholders = ignoreUnresolvablePlaceholders;
    }

placeholderPrefix和placeholderSuffix是从AbstractPropertyResolver传过来的${和},代表占位符的边界符号。valueSeparator也是传过来的默认值分隔符“:”。ignoreUnresolvablePlaceholders是否忽略占位符中不存在的数据源,false会抛出IllegalArgumentException。

replacePlaceholders()方法用来将value中占位符替换为从Properties或PlaceholderResolver取得的值。

    public String replacePlaceholders(String value, final Properties properties) {
       Assert.notNull(properties, "'properties' must not be null");
       return replacePlaceholders(value, properties::getProperty);
    }
    public String replacePlaceholders(String value, PlaceholderResolver placeholderResolver) {
       Assert.notNull(value, "'value' must not be null");
       return parseStringValue(value, placeholderResolver, new HashSet<>());
    }

PlaceholderResolver是一个接口定了一个方法,入参为占位符参数名,出参为占位符代表的值。这个对象由PropertySourcesPropertyResolver传入,具体后面再说。具体的解析占位符就是通过parseStringValue()方法了:

    protected String parseStringValue( String value, PlaceholderResolver placeholderResolver, Set<String> visitedPlaceholders) {
       StringBuilder result = new StringBuilder(value);
       int startIndex = value.indexOf(this.placeholderPrefix);
       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.add(originalPlaceholder)) {
                throw new IllegalArgumentException(
                      "Circular placeholder reference '" + originalPlaceholder + "' in property definitions");
             }
             // Recursive invocation, parsing placeholders contained in the placeholder key.
             placeholder = parseStringValue(placeholder, placeholderResolver, visitedPlaceholders);
             // Now obtain the value for the fully resolved key...
             String propVal = placeholderResolver.resolvePlaceholder(placeholder);
             if (propVal == null && this.valueSeparator != null) {
                int separatorIndex = placeholder.indexOf(this.valueSeparator);
                if (separatorIndex != -1) {
                   String actualPlaceholder = placeholder.substring(0, separatorIndex);
                   String defaultValue = placeholder.substring(separatorIndex + this.valueSeparator.length());
                   propVal = placeholderResolver.resolvePlaceholder(actualPlaceholder);
                   if (propVal == null) {
                      propVal = defaultValue;
                   }
                }
             }
             if (propVal != null) {
                // Recursive invocation, parsing placeholders contained in the
                // previously resolved placeholder value.
                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();
    }

这是一个递归的解析过程,遇到${开头就会查找最后一个}符号,将最外层占位符内的内容作为新的value再次传入 parseStringValue()方法中,这样最深层次也就是最先返回的就是最里层的占位符名字。调用placeholderResolver将占位符名字转换成它代表的值。如果值为null,则考虑使用默认值(valueSeparator后的内容)赋值给propVal。由于placeholderResolver转换过的值有可能还会包含占位符所以在此调用parseStringValue()方法将带有占位符的propVal传入返回真正的值,用propVal替换占位符。如果propVal==null,判断是否允许忽略不能解析的占位符,如果可以重置startIndex继续解析同一层次的占位符。否则抛出异常。这个函数的返回值就是它上一层次的占位符解析值。

需要注意的一点是:判断嵌套的占位符是依据simplePrefix。

    private int findPlaceholderEndIndex(CharSequence buf, int startIndex) {
       int index = startIndex + this.placeholderPrefix.length();
       int withinNestedPlaceholder = 0;
       while (index < buf.length()) {
          if (StringUtils.substringMatch(buf, index, this.placeholderSuffix)) {
             if (withinNestedPlaceholder > 0) {
                withinNestedPlaceholder--;
                index = index + this.placeholderSuffix.length();
             }
             else {
                return index;
             }
          }
          else if (StringUtils.substringMatch(buf, index, this.simplePrefix)) {
             withinNestedPlaceholder++;
             index = index + this.simplePrefix.length();
          }
          else {
             index++;
          }
       }
       return -1;
    }

AbstractPropertyResolver解析占位符的方法就是委托了PropertyPlaceholderHelper对象的replacePlaceholders()方法,placeholderResolver参数由抽象方法getPropertyAsRawString()定义,子类给出具体实现。

    @Override
    public String resolvePlaceholders(String text) {
       if (this.nonStrictHelper == null) {
          this.nonStrictHelper = createPlaceholderHelper(true);
       }
       return doResolvePlaceholders(text, this.nonStrictHelper);
    }

    @Override
    public String resolveRequiredPlaceholders(String text) throws IllegalArgumentException {
       if (this.strictHelper == null) {
          this.strictHelper = createPlaceholderHelper(false);
       }
       return doResolvePlaceholders(text, this.strictHelper);
    }
    private String doResolvePlaceholders(String text, PropertyPlaceholderHelper helper) {
       return helper.replacePlaceholders(text, this::getPropertyAsRawString);
    }
    @Nullable
    protected abstract String getPropertyAsRawString(String key);

getProperty()方法也是子类给出的具体实现,下面看一下PropertySourcesPropertyResolver。

构造方法会传入一个PropertySources对象作为数据源。

    public PropertySourcesPropertyResolver(@Nullable PropertySources propertySources) {
       this.propertySources = propertySources;
    }

PropertyPlaceholderHelper需要的PlaceholderResolver函数方法。

    @Override
    @Nullable
    protected String getPropertyAsRawString(String key) {
       return getProperty(key, String.class, false);
    }

可以看出核心方法就是getProperty(),这里resolveNestedPlaceholders传入的是false,因为占位符解析是交给了PropertyPlaceholderHelper对象,不需要PropertySourcesPropertyResolver再次使用父类的resolveNestedPlaceholders再次解析占位符。

    @Nullable
    protected <T> T getProperty(String key, Class<T> targetValueType, boolean resolveNestedPlaceholders) {
       if (this.propertySources != null) {
          for (PropertySource<?> propertySource : this.propertySources) {
             if (logger.isTraceEnabled()) {
                logger.trace("Searching for key '" + key + "' in PropertySource '" +
                      propertySource.getName() + "'");
             }
             Object value = propertySource.getProperty(key);
             if (value != null) {
                if (resolveNestedPlaceholders && value instanceof String) {
                   value = resolveNestedPlaceholders((String) value);
                }
                logKeyFound(key, propertySource, value);
                return convertValueIfNecessary(value, targetValueType);
             }
          }
       }
       if (logger.isDebugEnabled()) {
          logger.debug("Could not find key '" + key + "' in any property source");
       }
       return null;
    }

而直接调用getProperty()方法就需要 resolveNestedPlaceholders=true了。

    @Override
    @Nullable
    public String getProperty(String key) {
       return getProperty(key, String.class, true);
    }

    @Override
    @Nullable
    public <T> T getProperty(String key, Class<T> targetValueType) {
       return getProperty(key, targetValueType, true);
    }

来源:[]()

赞(0) 打赏
版权归原创作者所有,任何形式的转载请联系博主:daming_90:Java 技术驿站 » 【Spring源码分析】09-PropertySourcesPropertyResolver

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏