public abstract class AbstractPropertyResolver extends Object implements ConfigurablePropertyResolver
| Constructor and Description | 
|---|
| AbstractPropertyResolver() | 
| Modifier and Type | Method and Description | 
|---|---|
| boolean | containsProperty(String key)Return whether the given property key is available for resolution,
 i.e. | 
| protected <T> T | convertValueIfNecessary(Object value,
                       Class<T> targetType)Convert the given value to the specified target type, if necessary. | 
| ConfigurableConversionService | getConversionService()Return the  ConfigurableConversionServiceused when performing type
 conversions on properties. | 
| String | getProperty(String key)Return the property value associated with the given key,
 or  nullif the key cannot be resolved. | 
| <T> T | getProperty(String key,
           Class<T> targetType,
           T defaultValue)Return the property value associated with the given key,
 or  defaultValueif the key cannot be resolved. | 
| String | getProperty(String key,
           String defaultValue)Return the property value associated with the given key, or
  defaultValueif 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 (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  ConfigurableConversionServiceto 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  nullif 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-nullvalue. | 
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, waitgetPropertyprotected final Log logger
public ConfigurableConversionService getConversionService()
ConfigurablePropertyResolverConfigurableConversionService 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());
public void setConversionService(ConfigurableConversionService conversionService)
ConfigurablePropertyResolverConfigurableConversionService 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.
public void setPlaceholderPrefix(String placeholderPrefix)
The default is "${".
setPlaceholderPrefix in interface ConfigurablePropertyResolverSystemPropertyUtils.PLACEHOLDER_PREFIXpublic void setPlaceholderSuffix(String placeholderSuffix)
The default is "}".
setPlaceholderSuffix in interface ConfigurablePropertyResolverSystemPropertyUtils.PLACEHOLDER_SUFFIXpublic void setValueSeparator(@Nullable String valueSeparator)
null if no such
 special character should be processed as a value separator.
 The default is ":".
setValueSeparator in interface ConfigurablePropertyResolverSystemPropertyUtils.VALUE_SEPARATORpublic void setIgnoreUnresolvableNestedPlaceholders(boolean ignoreUnresolvableNestedPlaceholders)
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.
 The default is false.
setIgnoreUnresolvableNestedPlaceholders in interface ConfigurablePropertyResolverpublic void setRequiredProperties(String... requiredProperties)
ConfigurablePropertyResolverConfigurablePropertyResolver.validateRequiredProperties().setRequiredProperties in interface ConfigurablePropertyResolverpublic void validateRequiredProperties()
ConfigurablePropertyResolverConfigurablePropertyResolver.setRequiredProperties(java.lang.String...) is present and resolves to a
 non-null value.validateRequiredProperties in interface ConfigurablePropertyResolverpublic boolean containsProperty(String key)
PropertyResolvernull.containsProperty in interface PropertyResolver@Nullable public String getProperty(String key)
PropertyResolvernull if the key cannot be resolved.getProperty in interface PropertyResolverkey - the property name to resolvePropertyResolver.getProperty(String, String), 
PropertyResolver.getProperty(String, Class), 
PropertyResolver.getRequiredProperty(String)public String getProperty(String key, String defaultValue)
PropertyResolverdefaultValue if the key cannot be resolved.getProperty in interface PropertyResolverkey - the property name to resolvedefaultValue - the default value to return if no value is foundPropertyResolver.getRequiredProperty(String), 
PropertyResolver.getProperty(String, Class)public <T> T getProperty(String key, Class<T> targetType, T defaultValue)
PropertyResolverdefaultValue if the key cannot be resolved.getProperty in interface PropertyResolverkey - the property name to resolvetargetType - the expected type of the property valuedefaultValue - the default value to return if no value is foundPropertyResolver.getRequiredProperty(String, Class)public String getRequiredProperty(String key) throws IllegalStateException
PropertyResolvernull).getRequiredProperty in interface PropertyResolverIllegalStateException - if the key cannot be resolvedPropertyResolver.getRequiredProperty(String, Class)public <T> T getRequiredProperty(String key, Class<T> valueType) throws IllegalStateException
PropertyResolvernull).getRequiredProperty in interface PropertyResolverIllegalStateException - if the given key cannot be resolvedpublic String resolvePlaceholders(String text)
PropertyResolverPropertyResolver.getProperty(java.lang.String). Unresolvable placeholders with
 no default value are ignored and passed through unchanged.resolvePlaceholders in interface PropertyResolvertext - the String to resolvenull)PropertyResolver.resolveRequiredPlaceholders(java.lang.String)public String resolveRequiredPlaceholders(String text) throws IllegalArgumentException
PropertyResolverPropertyResolver.getProperty(java.lang.String). Unresolvable placeholders with
 no default value will cause an IllegalArgumentException to be thrown.resolveRequiredPlaceholders in interface PropertyResolvernull)IllegalArgumentException - if given text is null
 or if any placeholders are unresolvableprotected String resolveNestedPlaceholders(String value)
setIgnoreUnresolvableNestedPlaceholders(boolean) to determine whether any
 unresolvable placeholders should raise an exception or be ignored.
 Invoked from getProperty(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.
setIgnoreUnresolvableNestedPlaceholders(boolean)@Nullable protected <T> T convertValueIfNecessary(Object value, @Nullable Class<T> targetType)
value - the original property valuetargetType - the specified target type for property retrieval