====== Related to [[http://www.springsource.org/|Spring]] ======

  * [[livejournal>ru-java/1033166|AOP на примере JSF 2 приложения]]
  * [[http://static.springsource.org/docs/Spring-MVC-step-by-step/|Developing a Spring Framework MVC application step-by-step]]
  * [[habrahabr>218203|Чем старше Spring, тем больше контекстов]]
  * [[http://www.javacodegeeks.com/2013/01/spring-property-placeholder-configurer-a-few-not-so-obvious-options.html|Spring Property Placeholder Configurer – A few not so obvious options (default values, recursive property resolution)]]
  * [[habrahabr>347816|Изучение Spring Framework 100% через практику. Активные туториалы и язык разметки KML]]. [[https://kciray8.github.io/KciTasks/App/src/|Проект KciTasks (beta)]].


===== Questions answered =====

=== Is it possible to set a bean property to given resource in module classpath as ''InputStream'' / as ''URL''? ===

<note tip>
Yes, this is possible due to build-in ''org.springframework.beans.propertyeditors.InputStreamEditor'', which allows conversion from ''String -> org.springframework.core.io.Resource -> java.io.InputStream''. If you have e.g. overloaded constructors, one of which has ''String'' argument, then you need to specify the target type explicitly:

<code xml>
<bean class="...">
	<constructor-arg value="classpath:/com/company/module/file.xml" type="java.io.InputStream" />
</bean>
</code>

The same conversion is also possible via build-in ''org.springframework.beans.propertyeditors.URLEditor'', which allows conversion from ''String -> org.springframework.core.io.Resource -> java.net.URL'':

<code xml>
<bean class="...">
	<constructor-arg value="classpath:/com/company/module/file.xml" type="java.net.URL" />
</bean>
</code>
</note>


=== How to programmatically enumerate all classpath resources using Ant mask? ===

<note tip>
<code java>
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;

for (Resource resource : new PathMatchingResourcePatternResolver().getResources("classpath*:/path/*.txt")) {
    resource.getInputStream();
}
</code>
</note>


=== [[stackoverflow>20084272|How to set ''null'' to a bean property?]] ===

<note tip>
Use SpEL: ''%%<bean ... p:fieldName="#{null}" />%%''
</note>


=== Implementation of cache which is based on [[https://commons.apache.org/proper/commons-collections/apidocs/org/apache/commons/collections4/map/LRUMap.html|Apache LRUMap]] ===

<note tip>
See {{:programming:java:lru_map_cache.7z}}. Usage:
<code xml|spring-context.xml>
<bean id="cacheManager" class="util.LRUMapCacheManager" />
</code>
</note>


=== Is it possible to set a bean property to given resource in module classpath as ''Property'' / as ''ResourceBundle''? ===

<note tip>
One alternative is to use ''PropertiesFactoryBean'' which allows you to load properties from text or XML file(s) and optionally merge with fixed values:

<code xml>
<bean class="...">
	<constructor-arg>
		<bean class="org.springframework.beans.factory.config.PropertiesFactoryBean">
			<property name="location" value="classpath:/com/company/module/list_en.properties" />
		</bean>
	</constructor-arg>
</bean>
</code>

or if you need to inject ''java.util.ResourceBundle'' type you may use ''org.springframework.beans.propertyeditors.ResourceBundleEditor'' (which is not registered in Spring context by default, so [[stackoverflow>1268021|one need to make it manually]]):

<code xml>
<bean class="org.springframework.beans.factory.config.CustomEditorConfigurer">
	<property name="customEditors">
		<map>
			<entry key="java.util.ResourceBundle">
				<bean class="org.springframework.beans.propertyeditors.ResourceBundleEditor" />
			</entry>
		</map>
	</property>
</bean>

<bean class="...">
	<!-- Resource location is the same as above: -->
	<constructor-arg value="com.company.module.list" />
</bean>
</code>

More information is [[stackoverflow>317687|here]].
</note>


=== How to override property declared in parent properties? ===

<note tip>
It is possible to pass an array of ''java.util.Properties'' objects to ''org.springframework.beans.factory.config.PropertiesFactoryBean'' which will be merged in given order. Note that under-the-hood below solution uses ''org.springframework.core.convert.support.StringToPropertiesConverter'' which converts from multi-line string to ''java.util.Properties''.

<code xml>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
                           http://www.springframework.org/schema/util  http://www.springframework.org/schema/util/spring-util-4.1.xsd">

	<util:properties id="configurationProperties">
		<prop key="location">/tmp</prop>
		<prop key="size">1000</prop>
	</util:properties>

	<bean id="testConfigurationProperties" class="org.springframework.beans.factory.config.PropertiesFactoryBean">
		<property name="propertiesArray">
			<list>
				<ref bean="configurationProperties" />
				<value>
					size=10
				</value>
			</list>
		</property>
	</bean>
</beans>
</code>
</note>


=== How to initialize the property value from system property or use the default value if system property is not defined? ===

<note tip>
Use SpEL:
<code xml>
<bean ...>
	<property name="url" value="#{ systemProperties[url] ?: 'http://default/url' }" />
</bean>
</code>
</note>


=== How to collect and inject all beans of a given type? ===

<note tip>
From [[stackoverflow>2799316|How to collect and inject all beans of a given type in Spring]]:

  * ''@Autowired List<ChildBean> list'' will work OK both for lists and arrays.
  * The analogue for XML configuration would be ''%%autowire="byType"%%'' or ''%%autowire="constructor"%%'' e.g. ''%%<bean class="ParentBean" autowire="byType" />%%'' (see [[http://static.springsource.org/spring/docs/3.0.x/reference/beans.html#beans-factory-autowire|Autowiring collaborators]]).
  
</note>


=== [[stackoverflow>50448238|What is the Spring bean lifecycle?]] ===

{{https://www.concretepage.com/spring/images/spring-bean-life-cycle-tutorial.jpg}}


=== How to create deamon threads? ===

<note tip>
<code xml>
<bean id="taskExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor"
	p:corePoolSize="5"
	p:maxPoolSize="30"
	p:daemon="true"
/>
</code>
</note>


=== How to call a method on specific bean? ===

<note tip>
  * Method using ''MethodInvokingFactoryBean'':
    <code xml>
<bean id="registerListener1" class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
	<property name="targetObject">
		<ref local="listenerContainer" />
	</property>
	<property name="targetMethod" value="addListener" />
	<property name="arguments">
		<list>
			<ref bean="listener1" />
		</list>
	</property>
</bean>
</code>
  * Method using SpEL: ''#{listenerContainer.addListener(listener1)}''.
</note>


=== How to inject correctly prototype-scoped bean into singleton-scoped bean? ===

<note tip>
Doing this via ''@Autowired'' (or normal declarative bean injection via ''<property>'') will not result the desired effect, as in our singleton bean we want to get new version of prototype bean each time on request. The solutions are:
  * Wire the Spring context and retrieve the bean using the context (''%%@Autowired ApplicationContext context; ... context.getBean("prototypeBean");%%''). Drawback: explicit dependency on Spring classes.
  * Use [[springdocs>beans.html#beans-factory-lookup-method-injection|Lookup method injection]]. Mind that method to be overridden does not necessarily need to be ''abstract'' (normal ''protected'' method is fairly OK) as it will some difficulties to unit test the bean. Unfortunately, there is no way to configure this functionality using annotations prior to Spring v4.1 (see [[https://jira.springsource.org/browse/SPR-5192|SPR-5192]]).
  * Use ''<aop:scoped-proxy/>'' (see [[springdocs>beans.html#beans-factory-scopes-other-injection|Scoped beans as dependencies]]). Drawback: does not make sense with ''prototype'' scope as each method invocation will operate with new bean instance which makes it impossible to use this approach with stateful beans.

See also:
  * [[https://prasanthnath.wordpress.com/2013/03/21/injecting-a-prototype-bean-into-a-singleton-bean/|Injecting a prototype bean into a singleton bean]]
</note>


=== How to configure Spring application to use aspect [[springdocs>aop.html#aop-aj-ltw|load-time weaving (LTW)]]? ===

<note tip>
  - Create ''META-INF/aop.xml'' (should be included into WAR or JAR) and e.g. aspect ''MultiThreadedHttpConnectionManagerAdvice.java'' as below:
    <code xml|META-INF/aop.xml>
<!DOCTYPE aspectj PUBLIC "-//AspectJ//DTD//EN" "http://www.eclipse.org/aspectj/dtd/aspectj.dtd">
<aspectj>

	<!-- Add options="-verbose -debug" for more logging -->
	<weaver>
		<!-- Only weave classes in these packages: -->
		<include within="org.apache.commons.httpclient..*" />
		<!-- Also include the aspect itself (otherwise "java.lang.NoSuchMethodError: MultiThreadedHttpConnectionManagerAdvice.aspectOf()" will be thrown): -->
		<include within="aspects.MultiThreadedHttpConnectionManagerAdvice" />
	</weaver>

	<aspects>
		<!-- weave in just this aspect -->
		<aspect name="aspects.MultiThreadedHttpConnectionManagerAdvice" />
	</aspects>

</aspectj>
</code>
    <code java5|MultiThreadedHttpConnectionManagerAdvice.java>
package aspects;

import java.lang.reflect.Field;
import java.util.IdentityHashMap;
import java.util.LinkedList;
import java.util.Map;

import org.apache.commons.logging.LogFactory;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.util.ReflectionUtils;

@Aspect
public class MultiThreadedHttpConnectionManagerAdvice {

	private final Map<Object, ConnectionPoolInfo> infos = new IdentityHashMap<Object, ConnectionPoolInfo>();

	/**
	 * Statistics is reset after this amount of invocations.
	 */
	private static final int NUMBER_OF_INVOCATIONS_PER_MEASUREMENT	= 100;

	static class ConnectionPoolInfo {
		public int	invocationsNumber;
		public int	maxWaitingThreadsNumber;

		@Override
		public String toString() {
			return "maxWaitingThreadsNumber:" + maxWaitingThreadsNumber;
		}
	}

	/**
	 * @param pool instance of {@link MultiThreadedHttpConnectionManager$ConnectionPool}.
	 */
	private void updateStatistics(Object pool) {
		LinkedList<?> waitingThreads = getField(pool, "waitingThreads");

		synchronized (infos) {
			ConnectionPoolInfo info = infos.get(pool);

			if (info == null) {
				info = new ConnectionPoolInfo();
				infos.put(pool, info);
			}

			if (info.maxWaitingThreadsNumber < waitingThreads.size()) {
				info.maxWaitingThreadsNumber = waitingThreads.size();
			}

			if (++info.invocationsNumber % NUMBER_OF_INVOCATIONS_PER_MEASUREMENT == 0) {
				LogFactory.getLog(getClass()).error(
						"After " + info.invocationsNumber + " invocations " + info + " poolsNumber:" + infos.size());

				info.maxWaitingThreadsNumber = 0;
			}
		}
	}

	@After("execution(* org.apache.commons.httpclient.MultiThreadedHttpConnectionManager.ConnectionPool.createConnection*(..))")
	public void createConnection(JoinPoint pjp) {
		updateStatistics(pjp.getThis());
	}

	@Before("execution(* org.apache.commons.httpclient.MultiThreadedHttpConnectionManager.ConnectionPool.getFreeConnection*(..))")
	public void getFreeConnection(JoinPoint pjp) {
		updateStatistics(pjp.getThis());
	}

	/**
	 * Get the value of private field {@code fieldName} of given object {@code target}.
	 */
	@SuppressWarnings("unchecked")
	public static <T> T getField(Object target, String fieldName) {
		Field field = ReflectionUtils.findField(target.getClass(), fieldName);
		ReflectionUtils.makeAccessible(field);
		return (T) ReflectionUtils.getField(field, target);
	}
}
</code>
  - Configure Spring to use LWP:
    <code xml|spring-aop-context.xml>
<?xml version="1.0" encoding="UTF-8"?>
<beans
    xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
                        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd
                        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd">

	<context:load-time-weaver />
	<aop:aspectj-autoproxy />

</beans>
</xml>
</code>
  - Add LWP agent to JVM startup: ''%%java ... -javaagent:/path/to/org.springframework.instrument-3.1.1.RELEASE.jar ...%%''

**Troubleshooting:**

<note>
If during application startup ''[[http://forum.spring.io/forum/spring-projects/aop/72229-nosuchmethoderror-aspect-aspectof#post469223|java.lang.NoSuchMethodError: aspectOf()]]'' is thrown then make sure that aspects are listed in ''aop.xml''.
</note>

See also [[springdocs>aop.html#aop-aj-configure|Configuring AspectJ aspects using Spring IoC]].
</note>


=== How to make a bean to implement an additional interface? ===

<note question>
Sounds weird, but let's assume you have a class that you don't have sources for and you want to make this class implement an additional interface, ''[[springjava>core/PriorityOrdered.html|PriorityOrdered]]'' for example and to route all calls to this interface to some bean, while all other calls should be routed to original bean.
</note>
<note tip>
The solution is based on JDK proxy mechanism, it means that a bean that needs to be tricked (''service.MyServiceImpl'' in the example), has to implement some business interface (''service.MyService'') which is exposed to other beans in the context.

First write the implementation for the interface that needs to be introduced (if necessary):
<code java5|FixedPriorityOrder.java>
package util;

import org.springframework.core.PriorityOrdered;

/**
 * Simple implementation of {@link PriorityOrdered} interface that returns the pre-configured order.
 */
public class FixedPriorityOrder implements PriorityOrdered {

	private final int order;

	private FixedPriorityOrder(int order) {
		this.order = order;
	}

	@Override
	public int getOrder() {
		return order;
	}
}
</code>

Now bringing all together:
<code xml>
<!--
	This interceptor will route calls to interfaces that passed bean implements to that bean.
-->
<bean id="normalPriorityOrder" class="org.springframework.aop.support.DelegatingIntroductionInterceptor">
	<constructor-arg>
		<bean class="util.FixedPriorityOrder">
			<constructor-arg value="0" />
		</bean>
	</constructor-arg>
</bean>

<bean id="descriptorComponent" class="org.springframework.aop.framework.ProxyFactoryBean">
	<property name="proxyInterfaces">
		<list>
			<value>org.springframework.beans.factory.InitializingBean</value>
			<value>org.springframework.core.PriorityOrdered</value>
			<!-- ... add all other interfaces that target bean implements... -->
			<value>service.MyService</value>
		</list>
	</property>
	<property name="target">
		<bean class="service.MyServiceImpl">
			...
		</bean>
	</property>
	<property name="interceptorNames">
		<list>
			<value>normalPriorityOrder</value>
		</list>
	</property>
</bean>
</code>
</note>


==== JDBC ====

=== How ''@Transactional'' support is actually implemented? ===

<note tip>
  * Annotation-driven transaction support is enabled by adding ''<tx:annotation-driven ... />'' in your context file. Element is processed by ''[[springfish>org.springframework.transaction/src/main/java/org/springframework/transaction/config/AnnotationDrivenBeanDefinitionParser.java?r=2462|AnnotationDrivenBeanDefinitionParser]]''
  * The last one adds ''[[springfish>org.springframework.transaction/src/main/java/org/springframework/transaction/interceptor/BeanFactoryTransactionAttributeSourceAdvisor.java?r=154|BeanFactoryTransactionAttributeSourceAdvisor]]'' into the context, which implements ''[[springfish>org.springframework.aop/src/main/java/org/springframework/aop/PointcutAdvisor.java?r=114|PointcutAdvisor]]'' interface.
    * ''[[springfish>org.springframework.transaction/src/main/java/org/springframework/transaction/interceptor/BeanFactoryTransactionAttributeSourceAdvisor.java?r=154#l63|getPointcut()]]'' of this advisor returns pre-configured ''[[springfish>org.springframework.transaction/src/main/java/org/springframework/transaction/interceptor/TransactionAttributeSourcePointcut.java?r=154|TransactionAttributeSourcePointcut]]'' class instance, that uses ''[[springfish>org.springframework.transaction/src/main/java/org/springframework/transaction/annotation/AnnotationTransactionAttributeSource.java?r=3566|AnnotationTransactionAttributeSource]]'' to check if the given method / class should be advised in ''[[springfish>org.springframework.transaction/src/main/java/org/springframework/transaction/interceptor/TransactionAttributeSourcePointcut.java?r=154#l34|boolean matches(Method method, Class targetClass)]]'' method.
    * ''[[springfish>org.springframework.aop/src/main/java/org/springframework/aop/support/AbstractBeanFactoryPointcutAdvisor.java?r=150#l73|getAdvice()]]'' method of this class returns pre-configured ''[[springfish>org.springframework.transaction/src/main/java/org/springframework/transaction/interceptor/TransactionInterceptor.java?r=3465|TransactionInterceptor]]'' class instance (which is pre-configured with transaction manager).
  * For each created bean ''[[springfish>org.springframework.aop/src/main/java/org/springframework/aop/framework/autoproxy/AbstractAutoProxyCreator.java?r=596#l346|AbstractAutoProxyCreator#wrapIfNecessary(Object bean, String beanName, Object cacheKey)]]'' (which implements ''[[https://fisheye.springsource.org/browse/spring-framework/trunk/org.springframework.beans/src/main/java/org/springframework/beans/factory/config/BeanPostProcessor.java?r=596|BeanPostProcessor]]'') is called. It looks up advisors in the context and finally calls ''[[springfish>org.springframework.aop/src/main/java/org/springframework/aop/support/AopUtils.java?r=3570#l270|AopUtils#findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz)]]''. If the last one returns the non-empty list, then the target bean is warped into a proxy.
  * When the target class instance method is invoked, the ''[[springfish>org.springframework.aop/src/main/java/org/springframework/aop/framework/JdkDynamicAopProxy.java?r=3137#l148|JdkDynamicAopProxy#invoke(Object proxy, Method method, Object[] args)]]'' is called. It uses ''[[springfish>org.springframework.aop/src/main/java/org/springframework/aop/framework/DefaultAdvisorChainFactory.java?r=305#l48|DefaultAdvisorChainFactory#getInterceptorsAndDynamicInterceptionAdvice(Advised config, Method method, Class targetClass)]]'' to collect all advisors and build the advisor chain.
    * ''[[springfish>org.springframework.transaction/src/main/java/org/springframework/transaction/interceptor/TransactionInterceptor.java?r=3465#l91|TransactionInterceptor#invoke(final MethodInvocation invocation)]]'' is called, which creates new transaction using the transaction manager.
</note>


=== What are the possibilities to add transactional support to my application? ===

<note tip>
  * Using programmatic transaction management facilities via ''[[springjava>transaction/support/TransactionTemplate.html|TransactionTemplate]]'' (see [[springdocs>transaction.html#tx-prog-template|Using the TransactionTemplate]]) or via ''[[springjava>transaction/PlatformTransactionManager.html|PlatformTransactionManager]]'':
    <code java5>
@Autowired
private PlatformTransactionManager	transactionManager;

void doInTransaction() {
	DefaultTransactionDefinition transactionDefinition = new DefaultTransactionDefinition();
	transactionDefinition.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);

	TransactionStatus transactionStatus = transactionManager.getTransaction(transactionDefinition);

	// Do the job

	transactionManager.commit(transactionStatus);

	// Error handling is omitted:
	//transactionManager.rollback(transactionStatus);
}
</code>
  * Using ''[[springjava>transaction/annotation/Transactional.html|@Transactional]]'' annotations and ''<tx:annotation-driven />'' (see [[springdocs>transaction.html#transaction-declarative-annotations|Using @Transactional]])
  * Using Spring 2.0 transaction advice via ''<aop:advisor>'' and ''<tx:advice>'' (see [[springdocs>transaction.html#transaction-declarative-txadvice-settings|<tx:advice/> settings]])

And [[http://forum.springsource.org/showthread.php?t=37178#post112485|more exotic]]:
  * Using Spring 1.x ''[[springjava>transaction/interceptor/TransactionProxyFactoryBean.html|TransactionProxyFactoryBean]]''
  * Using ''[[springjava>aop/framework/ProxyFactoryBean.html|ProxyFactoryBean]]'' and ''[[springjava>transaction/interceptor/TransactionInterceptor.html|TransactionInterceptor]]''
  * Using ''[[springjava>aop/framework/autoproxy/BeanNameAutoProxyCreator.html|BeanNameAutoProxyCreator]]'' or a different ''[[springjava>aop/framework/autoproxy/AbstractAutoProxyCreator.html|...AutoProxyCreator]]''
  * Using EJB transaction management facilities
</note>


=== How to define custom mapping for SQL error codes to exception classes? ===

<note tip>
In this scenario we want custom ''DataTruncationException'' to be thrown in case of specific SQL error codes:

<code java5>
package org.mycompany.dao.exception;

import org.springframework.dao.DataIntegrityViolationException;

public class DataTruncationException extends DataIntegrityViolationException {

	public DataTruncationException(String msg, Throwable cause) {
		super(msg, cause);
	}
}
</code>
<code xml>
<bean id="exceptionTranslator" class="org.springframework.jdbc.support.SQLErrorCodeSQLExceptionTranslator">
	<property name="dataSource">
		<ref bean="myDataSource" />
	</property>
	<!--
		Important that this property is set after datasource was set.
		Relies on actual SQLErrorCodeSQLExceptionTranslator implementation.
	-->
	<property name="sqlErrorCodes.customTranslations">
		<array>
			<!-- Custom mapping of MSSQL (8152) and HSQL (-3401) error code to specific exception for data truncation. -->
			<bean class="org.springframework.jdbc.support.CustomSQLErrorCodesTranslation">
				<property name="errorCodes">
					<array>
						<value>8152</value>
						<value>-3401</value>
					</array>
				</property>
				<property name="exceptionClass" value="org.mycompany.dao.exception.DataTruncationException" />
			</bean>
		</array>
	</property>
</bean>

<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"
	p:dataSource-ref="myDataSource"
	p:exceptionTranslator-ref="exceptionTranslator"
/>
</code>

Later in your Web controller you can for example map given exception to corresponding HTTP code:

<code java5>
import javax.servlet.http.HttpServletRequest;
import org.apache.commons.lang3.exception.ExceptionUtils;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.ResponseStatus;

...

@ExceptionHandler(DataTruncationException.class)
@ResponseStatus(value = HttpStatus.REQUEST_ENTITY_TOO_LARGE)
@ResponseBody
public String handleDataTruncationException(DataTruncationException ex) {
	return ExceptionUtils.getStackTrace(ex);
}
</code>
</note>


=== How to mock JNDI lookups in unit tests? ===

<note tip>
From [[stackoverflow>3039725|here]] and [[stackoverflow>5682732|here]]:
  * In your shared Spring context define:
    <code xml|dao.xml>
<jee:jndi-lookup id="dataSource" jndi-name="java:comp/env/jdbc/SampleDB"/>

<bean id="myDao" class="org.springframework.jdbc.core.JdbcTemplate">
	<constructor-arg ref="dataSource" />
</bean>
</code>
  * In your test context define:
    <code xml|dao-test.xml>
<import resource="classpath:/com/company/module/dao/dao.xml"/>

<bean id="testDataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
	<property name="driverClassName" value="org.hsqldb.jdbcDriver" />
	<property name="url" value="jdbc:hsqldb:mem:test" />
	<property name="username" value="sa" />
	<property name="password" value="" />
</bean>
</code>
  * In your unit test:
    <code java5>
@RunWith(SpringRunner.class)
@ContextConfiguration({"classpath:/com/company/module/dao/dao-test.xml"})
public class MyDaoImplTest {

	@Resource
	private JdbcTemplate myDao;

	@Resource
	private DataSource testDataSource;

	@Before
	public void setupJndi() throws NamingException {
		SimpleNamingContextBuilder.emptyActivatedContextBuilder();
		SimpleNamingContextBuilder.getCurrentContextBuilder().bind("java:comp/env/jdbc/SampleDB", testDataSource);
	}
}
</code>
</note>


=== Why do I get ''CacheException'' in my unit test? ===

<note question>
Setup:
  * Hibenate session is managed by Spring and has second-level cache enabled:
    <code xml|dao-context.xml>
<bean id="hibernateSessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean" lazy-init="true">
	<property name="dataSource" ref="myDataSource" />
	<property name="mappingResources">
		<list>
			<value>/.../hibernate-mapping.xml</value>
		</list>
	</property>
	<property name="hibernateProperties">
		<props>
			<prop key="hibernate.dialect">...</prop>
			<prop key="hibernate.cache.use_query_cache">true</prop>
			<prop key="hibernate.cache.use_second_level_cache">true</prop>
			<prop key="hibernate.cache.provider_class">net.sf.ehcache.hibernate.EhCacheProvider</prop>
			<prop key="hibernate.cache.region.factory_class">net.sf.ehcache.hibernate.EhCacheRegionFactory</prop>
			<prop key="net.sf.ehcache.configurationResourceName">/.../ehcache.xml</prop>
		</props>
	</property>
</bean>
</code>
  * Unit test classes refer this context using ''@ContextConfiguration'':
    <code java5|MyTest.java>
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;

@ContextConfiguration("classpath:/.../dao-context.xml")
@RunWith(SpringRunner.class)
public class MyTest {
	...
}
</code>
  * The exception is:
    <code>
Caused by: net.sf.ehcache.CacheException: Another CacheManager with same name 'hibernate-cache' already exists in the same VM. Please provide unique names for each CacheManager in the config or do one of following:
1. Use one of the CacheManager.create() static factory methods to reuse same CacheManager with same name or create one if necessary
2. Shutdown the earlier cacheManager before creating new one with same name.
The source of the existing CacheManager is: URLConfigurationSource [url=file:/C:/workspace/chepo/chepo-dataaccess-db/bin/org/epo/lifesciences/chepo/dao/ehcache.xml]
	at net.sf.ehcache.CacheManager.assertNoCacheManagerExistsWithSameName(CacheManager.java:457)
	at net.sf.ehcache.CacheManager.init(CacheManager.java:354)
	at net.sf.ehcache.CacheManager.<init>(CacheManager.java:242)
	at net.sf.ehcache.hibernate.EhCacheRegionFactory.start(EhCacheRegionFactory.java:79)
	... 59 more
	at net.sf.ehcache.hibernate.EhCacheRegionFactory.start(EhCacheRegionFactory.java:89)
	at org.hibernate.impl.SessionFactoryImpl.<init>(SessionFactoryImpl.java:238)
	at org.hibernate.cfg.Configuration.buildSessionFactory(Configuration.java:1872)
	at org.springframework.orm.hibernate3.LocalSessionFactoryBean.newSessionFactory(LocalSessionFactoryBean.java:860)
	at org.springframework.orm.hibernate3.LocalSessionFactoryBean.buildSessionFactory(LocalSessionFactoryBean.java:779)
	at org.springframework.orm.hibernate3.AbstractSessionFactoryBean.afterPropertiesSet(AbstractSessionFactoryBean.java:188)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.invokeInitMethods(AbstractAutowireCapableBeanFactory.java:1514)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.initializeBean(AbstractAutowireCapableBeanFactory.java:1452)
	... 52 more
	at org.springframework.beans.factory.support.ConstructorResolver.createArgumentArray(ConstructorResolver.java:730)
	at org.springframework.beans.factory.support.ConstructorResolver.autowireConstructor(ConstructorResolver.java:196)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.autowireConstructor(AbstractAutowireCapableBeanFactory.java:1035)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBeanInstance(AbstractAutowireCapableBeanFactory.java:939)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:485)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:456)
	at org.springframework.beans.factory.support.AbstractBeanFactory$1.getObject(AbstractBeanFactory.java:294)
	at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:225)
	at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:291)
	at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:193)
	at org.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons(DefaultListableBeanFactory.java:585)
	at org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:913)
	at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:464)
	at org.springframework.test.context.support.AbstractGenericContextLoader.loadContext(AbstractGenericContextLoader.java:103)
	at org.springframework.test.context.support.AbstractGenericContextLoader.loadContext(AbstractGenericContextLoader.java:1)
	at org.springframework.test.context.support.DelegatingSmartContextLoader.loadContext(DelegatingSmartContextLoader.java:228)
	at org.springframework.test.context.TestContext.loadApplicationContext(TestContext.java:124)
	at org.springframework.test.context.TestContext.getApplicationContext(TestContext.java:148)
	... 24 more
</code>
</note>

<note tip>
In this scenario ''net.sf.ehcache.CacheManager'' with name ''hibernate-cache'' is started by some unit test and as ''CacheManager'' shares cache instances via static variable, this cache instance looks like already being initialized for following unit test. In order to solve the issue make sure that:
  * You close the context after each unit test (see [[stackoverflowa>7498384/267197|''SpringRunner'' does not close the Application Context at the end of JUnit test case]]):
    <code java5|MyTest.java>
import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.annotation.DirtiesContext.ClassMode;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;

@ContextConfiguration("classpath:/.../dao-context.xml")
@RunWith(SpringRunner.class)
@DirtiesContext(classMode = ClassMode.AFTER_CLASS)
public class MyTest {
	...
}
</code>
    This will guarantee that Hibernate factory is correctly closed, which in its turn will shutdown cache manager.
  * You shutdown all other (not Hibernate managed) cache managers using ''destroy-method'':
    <code xml|another-context.xml>
<bean id="cacheManager" class="net.sf.ehcache.CacheManager" destroy-method="shutdown">
	<constructor-arg value="classpath:/.../negative-cache.xml" type="java.net.URL" />
</bean>
</code>
</note>


==== MVC ====

=== [[stackoverflow>6395621|How to call a static method in JSP/EL?]] ===

<note tip>
In general you need to make you method as normal getter, however with [[springdocs>expressions.html#expressions-types|SpEL]] this is possible:

<code jsp>
<%@taglib prefix="s" uri="http://www.springframework.org/tags" %>

<s:eval expression="T(org.company.Calculate).getAmount(row.balance)" />
</code>

Other examples of SpEL expressions:
  * ''%%#{T(Math).min(T(Runtime).getRuntime().maxMemory() / 3, 0L + T(Integer).MAX_VALUE)}%%'' \\
    Mind how 2nd argument was forced to ''long'', otherwise "Method call of 'min' is ambiguous, supported type conversions allow multiple variants to match" exception will be thrown.
  * ''%%#{T(org.apache.commons.io.IOUtils).toString(new java.net.URL('file:///etc/HOSTNAME'))}%%'' \\
    This will stringify the given system file.

For non-JSP, non-EL approach check [[stackoverflowa>39374686/267197|Invoke static method from spring config]]:

<code java5>
<bean id="test" class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
	<property name="targetClass" value="MyClass" />
	<property name="targetMethod" value="staticMethod" />
	<property name="arguments">
	<list>
		<value>anArgument</value>
	</list>
	</property>
</bean>
</code>
</note>


=== What is the lifecycle of Spring MVC Controller? ===

<note tip>
By default Spring MVC controllers are singletons. The request lifecycle is displayed on this diagram:

{{http://farm1.staticflickr.com/14/89101625_26c5be9fd9_b.jpg?800|Spring MVC Request Lifecycle}}
</note>


=== What are the options for exception handling in Spring MVC? ===

<note tip>
From [[http://doanduyhai.wordpress.com/2012/05/06/spring-mvc-part-v-exception-handling/|Spring MVC part V: Exception handling]]:

  * Return the error code with exception as a body:
    <code java5>
import org.apache.commons.lang.exception.ExceptionUtils;

@ExceptionHandler(IllegalArgumentException.class)
@ResponseStatus(value = HttpStatus.BAD_REQUEST)
@ResponseBody
public String handleIllegalArgumentException(IllegalArgumentException ex) {
	return ExceptionUtils.getStackTrace(ex);
}
</code>
    <note>
If you specify the custom reason for error response, then response body is ignored:
<code java5>
@ExceptionHandler(IllegalArgumentException.class)
@ResponseStatus(value = HttpStatus.BAD_REQUEST, reason = "The passed argument is invalid")
public void handleIllegalArgumentException(IllegalArgumentException ex) {
}
</code>
</note>
  * Redirect to a dedicated error page:
    <code java5>
@ExceptionHandler(IndexOutOfBoundsException.class)
public String handleException(IndexOutOfBoundsException ex) {
	return "pages/errorPage";
}
</code>
</note>


=== How to override returned media type for response body in case of exception handling? ===

<note question>
It may happen that during processing of request the exception occurs. If mapped method defines the produced media type, this media type is remembered and used for response body of the exception handler, which in most cases is not appropriate, because the browser expects text/plain MIME type for error HTTP codes.
</note>
<note tip>
In below scenario let's assume that ''myService.getInfo()'' throws ''IllegalArgumentException''. In this case Spring will convert returned value from ''handleIllegalArgumentException()'' into application/json, however more appropriate will be text/plain.

To overcome this, exception hander should reset the remembered produced types before returning the response body:
<code java5>
import java.security.Principal;
import org.apache.commons.lang3.exception.ExceptionUtils;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.servlet.HandlerMapping;

...

@RequestMapping(value = "/", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
@ResponseBody
public Info getInfo(Principal principal) {
	return myService.getInfo(principal);
}

@ExceptionHandler(IllegalArgumentException.class)
@ResponseStatus(value = HttpStatus.BAD_REQUEST)
@ResponseBody
public String handleIllegalArgumentException(HttpServletRequest request, IllegalArgumentException ex) {
	resetProducibleMediaTypes(request);

	return ExceptionUtils.getStackTrace(ex);
}

/**
 * Media types to negotiate for error conditions.
 */
private static final Set<MediaType>	DEFAULT_MEDIA_TYPES;

static {
	Set<MediaType> mediaTypes = new HashSet<MediaType>();

	Collections.addAll(mediaTypes, MediaType.TEXT_PLAIN, MediaType.ALL);

	DEFAULT_MEDIA_TYPES = Collections.unmodifiableSet(mediaTypes);
}

/**
 * Content types, which have been remembered to handle the return type of handler method, need to be reset to allow
 * the return type of exception handler to have different content type.
 */
private static void resetProducibleMediaTypes(HttpServletRequest request) {
	request.setAttribute(HandlerMapping.PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE, DEFAULT_MEDIA_TYPES);
}
</code>
</note>


=== How to add HTTP request post-processing handler in Spring Web? ===

<note tip>
Add the following to your Web context (see also [[stackoverflowa>3469996/267197|Bind Spring ''HandlerInterceptor'' only to one controller]]):

<code xml>
<mvc:interceptors>
	<bean class="org.springframework.web.servlet.i18n.LocaleChangeInterceptor" />
</mvc:interceptors>
</code>
</note>


=== [[stackoverflowa>21400914/267197|How to use a request-scoped bean inside a spawned thread?]] ===

<note tip>
Spring infrastructure (e.g. ''[[springjava>web/servlet/DispatcherServlet.html|DispatcherServlet]]'') binds the HTTP request to current thread, which makes it inaccessible for spawned threads. To overcome the problem the following conditions should be met:
  * ''threadContextInheritable'' property of ''[[springjava>web/servlet/DispatcherServlet.html|DispatcherServlet]]'' or ''[[springjava>web/filter/RequestContextFilter.html|RequestContextFilter]]'' should be set to true, for example:
    <code xml|web.xml>
<servlet>
	<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
	<init-param>
		<param-name>threadContextInheritable</param-name>
		<param-value>true</param-value>
	</init-param>
</servlet>
</code>
  * The execution that does not pool threads (e.g. ''[[springjava>core/task/SimpleAsyncTaskExecutor.html|SimpleAsyncTaskExecutor]]'') should be used. That means: ''[[springjava>scheduling/concurrent/ThreadPoolTaskExecutor.html|ThreadPoolTaskExecutor]]'' or ''[[springjava>jca/work/WorkManagerTaskExecutor.html|WorkManagerTaskExecutor]]'' will not work.
</note>


=== Is it possible to return several model objects? ===

<note tip>
One should use ''[[springjava>web/servlet/ModelAndView.html|ModelAndView]]'' for that (from [[stackoverflowa>5068941/267197|Can I return two models in ModelAndView in Spring MVC]]):

<code java5>
@RequestMapping(value = {"/registrationForm"}, method = RequestMethod.GET)
public ModelAndView newForm() {
	final ModelAndView modelAndView = new ModelAndView("registrationForm");

	modelAndView.addObject("registrationForm", new RegistrationForm());
	modelAndView.addObject("sharedData", sharedData);

	return modelAndView;
}
</code>
</note>


=== How to enable validation in Spring MVC? ===

<note tip>
As from [[springdocs>validation.html#validation-beanvalidation|Spring Validation]] and [[stackoverflow>5576790#5577093|Validation in Spring MVC]] you need to:
  * Include ''javax.validation:validation-api'' into you dependencies list.
  * Annotate the model with ''@Valid'':
    <code java5>
@RequestMapping(method = RequestMethod.POST)
public String onFormSubmitted(@ModelAttribute("myForm") @Valid MyForm myForm, BindingResult result) {
	if (result.hasErrors()) {
		return "myForm";
	}

	return "formSubmitted";
}
</code>
  * Initialize validator for binder:
    <code java5>
@InitBinder
protected void initBinder(WebDataBinder binder) {
	binder.setValidator(new MyFormValidator());
}
</code>
  * Implement custom validator:
    <code java5>
import org.springframework.validation.Errors;
import org.springframework.validation.ValidationUtils;
import org.springframework.validation.Validator;

public class MyFormValidator implements Validator {

	/**
	 * @see org.springframework.validation.Validator#supports(java.lang.Class)
	 */
	public boolean supports(Class<?> clazz) {
		return MyForm.class.isAssignableFrom(clazz);
	}

	/**
	 * @see org.springframework.validation.Validator#validate(java.lang.Object, org.springframework.validation.Errors)
	 */
	public void validate(Object target, Errors errors) {
		ValidationUtils.rejectIfEmptyOrWhitespace(errors, "email", "required", "Field is required.");
	}
}
</code>

Additional info:
  * [[http://blog.jteam.nl/2009/08/04/bean-validation-integrating-jsr-303-with-spring/|Bean validation: integrating JSR-303 with Spring]]
  * [[http://numberformat.wordpress.com/tag/spring-mvc-validation/|Spring MVC Validation using Commons Validator]]
</note>


=== How to integrate [[googlecode>apis/recaptcha/docs/java.html|ReCaptcha]] into Spring MVC? ===

<note tip>

See [[http://wheelersoftware.com/articles/recaptcha-java-2.html|here]] and [[stackoverflow>4991335|here]]:

<code xml|pom.xml>
<dependency>
	<groupId>net.tanesha.recaptcha4j</groupId>
	<artifactId>recaptcha4j</artifactId>
	<version>0.0.7</version>
</dependency>
</code>

Use of a "*" for the field name is important, otherwise MVC will try to resolve the field value:

<code jsp|registrationForm.jsp>
<%@ page import="net.tanesha.recaptcha.ReCaptcha" %>
<%@ page import="net.tanesha.recaptcha.ReCaptchaFactory" %>
<%@ page import="com.company.module.web.SharedData" %>
...
<form:form method="post" commandName="registrationForm">

<form:errors path="captcha*" /><br/>
<%
	SharedData sharedData = (SharedData) request.getAttribute("sharedData");
	ReCaptcha captcha = ReCaptchaFactory.newReCaptcha(sharedData.getRecaptchaPublicKey(), sharedData.getRecaptchaPrivateKey(), false);
	out.print(captcha.createRecaptchaHtml(null, null));
%>

</form:form>
</code>

The controller code:

<code java5>
import net.tanesha.recaptcha.ReCaptchaImpl;
import net.tanesha.recaptcha.ReCaptchaResponse;

@Controller
@SessionAttributes("sharedData")
public class RegistrationFormController {

	@Autowired
	private SharedData sharedData;
	
	@RequestMapping(value = {"/registrationForm"}, method = RequestMethod.GET)
	public ModelAndView newForm() {
		final ModelAndView modelAndView = new ModelAndView("registrationForm");

		modelAndView.addObject("registrationForm", new RegistrationForm());
		modelAndView.addObject("sharedData", sharedData);

		return modelAndView;
	}

	@RequestMapping(value = {"/registrationForm"}, method = RequestMethod.POST)
	public String onRegistrationFormSubmitted(HttpServletRequest request,
				@RequestParam("recaptcha_challenge_field") String challenge,
				@RequestParam("recaptcha_response_field") String response,
				@ModelAttribute("registrationForm") @Valid RegistrationForm registrationForm, BindingResult result) {

		final ReCaptchaImpl recaptcha = new ReCaptchaImpl();

		recaptcha.setPrivateKey(sharedData.getRecaptchaPrivateKey());

		final ReCaptchaResponse captchaResponse = recaptcha.checkAnswer(request.getRemoteAddr(), challenge, response);

		if (!captchaResponse.isValid()) {
			// 2nd argument should match <form:errors path="..."> in JSP:
			result.addError(new FieldError("comment", "captcha", "Captcha is wrong"));
		}

		if (result.hasErrors()) {
			return "registrationForm";
		}

		// Perform business logic, e.g. persist registration data

		return "formSubmitted";
	}
}
</code>

And shared data is initialized in Spring context:

<code xml|web-context.xml>
<bean class="com.company.module.web.SharedData">
	<!-- ReCaptcha private key -->
	<constructor-arg value="5LemXMassAAsAJ9itNONm2hYjWmvAsaRBxyIWYfk" />
	<!-- ReCaptcha public key -->
	<constructor-arg value="5LemcnmaAAssaBJcF6gYH-zcBTeJ_ArWakbg3wsX" />
</bean>
</code>

Check also [[stackoverflow>217511|Integrating Captcha with Spring Security]], [[stackoverflow>3326778|CAPTCHA in java]].

</note>


=== How do you make the "welcome file" (''index.html'') be handled via Spring and not your web container? ===

<note tip>
From [[http://technologicaloddity.com/2010/03/25/spring-welcome-file-without-redirect/|here]]:

<code xml|web.xml>
<servlet-mapping>
	<servlet-name>spring</servlet-name>
	<url-pattern>*.html</url-pattern>
	<url-pattern>/index.html</url-pattern>
</servlet-mapping>

<welcome-file-list>
	<welcome-file>index.html</welcome-file>
</welcome-file-list>
</code>

To map certain resources back to default servlet, use the following:

<code xml|web.xml>
<servlet-mapping>
	<servlet-name>default</servlet-name>
	<url-pattern>*.jpg</url-pattern>
</servlet-mapping>
</code>

:WARN: Mind the priority of URL-matching rules((See [[stackoverflowa>45360749/267197|Difference between / and /* in servlet mapping url pattern]])):
  - URL patterns (''/*'')
  - extension patterns (''*.html'')
  - default servlet (''/'')
</note>


{{tag>Spring Jersey JSON MVC}}