revised cache abstraction

Costin Leau · Costin Leau · commit b39673aa79d2 · 2011-05-18T18:34:41.000Z
- removed generics from Cache/CacheManager (they add no value since it's an SPI not API)
+ update docs and tests
+ renamed ConcurrentCacheFactoryBean to ConcurrentMapCacheFactoryBean
diff --git a/org.springframework.aspects/src/test/java/org/springframework/cache/config/annotation-cache-aspectj.xml b/org.springframework.aspects/src/test/java/org/springframework/cache/config/annotation-cache-aspectj.xml
@@ -19,7 +19,7 @@
 	<bean id="cacheManager" class="org.springframework.cache.support.SimpleCacheManager">
 		<property name="caches">
 			<set>
-				<bean class="org.springframework.cache.concurrent.ConcurrentCacheFactoryBean" p:name="default"/>
+				<bean class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean" p:name="default"/>
 			</set>
 		</property>
 	</bean>
diff --git a/org.springframework.context/src/main/java/org/springframework/cache/Cache.java b/org.springframework.context/src/main/java/org/springframework/cache/Cache.java
@@ -26,18 +26,18 @@
  * 
  * @author Costin Leau
  */
-public interface Cache<K, V> {
+public interface Cache {
 
 	/**
 	 * A (wrapper) object representing a cache value.
 	 */
-	interface ValueWrapper<V> {
+	interface ValueWrapper {
 		/**
 		 * Returns the actual value in the cache.
 		 *  
 		 * @return cache value
 		 */
-		V get();
+		Object get();
 	}
 
 	/**
@@ -62,7 +62,7 @@ interface ValueWrapper<V> {
 	 * @return the value to which this cache maps the specified key, or
 	 *	       <tt>null</tt> if the cache contains no mapping for this key.
 	 */
-	ValueWrapper<V> get(Object key);
+	ValueWrapper get(Object key);
 
 	/**
 	 * Associates the specified value with the specified key in this cache.
@@ -72,7 +72,7 @@ interface ValueWrapper<V> {
 	 * @param key key with which the specified value is to be associated.
 	 * @param value value to be associated with the specified key.
 	 */
-	void put(K key, V value);
+	void put(Object key, Object value);
 
 	/**
 	 * Evicts the mapping for this key from this cache if it is present.
diff --git a/org.springframework.context/src/main/java/org/springframework/cache/CacheManager.java b/org.springframework.context/src/main/java/org/springframework/cache/CacheManager.java
@@ -32,7 +32,7 @@ public interface CacheManager {
 	 * @param name cache identifier - cannot be null
 	 * @return associated cache or null if none is found
 	 */
-	<K, V> Cache<K, V> getCache(String name);
+	Cache getCache(String name);
 
 	/**
 	 * Returns a collection of the caches known by this cache manager. 
diff --git a/org.springframework.context/src/main/java/org/springframework/cache/concurrent/ConcurrentMapCache.java b/org.springframework.context/src/main/java/org/springframework/cache/concurrent/ConcurrentMapCache.java
@@ -34,14 +34,14 @@
  * 
  * @author Costin Leau
  */
-public class ConcurrentMapCache<K, V> implements Cache<K, V> {
+public class ConcurrentMapCache implements Cache {
 
 	private static class NullHolder implements Serializable {
 		private static final long serialVersionUID = 1L;
 	}
 
 	private static final Object NULL_HOLDER = new NullHolder();
-	private final ConcurrentMap<K, V> store;
+	private final ConcurrentMap store;
 	private final String name;
 	private final boolean allowNullValues;
 
@@ -50,10 +50,10 @@ public ConcurrentMapCache() {
 	}
 
 	public ConcurrentMapCache(String name) {
-		this(new ConcurrentHashMap<K, V>(), name, true);
+		this(new ConcurrentHashMap(), name, true);
 	}
 
-	public ConcurrentMapCache(ConcurrentMap<K, V> delegate, String name, boolean allowNullValues) {
+	public ConcurrentMapCache(ConcurrentMap delegate, String name, boolean allowNullValues) {
 		this.store = delegate;
 		this.name = name;
 		this.allowNullValues = allowNullValues;
@@ -67,21 +67,20 @@ public boolean getAllowNullValues() {
 		return allowNullValues;
 	}
 
-	public ConcurrentMap<K, V> getNativeCache() {
+	public ConcurrentMap getNativeCache() {
 		return store;
 	}
 
 	public void clear() {
 		store.clear();
 	}
 
-	public ValueWrapper<V> get(Object key) {
-		V v = store.get(key);
-		return (v != null ? new DefaultValueWrapper<V>(filterNull(v)) : null);
+	public ValueWrapper get(Object key) {
+		Object v = store.get(key);
+		return (v != null ? new DefaultValueWrapper(filterNull(v)) : null);
 	}
 
-	@SuppressWarnings("unchecked")
-	public void put(K key, V value) {
+	public void put(Object key, Object value) {
 		if (allowNullValues && value == null) {
 			Map map = store;
 			map.put(key, NULL_HOLDER);
@@ -94,7 +93,7 @@ public void evict(Object key) {
 		store.remove(key);
 	}
 
-	protected V filterNull(V val) {
+	protected Object filterNull(Object val) {
 		if (allowNullValues && val == NULL_HOLDER) {
 			return null;
 		}
diff --git a/org.springframework.context/src/main/java/org/springframework/cache/concurrent/ConcurrentMapCacheFactoryBean.java b/org.springframework.context/src/main/java/org/springframework/cache/concurrent/ConcurrentMapCacheFactoryBean.java
@@ -28,19 +28,19 @@
  * 
  * @author Costin Leau
  */
-public class ConcurrentCacheFactoryBean<K, V> implements FactoryBean<ConcurrentMapCache<K, V>>, BeanNameAware,
+public class ConcurrentMapCacheFactoryBean implements FactoryBean<ConcurrentMapCache>, BeanNameAware,
 		InitializingBean {
 
 	private String name = "";
-	private ConcurrentMapCache<K, V> cache;
+	private ConcurrentMapCache cache;
 
-	private ConcurrentMap<K, V> store;
+	private ConcurrentMap store;
 
 	public void afterPropertiesSet() {
-		cache = (store == null ? new ConcurrentMapCache<K, V>(name) : new ConcurrentMapCache<K, V>(store, name, true));
+		cache = (store == null ? new ConcurrentMapCache(name) : new ConcurrentMapCache(store, name, true));
 	}
 
-	public ConcurrentMapCache<K, V> getObject() throws Exception {
+	public ConcurrentMapCache getObject() throws Exception {
 		return cache;
 	}
 
@@ -62,7 +62,7 @@ public void setName(String name) {
 		this.name = name;
 	}
 
-	public void setStore(ConcurrentMap<K, V> store) {
+	public void setStore(ConcurrentMap store) {
 		this.store = store;
 	}
 }
diff --git a/org.springframework.context/src/main/java/org/springframework/cache/ehcache/EhCacheCache.java b/org.springframework.context/src/main/java/org/springframework/cache/ehcache/EhCacheCache.java
@@ -29,7 +29,7 @@
  * 
  * @author Costin Leau
  */
-public class EhCacheCache implements Cache<Object, Object> {
+public class EhCacheCache implements Cache {
 
 	private final Ehcache cache;
 
@@ -58,7 +58,7 @@ public void clear() {
 		cache.removeAll();
 	}
 
-	public ValueWrapper<Object> get(Object key) {
+	public ValueWrapper get(Object key) {
 		Element element = cache.get(key);
 		return (element != null ? new DefaultValueWrapper<Object>(element.getObjectValue()) : null);
 	}
diff --git a/org.springframework.context/src/main/java/org/springframework/cache/ehcache/EhCacheCacheManager.java b/org.springframework.context/src/main/java/org/springframework/cache/ehcache/EhCacheCacheManager.java
@@ -36,15 +36,15 @@ public class EhCacheCacheManager extends AbstractCacheManager {
 	private net.sf.ehcache.CacheManager cacheManager;
 
 	@Override
-	protected Collection<Cache<?, ?>> loadCaches() {
+	protected Collection<Cache> loadCaches() {
 		Assert.notNull(cacheManager, "a backing Ehcache cache manager is required");
 		Status status = cacheManager.getStatus();
 
 		Assert.isTrue(Status.STATUS_ALIVE.equals(status),
 				"an 'alive' Ehcache cache manager is required - current cache is " + status.toString());
 
 		String[] names = cacheManager.getCacheNames();
-		Collection<Cache<?, ?>> caches = new LinkedHashSet<Cache<?, ?>>(names.length);
+		Collection<Cache> caches = new LinkedHashSet<Cache>(names.length);
 		
 		for (String name : names) {
 			caches.add(new EhCacheCache(cacheManager.getEhcache(name)));
@@ -53,8 +53,7 @@ public class EhCacheCacheManager extends AbstractCacheManager {
 		return caches;
 	}
 
-	@SuppressWarnings("unchecked")
-	public <K, V> Cache<K, V> getCache(String name) {
+	public Cache getCache(String name) {
 		Cache cache = super.getCache(name);
 		if (cache == null) {
 			// check the Ehcache cache again
diff --git a/org.springframework.context/src/main/java/org/springframework/cache/interceptor/CacheAspectSupport.java b/org.springframework.context/src/main/java/org/springframework/cache/interceptor/CacheAspectSupport.java
@@ -124,13 +124,13 @@ public void setCacheDefinitionSources(CacheOperationSource... cacheDefinitionSou
 				cacheDefinitionSources) : cacheDefinitionSources[0]);
 	}
 
-	protected Collection<Cache<?, ?>> getCaches(CacheOperation operation) {
+	protected Collection<Cache> getCaches(CacheOperation operation) {
 		Set<String> cacheNames = operation.getCacheNames();
 
-		Collection<Cache<?, ?>> caches = new ArrayList<Cache<?, ?>>(cacheNames.size());
+		Collection<Cache> caches = new ArrayList<Cache>(cacheNames.size());
 
 		for (String cacheName : cacheNames) {
-			Cache<Object, Object> cache = cacheManager.getCache(cacheName);
+			Cache cache = cacheManager.getCache(cacheName);
 			if (cache == null) {
 				throw new IllegalArgumentException("Cannot find cache named [" + cacheName + "] for " + operation);
 			}
@@ -145,7 +145,6 @@ protected CacheOperationContext getOperationContext(CacheOperation operation, Me
 		return new CacheOperationContext(operation, method, args, target, targetClass);
 	}
 
-	@SuppressWarnings("unchecked")
 	protected Object execute(Callable<Object> invocation, Object target, Method method, Object[] args) throws Exception {
 		// get backing class
 		Class<?> targetClass = AopProxyUtils.ultimateTargetClass(target);
@@ -163,7 +162,7 @@ protected Object execute(Callable<Object> invocation, Object target, Method meth
 		// analyze caching information
 		if (cacheOp != null) {
 			CacheOperationContext context = getOperationContext(cacheOp, method, args, target, targetClass);
-			Collection<Cache<?, ?>> caches = context.getCaches();
+			Collection<Cache> caches = context.getCaches();
 
 			if (context.hasConditionPassed()) {
 				// check operation
@@ -183,9 +182,9 @@ protected Object execute(Callable<Object> invocation, Object target, Method meth
 					// for each cache
 					boolean cacheHit = false;
 
-					for (Iterator<Cache<?, ?>> iterator = caches.iterator(); iterator.hasNext() && !cacheHit;) {
+					for (Iterator<Cache> iterator = caches.iterator(); iterator.hasNext() && !cacheHit;) {
 						Cache cache = iterator.next();
-						Cache.ValueWrapper<Object> wrapper = cache.get(key);
+						Cache.ValueWrapper wrapper = cache.get(key);
 
 						if (wrapper != null) {
 							cacheHit = true;
@@ -255,7 +254,7 @@ protected Object execute(Callable<Object> invocation, Object target, Method meth
 	protected class CacheOperationContext {
 
 		private CacheOperation operation;
-		private final Collection<Cache<?, ?>> caches;
+		private final Collection<Cache> caches;
 		private final Object target;
 		private final Method method;
 		private final Object[] args;
@@ -307,7 +306,7 @@ protected Object generateKey() {
 			return keyGenerator.extract(target, method, args);
 		}
 
-		protected Collection<Cache<?, ?>> getCaches() {
+		protected Collection<Cache> getCaches() {
 			return caches;
 		}
 	}
diff --git a/org.springframework.context/src/main/java/org/springframework/cache/interceptor/CacheExpressionRootObject.java b/org.springframework.context/src/main/java/org/springframework/cache/interceptor/CacheExpressionRootObject.java
@@ -68,5 +68,5 @@ interface CacheExpressionRootObject {
 	 * 
 	 * @return current cache
 	 */
-	Collection<Cache<?,?>> getCaches();
+	Collection<Cache> getCaches();
 }
diff --git a/org.springframework.context/src/main/java/org/springframework/cache/interceptor/DefaultCacheExpressionRootObject.java b/org.springframework.context/src/main/java/org/springframework/cache/interceptor/DefaultCacheExpressionRootObject.java
@@ -33,10 +33,10 @@ public class DefaultCacheExpressionRootObject implements CacheExpressionRootObje
 	private final Class<?> targetClass;
 	private final String methodName;
 	private final Method method;
-	private final Collection<Cache<?, ?>> caches;
+	private final Collection<Cache> caches;
 	private final Object[] args;
 
-	public DefaultCacheExpressionRootObject(Collection<Cache<?, ?>> caches, Method method, Object[] args,
+	public DefaultCacheExpressionRootObject(Collection<Cache> caches, Method method, Object[] args,
 			Object target, Class<?> targetClass) {
 		Assert.notNull(method, "method is required");
 		Assert.notNull(targetClass, "targetClass is required");
@@ -52,7 +52,7 @@ public String getMethodName() {
 		return methodName;
 	}
 
-	public Collection<Cache<?, ?>> getCaches() {
+	public Collection<Cache> getCaches() {
 		return caches;
 	}
 
diff --git a/org.springframework.context/src/main/java/org/springframework/cache/interceptor/DefaultValueWrapper.java b/org.springframework.context/src/main/java/org/springframework/cache/interceptor/DefaultValueWrapper.java
@@ -23,15 +23,15 @@
  * 
  * @author Costin Leau
  */
-public class DefaultValueWrapper<V> implements ValueWrapper<V> {
+public class DefaultValueWrapper<V> implements ValueWrapper {
 
-	private final V value;
+	private final Object value;
 
-	public DefaultValueWrapper(V value) {
+	public DefaultValueWrapper(Object value) {
 		this.value = value;
 	}
 
-	public V get() {
+	public Object get() {
 		return value;
 	}
 }
diff --git a/org.springframework.context/src/main/java/org/springframework/cache/interceptor/ExpressionEvaluator.java b/org.springframework.context/src/main/java/org/springframework/cache/interceptor/ExpressionEvaluator.java
@@ -47,7 +47,7 @@ class ExpressionEvaluator {
 	private Map<Method, Expression> keyCache = new ConcurrentHashMap<Method, Expression>();
 	private Map<Method, Method> targetMethodCache = new ConcurrentHashMap<Method, Method>();
 
-	EvaluationContext createEvaluationContext(Collection<Cache<?, ?>> caches, Method method, Object[] args,
+	EvaluationContext createEvaluationContext(Collection<Cache> caches, Method method, Object[] args,
 			Object target, Class<?> targetClass) {
 		DefaultCacheExpressionRootObject rootObject = new DefaultCacheExpressionRootObject(caches, method, args,
 				target, targetClass);
diff --git a/org.springframework.context/src/main/java/org/springframework/cache/support/AbstractCacheManager.java b/org.springframework.context/src/main/java/org/springframework/cache/support/AbstractCacheManager.java
@@ -37,11 +37,11 @@
 public abstract class AbstractCacheManager implements CacheManager, InitializingBean {
 
 	// fast lookup by name map
-	private final ConcurrentMap<String, Cache<?, ?>> caches = new ConcurrentHashMap<String, Cache<?, ?>>();
+	private final ConcurrentMap<String, Cache> caches = new ConcurrentHashMap<String, Cache>();
 	private Collection<String> names;
 
 	public void afterPropertiesSet() {
-		Collection<Cache<?, ?>> cacheSet = loadCaches();
+		Collection<Cache> cacheSet = loadCaches();
 
 		Assert.notEmpty(cacheSet);
 
@@ -50,7 +50,7 @@ public void afterPropertiesSet() {
 		// preserve the initial order of the cache names
 		Set<String> cacheNames = new LinkedHashSet<String>(cacheSet.size());
 
-		for (Cache<?, ?> cache : cacheSet) {
+		for (Cache cache : cacheSet) {
 			caches.put(cache.getName(), cache);
 			cacheNames.add(cache.getName());
 		}
@@ -64,20 +64,19 @@ public void afterPropertiesSet() {
 	 * 
 	 * @param caches the collection of caches handled by the manager
 	 */
-	protected abstract Collection<Cache<?, ?>> loadCaches();
+	protected abstract Collection<Cache> loadCaches();
 
 	/**
 	 * Returns the internal cache map.
 	 * 
 	 * @return internal cache map
 	 */
-	protected final ConcurrentMap<String, Cache<?, ?>> getCacheMap() {
+	protected final ConcurrentMap<String, Cache> getCacheMap() {
 		return caches;
 	}
 
-	@SuppressWarnings("unchecked")
-	public <K, V> Cache<K, V> getCache(String name) {
-		return (Cache<K, V>) caches.get(name);
+	public Cache getCache(String name) {
+		return caches.get(name);
 	}
 
 	public Collection<String> getCacheNames() {
diff --git a/org.springframework.context/src/main/java/org/springframework/cache/support/CompositeCacheManager.java b/org.springframework.context/src/main/java/org/springframework/cache/support/CompositeCacheManager.java
@@ -35,8 +35,8 @@ public class CompositeCacheManager implements CacheManager {
 
 	private CacheManager[] cacheManagers;
 
-	public <K, V> Cache<K, V> getCache(String name) {
-		Cache<K, V> cache = null;
+	public Cache getCache(String name) {
+		Cache cache = null;
 		for (CacheManager cacheManager : cacheManagers) {
 			cache = cacheManager.getCache(name);
 			if (cache != null) {
diff --git a/org.springframework.context/src/main/java/org/springframework/cache/support/SimpleCacheManager.java b/org.springframework.context/src/main/java/org/springframework/cache/support/SimpleCacheManager.java
diff --git a/org.springframework.context/src/test/java/org/springframework/cache/config/AbstractAnnotationTest.java b/org.springframework.context/src/test/java/org/springframework/cache/config/AbstractAnnotationTest.java
diff --git a/org.springframework.context/src/test/resources/org/springframework/cache/config/annotationDrivenCacheConfig.xml b/org.springframework.context/src/test/resources/org/springframework/cache/config/annotationDrivenCacheConfig.xml
diff --git a/org.springframework.context/src/test/resources/org/springframework/cache/config/annotationDrivenCacheNamespace.xml b/org.springframework.context/src/test/resources/org/springframework/cache/config/annotationDrivenCacheNamespace.xml
diff --git a/spring-framework-reference/src/cache.xml b/spring-framework-reference/src/cache.xml

Original file line number	Diff line number	Diff line change
`@@ -34,14 +34,14 @@`
`34`	`34`	`*`
`35`	`35`	`* @author Costin Leau`
`36`	`36`	`*/`
`37`		`-public class ConcurrentMapCache<K, V> implements Cache<K, V> {`
	`37`	`+public class ConcurrentMapCache implements Cache {`
`38`	`38`
`39`	`39`	`private static class NullHolder implements Serializable {`
`40`	`40`	`private static final long serialVersionUID = 1L;`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`private static final Object NULL_HOLDER = new NullHolder();`
`44`		`- private final ConcurrentMap<K, V> store;`
	`44`	`+ private final ConcurrentMap store;`
`45`	`45`	`private final String name;`
`46`	`46`	`private final boolean allowNullValues;`
`47`	`47`
`@@ -50,10 +50,10 @@ public ConcurrentMapCache() {`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`public ConcurrentMapCache(String name) {`
`53`		`- this(new ConcurrentHashMap<K, V>(), name, true);`
	`53`	`+ this(new ConcurrentHashMap(), name, true);`
`54`	`54`	`}`
`55`	`55`
`56`		`- public ConcurrentMapCache(ConcurrentMap<K, V> delegate, String name, boolean allowNullValues) {`
	`56`	`+ public ConcurrentMapCache(ConcurrentMap delegate, String name, boolean allowNullValues) {`
`57`	`57`	`this.store = delegate;`
`58`	`58`	`this.name = name;`
`59`	`59`	`this.allowNullValues = allowNullValues;`
`@@ -67,21 +67,20 @@ public boolean getAllowNullValues() {`
`67`	`67`	`return allowNullValues;`
`68`	`68`	`}`
`69`	`69`
`70`		`- public ConcurrentMap<K, V> getNativeCache() {`
	`70`	`+ public ConcurrentMap getNativeCache() {`
`71`	`71`	`return store;`
`72`	`72`	`}`
`73`	`73`
`74`	`74`	`public void clear() {`
`75`	`75`	`store.clear();`
`76`	`76`	`}`
`77`	`77`
`78`		`- public ValueWrapper<V> get(Object key) {`
`79`		`- V v = store.get(key);`
`80`		`- return (v != null ? new DefaultValueWrapper<V>(filterNull(v)) : null);`
	`78`	`+ public ValueWrapper get(Object key) {`
	`79`	`+ Object v = store.get(key);`
	`80`	`+ return (v != null ? new DefaultValueWrapper(filterNull(v)) : null);`
`81`	`81`	`}`
`82`	`82`
`83`		`- @SuppressWarnings("unchecked")`
`84`		`- public void put(K key, V value) {`
	`83`	`+ public void put(Object key, Object value) {`
`85`	`84`	`if (allowNullValues && value == null) {`
`86`	`85`	`Map map = store;`
`87`	`86`	`map.put(key, NULL_HOLDER);`
`@@ -94,7 +93,7 @@ public void evict(Object key) {`
`94`	`93`	`store.remove(key);`
`95`	`94`	`}`
`96`	`95`
`97`		`- protected V filterNull(V val) {`
	`96`	`+ protected Object filterNull(Object val) {`
`98`	`97`	`if (allowNullValues && val == NULL_HOLDER) {`
`99`	`98`	`return null;`
`100`	`99`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,19 +28,19 @@`
`28`	`28`	`*`
`29`	`29`	`* @author Costin Leau`
`30`	`30`	`*/`
`31`		`-public class ConcurrentCacheFactoryBean<K, V> implements FactoryBean<ConcurrentMapCache<K, V>>, BeanNameAware,`
	`31`	`+public class ConcurrentMapCacheFactoryBean implements FactoryBean<ConcurrentMapCache>, BeanNameAware,`
`32`	`32`	`InitializingBean {`
`33`	`33`
`34`	`34`	`private String name = "";`
`35`		`- private ConcurrentMapCache<K, V> cache;`
	`35`	`+ private ConcurrentMapCache cache;`
`36`	`36`
`37`		`- private ConcurrentMap<K, V> store;`
	`37`	`+ private ConcurrentMap store;`
`38`	`38`
`39`	`39`	`public void afterPropertiesSet() {`
`40`		`- cache = (store == null ? new ConcurrentMapCache<K, V>(name) : new ConcurrentMapCache<K, V>(store, name, true));`
	`40`	`+ cache = (store == null ? new ConcurrentMapCache(name) : new ConcurrentMapCache(store, name, true));`
`41`	`41`	`}`
`42`	`42`
`43`		`- public ConcurrentMapCache<K, V> getObject() throws Exception {`
	`43`	`+ public ConcurrentMapCache getObject() throws Exception {`
`44`	`44`	`return cache;`
`45`	`45`	`}`
`46`	`46`
`@@ -62,7 +62,7 @@ public void setName(String name) {`
`62`	`62`	`this.name = name;`
`63`	`63`	`}`
`64`	`64`
`65`		`- public void setStore(ConcurrentMap<K, V> store) {`
	`65`	`+ public void setStore(ConcurrentMap store) {`
`66`	`66`	`this.store = store;`
`67`	`67`	`}`
`68`	`68`	`}`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@`
`29`	`29`	`*`
`30`	`30`	`* @author Costin Leau`
`31`	`31`	`*/`
`32`		`-public class EhCacheCache implements Cache<Object, Object> {`
	`32`	`+public class EhCacheCache implements Cache {`
`33`	`33`
`34`	`34`	`private final Ehcache cache;`
`35`	`35`
`@@ -58,7 +58,7 @@ public void clear() {`
`58`	`58`	`cache.removeAll();`
`59`	`59`	`}`
`60`	`60`
`61`		`- public ValueWrapper<Object> get(Object key) {`
	`61`	`+ public ValueWrapper get(Object key) {`
`62`	`62`	`Element element = cache.get(key);`
`63`	`63`	`return (element != null ? new DefaultValueWrapper<Object>(element.getObjectValue()) : null);`
`64`	`64`	`}`
Original file line number	Diff line number	Diff line change
`@@ -68,5 +68,5 @@ interface CacheExpressionRootObject {`
`68`	`68`	`*`
`69`	`69`	`* @return current cache`
`70`	`70`	`*/`
`71`		`- Collection<Cache<?,?>> getCaches();`
	`71`	`+ Collection<Cache> getCaches();`
`72`	`72`	`}`