org.springframework.core.env

## Class AbstractPropertyResolver

- java.lang.Object
- - org.springframework.core.env.AbstractPropertyResolver

- All Implemented Interfaces:
    ConfigurablePropertyResolver, PropertyResolver
  Direct Known Subclasses:
    PropertySourcesPropertyResolver

      public abstract class AbstractPropertyResolver
      extends Object
      implements ConfigurablePropertyResolver

  Abstract base class for resolving properties against any underlying source.
  Since:
    3.1
  Author:
    Chris Beams, Juergen Hoeller

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected ConfigurableConversionService` | `conversionService`
    `protected Log` | `logger`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `AbstractPropertyResolver()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `ConfigurableConversionService` | `getConversionService()`
    `<T> T` | `getProperty(String key, Class<T> targetType, T defaultValue)` Return the property value associated with the given key, or `defaultValue` if the key cannot be resolved.
    `String` | `getProperty(String key, String defaultValue)` Return the property value associated with the given key, or `defaultValue` if the key cannot be resolved.
    `protected abstract String` | `getPropertyAsRawString(String key)` Retrieve the specified property as a raw String, i.e.
    `String` | `getRequiredProperty(String key)` Return the property value associated with the given key, converted to the given targetType (never `null`).
    `<T> T` | `getRequiredProperty(String key, Class<T> valueType)` Return the property value associated with the given key, converted to the given targetType (never `null`).
    `protected String` | `resolveNestedPlaceholders(String value)` Resolve placeholders within the given string, deferring to the value of `setIgnoreUnresolvableNestedPlaceholders(boolean)` to determine whether any unresolvable placeholders should raise an exception or be ignored.
    `String` | `resolvePlaceholders(String text)` Resolve ${...} placeholders in the given text, replacing them with corresponding property values as resolved by `PropertyResolver.getProperty(java.lang.String)`.
    `String` | `resolveRequiredPlaceholders(String text)` Resolve ${...} placeholders in the given text, replacing them with corresponding property values as resolved by `PropertyResolver.getProperty(java.lang.String)`.
    `void` | `setConversionService(ConfigurableConversionService conversionService)` Set the `ConfigurableConversionService` to be used when performing type conversions on properties.
    `void` | `setIgnoreUnresolvableNestedPlaceholders(boolean ignoreUnresolvableNestedPlaceholders)` Set whether to throw an exception when encountering an unresolvable placeholder nested within the value of a given property.
    `void` | `setPlaceholderPrefix(String placeholderPrefix)` Set the prefix that placeholders replaced by this resolver must begin with.
    `void` | `setPlaceholderSuffix(String placeholderSuffix)` Set the suffix that placeholders replaced by this resolver must end with.
    `void` | `setRequiredProperties(String... requiredProperties)` Specify which properties must be present, to be verified by `ConfigurablePropertyResolver.validateRequiredProperties()`.
    `void` | `setValueSeparator(String valueSeparator)` Specify the separating character between the placeholders replaced by this resolver and their associated default value, or `null` if no such special character should be processed as a value separator.
    `void` | `validateRequiredProperties()` Validate that each of the properties specified by `ConfigurablePropertyResolver.setRequiredProperties(java.lang.String...)` is present and resolves to a non-`null` value.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

    - ### Methods inherited from interface org.springframework.core.env.PropertyResolver

      `containsProperty, getProperty, getProperty, getPropertyAsClass`

- - ### Field Detail

    - #### logger

          protected final Log logger

    - #### conversionService

          protected ConfigurableConversionService conversionService

  - ### Constructor Detail

    - #### AbstractPropertyResolver

          public AbstractPropertyResolver()

  - ### Method Detail

    - #### getConversionService

          public ConfigurableConversionService getConversionService()

      Specified by:
        `getConversionService` in interface `ConfigurablePropertyResolver`
      Returns:
        the `ConfigurableConversionService` used when performing type conversions on properties.

        The configurable nature of the returned conversion service allows for the convenient addition and removal of individual `Converter` instances:

             ConfigurableConversionService cs = env.getConversionService();
             cs.addConverter(new FooConverter());

      See Also:
        `PropertyResolver.getProperty(String, Class)`, `ConverterRegistry.addConverter(org.springframework.core.convert.converter.Converter<?, ?>)`

    - #### setConversionService

          public void setConversionService(ConfigurableConversionService conversionService)

      Description copied from interface: `ConfigurablePropertyResolver`
      Set the `ConfigurableConversionService` to be used when performing type conversions on properties.

      Note: as an alternative to fully replacing the `ConversionService`, consider adding or removing individual `Converter` instances by drilling into `ConfigurablePropertyResolver.getConversionService()` and calling methods such as `#addConverter`.

      Specified by:
        `setConversionService` in interface `ConfigurablePropertyResolver`
      See Also:
        `PropertyResolver.getProperty(String, Class)`, `ConfigurablePropertyResolver.getConversionService()`, `ConverterRegistry.addConverter(org.springframework.core.convert.converter.Converter<?, ?>)`

    - #### getProperty

          public String getProperty(String key,
                           String defaultValue)

      Description copied from interface: `PropertyResolver`
      Return the property value associated with the given key, or `defaultValue` if the key cannot be resolved.
      Specified by:
        `getProperty` in interface `PropertyResolver`
      Parameters:
        `key` - the property name to resolve
        `defaultValue` - the default value to return if no value is found
      See Also:
        `PropertyResolver.getRequiredProperty(String)`, `PropertyResolver.getProperty(String, Class)`

    - #### getProperty

          public <T> T getProperty(String key,
                          Class<T> targetType,
                          T defaultValue)

      Description copied from interface: `PropertyResolver`
      Return the property value associated with the given key, or `defaultValue` if the key cannot be resolved.
      Specified by:
        `getProperty` in interface `PropertyResolver`
      Parameters:
        `key` - the property name to resolve
        `targetType` - the expected type of the property value
        `defaultValue` - the default value to return if no value is found
      See Also:
        `PropertyResolver.getRequiredProperty(String, Class)`

    - #### setRequiredProperties

          public void setRequiredProperties(String... requiredProperties)

      Description copied from interface: `ConfigurablePropertyResolver`
      Specify which properties must be present, to be verified by `ConfigurablePropertyResolver.validateRequiredProperties()`.
      Specified by:
        `setRequiredProperties` in interface `ConfigurablePropertyResolver`

    - #### validateRequiredProperties

          public void validateRequiredProperties()

      Description copied from interface: `ConfigurablePropertyResolver`
      Validate that each of the properties specified by `ConfigurablePropertyResolver.setRequiredProperties(java.lang.String...)` is present and resolves to a non-`null` value.
      Specified by:
        `validateRequiredProperties` in interface `ConfigurablePropertyResolver`

    - #### getRequiredProperty

          public String getRequiredProperty(String key)
                                     throws IllegalStateException

      Description copied from interface: `PropertyResolver`
      Return the property value associated with the given key, converted to the given targetType (never `null`).
      Specified by:
        `getRequiredProperty` in interface `PropertyResolver`
      Throws:
        `IllegalStateException` - if the key cannot be resolved
      See Also:
        `PropertyResolver.getRequiredProperty(String, Class)`

    - #### getRequiredProperty

          public <T> T getRequiredProperty(String key,
                                  Class<T> valueType)
                                throws IllegalStateException

      Description copied from interface: `PropertyResolver`
      Return the property value associated with the given key, converted to the given targetType (never `null`).
      Specified by:
        `getRequiredProperty` in interface `PropertyResolver`
      Throws:
        `IllegalStateException` - if the given key cannot be resolved

    - #### setPlaceholderPrefix

          public void setPlaceholderPrefix(String placeholderPrefix)

      Set the prefix that placeholders replaced by this resolver must begin with. The default is "${".
      Specified by:
        `setPlaceholderPrefix` in interface `ConfigurablePropertyResolver`
      See Also:
        `SystemPropertyUtils.PLACEHOLDER_PREFIX`

    - #### setPlaceholderSuffix

          public void setPlaceholderSuffix(String placeholderSuffix)

      Set the suffix that placeholders replaced by this resolver must end with. The default is "}".
      Specified by:
        `setPlaceholderSuffix` in interface `ConfigurablePropertyResolver`
      See Also:
        `SystemPropertyUtils.PLACEHOLDER_SUFFIX`

    - #### setValueSeparator

          public void setValueSeparator(String valueSeparator)

      Specify the separating character between the placeholders replaced by this resolver and their associated default value, or `null` if no such special character should be processed as a value separator. The default is ":".
      Specified by:
        `setValueSeparator` in interface `ConfigurablePropertyResolver`
      See Also:
        `SystemPropertyUtils.VALUE_SEPARATOR`

    - #### resolvePlaceholders

          public String resolvePlaceholders(String text)

      Description copied from interface: `PropertyResolver`
      Resolve ${...} placeholders in the given text, replacing them with corresponding property values as resolved by `PropertyResolver.getProperty(java.lang.String)`. Unresolvable placeholders with no default value are ignored and passed through unchanged.
      Specified by:
        `resolvePlaceholders` in interface `PropertyResolver`
      Parameters:
        `text` - the String to resolve
      Returns:
        the resolved String (never `null`)
      See Also:
        `PropertyResolver.resolveRequiredPlaceholders(java.lang.String)`, `SystemPropertyUtils.resolvePlaceholders(String)`

    - #### resolveRequiredPlaceholders

          public String resolveRequiredPlaceholders(String text)
                                             throws IllegalArgumentException

      Description copied from interface: `PropertyResolver`
      Resolve ${...} placeholders in the given text, replacing them with corresponding property values as resolved by `PropertyResolver.getProperty(java.lang.String)`. Unresolvable placeholders with no default value will cause an IllegalArgumentException to be thrown.
      Specified by:
        `resolveRequiredPlaceholders` in interface `PropertyResolver`
      Returns:
        the resolved String (never `null`)
      Throws:
        `IllegalArgumentException` - if given text is `null` or if any placeholders are unresolvable
      See Also:
        `SystemPropertyUtils.resolvePlaceholders(String, boolean)`

    - #### setIgnoreUnresolvableNestedPlaceholders

          public void setIgnoreUnresolvableNestedPlaceholders(boolean ignoreUnresolvableNestedPlaceholders)

      Set whether to throw an exception when encountering an unresolvable placeholder nested within the value of a given property. A `false` value indicates strict resolution, i.e. that an exception will be thrown. A `true` value indicates that unresolvable nested placeholders should be passed through in their unresolved ${...} form.

      Implementations of `PropertyResolver.getProperty(String)` and its variants must inspect the value set here to determine correct behavior when property values contain unresolvable placeholders.

      The default value for this implementation is `false`.

      Specified by:
        `setIgnoreUnresolvableNestedPlaceholders` in interface `ConfigurablePropertyResolver`
      Since:
        3.2

    - #### resolveNestedPlaceholders

          protected String resolveNestedPlaceholders(String value)

      Resolve placeholders within the given string, deferring to the value of `setIgnoreUnresolvableNestedPlaceholders(boolean)` to determine whether any unresolvable placeholders should raise an exception or be ignored.

      Invoked from `getProperty(java.lang.String, java.lang.String)` and its variants, implicitly resolving nested placeholders. In contrast, `resolvePlaceholders(java.lang.String)` and `resolveRequiredPlaceholders(java.lang.String)` do not delegate to this method but rather perform their own handling of unresolvable placeholders, as specified by each of those methods.

      Since:
        3.2
      See Also:
        `setIgnoreUnresolvableNestedPlaceholders(boolean)`

    - #### getPropertyAsRawString

          protected abstract String getPropertyAsRawString(String key)

      Retrieve the specified property as a raw String, i.e. without resolution of nested placeholders.
      Parameters:
        `key` - the property name to resolve
      Returns:
        the property value or `null` if none found