|
The Spring Framework | |||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectorg.springframework.core.io.support.PropertiesLoaderSupport
org.springframework.beans.factory.config.PropertyResourceConfigurer
org.springframework.beans.factory.config.PropertyPlaceholderConfigurer
public class PropertyPlaceholderConfigurer
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:mydbPropertyPlaceholderConfigurer 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}/subdirIn 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 PropertyResourceConfigurer.convertPropertyValue(java.lang.String)
method. For example, encrypted values can
be detected and decrypted accordingly before processing them.
PropertiesLoaderSupport.setLocations(org.springframework.core.io.Resource[])
,
PropertiesLoaderSupport.setProperties(java.util.Properties)
,
setPlaceholderPrefix(java.lang.String)
,
setPlaceholderSuffix(java.lang.String)
,
setSystemPropertiesModeName(java.lang.String)
,
System.getProperty(String)
,
PropertyResourceConfigurer.convertPropertyValue(java.lang.String)
,
PropertyOverrideConfigurer
Field Summary | |
---|---|
static String |
DEFAULT_PLACEHOLDER_PREFIX
Default placeholder prefix: "${" |
static String |
DEFAULT_PLACEHOLDER_SUFFIX
Default placeholder suffix: "}" |
static int |
SYSTEM_PROPERTIES_MODE_FALLBACK
Check system properties if not resolvable in the specified properties. |
static int |
SYSTEM_PROPERTIES_MODE_NEVER
Never check system properties. |
static int |
SYSTEM_PROPERTIES_MODE_OVERRIDE
Check system properties first, before trying the specified properties. |
Fields inherited from class org.springframework.core.io.support.PropertiesLoaderSupport |
---|
logger, XML_FILE_EXTENSION |
Fields inherited from interface org.springframework.core.Ordered |
---|
HIGHEST_PRECEDENCE, LOWEST_PRECEDENCE |
Constructor Summary | |
---|---|
PropertyPlaceholderConfigurer()
|
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). |
protected void |
processProperties(ConfigurableListableBeanFactory beanFactoryToProcess,
Properties props)
Apply the given Properties to the bean factory. |
protected String |
resolvePlaceholder(String placeholder,
Properties props)
Resolve the given placeholder using the given properties. |
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 |
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. |
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. |
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. |
void |
setIgnoreUnresolvablePlaceholders(boolean ignoreUnresolvablePlaceholders)
Set whether to ignore unresolvable placeholders. |
void |
setPlaceholderPrefix(String placeholderPrefix)
Set the prefix that a placeholder string starts with. |
void |
setPlaceholderSuffix(String placeholderSuffix)
Set the suffix that a placeholder string ends with. |
void |
setSearchSystemEnvironment(boolean searchSystemEnvironment)
Set whether to search for a matching system environment variable if no matching system property has been found. |
void |
setSystemPropertiesMode(int systemPropertiesMode)
Set how to check system properties: as fallback, as override, or never. |
void |
setSystemPropertiesModeName(String constantName)
Set the system property mode by the name of the corresponding constant, e.g. |
Methods inherited from class org.springframework.beans.factory.config.PropertyResourceConfigurer |
---|
convertProperties, convertPropertyValue, getOrder, postProcessBeanFactory, setOrder |
Methods inherited from class org.springframework.core.io.support.PropertiesLoaderSupport |
---|
loadProperties, mergeProperties, setFileEncoding, setIgnoreResourceNotFound, setLocalOverride, setLocation, setLocations, setProperties, setPropertiesArray, setPropertiesPersister |
Methods inherited from class java.lang.Object |
---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
Field Detail |
---|
public static final String DEFAULT_PLACEHOLDER_PREFIX
public static final String DEFAULT_PLACEHOLDER_SUFFIX
public static final int SYSTEM_PROPERTIES_MODE_NEVER
public static final int SYSTEM_PROPERTIES_MODE_FALLBACK
public static final int SYSTEM_PROPERTIES_MODE_OVERRIDE
Constructor Detail |
---|
public PropertyPlaceholderConfigurer()
Method Detail |
---|
public void setPlaceholderPrefix(String placeholderPrefix)
DEFAULT_PLACEHOLDER_PREFIX
public void setPlaceholderSuffix(String placeholderSuffix)
DEFAULT_PLACEHOLDER_SUFFIX
public void setSystemPropertiesModeName(String constantName) throws IllegalArgumentException
constantName
- name of the constant
IllegalArgumentException
- if an invalid constant was specifiedsetSystemPropertiesMode(int)
public void setSystemPropertiesMode(int systemPropertiesMode)
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. "never" will not check system properties at all.
SYSTEM_PROPERTIES_MODE_NEVER
,
SYSTEM_PROPERTIES_MODE_FALLBACK
,
SYSTEM_PROPERTIES_MODE_OVERRIDE
,
setSystemPropertiesModeName(java.lang.String)
public void setSearchSystemEnvironment(boolean searchSystemEnvironment)
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(java.lang.String)
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.
setSystemPropertiesMode(int)
,
System.getProperty(String)
,
System.getenv(String)
public void setIgnoreUnresolvablePlaceholders(boolean ignoreUnresolvablePlaceholders)
public void setBeanName(String beanName)
setBeanName
in interface BeanNameAware
beanName
- the name of the bean in the factory.
Note that this name is the actual bean name used in the factory, which may
differ from the originally specified name: in particular for inner bean
names, the actual bean name might have been made unique through appending
"#..." suffixes. Use the BeanFactoryUtils.originalBeanName(String)
method to extract the original bean name (without suffix), if desired.PropertiesLoaderSupport.setLocations(org.springframework.core.io.Resource[])
,
ResourceEditor
public void setBeanFactory(BeanFactory beanFactory)
setBeanFactory
in interface BeanFactoryAware
beanFactory
- owning BeanFactory (never null
).
The bean can immediately call methods on the factory.PropertiesLoaderSupport.setLocations(org.springframework.core.io.Resource[])
,
ResourceEditor
protected void processProperties(ConfigurableListableBeanFactory beanFactoryToProcess, Properties props) throws BeansException
PropertyResourceConfigurer
processProperties
in class PropertyResourceConfigurer
beanFactoryToProcess
- the bean factory used by the application contextprops
- the Properties to apply
BeansException
- in case of errorsprotected String parseStringValue(String strVal, Properties props, Set visitedPlaceholders) throws BeanDefinitionStoreException
strVal
- the String value to parseprops
- the Properties to resolve placeholders againstvisitedPlaceholders
- the placeholders that have already been visited
during the current resolution attempt (used to detect circular references
between placeholders). Only non-null if we're parsing a nested placeholder.
BeanDefinitionStoreException
- if invalid values are encounteredresolvePlaceholder(String, java.util.Properties, int)
protected String resolvePlaceholder(String placeholder, Properties props, int systemPropertiesMode)
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.
placeholder
- the placeholder to resolveprops
- the merged properties of this configurersystemPropertiesMode
- the system properties mode,
according to the constants in this class
setSystemPropertiesMode(int)
,
System.getProperty(java.lang.String)
,
resolvePlaceholder(String, java.util.Properties)
protected String resolvePlaceholder(String placeholder, Properties props)
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.
placeholder
- the placeholder to resolveprops
- the merged properties of this configurer
null
if nonesetSystemPropertiesMode(int)
protected String resolveSystemProperty(String key)
key
- the placeholder to resolve as system property key
null
if not foundsetSearchSystemEnvironment(boolean)
,
System.getProperty(String)
,
System.getenv(String)
|
The Spring Framework | |||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |