org.dspace.servicemanager.config.DSpaceConfigurationFactoryBean Maven / Gradle / Ivy
/**
* The contents of this file are subject to the license and copyright
* detailed in the LICENSE and NOTICE files at the root of the source
* tree and available online at
*
* http://www.dspace.org/license/
*/
/**
* This based heavily on the CommonsConfigurationFactoryBean available in
* 'spring-modules-jakarta-commons' version 0.8:
* https://java.net/projects/springmodules/sources/svn/content/tags/release-0_8/projects/commons/src/java/org/springmodules/commons/configuration/CommonsConfigurationFactoryBean.java?rev=2110
*
* As this module is no longer maintained by Spring, it is now recommended to
* maintain it within your own codebase, so that minor updates can be made to
* support new versions of Apache Commons Configuration (as needed). See this
* Spring ticket: https://jira.spring.io/browse/SPR-10213
*
* For DSpace, we've specifically updated this bean to automatically load all
* configurations from the DSpaceConfigurationService (which uses Commons
* Configuration internally). See constructor below.
*
* This bean is loaded in 'spring-dspace-core-services.xml' where it is wired
* up to PropertyPlaceholderConfigurer.
*/
package org.dspace.servicemanager.config;
import java.net.URL;
import org.apache.commons.configuration.CompositeConfiguration;
import org.apache.commons.configuration.Configuration;
import org.apache.commons.configuration.ConfigurationConverter;
import org.apache.commons.configuration.PropertiesConfiguration;
import org.dspace.services.ConfigurationService;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.core.io.Resource;
import org.springframework.util.Assert;
/**
* FactoryBean which wraps a Commons CompositeConfiguration object for usage
* with PropertiesLoaderSupport. This allows the configuration object to behave
* like a normal java.util.Properties object which can be passed on to
* setProperties() method allowing PropertyOverrideConfigurer and
* PropertyPlaceholderConfigurer to take advantage of Commons Configuration.
* Internally a CompositeConfiguration object is used for merging multiple
* Configuration objects.
*
* @see java.util.Properties
* @see org.springframework.core.io.support.PropertiesLoaderSupport
*
* @author Costin Leau
*
*/
public class DSpaceConfigurationFactoryBean implements InitializingBean, FactoryBean {
private CompositeConfiguration configuration;
private Configuration[] configurations;
private Resource[] locations;
private boolean throwExceptionOnMissing = true;
/**
* Initialize all properties via the passed in DSpace ConfigurationService
* @param configurationService current DSpace configuration service
*/
public DSpaceConfigurationFactoryBean(ConfigurationService configurationService)
{
Assert.notNull(configurationService.getConfiguration());
this.configuration = new CompositeConfiguration(configurationService.getConfiguration());
}
/**
* Initialize all properties via the passed in Commons Configuration
* @param configuration Commons configuration
*/
public DSpaceConfigurationFactoryBean(Configuration configuration) {
Assert.notNull(configuration);
this.configuration = new CompositeConfiguration(configuration);
}
/**
* @see org.springframework.beans.factory.FactoryBean#getObject()
*/
@Override
public Object getObject() throws Exception {
return (configuration != null) ? ConfigurationConverter.getProperties(configuration) : null;
}
/**
* @see org.springframework.beans.factory.FactoryBean#getObjectType()
*/
@Override
public Class getObjectType() {
return java.util.Properties.class;
}
/**
* @see org.springframework.beans.factory.FactoryBean#isSingleton()
*/
@Override
public boolean isSingleton() {
return true;
}
/**
* @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet()
*/
public void afterPropertiesSet() throws Exception {
if (configuration == null && (configurations == null || configurations.length == 0)
&& (locations == null || locations.length == 0))
throw new IllegalArgumentException("no configuration object or location specified");
if (configuration == null)
configuration = new CompositeConfiguration();
configuration.setThrowExceptionOnMissing(throwExceptionOnMissing);
if (configurations != null) {
for (int i = 0; i < configurations.length; i++) {
configuration.addConfiguration(configurations[i]);
}
}
if (locations != null) {
for (int i = 0; i < locations.length; i++) {
URL url = locations[i].getURL();
Configuration props = new PropertiesConfiguration(url);
configuration.addConfiguration(props);
}
}
}
/**
* @return Returns the configurations.
*/
public Configuration[] getConfigurations() {
return configurations;
}
/**
* Set the commons configurations objects which will be used as properties.
*
* @param configurations array of Commons Configuration objects
*/
public void setConfigurations(Configuration[] configurations) {
this.configurations = configurations;
}
public Resource[] getLocations() {
return locations;
}
/**
* Shortcut for loading configuration from Spring resources. It will
* internally create a PropertiesConfiguration object based on the URL
* retrieved from the given Resources.
*
* @param locations array of resource locations
*/
public void setLocations(Resource[] locations) {
this.locations = locations;
}
/**
* Return whether to throw an exception if a configuration is missing.
* @return true if exception should be throw, false otherwise.
*/
public boolean isThrowExceptionOnMissing() {
return throwExceptionOnMissing;
}
/**
* Set the underlying Commons CompositeConfiguration throwExceptionOnMissing
* flag.
* @see org.apache.commons.configuration.AbstractConfiguration
* @param throwExceptionOnMissing whether to throw an exception if a config is missing
*/
public void setThrowExceptionOnMissing(boolean throwExceptionOnMissing) {
this.throwExceptionOnMissing = throwExceptionOnMissing;
}
/**
* Getter for the underlying CompositeConfiguration object.
*
* @return CompositeConfiguration object
*/
public CompositeConfiguration getConfiguration() {
return configuration;
}
}