/**
 * Invocation handler to create proxies for interfaces to be able to execute JPA queries on interface method calls.
 */
public class QueryInvocationHandler implements InvocationHandler {

    @PersistenceContext
    private EntityManager em;

    /**
     * Invoked when appropriate interface @Query annotated method is called
     *
     * @param proxy  - object to proxy
     * @param method - annotated method
     * @param args   - query parameters
     * @return proxy object
     * @throws Throwable
     */
    public Object invoke(Object proxy, Method method,
                         Object[] args) throws Throwable {

        if (method.getName().equals("toString")) {
            return "QueryInvocationHandler for " + proxy.getClass().getName();
        }
        //trying to find annotated method
        Query annotation = method.getAnnotation(Query.class);
        if (annotation == null) {
            throw new QueryAnnotationException("Cannot find @Query for the method " + method.getName());
        }
        //get named query and create it
        javax.persistence.Query jpaQuery = em.createNamedQuery(annotation.named());

        //set arguments taken from annotated method
        if (args != null) {
            for (int i = 1, argsLength = args.length; i <= argsLength; i++) {
                Object arg = args[i - 1];
                if (arg instanceof Collection && ((Collection) arg).isEmpty()) {
                    jpaQuery.setParameter(i, null);
                } else {
                    jpaQuery.setParameter(i, arg);
                }
            }
        }

        final List resultList = jpaQuery.getResultList();

        final Class<?> returnType = method.getReturnType();
        //result set can contain one or several elements, check for appropriate return type of the method
        if (returnType.equals(List.class)) {
            return resultList;
        } else {
            if (CollectionUtils.isNotEmpty(resultList)) {
                if (resultList.size() != 1) {
                    //throw exception if type is not java.util.List since result set size is more than 1
                    throw new IllegalReturnTypeException("java.util.List expected as a return type");
                } else {
                    final Object result = resultList.get(0);
                    if (result == null) {
                        return null;
                    }
                    //throw ClassCastException if type in result set is incompatible with annotated method
                    if (!returnType.isAssignableFrom(result.getClass())) {
                        throw new ClassCastException("Incompatible types : '" +
                                returnType.getName() + " " +
                                method.getName() + "' and query result type: " +
                                result.getClass().getName());
                    }

                    return result;
                }
            } else {
                return null;
            }
        }
    }
}
 

<beans xmlns="...">
    <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="systemPropertiesModeName" value="SYSTEM_PROPERTIES_MODE_OVERRIDE"/>
        <property name="locations">
            <list>
                <value>classpath*:*.properties</value>
            </list>
        </property>
    </bean>
    <!-- Turn on AspectJ @Configurable support -->
    <context:spring-configured/>

    <context:annotation-config />

    <context:component-scan base-package="com.lexaden.platform"/>

    <!-- Turn on @Autowired, @PostConstruct etc support -->
    <bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>
    <bean class="org.springframework.context.annotation.CommonAnnotationBeanPostProcessor"/>

    <bean class="com.mchange.v2.c3p0.ComboPooledDataSource" id="dataSource">
        <property name="driverClass" value="${database.driverClassName}"/>
        <property name="jdbcUrl" value="${database.url}"/>
        <property name="user" value="${database.username}"/>
        <property name="password" value="${database.password}"/>
        <property name="minPoolSize"><value>${c3p0.minPoolSize}</value></property>
        <property name="maxPoolSize"><value>${c3p0.maxPoolSize}</value></property>
        <property name="checkoutTimeout"><value>20000</value></property><!-- Give up waiting for a connection after this many milliseconds -->
        <property name="maxIdleTime"><value>${c3p0.maxIdleTime}</value></property>
        <property name="idleConnectionTestPeriod"><value>${c3p0.idleConnectionTestPeriod}</value></property>
        <property name="automaticTestTable"><value>${c3p0.automaticTestTable}</value></property>
    </bean>

    <tx:advice id="transactionAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="find*" read-only="true" propagation="SUPPORTS"/>
            <tx:method name="get*" read-only="true" propagation="SUPPORTS"/>

            <tx:method name="*" propagation="REQUIRED" rollback-for="Exception"/>
        </tx:attributes>
    </tx:advice>

    <aop:config>
        <aop:pointcut id="serviceFacade" expression="execution(* *..service.*Service*.*(..))"/>
        <aop:advisor advice-ref="transactionAdvice" pointcut-ref="serviceFacade"/>
    </aop:config>

    <bean class="org.springframework.orm.jpa.JpaTransactionManager" id="transactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"/>
    </bean>

    <tx:annotation-driven mode="aspectj" transaction-manager="transactionManager"/>

    <bean class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean" id="entityManagerFactory">
        <property name="dataSource" ref="dataSource"/>
        <property name="jpaProperties">
            <props>
                <prop key="hibernate.dialect">${hibernate.dialect}</prop>
                <prop key="hibernate.show_sql">${hibernate.showsql}</prop>
                <prop key="hibernate.jdbc.use_scrollable_resultset">${hibernate.scrollresult}</prop>
                <prop key="hibernate.cache.provider_class">${hibernate.cache.provider}</prop>
                <prop key="hibernate.generate_statistics">${hibernate.generate.statistics}</prop>
                <prop key="hibernate.max_fetch_depth">${hibernate.fetchdepth}</prop>
                <prop key="hibernate.hbm2ddl.auto">validate</prop>
                <prop key="hibernate.cache.use_query_cache">false</prop>

                <prop key="hibernate.jdbc.batch_size">20</prop>
                <prop key="hibernate.cache.use_second_level_cache">false</prop>
            </props>
        </property>
        <property name="jpaVendorAdapter">
            <bean id="jpaAdapter" class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                <property name="generateDdl" value="true"/>
                <property name="showSql" value="true"/>
            </bean>
        </property>
    </bean>
</beans>