org.springframework.beans.factory.config.PropertyResourceConfigurer Maven / Gradle / Ivy
/*
* Copyright 2002-2006 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.beans.factory.config;
import java.io.IOException;
import java.util.Enumeration;
import java.util.Properties;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanInitializationException;
import org.springframework.core.Ordered;
import org.springframework.core.io.support.PropertiesLoaderSupport;
import org.springframework.util.ObjectUtils;
/**
* Allows for configuration of individual bean property values from a property resource,
* i.e. a properties file. Useful for custom config files targetted at system
* administrators that override bean properties configured in the application context.
*
* 2 concrete implementations are provided in the distribution:
*
* - PropertyOverrideConfigurer for "beanName.property=value" style overriding
* (pushing values from a properties file into bean definitions)
*
- PropertyPlaceholderConfigurer for replacing "${...}" placeholders
* (pulling values from a properties file into bean definitions)
*
*
* Property values can be converted after reading them in, through overriding
* the convertPropertyValue method. For example, encrypted values
* can be detected and decrypted accordingly before processing them.
*
* @author Juergen Hoeller
* @since 02.10.2003
* @see PropertyOverrideConfigurer
* @see PropertyPlaceholderConfigurer
* @see #convertPropertyValue
*/
public abstract class PropertyResourceConfigurer extends PropertiesLoaderSupport
implements BeanFactoryPostProcessor, Ordered {
private int order = Ordered.LOWEST_PRECEDENCE; // default: same as non-Ordered
public void setOrder(int order) {
this.order = order;
}
public int getOrder() {
return order;
}
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
try {
Properties mergedProps = mergeProperties();
// Convert the merged properties, if necessary.
convertProperties(mergedProps);
// Let the subclass process the properties.
processProperties(beanFactory, mergedProps);
}
catch (IOException ex) {
throw new BeanInitializationException("Could not load properties", ex);
}
}
/**
* Convert the given merged properties, converting property values
* if necessary. The result will then be processed.
*
Default implementation will invoke convertPropertyValue
* for each property value, replacing the original with the converted value.
* @see #convertPropertyValue
* @see #processProperties
*/
protected void convertProperties(Properties props) {
Enumeration propertyNames = props.propertyNames();
while (propertyNames.hasMoreElements()) {
String propertyName = (String) propertyNames.nextElement();
String propertyValue = props.getProperty(propertyName);
String convertedValue = convertPropertyValue(propertyValue);
if (!ObjectUtils.nullSafeEquals(propertyValue, convertedValue)) {
props.setProperty(propertyName, convertedValue);
}
}
}
/**
* Convert the given property value from the properties source
* to the value that should be applied.
*
Default implementation simply returns the original value.
* Can be overridden in subclasses, for example to detect
* encrypted values and decrypt them accordingly.
* @param originalValue the original value from the properties source
* (properties file or local "properties")
* @return the converted value, to be used for processing
* @see #setProperties
* @see #setLocations
* @see #setLocation
*/
protected String convertPropertyValue(String originalValue) {
return originalValue;
}
/**
* Apply the given Properties to the bean factory.
* @param beanFactory the bean factory used by the application context
* @param props the Properties to apply
* @throws org.springframework.beans.BeansException in case of errors
*/
protected abstract void processProperties(ConfigurableListableBeanFactory beanFactory, Properties props)
throws BeansException;
}