SPR-7308

+ initial commit of caching abstraction
+ main API
+ Spring AOP and AspectJ support
+ annotation driven, declarative support
+ initial namespace draft

org.springframework.context.support/src/test/java/org/springframework/cache/concurrent/ConcurrentCacheTest.java

@@ -0,0 +1,39 @@
+/*
+ * Copyright 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.cache.concurrent;
+
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+import org.springframework.cache.Cache;
+import org.springframework.cache.vendor.AbstractNativeCacheTest;
+
+/**
+ * @author Costin Leau
+ */
+public class ConcurrentCacheTest extends AbstractNativeCacheTest<ConcurrentMap<Object, Object>> {
+
+	@Override
+	protected Cache createCache(ConcurrentMap<Object, Object> nativeCache) {
+		return new ConcurrentCache(nativeCache, CACHE_NAME);
+	}
+
+	@Override
+	protected ConcurrentMap<Object, Object> createNativeCache() throws Exception {
+		return new ConcurrentHashMap<Object, Object>();
+	}
+}

org.springframework.context.support/src/test/java/org/springframework/cache/config/AbstractAnnotationTest.java

@@ -0,0 +1,129 @@
+/*
+ * Copyright 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.cache.config;
+
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertSame;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.support.ClassPathXmlApplicationContext;
+
+/**
+ * Abstract annotation test (containing several reusable methods).
+ * @author Costin Leau
+ */
+public abstract class AbstractAnnotationTest {
+
+	protected ApplicationContext ctx;
+
+	protected CacheableService cs;
+
+	protected CacheableService ccs;
+
+	protected abstract String getConfig();
+
+	@Before
+	public void setup() {
+		ctx = new ClassPathXmlApplicationContext(getConfig());
+		cs = ctx.getBean("service", CacheableService.class);
+		ccs = ctx.getBean("classService", CacheableService.class);
+	}
+
+	public void testCacheable(CacheableService service) throws Exception {
+		Object o1 = new Object();
+		Object o2 = new Object();
+
+		Object r1 = service.cache(o1);
+		Object r2 = service.cache(o1);
+		Object r3 = service.cache(o1);
+
+		assertSame(r1, r2);
+		assertSame(r1, r3);
+	}
+
+	public void testInvalidate(CacheableService service) throws Exception {
+		Object o1 = new Object();
+		Object o2 = new Object();
+
+		Object r1 = service.cache(o1);
+		Object r2 = service.cache(o1);
+
+		assertSame(r1, r2);
+		service.invalidate(o1);
+		Object r3 = service.cache(o1);
+		Object r4 = service.cache(o1);
+		assertNotSame(r1, r3);
+		assertSame(r3, r4);
+	}
+
+	public void testConditionalExpression(CacheableService service) throws Exception {
+		Object r1 = service.conditional(4);
+		Object r2 = service.conditional(4);
+
+		assertNotSame(r1, r2);
+
+		Object r3 = service.conditional(3);
+		Object r4 = service.conditional(3);
+
+		assertSame(r3, r4);
+	}
+
+	public void testKeyExpression(CacheableService service) throws Exception {
+		Object r1 = service.key(5, 1);
+		Object r2 = service.key(5, 2);
+
+		assertSame(r1, r2);
+
+		Object r3 = service.key(1, 5);
+		Object r4 = service.key(2, 5);
+
+		assertNotSame(r3, r4);
+	}
+
+	@Test
+	public void testCacheable() throws Exception {
+		testCacheable(cs);
+	}
+
+	@Test
+	public void testInvalidate() throws Exception {
+		testInvalidate(cs);
+	}
+
+	@Test
+	public void testConditionalExpression() throws Exception {
+		testConditionalExpression(cs);
+	}
+
+	@Test
+	public void testKeyExpression() throws Exception {
+		testKeyExpression(cs);
+	}
+
+	@Test
+	public void testClassCacheCacheable() throws Exception {
+		testCacheable(ccs);
+	}
+
+	@Test
+	public void testClassCacheInvalidate() throws Exception {
+		testInvalidate(ccs);
+	}
+
+}

org.springframework.context.support/src/test/java/org/springframework/cache/config/AnnotatedClassCacheableService.java

@@ -0,0 +1,48 @@
+/*
+ * Copyright 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.cache.config;
+
+import java.util.concurrent.atomic.AtomicLong;
+
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.Cacheable;
+
+/**
+ * @author Costin Leau
+ */
+@Cacheable
+public class AnnotatedClassCacheableService implements CacheableService {
+
+	private AtomicLong counter = new AtomicLong();
+
+	public Object cache(Object arg1) {
+		return counter.getAndIncrement();
+	}
+
+	public Object conditional(int field) {
+		return null;
+	}
+
+	@CacheEvict
+	public void invalidate(Object arg1) {
+	}
+
+	@Cacheable(key = "#p0")
+	public Object key(Object arg1, Object arg2) {
+		return counter.getAndIncrement();
+	}
+}

org.springframework.context.support/src/test/java/org/springframework/cache/config/AnnotationNamespaceDrivenTest.java

@@ -0,0 +1,30 @@
+/*
+ * Copyright 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.cache.config;
+
+
+/**
+ * @author Costin Leau
+ */
+public class AnnotationNamespaceDrivenTest extends AbstractAnnotationTest {
+
+	@Override
+	protected String getConfig() {
+		return "/org/springframework/cache/config/annotationDrivenCacheNamespace.xml";
+	}
+
+}

org.springframework.context.support/src/test/java/org/springframework/cache/config/AnnotationTest.java

@@ -0,0 +1,29 @@
+/*
+ * Copyright 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.cache.config;
+
+
+/**
+ * @author Costin Leau
+ */
+public class AnnotationTest extends AbstractAnnotationTest {
+
+	@Override
+	protected String getConfig() {
+		return "/org/springframework/cache/config/annotationDrivenCacheConfig.xml";
+	}
+}

org.springframework.context.support/src/test/java/org/springframework/cache/config/CacheableService.java

@@ -0,0 +1,34 @@
+/*
+ * Copyright 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.cache.config;
+
+/**
+ * Basic service interface.
+ * 
+ * @author Costin Leau
+ */
+public interface CacheableService<T> {
+
+	T cache(Object arg1);
+
+	void invalidate(Object arg1);
+
+	T conditional(int field);
+
+	T key(Object arg1, Object arg2);
+
+}

org.springframework.context.support/src/test/java/org/springframework/cache/config/DefaultCacheableService.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright 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.cache.config;
+
+import java.util.concurrent.atomic.AtomicLong;
+
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.Cacheable;
+
+
+/**
+ * Simple cacheable service
+ * 
+ * @author Costin Leau
+ */
+public class DefaultCacheableService implements CacheableService<Long> {
+
+	private AtomicLong counter = new AtomicLong();
+
+	@Cacheable
+	public Long cache(Object arg1) {
+		return counter.getAndIncrement();
+	}
+
+	@CacheEvict
+	public void invalidate(Object arg1) {
+	}
+
+	@Cacheable(condition = "#classField == 3")
+	public Long conditional(int classField) {
+		return counter.getAndIncrement();
+	}
+
+	@Cacheable(key = "#p0")
+	public Long key(Object arg1, Object arg2) {
+		return counter.getAndIncrement();
+	}
+}

org.springframework.context.support/src/test/java/org/springframework/cache/ehcache/EhCacheCacheTest.java

@@ -0,0 +1,44 @@
+/*
+ * Copyright 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.cache.ehcache;
+
+import net.sf.ehcache.Ehcache;
+
+import org.springframework.cache.Cache;
+import org.springframework.cache.vendor.AbstractNativeCacheTest;
+
+/**
+ * Integration test for EhCache cache.
+ * 
+ * @author Costin Leau
+ */
+public class EhCacheCacheTest extends AbstractNativeCacheTest<Ehcache> {
+
+	@Override
+	protected Ehcache createNativeCache() throws Exception {
+		EhCacheFactoryBean fb = new EhCacheFactoryBean();
+		fb.setBeanName(CACHE_NAME);
+		fb.setCacheName(CACHE_NAME);
+		fb.afterPropertiesSet();
+		return fb.getObject();
+	}
+
+	@Override
+	protected Cache createCache(Ehcache nativeCache) {
+		return new EhCacheCache(nativeCache);
+	}
+}

org.springframework.context.support/src/test/java/org/springframework/cache/vendor/AbstractNativeCacheTest.java

@@ -0,0 +1,155 @@
+/*
+ * Copyright 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.cache.vendor;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.springframework.cache.Cache;
+
+/**
+ * Test for native cache implementations.
+ * 
+ * @author Costin Leau
+ */
+public abstract class AbstractNativeCacheTest<T> {
+
+	private T nativeCache;
+	private Cache cache;
+	protected final static String CACHE_NAME = "testCache";
+
+	@Before
+	public void setUp() throws Exception {
+		nativeCache = createNativeCache();
+		cache = createCache(nativeCache);
+		cache.clear();
+	}
+
+
+	protected abstract T createNativeCache() throws Exception;
+
+	protected abstract Cache createCache(T nativeCache);
+
+
+	@Test
+	public void testCacheName() throws Exception {
+		assertEquals(CACHE_NAME, cache.getName());
+	}
+
+	@Test
+	public void testNativeCache() throws Exception {
+		assertSame(nativeCache, cache.getNativeCache());
+	}
+
+	@Test
+	public void testCachePut() throws Exception {
+
+		Object key = "enescu";
+		Object value = "george";
+
+		assertNull(cache.get(key));
+		cache.put(key, value);
+		assertEquals(value, cache.get(key));
+	}
+
+	@Test
+	public void testCacheRemove() throws Exception {
+		Object key = "enescu";
+		Object value = "george";
+
+		assertNull(cache.get(key));
+		cache.put(key, value);
+		assertEquals(value, cache.remove(key));
+		assertNull(cache.get(key));
+	}
+
+	@Test
+	public void testCacheClear() throws Exception {
+		assertNull(cache.get("enescu"));
+		cache.put("enescu", "george");
+		assertNull(cache.get("vlaicu"));
+		cache.put("vlaicu", "aurel");
+		cache.clear();
+		assertNull(cache.get("vlaicu"));
+		assertNull(cache.get("enescu"));
+	}
+
+	// concurrent map tests
+	@Test
+	public void testPutIfAbsent() throws Exception {
+		Object key = "enescu";
+		Object value1 = "george";
+		Object value2 = "geo";
+
+		assertNull(cache.get("enescu"));
+		cache.put(key, value1);
+		cache.putIfAbsent(key, value2);
+		assertEquals(value1, cache.get(key));
+	}
+
+	@Test
+	public void testConcurrentRemove() throws Exception {
+		Object key = "enescu";
+		Object value1 = "george";
+		Object value2 = "geo";
+
+		assertNull(cache.get("enescu"));
+		cache.put(key, value1);
+		// no remove
+		cache.remove(key, value2);
+		assertEquals(value1, cache.get(key));
+		// one remove
+		cache.remove(key, value1);
+		assertNull(cache.get("enescu"));
+	}
+
+	@Test
+	public void testConcurrentReplace() throws Exception {
+		Object key = "enescu";
+		Object value1 = "george";
+		Object value2 = "geo";
+
+		assertNull(cache.get("enescu"));
+		cache.put(key, value1);
+		cache.replace(key, value2);
+		assertEquals(value2, cache.get(key));
+		cache.remove(key);
+		cache.replace(key, value1);
+		assertNull(cache.get("enescu"));
+	}
+
+	@Test
+	public void testConcurrentReplaceIfEqual() throws Exception {
+		Object key = "enescu";
+		Object value1 = "george";
+		Object value2 = "geo";
+
+		assertNull(cache.get("enescu"));
+		cache.put(key, value1);
+		assertEquals(value1, cache.get(key));
+		// no replace
+		cache.replace(key, value2, value1);
+		assertEquals(value1, cache.get(key));
+		cache.replace(key, value1, value2);
+		assertEquals(value2, cache.get(key));
+		cache.replace(key, value2, value1);
+		assertEquals(value1, cache.get(key));
+	}
+}

org.springframework.context.support/src/test/resources/org/springframework/cache/config/annotationDrivenCacheConfig.xml

@@ -0,0 +1,43 @@
+<?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:aop="http://www.springframework.org/schema/aop"
+       xmlns:tx="http://www.springframework.org/schema/tx"
+       xmlns:p="http://www.springframework.org/schema/p"
+       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd 
+       		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
+       		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
+
+	<bean id="apc" class="org.springframework.aop.framework.autoproxy.InfrastructureAdvisorAutoProxyCreator"/>
+
+	<bean id="annotationSource" class="org.springframework.cache.annotation.AnnotationCacheDefinitionSource"/>
+	
+	<aop:config>
+		<aop:advisor advice-ref="debugInterceptor" pointcut="execution(* *..CacheableService.*(..))" order="1"/>
+	</aop:config>
+	
+	<bean id="cacheInterceptor" class="org.springframework.cache.interceptor.CacheInterceptor">
+		<property name="cacheManager" ref="cacheManager"/>
+		<property name="cacheDefinitionSources" ref="annotationSource"/>
+	</bean>
+	
+	<bean id="advisor" class="org.springframework.cache.interceptor.BeanFactoryCacheDefinitionSourceAdvisor">
+		<property name="cacheDefinitionSource" ref="annotationSource"/>
+		<property name="adviceBeanName" value="cacheInterceptor"/>
+	</bean>
+	
+
+	<bean id="cacheManager" class="org.springframework.cache.support.MapCacheManager">
+		<property name="caches">
+			<set>
+				<bean class="org.springframework.cache.concurrent.ConcurrentCacheFactoryBean" p:name="default"/>
+			</set>
+		</property>
+	</bean>
+
+	<bean id="debugInterceptor" class="org.springframework.aop.interceptor.DebugInterceptor"/>
+	
+	<bean id="service" class="org.springframework.cache.config.DefaultCacheableService"/>
+	
+	<bean id="classService" class="org.springframework.cache.config.AnnotatedClassCacheableService"/>
+
+</beans>

org.springframework.context.support/src/test/resources/org/springframework/cache/config/annotationDrivenCacheNamespace.xml

@@ -0,0 +1,30 @@
+<?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:aop="http://www.springframework.org/schema/aop"
+       xmlns:cache="http://www.springframework.org/schema/cache"
+       xmlns:p="http://www.springframework.org/schema/p"
+       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd 
+       		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
+       		http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd">
+
+	<cache:annotation-driven proxy-target-class="false" order="0"/>
+		
+	<aop:config>
+		<aop:advisor advice-ref="debugInterceptor" pointcut="execution(* *..CacheableService.*(..))" order="1"/>
+	</aop:config>
+	
+	<bean id="cacheManager" class="org.springframework.cache.support.MapCacheManager">
+		<property name="caches">
+			<set>
+				<bean class="org.springframework.cache.concurrent.ConcurrentCacheFactoryBean" p:name="default"/>
+			</set>
+		</property>
+	</bean>
+
+	<bean id="debugInterceptor" class="org.springframework.aop.interceptor.DebugInterceptor"/>
+	
+	<bean id="service" class="org.springframework.cache.config.DefaultCacheableService"/>
+	
+	<bean id="classService" class="org.springframework.cache.config.AnnotatedClassCacheableService"/>
+
+</beans>