Support for multi-threaded cache access

Previously, if a `@Cacheable` method was accessed with the same key by
multiple threads, the underlying method was invoked several times instead
of blocking the threads while the value is computed. This scenario
typically affects users that enable caching to avoid calling a costly
method too often. When said method can be invoked by an arbitrary number
of clients on startup, caching has close to no effect.

This commit adds a new method on `Cache` that implements the read-through
pattern:

```
<T> T get(Object key, Callable<T> valueLoader);
```

If an entry for a given key is not found, the specified `Callable` is
invoked to "load" the value and cache it before returning it to the
caller. Because the entire operation is managed by the underlying cache
provider, it is much more easier to guarantee that the loader (e.g. the
annotated method) will be called only once in case of concurrent access.

A new `sync` attribute to the `@Cacheable` annotation has been addded.
When this flag is enabled, the caching abstraction invokes the new
`Cache` method define above. This new mode bring a set of limitations:

* It can't be combined with other cache operations
* Only one `@Cacheable` operation can be specified
* Only one cache is allowed
* `condition` and `unless` attribute are not supported

The rationale behind those limitations is that the underlying Cache is
taking care of the actual caching operation so we can't really apply
any SpEL or multiple caches handling there.

Issue: SPR-9254

Author: snicoll

spring-aspects/src/main/java/org/springframework/cache/aspectj/AbstractCacheAspect.aj

@@ -67,11 +67,22 @@ public abstract aspect AbstractCacheAspect extends CacheAspectSupport implements
 
 		CacheOperationInvoker aspectJInvoker = new CacheOperationInvoker() {
 			public Object invoke() {
-				return proceed(cachedObject);
+				try {
+					return proceed(cachedObject);
+				}
+				catch (Throwable ex) {
+					throw new ThrowableWrapper(ex);
+				}
 			}
 		};
 
-		return execute(aspectJInvoker, thisJoinPoint.getTarget(), method, thisJoinPoint.getArgs());
+		try {
+			return execute(aspectJInvoker, thisJoinPoint.getTarget(), method, thisJoinPoint.getArgs());
+		}
+		catch (CacheOperationInvoker.ThrowableWrapper th) {
+			AnyThrow.throwUnchecked(th.getOriginal());
+			return null; // never reached
+		}
 	}
 
 	/**

spring-aspects/src/main/java/org/springframework/cache/aspectj/AnyThrow.java

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2002-2015 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.aspectj;
+
+/**
+ * Utility to trick the compiler to throw a valid checked
+ * exceptions within the interceptor.
+ *
+ * @author Stephane Nicoll
+ */
+class AnyThrow {
+
+	static void throwUnchecked(Throwable e) {
+		AnyThrow.<RuntimeException>throwAny(e);
+	}
+
+	@SuppressWarnings("unchecked")
+	private static <E extends Throwable> void throwAny(Throwable e) throws E {
+		throw (E) e;
+	}
+}

spring-aspects/src/main/java/org/springframework/cache/aspectj/JCacheCacheAspect.aj

@@ -109,16 +109,4 @@ public aspect JCacheCacheAspect extends JCacheAspectSupport {
 		execution(@CacheRemoveAll * *(..));
 
 
-	private static class AnyThrow {
-
-		private static void throwUnchecked(Throwable e) {
-			AnyThrow.<RuntimeException>throwAny(e);
-		}
-
-		@SuppressWarnings("unchecked")
-		private static <E extends Throwable> void throwAny(Throwable e) throws E {
-			throw (E)e;
-		}
-	}
-
 }

spring-aspects/src/test/java/org/springframework/cache/config/AnnotatedClassCacheableService.java

@@ -27,6 +27,7 @@
 /**
  * @author Costin Leau
  * @author Phillip Webb
+ * @author Stephane Nicoll
  */
 @Cacheable("testCache")
 public class AnnotatedClassCacheableService implements CacheableService<Object> {
@@ -44,11 +45,28 @@ public Object cacheNull(Object arg1) {
 		return null;
 	}
 
+	@Override
+	@Cacheable(cacheNames = "testCache", sync = true)
+	public Object cacheSync(Object arg1) {
+		return counter.getAndIncrement();
+	}
+
+	@Override
+	@Cacheable(cacheNames = "testCache", sync = true)
+	public Object cacheSyncNull(Object arg1) {
+		return null;
+	}
+
 	@Override
 	public Object conditional(int field) {
 		return null;
 	}
 
+	@Override
+	public Object conditionalSync(int field) {
+		return null;
+	}
+
 	@Override
 	public Object unless(int arg) {
 		return arg;
@@ -168,6 +186,18 @@ public Long throwUnchecked(Object arg1) {
 		throw new UnsupportedOperationException(arg1.toString());
 	}
 
+	@Override
+	@Cacheable(cacheNames = "testCache", sync = true)
+	public Object throwCheckedSync(Object arg1) throws Exception {
+		throw new IOException(arg1.toString());
+	}
+
+	@Override
+	@Cacheable(cacheNames = "testCache", sync = true)
+	public Object throwUncheckedSync(Object arg1) {
+		throw new UnsupportedOperationException(arg1.toString());
+	}
+
 	// multi annotations
 
 	@Override

spring-aspects/src/test/java/org/springframework/cache/config/CacheableService.java

@@ -21,13 +21,18 @@
  *
  * @author Costin Leau
  * @author Phillip Webb
+ * @author Stephane Nicoll
  */
 public interface CacheableService<T> {
 
 	T cache(Object arg1);
 
 	T cacheNull(Object arg1);
 
+	T cacheSync(Object arg1);
+
+	T cacheSyncNull(Object arg1);
+
 	void invalidate(Object arg1);
 
 	void evictEarly(Object arg1);
@@ -42,6 +47,8 @@ public interface CacheableService<T> {
 
 	T conditional(int field);
 
+	T conditionalSync(int field);
+
 	T unless(int arg);
 
 	T key(Object arg1, Object arg2);
@@ -72,6 +79,10 @@ public interface CacheableService<T> {
 
 	T throwUnchecked(Object arg1);
 
+	T throwCheckedSync(Object arg1) throws Exception;
+
+	T throwUncheckedSync(Object arg1);
+
 	// multi annotations
 	T multiCache(Object arg1);
 

spring-aspects/src/test/java/org/springframework/cache/config/DefaultCacheableService.java

@@ -29,6 +29,7 @@
  *
  * @author Costin Leau
  * @author Phillip Webb
+ * @author Stephane Nicoll
  */
 public class DefaultCacheableService implements CacheableService<Long> {
 
@@ -47,6 +48,18 @@ public Long cacheNull(Object arg1) {
 		return null;
 	}
 
+	@Override
+	@Cacheable(cacheNames = "testCache", sync = true)
+	public Long cacheSync(Object arg1) {
+		return counter.getAndIncrement();
+	}
+
+	@Override
+	@Cacheable(cacheNames = "testCache", sync = true)
+	public Long cacheSyncNull(Object arg1) {
+		return null;
+	}
+
 	@Override
 	@CacheEvict("testCache")
 	public void invalidate(Object arg1) {
@@ -81,11 +94,17 @@ public void invalidateEarly(Object arg1, Object arg2) {
 	}
 
 	@Override
-	@Cacheable(cacheNames = "testCache", condition = "#classField == 3")
+	@Cacheable(cacheNames = "testCache", condition = "#p0 == 3")
 	public Long conditional(int classField) {
 		return counter.getAndIncrement();
 	}
 
+	@Override
+	@Cacheable(cacheNames = "testCache", sync = true, condition = "#p0 == 3")
+	public Long conditionalSync(int field) {
+		return counter.getAndIncrement();
+	}
+
 	@Override
 	@Cacheable(cacheNames = "testCache", unless = "#result > 10")
 	public Long unless(int arg) {
@@ -99,7 +118,7 @@ public Long key(Object arg1, Object arg2) {
 	}
 
 	@Override
-	@Cacheable("testCache")
+	@Cacheable(cacheNames = "testCache")
 	public Long varArgsKey(Object... args) {
 		return counter.getAndIncrement();
 	}
@@ -176,6 +195,18 @@ public Long throwUnchecked(Object arg1) {
 		throw new UnsupportedOperationException(arg1.toString());
 	}
 
+	@Override
+	@Cacheable(cacheNames = "testCache", sync = true)
+	public Long throwCheckedSync(Object arg1) throws Exception {
+		throw new IOException(arg1.toString());
+	}
+
+	@Override
+	@Cacheable(cacheNames = "testCache", sync = true)
+	public Long throwUncheckedSync(Object arg1) {
+		throw new UnsupportedOperationException(arg1.toString());
+	}
+
 	// multi annotations
 
 	@Override

spring-context-support/src/main/java/org/springframework/cache/caffeine/CaffeineCache.java

@@ -16,6 +16,7 @@
 
 package org.springframework.cache.caffeine;
 
+import java.util.concurrent.Callable;
 import java.util.function.Function;
 
 import com.github.benmanes.caffeine.cache.LoadingCache;
@@ -88,6 +89,12 @@ public ValueWrapper get(Object key) {
 		return super.get(key);
 	}
 
+	@SuppressWarnings("unchecked")
+	@Override
+	public <T> T get(Object key, final Callable<T> valueLoader) {
+		return (T) fromStoreValue(this.cache.get(key, new LoadFunction(valueLoader)));
+	}
+
 	@Override
 	protected Object lookup(Object key) {
 		return this.cache.getIfPresent(key);
@@ -133,4 +140,23 @@ public Object apply(Object key) {
 		}
 	}
 
+	private class LoadFunction implements Function<Object, Object> {
+
+		private final Callable<?> valueLoader;
+
+		public LoadFunction(Callable<?> valueLoader) {
+			this.valueLoader = valueLoader;
+		}
+
+		@Override
+		public Object apply(Object o) {
+			try {
+				return toStoreValue(valueLoader.call());
+			}
+			catch (Exception ex) {
+				throw new ValueRetrievalException(o, valueLoader, ex);
+			}
+		}
+	}
+
 }

spring-context-support/src/main/java/org/springframework/cache/ehcache/EhCacheCache.java

@@ -16,6 +16,8 @@
 
 package org.springframework.cache.ehcache;
 
+import java.util.concurrent.Callable;
+
 import net.sf.ehcache.Ehcache;
 import net.sf.ehcache.Element;
 import net.sf.ehcache.Status;
@@ -62,10 +64,47 @@ public final Ehcache getNativeCache() {
 
 	@Override
 	public ValueWrapper get(Object key) {
-		Element element = this.cache.get(key);
+		Element element = lookup(key);
 		return toValueWrapper(element);
 	}
 
+	@SuppressWarnings("unchecked")
+	@Override
+	public <T> T get(Object key, Callable<T> valueLoader) {
+		Element element = lookup(key);
+		if (element != null) {
+			return (T) element.getObjectValue();
+		}
+		else {
+			this.cache.acquireWriteLockOnKey(key);
+			try {
+				element = lookup(key); // One more attempt with the write lock
+				if (element != null) {
+					return (T) element.getObjectValue();
+				}
+				else {
+					return loadValue(key, valueLoader);
+				}
+			}
+			finally {
+				this.cache.releaseWriteLockOnKey(key);
+			}
+		}
+
+	}
+
+	private <T> T loadValue(Object key, Callable<T> valueLoader) {
+		T value;
+		try {
+			value = valueLoader.call();
+		}
+		catch (Exception ex) {
+			throw new ValueRetrievalException(key, valueLoader, ex);
+		}
+		put(key, value);
+		return value;
+	}
+
 	@Override
 	@SuppressWarnings("unchecked")
 	public <T> T get(Object key, Class<T> type) {
@@ -98,6 +137,11 @@ public void clear() {
 		this.cache.removeAll();
 	}
 
+
+	private Element lookup(Object key) {
+		return this.cache.get(key);
+	}
+
 	private ValueWrapper toValueWrapper(Element element) {
 		return (element != null ? new SimpleValueWrapper(element.getObjectValue()) : null);
 	}

spring-context-support/src/main/java/org/springframework/cache/guava/GuavaCache.java

@@ -93,6 +93,25 @@ public ValueWrapper get(Object key) {
 		return super.get(key);
 	}
 
+	@SuppressWarnings("unchecked")
+	@Override
+	public <T> T get(Object key, final Callable<T> valueLoader) {
+		try {
+			return (T) fromStoreValue(this.cache.get(key, new Callable<Object>() {
+				@Override
+				public Object call() throws Exception {
+					return toStoreValue(valueLoader.call());
+				}
+			}));
+		}
+		catch (ExecutionException ex) {
+			throw new ValueRetrievalException(key, valueLoader, ex.getCause());
+		}
+		catch (UncheckedExecutionException ex) {
+			throw new ValueRetrievalException(key, valueLoader, ex.getCause());
+		}
+	}
+
 	@Override
 	protected Object lookup(Object key) {
 		return this.cache.getIfPresent(key);