All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.springframework.beans.factory.config.PropertyResourceConfigurer Maven / Gradle / Ivy

There is a newer version: 6.1.13
Show newest version
/*
 * Copyright 2002-2005 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.io.InputStream;
import java.io.InputStreamReader;
import java.util.Enumeration;
import java.util.Properties;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanInitializationException;
import org.springframework.core.Ordered;
import org.springframework.core.io.Resource;
import org.springframework.util.DefaultPropertiesPersister;
import org.springframework.util.ObjectUtils;
import org.springframework.util.PropertiesPersister;

/**
 * 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 implements BeanFactoryPostProcessor, Ordered { protected final Log logger = LogFactory.getLog(getClass()); private int order = Integer.MAX_VALUE; // default: same as non-Ordered private Properties properties; private Resource[] locations; private String fileEncoding; private PropertiesPersister propertiesPersister = new DefaultPropertiesPersister(); private boolean ignoreResourceNotFound = false; public void setOrder(int order) { this.order = order; } public int getOrder() { return order; } /** * Set local properties, e.g. via the "props" tag in XML bean definitions. * These can be considered defaults, to be overridden by properties * loaded from files. * @see #setLocation * @see #setLocations */ public void setProperties(Properties properties) { this.properties = properties; } /** * Set a location of a properties file to be loaded. * @see #setLocations */ public void setLocation(Resource location) { this.locations = new Resource[] {location}; } /** * Set locations of properties files to be loaded. * @see #setLocation */ public void setLocations(Resource[] locations) { this.locations = locations; } /** * Set the encoding to use for parsing properties files. * Default is none, using java.util.Properties' default encoding. * @see org.springframework.util.PropertiesPersister#load */ public void setFileEncoding(String encoding) { this.fileEncoding = encoding; } /** * Set the PropertiesPersister to use for parsing properties files. * The default is DefaultPropertiesPersister. * @see org.springframework.util.DefaultPropertiesPersister */ public void setPropertiesPersister(PropertiesPersister propertiesPersister) { this.propertiesPersister = propertiesPersister; } /** * Set if failure to find the property resource should be ignored. * True is appropriate if the properties file is completely optional. * Default is false. */ public void setIgnoreResourceNotFound(boolean ignoreResourceNotFound) { this.ignoreResourceNotFound = ignoreResourceNotFound; } public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException { Properties mergedProps = new Properties(); if (this.properties != null) { // use propertyNames enumeration to also catch default properties for (Enumeration en = this.properties.propertyNames(); en.hasMoreElements();) { String key = (String) en.nextElement(); mergedProps.setProperty(key, this.properties.getProperty(key)); } } if (this.locations != null) { for (int i = 0; i < this.locations.length; i++) { Resource location = this.locations[i]; if (logger.isInfoEnabled()) { logger.info("Loading properties from " + location + ""); } try { InputStream is = location.getInputStream(); try { if (this.fileEncoding != null) { this.propertiesPersister.load(mergedProps, new InputStreamReader(is, this.fileEncoding)); } else { this.propertiesPersister.load(mergedProps, is); } } finally { is.close(); } } catch (IOException ex) { String msg = "Could not load properties from " + location; if (this.ignoreResourceNotFound) { if (logger.isWarnEnabled()) { logger.warn(msg + ": " + ex.getMessage()); } } else { throw new BeanInitializationException(msg, ex); } } } } // Convert the merged properties, if necessary. convertProperties(mergedProps); // Let the subclass process the properties. processProperties(beanFactory, mergedProps); } /** * 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; }





© 2015 - 2024 Weber Informatics LLC | Privacy Policy