Package org.springframework.core.env

# Class AbstractEnvironment

java.lang.Object
org.springframework.core.env.AbstractEnvironment

All Implemented Interfaces:
  `ConfigurableEnvironment`, `ConfigurablePropertyResolver`, `Environment`, `PropertyResolver`

Direct Known Subclasses:
  `StandardEnvironment`

public abstract class AbstractEnvironment extends Object implements ConfigurableEnvironment
Abstract base class for `Environment` implementations. Supports the notion of reserved default profile names and enables specifying active and default profiles through the `ACTIVE_PROFILES_PROPERTY_NAME` and `DEFAULT_PROFILES_PROPERTY_NAME` properties.

Concrete subclasses differ primarily on which `PropertySource` objects they add by default. `AbstractEnvironment` adds none. Subclasses should contribute property sources through the protected `customizePropertySources(MutablePropertySources)` hook, while clients should customize using `ConfigurableEnvironment.getPropertySources()` and work against the `MutablePropertySources` API. See `ConfigurableEnvironment` javadoc for usage examples.

Since:
  3.1
Author:
  Chris Beams, Juergen Hoeller, Phillip Webb
See Also:
  - `ConfigurableEnvironment`
  - `StandardEnvironment`

## Field Summary

Fields
Modifier and Type
Field
Description
`static final String`
`ACTIVE_PROFILES_PROPERTY_NAME`
Name of the property to specify active profiles: "spring.profiles.active".
`static final String`
`DEFAULT_PROFILES_PROPERTY_NAME`
Name of the property to specify profiles that are active by default: "spring.profiles.default".
`static final String`
`IGNORE_GETENV_PROPERTY_NAME`
System property that instructs Spring to ignore system environment variables, i.e.
`protected final org.apache.commons.logging.Log`
`logger`
`static final String`
`RESERVED_DEFAULT_PROFILE_NAME`
Name of the reserved default profile name: "default".

## Constructor Summary

Constructors
Modifier
Constructor
Description
``
`AbstractEnvironment()`
Create a new `Environment` instance, calling back to `customizePropertySources(MutablePropertySources)` during construction to allow subclasses to contribute or manipulate `PropertySource` instances as appropriate.
`protected`
`AbstractEnvironment(MutablePropertySources propertySources)`
Create a new `Environment` instance with a specific `MutablePropertySources` instance, calling back to `customizePropertySources(MutablePropertySources)` during construction to allow subclasses to contribute or manipulate `PropertySource` instances as appropriate.

## Method Summary

Modifier and Type
Method
Description
`boolean`
`acceptsProfiles(String... profiles)`
Deprecated.
`boolean`
`acceptsProfiles(Profiles profiles)`
Determine whether the given `Profiles` predicate matches the active profiles — or in the case of no explicit active profiles, whether the given `Profiles` predicate matches the default profiles.
`void`
`addActiveProfile(String profile)`
Add a profile to the current set of active profiles.
`boolean`
`containsProperty(String key)`
Determine whether the given property key is available for resolution — for example, if the value for the given key is not `null`.
`protected ConfigurablePropertyResolver`
`createPropertyResolver(MutablePropertySources propertySources)`
Factory method used to create the `ConfigurablePropertyResolver` used by this `Environment`.
`protected void`
`customizePropertySources(MutablePropertySources propertySources)`
Customize the set of `PropertySource` objects to be searched by this `Environment` during calls to `getProperty(String)` and related methods.
`protected Set<String>`
`doGetActiveProfiles()`
Return the set of active profiles as explicitly set through `setActiveProfiles(java.lang.String...)` or if the current set of active profiles is empty, check for the presence of `doGetActiveProfilesProperty()` and assign its value to the set of active profiles.
`protected String`
`doGetActiveProfilesProperty()`
Return the property value for the active profiles.
`protected Set<String>`
`doGetDefaultProfiles()`
Return the set of default profiles explicitly set via `setDefaultProfiles(String...)`, or if the current set of default profiles consists only of reserved default profiles, then check for the presence of `doGetDefaultProfilesProperty()` and assign its value (if any) to the set of default profiles.
`protected String`
`doGetDefaultProfilesProperty()`
Return the property value for the default profiles.
`String[]`
`getActiveProfiles()`
Return the set of profiles explicitly made active for this environment.
`ConfigurableConversionService`
`getConversionService()`
Return the `ConfigurableConversionService` used when performing type conversions on properties.
`String[]`
`getDefaultProfiles()`
Return the set of profiles to be active by default when no active profiles have been set explicitly.
`String`
`getProperty(String key)`
Resolve the property value associated with the given key, or `null` if the key cannot be resolved.
`<T> T`
`getProperty(String key, Class<T> targetType)`
Resolve the property value associated with the given key, or `null` if the key cannot be resolved.
`<T> T`
`getProperty(String key, Class<T> targetType, T defaultValue)`
Resolve the property value associated with the given key, or `defaultValue` if the key cannot be resolved.
`String`
`getProperty(String key, String defaultValue)`
Resolve the property value associated with the given key, or `defaultValue` if the key cannot be resolved.
`protected final ConfigurablePropertyResolver`
`getPropertyResolver()`
Return the `ConfigurablePropertyResolver` used by the `Environment`.
`MutablePropertySources`
`getPropertySources()`
Return the `PropertySources` for this `Environment` in mutable form, allowing for manipulation of the set of `PropertySource` objects that should be searched when resolving properties against this `Environment` object.
`String`
`getRequiredProperty(String key)`
Resolve the property value associated with the given key (never `null`).
`<T> T`
`getRequiredProperty(String key, Class<T> targetType)`
Resolve the property value associated with the given key, converted to the given targetType (never `null`).
`protected Set<String>`
`getReservedDefaultProfiles()`
Return the set of reserved default profile names.
`Map<String,Object>`
`getSystemEnvironment()`
Return the value of `System.getenv()`.
`Map<String,Object>`
`getSystemProperties()`
Return the value of `System.getProperties()`.
`protected boolean`
`isProfileActive(String profile)`
Return whether the given profile is active, or if active profiles are empty whether the profile should be active by default.
`void`
`merge(ConfigurableEnvironment parent)`
Append the given parent environment's active profiles, default profiles, and property sources to this (child) environment's respective collections of each.
`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`
`setActiveProfiles(String... profiles)`
Specify the set of profiles active for this `Environment`.
`void`
`setConversionService(ConfigurableConversionService conversionService)`
Set the `ConfigurableConversionService` to be used when performing type conversions on properties.
`void`
`setDefaultProfiles(String... profiles)`
Specify the set of profiles to be made active by default if no other profiles are explicitly made active through `setActiveProfiles(java.lang.String...)`.
`void`
`setEscapeCharacter(Character escapeCharacter)`
Set the escape character to use to ignore the placeholder prefix and the value separator, or `null` if no escaping should take place.
`void`
`setIgnoreUnresolvableNestedPlaceholders(boolean ignoreUnresolvableNestedPlaceholders)`
Specify 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)`
Set the separating character to be honored between placeholders replaced by this resolver and their associated default values, or `null` if no such special character should be processed as a value separator.
`protected boolean`
`suppressGetenvAccess()`
Determine whether to suppress `System.getenv()`/`System.getenv(String)` access for the purposes of `getSystemEnvironment()`.
`String`
`toString()`
`protected void`
`validateProfile(String profile)`
Validate the given profile, called internally prior to adding to the set of active or default profiles.
`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, wait, wait, wait`

### Methods inherited from interface org.springframework.core.env.Environment

`matchesProfiles`

## Field Details

### IGNORE_GETENV_PROPERTY_NAME

public static final String IGNORE_GETENV_PROPERTY_NAME
System property that instructs Spring to ignore system environment variables, i.e. to never attempt to retrieve such a variable via `System.getenv()`.

The default is "false", falling back to system environment variable checks if a Spring environment property (for example, a placeholder in a configuration String) isn't resolvable otherwise. Consider switching this flag to "true" if you experience log warnings from `getenv` calls coming from Spring.

See Also:
  - `suppressGetenvAccess()`
  - Constant Field Values

### ACTIVE_PROFILES_PROPERTY_NAME

public static final String ACTIVE_PROFILES_PROPERTY_NAME
Name of the property to specify active profiles: "spring.profiles.active".

The value may be comma delimited.

Note that certain shell environments such as Bash disallow the use of the period character in variable names. Assuming that Spring's `SystemEnvironmentPropertySource` is in use, this property may be specified as an environment variable named `SPRING_PROFILES_ACTIVE`.

See Also:
  - `ConfigurableEnvironment.setActiveProfiles(java.lang.String...)`
  - Constant Field Values

### DEFAULT_PROFILES_PROPERTY_NAME

public static final String DEFAULT_PROFILES_PROPERTY_NAME
Name of the property to specify profiles that are active by default: "spring.profiles.default".

The value may be comma delimited.

Note that certain shell environments such as Bash disallow the use of the period character in variable names. Assuming that Spring's `SystemEnvironmentPropertySource` is in use, this property may be specified as an environment variable named `SPRING_PROFILES_DEFAULT`.

See Also:
  - `ConfigurableEnvironment.setDefaultProfiles(java.lang.String...)`
  - Constant Field Values

### RESERVED_DEFAULT_PROFILE_NAME

public static final String RESERVED_DEFAULT_PROFILE_NAME
Name of the reserved default profile name: "default".

If no default profile names are explicitly set and no active profile names are explicitly set, this profile will automatically be activated by default.

See Also:
  - `getReservedDefaultProfiles()`
  - `ConfigurableEnvironment.setDefaultProfiles(java.lang.String...)`
  - `ConfigurableEnvironment.setActiveProfiles(java.lang.String...)`
  - `DEFAULT_PROFILES_PROPERTY_NAME`
  - `ACTIVE_PROFILES_PROPERTY_NAME`
  - Constant Field Values

### logger

protected final org.apache.commons.logging.Log logger

## Constructor Details

### AbstractEnvironment

public AbstractEnvironment()
Create a new `Environment` instance, calling back to `customizePropertySources(MutablePropertySources)` during construction to allow subclasses to contribute or manipulate `PropertySource` instances as appropriate.

See Also:
  - `customizePropertySources(MutablePropertySources)`

### AbstractEnvironment

protected AbstractEnvironment(MutablePropertySources propertySources)
Create a new `Environment` instance with a specific `MutablePropertySources` instance, calling back to `customizePropertySources(MutablePropertySources)` during construction to allow subclasses to contribute or manipulate `PropertySource` instances as appropriate.

Parameters:
  `propertySources` - property sources to use
Since:
  5.3.4
See Also:
  - `customizePropertySources(MutablePropertySources)`

## Method Details

### createPropertyResolver

protected ConfigurablePropertyResolver createPropertyResolver(MutablePropertySources propertySources)
Factory method used to create the `ConfigurablePropertyResolver` used by this `Environment`.

Since:
  5.3.4
See Also:
  - `getPropertyResolver()`

### getPropertyResolver

protected final ConfigurablePropertyResolver getPropertyResolver()
Return the `ConfigurablePropertyResolver` used by the `Environment`.

Since:
  5.3.4
See Also:
  - `createPropertyResolver(MutablePropertySources)`

### customizePropertySources

protected void customizePropertySources(MutablePropertySources propertySources)
Customize the set of `PropertySource` objects to be searched by this `Environment` during calls to `getProperty(String)` and related methods.

Subclasses that override this method are encouraged to add property sources using `MutablePropertySources.addLast(PropertySource)` such that further subclasses may call `super.customizePropertySources()` with predictable results. For example:

     public class Level1Environment extends AbstractEnvironment {
         @Override
         protected void customizePropertySources(MutablePropertySources propertySources) {
             super.customizePropertySources(propertySources); // no-op from base class
             propertySources.addLast(new PropertySourceA(...));
             propertySources.addLast(new PropertySourceB(...));
         }
     }

     public class Level2Environment extends Level1Environment {
         @Override
         protected void customizePropertySources(MutablePropertySources propertySources) {
             super.customizePropertySources(propertySources); // add all from superclass
             propertySources.addLast(new PropertySourceC(...));
             propertySources.addLast(new PropertySourceD(...));
         }
     }

In this arrangement, properties will be resolved against sources A, B, C, D in that order. That is to say that property source "A" has precedence over property source "D". If the `Level2Environment` subclass wished to give property sources C and D higher precedence than A and B, it could simply call `super.customizePropertySources` after, rather than before adding its own:

     public class Level2Environment extends Level1Environment {
         @Override
         protected void customizePropertySources(MutablePropertySources propertySources) {
             propertySources.addLast(new PropertySourceC(...));
             propertySources.addLast(new PropertySourceD(...));
             super.customizePropertySources(propertySources); // add all from superclass
         }
     }

The search order is now C, D, A, B as desired.

Beyond these recommendations, subclasses may use any of the `add*`, `remove`, or `replace` methods exposed by `MutablePropertySources` in order to create the exact arrangement of property sources desired.

The base implementation registers no property sources.

Note that clients of any `ConfigurableEnvironment` may further customize property sources via the `getPropertySources()` accessor, typically within an `ApplicationContextInitializer`. For example:

     ConfigurableEnvironment env = new StandardEnvironment();
     env.getPropertySources().addLast(new PropertySourceX(...));

## A warning about instance variable access

Instance variables declared in subclasses and having default initial values should not be accessed from within this method. Due to Java object creation lifecycle constraints, any initial value will not yet be assigned when this callback is invoked by the `AbstractEnvironment()` constructor, which may lead to a `NullPointerException` or other problems. If you need to access default values of instance variables, leave this method as a no-op and perform property source manipulation and instance variable access directly within the subclass constructor. Note that assigning values to instance variables is not problematic; it is only attempting to read default values that must be avoided.

See Also:
  - `MutablePropertySources`
  - `PropertySourcesPropertyResolver`
  - `org.springframework.context.ApplicationContextInitializer`

### getReservedDefaultProfiles

protected Set<String> getReservedDefaultProfiles()
Return the set of reserved default profile names. This implementation returns "default". Subclasses may override in order to customize the set of reserved names.

See Also:
  - `RESERVED_DEFAULT_PROFILE_NAME`
  - `doGetDefaultProfiles()`

### getActiveProfiles

public String[] getActiveProfiles()
Description copied from interface: `Environment`
Return the set of profiles explicitly made active for this environment. Profiles are used for creating logical groupings of bean definitions to be registered conditionally, for example based on deployment environment. Profiles can be activated by setting "spring.profiles.active" as a system property or by calling `ConfigurableEnvironment.setActiveProfiles(String...)`.

If no profiles have explicitly been specified as active, then any default profiles will automatically be activated.

Specified by:
  `getActiveProfiles` in interface `Environment`
See Also:
  - `Environment.getDefaultProfiles()`
  - `ConfigurableEnvironment.setActiveProfiles(java.lang.String...)`
  - `ACTIVE_PROFILES_PROPERTY_NAME`

### doGetActiveProfiles

protected Set<String> doGetActiveProfiles()
Return the set of active profiles as explicitly set through `setActiveProfiles(java.lang.String...)` or if the current set of active profiles is empty, check for the presence of `doGetActiveProfilesProperty()` and assign its value to the set of active profiles.

See Also:
  - `getActiveProfiles()`
  - `doGetActiveProfilesProperty()`

### doGetActiveProfilesProperty

@Nullable protected String doGetActiveProfilesProperty()
Return the property value for the active profiles.

Since:
  5.3.4
See Also:
  - `ACTIVE_PROFILES_PROPERTY_NAME`

### setActiveProfiles

public void setActiveProfiles(String... profiles)
Description copied from interface: `ConfigurableEnvironment`
Specify the set of profiles active for this `Environment`. Profiles are evaluated during container bootstrap to determine whether bean definitions should be registered with the container.

Any existing active profiles will be replaced with the given arguments; call with zero arguments to clear the current set of active profiles. Use `ConfigurableEnvironment.addActiveProfile(java.lang.String)` to add a profile while preserving the existing set.

Specified by:
  `setActiveProfiles` in interface `ConfigurableEnvironment`
See Also:
  - `ConfigurableEnvironment.addActiveProfile(java.lang.String)`
  - `ConfigurableEnvironment.setDefaultProfiles(java.lang.String...)`
  - `org.springframework.context.annotation.Profile`
  - `ACTIVE_PROFILES_PROPERTY_NAME`

### addActiveProfile

public void addActiveProfile(String profile)
Description copied from interface: `ConfigurableEnvironment`
Add a profile to the current set of active profiles.

Specified by:
  `addActiveProfile` in interface `ConfigurableEnvironment`
See Also:
  - `ConfigurableEnvironment.setActiveProfiles(java.lang.String...)`

### getDefaultProfiles

public String[] getDefaultProfiles()
Description copied from interface: `Environment`
Return the set of profiles to be active by default when no active profiles have been set explicitly.

Specified by:
  `getDefaultProfiles` in interface `Environment`
See Also:
  - `Environment.getActiveProfiles()`
  - `ConfigurableEnvironment.setDefaultProfiles(java.lang.String...)`
  - `DEFAULT_PROFILES_PROPERTY_NAME`

### doGetDefaultProfiles

protected Set<String> doGetDefaultProfiles()
Return the set of default profiles explicitly set via `setDefaultProfiles(String...)`, or if the current set of default profiles consists only of reserved default profiles, then check for the presence of `doGetDefaultProfilesProperty()` and assign its value (if any) to the set of default profiles.

See Also:
  - `AbstractEnvironment()`
  - `getDefaultProfiles()`
  - `getReservedDefaultProfiles()`
  - `doGetDefaultProfilesProperty()`

### doGetDefaultProfilesProperty

@Nullable protected String doGetDefaultProfilesProperty()
Return the property value for the default profiles.

Since:
  5.3.4
See Also:
  - `DEFAULT_PROFILES_PROPERTY_NAME`

### setDefaultProfiles

public void setDefaultProfiles(String... profiles)
Specify the set of profiles to be made active by default if no other profiles are explicitly made active through `setActiveProfiles(java.lang.String...)`.

Calling this method removes overrides any reserved default profiles that may have been added during construction of the environment.

Specified by:
  `setDefaultProfiles` in interface `ConfigurableEnvironment`
See Also:
  - `AbstractEnvironment()`
  - `getReservedDefaultProfiles()`

### acceptsProfiles

@Deprecated public boolean acceptsProfiles(String... profiles)
Deprecated.
Description copied from interface: `Environment`
Determine whether one or more of the given profiles is active — or in the case of no explicit active profiles, whether one or more of the given profiles is included in the set of default profiles.

If a profile begins with '!' the logic is inverted, meaning this method will return `true` if the given profile is not active. For example, `env.acceptsProfiles("p1", "!p2")` will return `true` if profile 'p1' is active or 'p2' is not active.

Specified by:
  `acceptsProfiles` in interface `Environment`
See Also:
  - `Environment.getActiveProfiles()`
  - `Environment.getDefaultProfiles()`
  - `Environment.matchesProfiles(String...)`
  - `Environment.acceptsProfiles(Profiles)`

### acceptsProfiles

public boolean acceptsProfiles(Profiles profiles)
Description copied from interface: `Environment`
Determine whether the given `Profiles` predicate matches the active profiles — or in the case of no explicit active profiles, whether the given `Profiles` predicate matches the default profiles.

If you wish provide profile expressions directly as strings, use `Environment.matchesProfiles(String...)` instead.

Specified by:
  `acceptsProfiles` in interface `Environment`
See Also:
  - `Environment.matchesProfiles(String...)`
  - `Profiles.of(String...)`

### isProfileActive

protected boolean isProfileActive(String profile)
Return whether the given profile is active, or if active profiles are empty whether the profile should be active by default.

Throws:
  `IllegalArgumentException` - per `validateProfile(String)`

### validateProfile

protected void validateProfile(String profile)
Validate the given profile, called internally prior to adding to the set of active or default profiles.

Subclasses may override to impose further restrictions on profile syntax.

Throws:
  `IllegalArgumentException` - if the profile is null, empty, whitespace-only or begins with the profile NOT operator (!)
See Also:
  - `acceptsProfiles(java.lang.String...)`
  - `addActiveProfile(java.lang.String)`
  - `setDefaultProfiles(java.lang.String...)`

### getPropertySources

public MutablePropertySources getPropertySources()
Description copied from interface: `ConfigurableEnvironment`
Return the `PropertySources` for this `Environment` in mutable form, allowing for manipulation of the set of `PropertySource` objects that should be searched when resolving properties against this `Environment` object. The various `MutablePropertySources` methods such as `addFirst`, `addLast`, `addBefore` and `addAfter` allow for fine-grained control over property source ordering. This is useful, for example, in ensuring that certain user-defined property sources have search precedence over default property sources such as the set of system properties or the set of system environment variables.

Specified by:
  `getPropertySources` in interface `ConfigurableEnvironment`
See Also:
  - `customizePropertySources(org.springframework.core.env.MutablePropertySources)`

### getSystemProperties

public Map<String,Object> getSystemProperties()
Description copied from interface: `ConfigurableEnvironment`
Return the value of `System.getProperties()`.

Note that most `Environment` implementations will include this system properties map as a default `PropertySource` to be searched. Therefore, it is recommended that this method not be used directly unless bypassing other property sources is expressly intended.

Specified by:
  `getSystemProperties` in interface `ConfigurableEnvironment`

### getSystemEnvironment

public Map<String,Object> getSystemEnvironment()
Description copied from interface: `ConfigurableEnvironment`
Return the value of `System.getenv()`.

Note that most `Environment` implementations will include this system environment map as a default `PropertySource` to be searched. Therefore, it is recommended that this method not be used directly unless bypassing other property sources is expressly intended.

Specified by:
  `getSystemEnvironment` in interface `ConfigurableEnvironment`

### suppressGetenvAccess

protected boolean suppressGetenvAccess()
Determine whether to suppress `System.getenv()`/`System.getenv(String)` access for the purposes of `getSystemEnvironment()`.

If this method returns `true`, an empty dummy Map will be used instead of the regular system environment Map, never even trying to call `getenv` and therefore avoiding security manager warnings (if any).

The default implementation checks for the "spring.getenv.ignore" system property, returning `true` if its value equals "true" in any case.

See Also:
  - `IGNORE_GETENV_PROPERTY_NAME`
  - `SpringProperties.getFlag(java.lang.String)`

### merge

public void merge(ConfigurableEnvironment parent)
Description copied from interface: `ConfigurableEnvironment`
Append the given parent environment's active profiles, default profiles, and property sources to this (child) environment's respective collections of each.

For any identically-named `PropertySource` instance existing in both parent and child, the child instance is to be preserved and the parent instance discarded. This has the effect of allowing overriding of property sources by the child as well as avoiding redundant searches through common property source types — for example, system environment and system properties.

Active and default profile names are also filtered for duplicates, to avoid confusion and redundant storage.

The parent environment remains unmodified in any case. Note that any changes to the parent environment occurring after the call to `merge` will not be reflected in the child. Therefore, care should be taken to configure parent property sources and profile information prior to calling `merge`.

Specified by:
  `merge` in interface `ConfigurableEnvironment`
Parameters:
  `parent` - the environment to merge with
See Also:
  - `org.springframework.context.support.AbstractApplicationContext#setParent`

### getConversionService

public ConfigurableConversionService getConversionService()
Description copied from interface: `ConfigurablePropertyResolver`
Return 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());

Specified by:
  `getConversionService` in interface `ConfigurablePropertyResolver`
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<?, ?>)`

### setPlaceholderPrefix

public void setPlaceholderPrefix(String placeholderPrefix)
Description copied from interface: `ConfigurablePropertyResolver`
Set the prefix that placeholders replaced by this resolver must begin with.

Specified by:
  `setPlaceholderPrefix` in interface `ConfigurablePropertyResolver`

### setPlaceholderSuffix

public void setPlaceholderSuffix(String placeholderSuffix)
Description copied from interface: `ConfigurablePropertyResolver`
Set the suffix that placeholders replaced by this resolver must end with.

Specified by:
  `setPlaceholderSuffix` in interface `ConfigurablePropertyResolver`

### setValueSeparator

public void setValueSeparator(@Nullable String valueSeparator)
Description copied from interface: `ConfigurablePropertyResolver`
Set the separating character to be honored between placeholders replaced by this resolver and their associated default values, or `null` if no such special character should be processed as a value separator.

Specified by:
  `setValueSeparator` in interface `ConfigurablePropertyResolver`

### setEscapeCharacter

public void setEscapeCharacter(@Nullable Character escapeCharacter)
Description copied from interface: `ConfigurablePropertyResolver`
Set the escape character to use to ignore the placeholder prefix and the value separator, or `null` if no escaping should take place.

Specified by:
  `setEscapeCharacter` in interface `ConfigurablePropertyResolver`

### setIgnoreUnresolvableNestedPlaceholders

public void setIgnoreUnresolvableNestedPlaceholders(boolean ignoreUnresolvableNestedPlaceholders)
Description copied from interface: `ConfigurablePropertyResolver`
Specify 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.

Specified by:
  `setIgnoreUnresolvableNestedPlaceholders` in interface `ConfigurablePropertyResolver`

### 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() throws MissingRequiredPropertiesException
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`
Throws:
  `MissingRequiredPropertiesException` - if any of the required properties are not resolvable

### containsProperty

public boolean containsProperty(String key)
Description copied from interface: `PropertyResolver`
Determine whether the given property key is available for resolution — for example, if the value for the given key is not `null`.

Specified by:
  `containsProperty` in interface `PropertyResolver`

### getProperty

@Nullable public String getProperty(String key)
Description copied from interface: `PropertyResolver`
Resolve the property value associated with the given key, or `null` if the key cannot be resolved.

Specified by:
  `getProperty` in interface `PropertyResolver`
Parameters:
  `key` - the property name to resolve
See Also:
  - `PropertyResolver.getProperty(String, String)`
  - `PropertyResolver.getProperty(String, Class)`
  - `PropertyResolver.getRequiredProperty(String)`

### getProperty

public String getProperty(String key, String defaultValue)
Description copied from interface: `PropertyResolver`
Resolve 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

@Nullable public <T> T getProperty(String key, Class<T> targetType)
Description copied from interface: `PropertyResolver`
Resolve the property value associated with the given key, or `null` 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
See Also:
  - `PropertyResolver.getRequiredProperty(String, Class)`

### getProperty

public <T> T getProperty(String key, Class<T> targetType, T defaultValue)
Description copied from interface: `PropertyResolver`
Resolve 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)`

### getRequiredProperty

public String getRequiredProperty(String key) throws IllegalStateException
Description copied from interface: `PropertyResolver`
Resolve the property value associated with the given key (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> targetType) throws IllegalStateException
Description copied from interface: `PropertyResolver`
Resolve 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

### 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)`

### 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

### toString

public String toString()

Overrides:
  `toString` in class `Object`