Loading environment specific spring configurations.

At my work we try to deploy locally on tomcat or glassfish and in production (and the other test environments) on webspere. For this we often need to overwrite a spring bean to implement it differently. For example we use jdni to loopup the datasource in the websphere environments, but we prefer to use a commons dbcp pool on tomcat. Also workloadmanager, shedulers, and MQ configurations tend to differ on the different locations.

Each application dealt with this in a different manner, so we wanted a general flexible solution to work with different configuration files in different locations. The solution present and the solution we choose where based on the on Joris Kuipers introduced in an older application, he blogged about this in http://blog.springsource.com/2007/06/25/code-samples-from-springone-beyond-the-obvious-talk/

We wanted to put our configuration files in a hierarchical structure as for example the following:

• context/
• context/env/{environment} ie context/env/l-tomcat context/env/p etc.

And configure the environment by using a system property.

The idea is that first all configuration files from the base directory and then the environment specific files are loaded. To make this work we extended the ContextLoader from spring the following way:

/**
 * A EnvironmentDependent {@link ContextLoader} that reads the environment property and loads the base + the environment specific context files.
 * The environment specif context is expected under the normal context in a directoy /env/{environment}.
 *
 * If you for example specify a <b>contextConfigLocation</b> param with the following: <b>/WEB-INF/applicationContext.xml,classpath:/context/*Context.xml</b>
 * this loader will load the following if the environment is set to L-TOMCAT:
 * <ul>
 * 	<li>/WEB-INF/applicationContext.xml</li>
 *  <li>/WEB-INF/env/L-TOMCAT/applicationContext.xml</li>
 *  <li>all xml files ending with Context in the classpath directory /context</li>
 *  <li>all xml files ending with Context in the classpath directory /context/env/L-TOMCAT</li>
 *</ul>
 * @author Job de Noo
 */
public class EnvironmentDependentContextLoader extends ContextLoader{
	private static final Logger log = Logger.getLogger(EnvironmentDependentContextLoader.class);

    @Override
    protected void customizeContext(ServletContext servletContext, ConfigurableWebApplicationContext applicationContext) {
	    super.customizeContext(servletContext, applicationContext);
	    String environment = new EnvironmentResolver().getEnvironment();
    	log.info("cusotmizing the context with the EnvironmentDependentContextLoaderListener for environment:" + environment);

	    List<String> configLocations = new ArrayList<String>();
	    configLocations.addAll(Arrays.asList(applicationContext.getConfigLocations()));
    	for (String configLocation : applicationContext.getConfigLocations()){
			if (new AntPathMatcher().isPattern(configLocation)){
	    		handlePattern(configLocations, environment, configLocation);
	    	}else{
	    	    handleNormalLocation(applicationContext, configLocations, environment, configLocation);
	    	}
	    }
	    String[] configLocs = new String[configLocations.size()];
	    configLocations.toArray(configLocs);
	    applicationContext.setConfigLocations(configLocs);
	    log.info("done cusotmizing the context with the EnvironmentDependentContextLoaderListener for environment:" + environment);
	    log.info("loading the following config loactions:" +  configLocs);
    }

	private void handleNormalLocation(ConfigurableWebApplicationContext applicationContext, List<String> configLocations,
            String environment, String configLocation) {
	    String environmentDependentLocation = StringUtils.applyRelativePath(configLocation, "env/" +environment+ "/"+ StringUtils.getFilename(configLocation));
	    Resource overridingResource = applicationContext.getResource(environmentDependentLocation);
	    if (overridingResource.exists()){
	    	configLocations.add(environmentDependentLocation);
	    	log.info("added a environmentspecific location: " + environmentDependentLocation);
	    }
    }

	private void handlePattern(List<String> configLocations, String environment, String configLocation) {
		String environmentDependentLocation;
		if (configLocation.contains("/")){
			environmentDependentLocation = StringUtils.applyRelativePath(configLocation, "env/" +environment+ "/"+ StringUtils.getFilename(configLocation));
		}else{
			int prefixEnd = configLocation.indexOf(":") + 1;
			if (prefixEnd == 0){
				environmentDependentLocation = StringUtils.applyRelativePath(configLocation, "env/" +environment+ "/"+ StringUtils.getFilename(configLocation));
			}else{
		    	String prefix = configLocation.substring(0, prefixEnd);
		    	String pattern = configLocation.substring(prefixEnd);
		    	environmentDependentLocation = prefix + StringUtils.applyRelativePath(pattern, "env/" +environment+ "/"+ StringUtils.getFilename(pattern));
			}
		}
    	log.info("added a environmentspecific location: " + environmentDependentLocation);
		configLocations.add(environmentDependentLocation);
    }
}

Note: In Spring 3 this class should extend the ContextLoaderListener instead of the ContextLoader.

For Spring 2.5 a simple implementation of the ContextLoaderListener that creates the above ContextLoader is enough:

/**
 * ContextLoaderListener implementation that will use the {@link EnvironmentDependentContextLoader} as ContextLoader.
 * @author Job de Noo
 *
 */
public class EnvironmentDependentContextLoaderListener extends ContextLoaderListener{
	private static final Logger log = Logger.getLogger(EnvironmentDependentContextLoader.class);

	@Override
    public ContextLoader createContextLoader() {
		log.info("returning the EnvironmentDependentContextLoader");
		return new EnvironmentDependentContextLoader();
    }
}

To use this contextListener simply replace the ContextLoaderListener configured in the web.xml by this one.
Then if you specify the conf

[/xml]

	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>
			classpath:application-context.xml
                        classpath:jms-context.xml
                        WEB-INF/spring-web.xml
              </param-value>
	</context-param>
[xml]

it will load the above files plus the following if they exist:(assuming you environment variable is set to D.
classpath:/env/d/application-context.xml
classpath:/env/d/jms-context.xml
WEB-INF/env/d/spring-web.xml

It also supports patterns like *Context.xml etc.