| org.springframework.beans.factory.config.PropertyResourceConfigurer
 org.springframework.beans.factory.config.PropertyPlaceholderConfigurer
All known Subclasses: org.springframework.web.context.support.ServletContextPropertyPlaceholderConfigurer, org.springframework.beans.factory.config.PreferencesPlaceholderConfigurer,
| PropertyPlaceholderConfigurer | | public class PropertyPlaceholderConfigurer extends PropertyResourceConfigurer implements BeanNameAware,BeanFactoryAware(Code) | | A property resource configurer that resolves placeholders in bean property values of
context definitions. It pulls values from a properties file into bean definitions.
The default placeholder syntax follows the Ant / Log4J / JSP EL style:
${...}
Example XML context definition:
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName"><value>${driver}</value></property>
<property name="url"><value>jdbc:${dbname}</value></property>
</bean>
Example properties file:
driver=com.mysql.jdbc.Driver
dbname=mysql:mydb
PropertyPlaceholderConfigurer checks simple property values, lists, maps,
props, and bean names in bean references. Furthermore, placeholder values can
also cross-reference other placeholders, like:
rootPath=myrootdir
subPath=${rootPath}/subdir
In contrast to PropertyOverrideConfigurer, this configurer allows to fill in
explicit placeholders in context definitions. Therefore, the original definition
cannot specify any default values for such bean properties, and the placeholder
properties file is supposed to contain an entry for each defined placeholder.
If a configurer cannot resolve a placeholder, a BeanDefinitionStoreException
will be thrown. If you want to check against multiple properties files, specify
multiple resources via the "locations" setting. You can also define multiple
PropertyPlaceholderConfigurers, each with its own placeholder syntax.
Default property values can be defined via "properties", to make overriding
definitions in properties files optional. A configurer will also check against
system properties (e.g. "user.dir") if it cannot resolve a placeholder with any
of the specified properties. This can be customized via "systemPropertiesMode".
Note that the context definition is aware of being incomplete;
this is immediately obvious to users when looking at the XML definition file.
Hence, placeholders have to be resolved; any desired defaults have to be
defined as placeholder values as well (for example in a default properties file).
Property values can be converted after reading them in, through overriding
the
PropertyPlaceholderConfigurer.convertPropertyValue method. For example, encrypted values can
be detected and decrypted accordingly before processing them.
author:
Juergen Hoeller
since:
02.10.2003
See Also: PropertyPlaceholderConfigurer.setLocations
See Also: PropertyPlaceholderConfigurer.setProperties
See Also: PropertyPlaceholderConfigurer.setPlaceholderPrefix
See Also: PropertyPlaceholderConfigurer.setPlaceholderSuffix
See Also: PropertyPlaceholderConfigurer.setSystemPropertiesModeName
See Also: System.getProperty(String)
See Also: PropertyPlaceholderConfigurer.convertPropertyValue
See Also: PropertyOverrideConfigurer |
| Method Summary | |
| protected String | parseStringValue(String strVal, Properties props, Set visitedPlaceholders)
Parse the given String value recursively, to be able to resolve
nested placeholders (when resolved property values in turn contain
placeholders again).
Parameters:
strVal - the String value to parse
Parameters:
props - the Properties to resolve placeholders against
Parameters:
visitedPlaceholders - the placeholders that have already been visitedduring the current resolution attempt (used to detect circular referencesbetween placeholders). | | protected void | processProperties(ConfigurableListableBeanFactory beanFactoryToProcess, Properties props)
| | protected String | resolvePlaceholder(String placeholder, Properties props, int systemPropertiesMode)
Resolve the given placeholder using the given properties, performing
a system properties check according to the given mode. | | protected String | resolvePlaceholder(String placeholder, Properties props)
Resolve the given placeholder using the given properties. | | protected String | resolveSystemProperty(String key)
Resolve the given key as JVM system property, and optionally also as
system environment variable if no matching system property has been found. | | public void | setBeanFactory(BeanFactory beanFactory)
Only necessary to check that we're not parsing our own bean definition,
to avoid failing on unresolvable placeholders in properties file locations. | | public void | setBeanName(String beanName)
Only necessary to check that we're not parsing our own bean definition,
to avoid failing on unresolvable placeholders in properties file locations. | | public void | setIgnoreUnresolvablePlaceholders(boolean ignoreUnresolvablePlaceholders)
Set whether to ignore unresolvable placeholders. | | public void | setPlaceholderPrefix(String placeholderPrefix)
Set the prefix that a placeholder string starts with. | | public void | setPlaceholderSuffix(String placeholderSuffix)
Set the suffix that a placeholder string ends with. | | public void | setSearchSystemEnvironment(boolean searchSystemEnvironment)
Set whether to search for a matching system environment variable
if no matching system property has been found. | | public void | setSystemPropertiesMode(int systemPropertiesMode)
Set how to check system properties: as fallback, as override, or never.
For example, will resolve ${user.dir} to the "user.dir" system property.
The default is "fallback": If not being able to resolve a placeholder
with the specified properties, a system property will be tried.
"override" will check for a system property first, before trying the
specified properties. | | public void | setSystemPropertiesModeName(String constantName)
Set the system property mode by the name of the corresponding constant,
e.g. |
| DEFAULT_PLACEHOLDER_PREFIX | | final public static String DEFAULT_PLACEHOLDER_PREFIX(Code) | | Default placeholder prefix: "${"
|
| DEFAULT_PLACEHOLDER_SUFFIX | | final public static String DEFAULT_PLACEHOLDER_SUFFIX(Code) | | Default placeholder suffix: "}"
|
| SYSTEM_PROPERTIES_MODE_FALLBACK | | final public static int SYSTEM_PROPERTIES_MODE_FALLBACK(Code) | | Check system properties if not resolvable in the specified properties.
This is the default.
|
| SYSTEM_PROPERTIES_MODE_NEVER | | final public static int SYSTEM_PROPERTIES_MODE_NEVER(Code) | | Never check system properties.
|
| SYSTEM_PROPERTIES_MODE_OVERRIDE | | final public static int SYSTEM_PROPERTIES_MODE_OVERRIDE(Code) | | Check system properties first, before trying the specified properties.
This allows system properties to override any other property source.
|
| resolvePlaceholder | | protected String resolvePlaceholder(String placeholder, Properties props, int systemPropertiesMode)(Code) | | Resolve the given placeholder using the given properties, performing
a system properties check according to the given mode.
Default implementation delegates to resolvePlaceholder
(placeholder, props) before/after the system properties check.
Subclasses can override this for custom resolution strategies,
including customized points for the system properties check.
Parameters:
placeholder - the placeholder to resolve
Parameters:
props - the merged properties of this configurer
Parameters:
systemPropertiesMode - the system properties mode,according to the constants in this class the resolved value, of null if none
See Also: PropertyPlaceholderConfigurer.setSystemPropertiesMode
See Also: System.getProperty
See Also: PropertyPlaceholderConfigurer.resolvePlaceholder(String,java.util.Properties) |
| resolvePlaceholder | | protected String resolvePlaceholder(String placeholder, Properties props)(Code) | | Resolve the given placeholder using the given properties.
The default implementation simply checks for a corresponding property key.
Subclasses can override this for customized placeholder-to-key mappings
or custom resolution strategies, possibly just using the given properties
as fallback.
Note that system properties will still be checked before respectively
after this method is invoked, according to the system properties mode.
Parameters:
placeholder - the placeholder to resolve
Parameters:
props - the merged properties of this configurer the resolved value, of null if none
See Also: PropertyPlaceholderConfigurer.setSystemPropertiesMode |
| setIgnoreUnresolvablePlaceholders | | public void setIgnoreUnresolvablePlaceholders(boolean ignoreUnresolvablePlaceholders)(Code) | | Set whether to ignore unresolvable placeholders. Default is "false":
An exception will be thrown if a placeholder cannot be resolved.
|
| setSearchSystemEnvironment | | public void setSearchSystemEnvironment(boolean searchSystemEnvironment)(Code) | | Set whether to search for a matching system environment variable
if no matching system property has been found. Only applied when
"systemPropertyMode" is active (i.e. "fallback" or "override"), right
after checking JVM system properties.
Default is "true". Switch this setting off to never resolve placeholders
against system environment variables. Note that it is generally recommended
to pass external values in as JVM system properties: This can easily be
achieved in a startup script, even for existing environment variables.
NOTE: Access to environment variables does not work on the
Sun VM 1.4, where the corresponding
System.getenv support was
disabled - before it eventually got re-enabled for the Sun VM 1.5.
Please upgrade to 1.5 (or higher) if you intend to rely on the
environment variable support.
See Also: PropertyPlaceholderConfigurer.setSystemPropertiesMode
See Also: java.lang.System.getProperty(String)
See Also: java.lang.System.getenv(String) |
|
|