protected String parseStringValue(String strVal,
    Properties props,
    Set visitedPlaceholders) throws BeanDefinitionStoreException 
{
		StringBuffer buf = new StringBuffer(strVal);
		int startIndex = strVal.indexOf(this.placeholderPrefix);
		while (startIndex != -1) {
			int endIndex = findPlaceholderEndIndex(buf, startIndex);
			if (endIndex != -1) {
				String placeholder = buf.substring(startIndex + this.placeholderPrefix.length(), endIndex);
				if (!visitedPlaceholders.add(placeholder)) {
					throw new BeanDefinitionStoreException(
							"Circular placeholder reference '" + placeholder + "' in property definitions");
				}
				// Recursive invocation, parsing placeholders contained in the placeholder key.
				placeholder = parseStringValue(placeholder, props, visitedPlaceholders);
				// Now obtain the value for the fully resolved key...
				String propVal = resolvePlaceholder(placeholder, props, this.systemPropertiesMode);
				if (propVal != null) {
					// Recursive invocation, parsing placeholders contained in the
					// previously resolved placeholder value.
					propVal = parseStringValue(propVal, props, visitedPlaceholders);
					buf.replace(startIndex, endIndex + this.placeholderSuffix.length(), propVal);
					if (logger.isTraceEnabled()) {
						logger.trace("Resolved placeholder '" + placeholder + "'");
					}
					startIndex = buf.indexOf(this.placeholderPrefix, startIndex + propVal.length());
				}
				else if (this.ignoreUnresolvablePlaceholders) {
					// Proceed with unprocessed value.
					startIndex = buf.indexOf(this.placeholderPrefix, endIndex + this.placeholderSuffix.length());
				}
				else {
					throw new BeanDefinitionStoreException("Could not resolve placeholder '" + placeholder + "'");
				}
				visitedPlaceholders.remove(placeholder);
			}
			else {
				startIndex = -1;
			}
		}
		return buf.toString();
}

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) throws BeansException 
{
		StringValueResolver valueResolver = new PlaceholderResolvingStringValueResolver(props);
		BeanDefinitionVisitor visitor = new BeanDefinitionVisitor(valueResolver);
		String[] beanNames = beanFactoryToProcess.getBeanDefinitionNames();
		for (int i = 0; i <  beanNames.length; i++) {
			// Check that we're not parsing our own bean definition,
			// to avoid failing on unresolvable placeholders in properties file locations.
			if (!(beanNames[i].equals(this.beanName) && beanFactoryToProcess.equals(this.beanFactory))) {
				BeanDefinition bd = beanFactoryToProcess.getBeanDefinition(beanNames[i]);
				try {
					visitor.visitBeanDefinition(bd);
				}
				catch (BeanDefinitionStoreException ex) {
					throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanNames[i], ex.getMessage());
				}
			}
		}
		// New in Spring 2.5: resolve placeholders in alias target names and aliases as well.
		beanFactoryToProcess.resolveAliases(valueResolver);
}

 protected String resolvePlaceholder(String placeholder,
    Properties props) 
{
		return props.getProperty(placeholder);
}

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.

 protected String resolvePlaceholder(String placeholder,
    Properties props,
    int systemPropertiesMode) 
{
		String propVal = null;
		if (systemPropertiesMode == SYSTEM_PROPERTIES_MODE_OVERRIDE) {
			propVal = resolveSystemProperty(placeholder);
		}
		if (propVal == null) {
			propVal = resolvePlaceholder(placeholder, props);
		}
		if (propVal == null && systemPropertiesMode == SYSTEM_PROPERTIES_MODE_FALLBACK) {
			propVal = resolveSystemProperty(placeholder);
		}
		return propVal;
}

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.

 protected String resolveSystemProperty(String key) 
{
		try {
			String value = System.getProperty(key);
			if (value == null && this.searchSystemEnvironment) {
				value = System.getenv(key);
			}
			return value;
		}
		catch (Throwable ex) {
			if (logger.isDebugEnabled()) {
				logger.debug("Could not access system property '" + key + "': " + ex);
			}
			return null;
		}
}

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) 
{
		this.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. The latter case can happen with placeholders for system properties in resource locations.

 public  void setBeanName(String beanName) 
{
		this.beanName = beanName;
}

Only necessary to check that we're not parsing our own bean definition, to avoid failing on unresolvable placeholders in properties file locations. The latter case can happen with placeholders for system properties in resource locations.

 public  void setIgnoreUnresolvablePlaceholders(boolean ignoreUnresolvablePlaceholders) 
{
		this.ignoreUnresolvablePlaceholders = ignoreUnresolvablePlaceholders;
}

Set whether to ignore unresolvable placeholders. Default is "false": An exception will be thrown if a placeholder cannot be resolved.

 public  void setNullValue(String nullValue) 
{
		this.nullValue = nullValue;
}

Set a value that should be treated as null when resolved as a placeholder value: e.g. "" (empty String) or "null".

Note that this will only apply to full property values, not to parts of concatenated values.

By default, no such null value is defined. This means that there is no way to express null as a property value unless you explictly map a corresponding value here.

 public  void setPlaceholderPrefix(String placeholderPrefix) 
{
	               	 
		this.placeholderPrefix = placeholderPrefix;
}

Set the prefix that a placeholder string starts with. The default is "${".

 public  void setPlaceholderSuffix(String placeholderSuffix) 
{
		this.placeholderSuffix = placeholderSuffix;
}

Set the suffix that a placeholder string ends with. The default is "}".

 public  void setSearchSystemEnvironment(boolean searchSystemEnvironment) 
{
		this.searchSystemEnvironment = searchSystemEnvironment;
}

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.

 public  void setSystemPropertiesMode(int systemPropertiesMode) 
{
		this.systemPropertiesMode = 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. "never" will not check system properties at all.

 public  void setSystemPropertiesModeName(String constantName) throws IllegalArgumentException 
{
		this.systemPropertiesMode = constants.asNumber(constantName).intValue();
}

Set the system property mode by the name of the corresponding constant, e.g. "SYSTEM_PROPERTIES_MODE_OVERRIDE".