/*
* Copyright 2005-2010 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.ws.test.support;
import java.util.Map;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.BeanCreationException;
import org.springframework.beans.factory.BeanInitializationException;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
* Helper class for for loading default implementations of an interface.
*
* @author Arjen Poutsma
* @since 2.0
*/
public class MockStrategiesHelper {
private static final Log logger = LogFactory.getLog(MockStrategiesHelper.class);
private final ApplicationContext applicationContext;
/**
* Creates a new instance of the {@code MockStrategiesHelper} with the given application context.
*
* @param applicationContext the application context
*/
public MockStrategiesHelper(ApplicationContext applicationContext) {
Assert.notNull(applicationContext, "'applicationContext' must not be null");
this.applicationContext = applicationContext;
}
/**
* Returns the application context.
*/
public ApplicationContext getApplicationContext() {
return applicationContext;
}
/**
* Returns a single strategy found in the given application context.
*
* @param type the type of bean to be found in the application context
* @return the bean, or {@code null} if no bean of the given type can be found
* @throws BeanInitializationException if there is more than 1 beans of the given type
*/
public <T> T getStrategy(Class<T> type) {
Assert.notNull(type, "'type' must not be null");
Map<String, T> map = applicationContext.getBeansOfType(type);
if (map.isEmpty()) {
return null;
}
else if (map.size() == 1) {
Map.Entry<String, T> entry = map.entrySet().iterator().next();
if (logger.isDebugEnabled()) {
logger.debug("Using " + ClassUtils.getShortName(type) + " [" + entry.getKey() + "]");
}
return entry.getValue();
}
else {
throw new BeanInitializationException(
"Could not find exactly 1 " + ClassUtils.getShortName(type) + " in application context");
}
}
/**
* Returns a single strategy found in the given application context, or instantiates a default strategy if no
* applicable strategy was found.
*
* @param type the type of bean to be found in the application context
* @param defaultType the type to instantiate and return when no bean of the specified type could be found
* @return the bean found in the application context, or the default type if no bean of the given type can be found
* @throws BeanInitializationException if there is more than 1 beans of the given type
*/
public <T, D extends T> T getStrategy(Class<T> type, Class<D> defaultType) {
Assert.notNull(defaultType, "'defaultType' must not be null");
T t = getStrategy(type);
if (t != null) {
return t;
}
else {
if (logger.isDebugEnabled()) {
logger.debug("No " + ClassUtils.getShortName(type) + " found, using default " +
ClassUtils.getShortName(defaultType));
}
T defaultStrategy = BeanUtils.instantiateClass(defaultType);
if (defaultStrategy instanceof ApplicationContextAware) {
ApplicationContextAware applicationContextAware = (ApplicationContextAware) defaultStrategy;
applicationContextAware.setApplicationContext(applicationContext);
}
if (defaultStrategy instanceof InitializingBean) {
InitializingBean initializingBean = (InitializingBean) defaultStrategy;
try {
initializingBean.afterPropertiesSet();
}
catch (Exception ex) {
throw new BeanCreationException("Invocation of init method failed", ex);
}
}
return defaultStrategy;
}
}
}