root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions 6 Packages Projects Releases Wiki Activity

Introduce alias for 'value' attribute in caching annotations 

This commit introduces new 'cacheNames' attributes (analogous to the
existing attribute of the same name in @CacheConfig) as aliases for the
'value' attributes in @Cacheable, @CachePut, and @CacheEvict.

In addition, SpringCacheAnnotationParser.getAnnotations() has been
refactored to support synthesized annotations.

Issue: SPR-11393
This commit is contained in:
Sam Brannen 2015-05-31 22:51:37 +02:00
parent de06f422f3
commit 4dffeeee64
10 changed files with 172 additions and 134 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
spring-aspects/src/test/java/org/springframework/cache/config/AnnotatedClassCacheableService.java vendored
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2014 the original author or authors.
* 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.
@ -60,71 +60,71 @@ public class AnnotatedClassCacheableService implements CacheableService<Object>
}
@Override
@CacheEvict(value = "testCache", allEntries = true)
@CacheEvict(cacheNames = "testCache", allEntries = true)
public void evictAll(Object arg1) {
}
@Override
@CacheEvict(value = "testCache", beforeInvocation = true)
@CacheEvict(cacheNames = "testCache", beforeInvocation = true)
public void evictEarly(Object arg1) {
throw new RuntimeException("exception thrown - evict should still occur");
}
@Override
@CacheEvict(value = "testCache", key = "#p0")
@CacheEvict(cacheNames = "testCache", key = "#p0")
public void evict(Object arg1, Object arg2) {
}
@Override
@CacheEvict(value = "testCache", key = "#p0", beforeInvocation = true)
@CacheEvict(cacheNames = "testCache", key = "#p0", beforeInvocation = true)
public void invalidateEarly(Object arg1, Object arg2) {
throw new RuntimeException("exception thrown - evict should still occur");
}
@Override
@Cacheable(value = "testCache", key = "#p0")
@Cacheable(cacheNames = "testCache", key = "#p0")
public Object key(Object arg1, Object arg2) {
return counter.getAndIncrement();
}
@Override
@Cacheable(value = "testCache")
@Cacheable("testCache")
public Object varArgsKey(Object... args) {
return counter.getAndIncrement();
}
@Override
@Cacheable(value = "testCache", key = "#root.methodName + #root.caches[0].name")
@Cacheable(cacheNames = "testCache", key = "#root.methodName + #root.caches[0].name")
public Object name(Object arg1) {
return counter.getAndIncrement();
}
@Override
@Cacheable(value = "testCache", key = "#root.methodName + #root.method.name + #root.targetClass + #root.target")
@Cacheable(cacheNames = "testCache", key = "#root.methodName + #root.method.name + #root.targetClass + #root.target")
public Object rootVars(Object arg1) {
return counter.getAndIncrement();
}
@Override
@Cacheable(value = "testCache", keyGenerator = "customKyeGenerator")
@Cacheable(cacheNames = "testCache", keyGenerator = "customKyeGenerator")
public Object customKeyGenerator(Object arg1) {
return counter.getAndIncrement();
}
@Override
@Cacheable(value = "testCache", keyGenerator = "unknownBeanName")
@Cacheable(cacheNames = "testCache", keyGenerator = "unknownBeanName")
public Object unknownCustomKeyGenerator(Object arg1) {
return counter.getAndIncrement();
}
@Override
@Cacheable(value = "testCache", cacheManager = "customCacheManager")
@Cacheable(cacheNames = "testCache", cacheManager = "customCacheManager")
public Object customCacheManager(Object arg1) {
return counter.getAndIncrement();
}
@Override
@Cacheable(value = "testCache", cacheManager = "unknownBeanName")
@Cacheable(cacheNames = "testCache", cacheManager = "unknownBeanName")
public Object unknownCustomCacheManager(Object arg1) {
return counter.getAndIncrement();
}
@ -136,7 +136,7 @@ public class AnnotatedClassCacheableService implements CacheableService<Object>
}
@Override
@CachePut(value = "testCache", condition = "#arg.equals(3)")
@CachePut(cacheNames = "testCache", condition = "#arg.equals(3)")
public Object conditionalUpdate(Object arg) {
return arg;
}
@ -171,19 +171,19 @@ public class AnnotatedClassCacheableService implements CacheableService<Object>
}
@Override
@Caching(evict = { @CacheEvict("primary"), @CacheEvict(value = "secondary", key = "#p0") })
@Caching(evict = { @CacheEvict("primary"), @CacheEvict(cacheNames = "secondary", key = "#p0") })
public Object multiEvict(Object arg1) {
return counter.getAndIncrement();
}
@Override
@Caching(cacheable = { @Cacheable(value = "primary", key = "#root.methodName") }, evict = { @CacheEvict("secondary") })
@Caching(cacheable = { @Cacheable(cacheNames = "primary", key = "#root.methodName") }, evict = { @CacheEvict("secondary") })
public Object multiCacheAndEvict(Object arg1) {
return counter.getAndIncrement();
}
@Override
@Caching(cacheable = { @Cacheable(value = "primary", condition = "#p0 == 3") }, evict = { @CacheEvict("secondary") })
@Caching(cacheable = { @Cacheable(cacheNames = "primary", condition = "#p0 == 3") }, evict = { @CacheEvict("secondary") })
public Object multiConditionalCacheAndEvict(Object arg1) {
return counter.getAndIncrement();
}
@ -195,7 +195,7 @@ public class AnnotatedClassCacheableService implements CacheableService<Object>
}
@Override
@CachePut(value="primary", key="#result.id")
@CachePut(cacheNames = "primary", key = "#result.id")
public TestEntity putRefersToResult(TestEntity arg1) {
arg1.setId(Long.MIN_VALUE);
return arg1;

42
spring-aspects/src/test/java/org/springframework/cache/config/DefaultCacheableService.java vendored
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2014 the original author or authors.
* 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.
@ -52,83 +52,83 @@ public class DefaultCacheableService implements CacheableService<Long> {
}
@Override
@CacheEvict(value = "testCache", allEntries = true)
@CacheEvict(cacheNames = "testCache", allEntries = true)
public void evictAll(Object arg1) {
}
@Override
@CacheEvict(value = "testCache", beforeInvocation = true)
@CacheEvict(cacheNames = "testCache", beforeInvocation = true)
public void evictEarly(Object arg1) {
throw new RuntimeException("exception thrown - evict should still occur");
}
@Override
@CacheEvict(value = "testCache", key = "#p0")
@CacheEvict(cacheNames = "testCache", key = "#p0")
public void evict(Object arg1, Object arg2) {
}
@Override
@CacheEvict(value = "testCache", key = "#p0", beforeInvocation = true)
@CacheEvict(cacheNames = "testCache", key = "#p0", beforeInvocation = true)
public void invalidateEarly(Object arg1, Object arg2) {
throw new RuntimeException("exception thrown - evict should still occur");
}
@Override
@Cacheable(value = "testCache", condition = "#classField == 3")
@Cacheable(cacheNames = "testCache", condition = "#classField == 3")
public Long conditional(int classField) {
return counter.getAndIncrement();
}
@Override
@Cacheable(value = "testCache", unless = "#result > 10")
@Cacheable(cacheNames = "testCache", unless = "#result > 10")
public Long unless(int arg) {
return (long) arg;
}
@Override
@Cacheable(value = "testCache", key = "#p0")
@Cacheable(cacheNames = "testCache", key = "#p0")
public Long key(Object arg1, Object arg2) {
return counter.getAndIncrement();
}
@Override
@Cacheable(value = "testCache")
@Cacheable("testCache")
public Long varArgsKey(Object... args) {
return counter.getAndIncrement();
}
@Override
@Cacheable(value = "testCache", key = "#root.methodName")
@Cacheable(cacheNames = "testCache", key = "#root.methodName")
public Long name(Object arg1) {
return counter.getAndIncrement();
}
@Override
@Cacheable(value = "testCache", key = "#root.methodName + #root.method.name + #root.targetClass + #root.target")
@Cacheable(cacheNames = "testCache", key = "#root.methodName + #root.method.name + #root.targetClass + #root.target")
public Long rootVars(Object arg1) {
return counter.getAndIncrement();
}
@Override
@Cacheable(value = "testCache", keyGenerator = "customKeyGenerator")
@Cacheable(cacheNames = "testCache", keyGenerator = "customKeyGenerator")
public Long customKeyGenerator(Object arg1) {
return counter.getAndIncrement();
}
@Override
@Cacheable(value = "testCache", keyGenerator = "unknownBeanName")
@Cacheable(cacheNames = "testCache", keyGenerator = "unknownBeanName")
public Long unknownCustomKeyGenerator(Object arg1) {
return counter.getAndIncrement();
}
@Override
@Cacheable(value = "testCache", cacheManager = "customCacheManager")
@Cacheable(cacheNames = "testCache", cacheManager = "customCacheManager")
public Long customCacheManager(Object arg1) {
return counter.getAndIncrement();
}
@Override
@Cacheable(value = "testCache", cacheManager = "unknownBeanName")
@Cacheable(cacheNames = "testCache", cacheManager = "unknownBeanName")
public Long unknownCustomCacheManager(Object arg1) {
return counter.getAndIncrement();
}
@ -140,7 +140,7 @@ public class DefaultCacheableService implements CacheableService<Long> {
}
@Override
@CachePut(value = "testCache", condition = "#arg.equals(3)")
@CachePut(cacheNames = "testCache", condition = "#arg.equals(3)")
public Long conditionalUpdate(Object arg) {
return Long.valueOf(arg.toString());
}
@ -178,20 +178,20 @@ public class DefaultCacheableService implements CacheableService<Long> {
}
@Override
//FIXME @Caching(evict = { @CacheEvict("primary"), @CacheEvict(value = "secondary", key = "#p0"), @CacheEvict(value = "primary", key = "#p0 + 'A'") })
@Caching(evict = { @CacheEvict("primary"), @CacheEvict(value = "secondary", key = "#p0") })
//FIXME @Caching(evict = { @CacheEvict("primary"), @CacheEvict(cacheNames = "secondary", key = "#p0"), @CacheEvict(cacheNames = "primary", key = "#p0 + 'A'") })
@Caching(evict = { @CacheEvict("primary"), @CacheEvict(cacheNames = "secondary", key = "#p0") })
public Long multiEvict(Object arg1) {
return counter.getAndIncrement();
}
@Override
@Caching(cacheable = { @Cacheable(value = "primary", key = "#root.methodName") }, evict = { @CacheEvict("secondary") })
@Caching(cacheable = { @Cacheable(cacheNames = "primary", key = "#root.methodName") }, evict = { @CacheEvict("secondary") })
public Long multiCacheAndEvict(Object arg1) {
return counter.getAndIncrement();
}
@Override
@Caching(cacheable = { @Cacheable(value = "primary", condition = "#p0 == 3") }, evict = { @CacheEvict("secondary") })
@Caching(cacheable = { @Cacheable(cacheNames = "primary", condition = "#p0 == 3") }, evict = { @CacheEvict("secondary") })
public Long multiConditionalCacheAndEvict(Object arg1) {
return counter.getAndIncrement();
}
@ -203,7 +203,7 @@ public class DefaultCacheableService implements CacheableService<Long> {
}
@Override
@CachePut(value="primary", key="#result.id")
@CachePut(cacheNames = "primary", key = "#result.id")
public TestEntity putRefersToResult(TestEntity arg1) {
arg1.setId(Long.MIN_VALUE);
return arg1;

14
spring-context/src/main/java/org/springframework/cache/annotation/CacheEvict.java vendored
View File

@ -23,6 +23,8 @@ import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.springframework.core.annotation.AliasFor;
/**
* Annotation indicating that a method (or all methods on a class) triggers
* a cache eviction operation.
@ -39,12 +41,22 @@ import java.lang.annotation.Target;
@Documented
public @interface CacheEvict {
/**
* Alias for {@link #cacheNames}.
*/
@AliasFor(attribute = "cacheNames")
String[] value() default {};
/**
* Names of the caches to use for the cache eviction operation.
* <p>Names may be used to determine the target cache (or caches), matching
* the qualifier value or bean name of a specific bean definition.
* @since 4.2
* @see #value
* @see CacheConfig#cacheNames
*/
String[] value() default {};
@AliasFor(attribute = "value")
String[] cacheNames() default {};
/**
* Spring Expression Language (SpEL) expression for computing the key dynamically.

13
spring-context/src/main/java/org/springframework/cache/annotation/CachePut.java vendored
View File

@ -24,6 +24,7 @@ import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.springframework.cache.Cache;
import org.springframework.core.annotation.AliasFor;
/**
* Annotation indicating that a method (or all methods on a class) triggers
@ -46,12 +47,22 @@ import org.springframework.cache.Cache;
@Documented
public @interface CachePut {
/**
* Alias for {@link #cacheNames}.
*/
@AliasFor(attribute = "cacheNames")
String[] value() default {};
/**
* Names of the caches to use for the cache put operation.
* <p>Names may be used to determine the target cache (or caches), matching
* the qualifier value or bean name of a specific bean definition.
* @since 4.2
* @see #value
* @see CacheConfig#cacheNames
*/
String[] value() default {};
@AliasFor(attribute = "value")
String[] cacheNames() default {};
/**
* Spring Expression Language (SpEL) expression for computing the key dynamically.

14
spring-context/src/main/java/org/springframework/cache/annotation/Cacheable.java vendored
View File

@ -23,6 +23,8 @@ import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.springframework.core.annotation.AliasFor;
/**
* Annotation indicating that the result of invoking a method (or all methods
* in a class) can be cached.
@ -50,12 +52,22 @@ import java.lang.annotation.Target;
@Documented
public @interface Cacheable {
/**
* Alias for {@link #cacheNames}.
*/
@AliasFor(attribute = "cacheNames")
String[] value() default {};
/**
* Names of the caches in which method invocation results are stored.
* <p>Names may be used to determine the target cache (or caches), matching
* the qualifier value or bean name of a specific bean definition.
* @since 4.2
* @see #value
* @see CacheConfig#cacheNames
*/
String[] value() default {};
@AliasFor(attribute = "value")
String[] cacheNames() default {};
/**
* Spring Expression Language (SpEL) expression for computing the key dynamically.

75
spring-context/src/main/java/org/springframework/cache/annotation/SpringCacheAnnotationParser.java vendored
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2014 the original author or authors.
* 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.
@ -33,13 +33,14 @@ import org.springframework.util.StringUtils;
/**
* Strategy implementation for parsing Spring's {@link Caching}, {@link Cacheable},
* {@link CacheEvict} and {@link CachePut} annotations.
* {@link CacheEvict}, and {@link CachePut} annotations.
*
* @author Costin Leau
* @author Juergen Hoeller
* @author Chris Beams
* @author Phillip Webb
* @author Stephane Nicoll
* @author Sam Brannen
* @since 3.1
*/
@SuppressWarnings("serial")
@ -96,16 +97,16 @@ public class SpringCacheAnnotationParser implements CacheAnnotationParser, Seria
return (ops != null ? ops : new ArrayList<CacheOperation>(1));
}
CacheableOperation parseCacheableAnnotation(AnnotatedElement ae, DefaultCacheConfig defaultConfig, Cacheable caching) {
CacheableOperation parseCacheableAnnotation(AnnotatedElement ae, DefaultCacheConfig defaultConfig, Cacheable cacheable) {
CacheableOperation op = new CacheableOperation();
op.setCacheNames(caching.value());
op.setCondition(caching.condition());
op.setUnless(caching.unless());
op.setKey(caching.key());
op.setKeyGenerator(caching.keyGenerator());
op.setCacheManager(caching.cacheManager());
op.setCacheResolver(caching.cacheResolver());
op.setCacheNames(cacheable.cacheNames());
op.setCondition(cacheable.condition());
op.setUnless(cacheable.unless());
op.setKey(cacheable.key());
op.setKeyGenerator(cacheable.keyGenerator());
op.setCacheManager(cacheable.cacheManager());
op.setCacheResolver(cacheable.cacheResolver());
op.setName(ae.toString());
defaultConfig.applyDefault(op);
@ -114,17 +115,17 @@ public class SpringCacheAnnotationParser implements CacheAnnotationParser, Seria
return op;
}
CacheEvictOperation parseEvictAnnotation(AnnotatedElement ae, DefaultCacheConfig defaultConfig, CacheEvict caching) {
CacheEvictOperation parseEvictAnnotation(AnnotatedElement ae, DefaultCacheConfig defaultConfig, CacheEvict cacheEvict) {
CacheEvictOperation op = new CacheEvictOperation();
op.setCacheNames(caching.value());
op.setCondition(caching.condition());
op.setKey(caching.key());
op.setKeyGenerator(caching.keyGenerator());
op.setCacheManager(caching.cacheManager());
op.setCacheResolver(caching.cacheResolver());
op.setCacheWide(caching.allEntries());
op.setBeforeInvocation(caching.beforeInvocation());
op.setCacheNames(cacheEvict.cacheNames());
op.setCondition(cacheEvict.condition());
op.setKey(cacheEvict.key());
op.setKeyGenerator(cacheEvict.keyGenerator());
op.setCacheManager(cacheEvict.cacheManager());
op.setCacheResolver(cacheEvict.cacheResolver());
op.setCacheWide(cacheEvict.allEntries());
op.setBeforeInvocation(cacheEvict.beforeInvocation());
op.setName(ae.toString());
defaultConfig.applyDefault(op);
@ -133,16 +134,16 @@ public class SpringCacheAnnotationParser implements CacheAnnotationParser, Seria
return op;
}
CacheOperation parsePutAnnotation(AnnotatedElement ae, DefaultCacheConfig defaultConfig, CachePut caching) {
CacheOperation parsePutAnnotation(AnnotatedElement ae, DefaultCacheConfig defaultConfig, CachePut cachePut) {
CachePutOperation op = new CachePutOperation();
op.setCacheNames(caching.value());
op.setCondition(caching.condition());
op.setUnless(caching.unless());
op.setKey(caching.key());
op.setKeyGenerator(caching.keyGenerator());
op.setCacheManager(caching.cacheManager());
op.setCacheResolver(caching.cacheResolver());
op.setCacheNames(cachePut.cacheNames());
op.setCondition(cachePut.condition());
op.setUnless(cachePut.unless());
op.setKey(cachePut.key());
op.setKeyGenerator(cachePut.keyGenerator());
op.setCacheManager(cachePut.cacheManager());
op.setCacheResolver(cachePut.cacheResolver());
op.setName(ae.toString());
defaultConfig.applyDefault(op);
@ -161,18 +162,18 @@ public class SpringCacheAnnotationParser implements CacheAnnotationParser, Seria
ops.add(parseCacheableAnnotation(ae, defaultConfig, cacheable));
}
}
CacheEvict[] evicts = caching.evict();
if (!ObjectUtils.isEmpty(evicts)) {
CacheEvict[] cacheEvicts = caching.evict();
if (!ObjectUtils.isEmpty(cacheEvicts)) {
ops = lazyInit(ops);
for (CacheEvict evict : evicts) {
ops.add(parseEvictAnnotation(ae, defaultConfig, evict));
for (CacheEvict cacheEvict : cacheEvicts) {
ops.add(parseEvictAnnotation(ae, defaultConfig, cacheEvict));
}
}
CachePut[] updates = caching.put();
if (!ObjectUtils.isEmpty(updates)) {
CachePut[] cachePuts = caching.put();
if (!ObjectUtils.isEmpty(cachePuts)) {
ops = lazyInit(ops);
for (CachePut update : updates) {
ops.add(parsePutAnnotation(ae, defaultConfig, update));
for (CachePut cachePut : cachePuts) {
ops.add(parsePutAnnotation(ae, defaultConfig, cachePut));
}
}
@ -199,14 +200,14 @@ public class SpringCacheAnnotationParser implements CacheAnnotationParser, Seria
// look at raw annotation
T ann = ae.getAnnotation(annotationType);
if (ann != null) {
anns.add(ann);
anns.add(AnnotationUtils.synthesizeAnnotation(ann, ae));
}
// scan meta-annotations
for (Annotation metaAnn : ae.getAnnotations()) {
ann = metaAnn.annotationType().getAnnotation(annotationType);
if (ann != null) {
anns.add(ann);
anns.add(AnnotationUtils.synthesizeAnnotation(ann, ae));
}
}

9
spring-context/src/test/java/org/springframework/cache/CacheReproTests.java vendored
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2014 the original author or authors.
* 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.
@ -21,6 +21,7 @@ import java.util.Collections;
import java.util.List;
import org.junit.Test;
import org.mockito.Mockito;
import org.springframework.cache.annotation.Cacheable;
@ -140,8 +141,8 @@ public class CacheReproTests {
@Override
@Caching(cacheable = {
@Cacheable(value = "bigCache", unless = "#result.size() < 4"),
@Cacheable(value = "smallCache", unless = "#result.size() > 3") })
@Cacheable(cacheNames = "bigCache", unless = "#result.size() < 4"),
@Cacheable(cacheNames = "smallCache", unless = "#result.size() > 3") })
public List<String> multiple(int id) {
if (this.multipleCount > 0) {
fail("Called too many times");
@ -208,7 +209,7 @@ public class CacheReproTests {
return new Object();
}
@Cacheable(value = "cache", condition = "false")
@Cacheable(cacheNames = "cache", condition = "false")
public Object getNeverCache(String key) {
return new Object();
}

24
spring-context/src/test/java/org/springframework/cache/annotation/AnnotationCacheOperationSourceTests.java vendored
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2014 the original author or authors.
* 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.
@ -257,15 +257,15 @@ public class AnnotationCacheOperationSourceTests {
public void caching() {
}
@Cacheable(value = "test", keyGenerator = "custom")
@Cacheable(cacheNames = "test", keyGenerator = "custom")
public void customKeyGenerator() {
}
@Cacheable(value = "test", cacheManager = "custom")
@Cacheable(cacheNames = "test", cacheManager = "custom")
public void customCacheManager() {
}
@Cacheable(value = "test", cacheResolver = "custom")
@Cacheable(cacheNames = "test", cacheResolver = "custom")
public void customCacheResolver() {
}
@ -279,7 +279,7 @@ public class AnnotationCacheOperationSourceTests {
public void multipleStereotype() {
}
@Caching(cacheable = {@Cacheable(value = "test", key = "a"), @Cacheable(value = "test", key = "b")})
@Caching(cacheable = { @Cacheable(cacheNames = "test", key = "a"), @Cacheable(cacheNames = "test", key = "b") })
public void multipleCaching() {
}
@ -287,7 +287,7 @@ public class AnnotationCacheOperationSourceTests {
public void customKeyGeneratorInherited() {
}
@Cacheable(value = "test", key = "#root.methodName", keyGenerator = "custom")
@Cacheable(cacheNames = "test", key = "#root.methodName", keyGenerator = "custom")
public void invalidKeyAndKeyGeneratorSet() {
}
@ -299,7 +299,7 @@ public class AnnotationCacheOperationSourceTests {
public void customCacheResolverInherited() {
}
@Cacheable(value = "test", cacheManager = "custom", cacheResolver = "custom")
@Cacheable(cacheNames = "test", cacheManager = "custom", cacheResolver = "custom")
public void invalidCacheResolverAndCacheManagerSet() {
}
@ -374,31 +374,31 @@ public class AnnotationCacheOperationSourceTests {
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Cacheable(value = "foo", keyGenerator = "custom")
@Cacheable(cacheNames = "foo", keyGenerator = "custom")
public @interface CacheableFooCustomKeyGenerator {
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Cacheable(value = "foo", cacheManager = "custom")
@Cacheable(cacheNames = "foo", cacheManager = "custom")
public @interface CacheableFooCustomCacheManager {
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Cacheable(value = "foo", cacheResolver = "custom")
@Cacheable(cacheNames = "foo", cacheResolver = "custom")
public @interface CacheableFooCustomCacheResolver {
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@CacheEvict(value = "foo")
@CacheEvict("foo")
public @interface EvictFoo {
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@CacheEvict(value = "bar")
@CacheEvict("bar")
public @interface EvictBar {
}

38
spring-context/src/test/java/org/springframework/cache/config/AnnotatedClassCacheableService.java vendored
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2014 the original author or authors.
* 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.
@ -46,7 +46,7 @@ public class AnnotatedClassCacheableService implements CacheableService<Object>
}
@Override
@Cacheable(value = "testCache", unless = "#result > 10")
@Cacheable(cacheNames = "testCache", unless = "#result > 10")
public Object unless(int arg) {
return arg;
}
@ -63,71 +63,71 @@ public class AnnotatedClassCacheableService implements CacheableService<Object>
}
@Override
@CacheEvict(value = "testCache", allEntries = true)
@CacheEvict(cacheNames = "testCache", allEntries = true)
public void evictAll(Object arg1) {
}
@Override
@CacheEvict(value = "testCache", beforeInvocation = true)
@CacheEvict(cacheNames = "testCache", beforeInvocation = true)
public void evictEarly(Object arg1) {
throw new RuntimeException("exception thrown - evict should still occur");
}
@Override
@CacheEvict(value = "testCache", key = "#p0")
@CacheEvict(cacheNames = "testCache", key = "#p0")
public void evict(Object arg1, Object arg2) {
}
@Override
@CacheEvict(value = "testCache", key = "#p0", beforeInvocation = true)
@CacheEvict(cacheNames = "testCache", key = "#p0", beforeInvocation = true)
public void invalidateEarly(Object arg1, Object arg2) {
throw new RuntimeException("exception thrown - evict should still occur");
}
@Override
@Cacheable(value = "testCache", key = "#p0")
@Cacheable(cacheNames = "testCache", key = "#p0")
public Object key(Object arg1, Object arg2) {
return counter.getAndIncrement();
}
@Override
@Cacheable(value = "testCache")
@Cacheable("testCache")
public Object varArgsKey(Object... args) {
return counter.getAndIncrement();
}
@Override
@Cacheable(value = "testCache", key = "#root.methodName + #root.caches[0].name")
@Cacheable(cacheNames = "testCache", key = "#root.methodName + #root.caches[0].name")
public Object name(Object arg1) {
return counter.getAndIncrement();
}
@Override
@Cacheable(value = "testCache", key = "#root.methodName + #root.method.name + #root.targetClass + #root.target")
@Cacheable(cacheNames = "testCache", key = "#root.methodName + #root.method.name + #root.targetClass + #root.target")
public Object rootVars(Object arg1) {
return counter.getAndIncrement();
}
@Override
@Cacheable(value = "testCache", keyGenerator = "customKyeGenerator")
@Cacheable(cacheNames = "testCache", keyGenerator = "customKyeGenerator")
public Object customKeyGenerator(Object arg1) {
return counter.getAndIncrement();
}
@Override
@Cacheable(value = "testCache", keyGenerator = "unknownBeanName")
@Cacheable(cacheNames = "testCache", keyGenerator = "unknownBeanName")
public Object unknownCustomKeyGenerator(Object arg1) {
return counter.getAndIncrement();
}
@Override
@Cacheable(value = "testCache", cacheManager = "customCacheManager")
@Cacheable(cacheNames = "testCache", cacheManager = "customCacheManager")
public Object customCacheManager(Object arg1) {
return counter.getAndIncrement();
}
@Override
@Cacheable(value = "testCache", cacheManager = "unknownBeanName")
@Cacheable(cacheNames = "testCache", cacheManager = "unknownBeanName")
public Object unknownCustomCacheManager(Object arg1) {
return counter.getAndIncrement();
}
@ -139,7 +139,7 @@ public class AnnotatedClassCacheableService implements CacheableService<Object>
}
@Override
@CachePut(value = "testCache", condition = "#arg.equals(3)")
@CachePut(cacheNames = "testCache", condition = "#arg.equals(3)")
public Object conditionalUpdate(Object arg) {
return arg;
}
@ -174,19 +174,19 @@ public class AnnotatedClassCacheableService implements CacheableService<Object>
}
@Override
@Caching(evict = { @CacheEvict("primary"), @CacheEvict(value = "secondary", key = "#a0"), @CacheEvict(value = "primary", key = "#p0 + 'A'") })
@Caching(evict = { @CacheEvict("primary"), @CacheEvict(cacheNames = "secondary", key = "#a0"), @CacheEvict(cacheNames = "primary", key = "#p0 + 'A'") })
public Object multiEvict(Object arg1) {
return counter.getAndIncrement();
}
@Override
@Caching(cacheable = { @Cacheable(value = "primary", key = "#root.methodName") }, evict = { @CacheEvict("secondary") })
@Caching(cacheable = { @Cacheable(cacheNames = "primary", key = "#root.methodName") }, evict = { @CacheEvict("secondary") })
public Object multiCacheAndEvict(Object arg1) {
return counter.getAndIncrement();
}
@Override
@Caching(cacheable = { @Cacheable(value = "primary", condition = "#a0 == 3") }, evict = { @CacheEvict("secondary") })
@Caching(cacheable = { @Cacheable(cacheNames = "primary", condition = "#a0 == 3") }, evict = { @CacheEvict("secondary") })
public Object multiConditionalCacheAndEvict(Object arg1) {
return counter.getAndIncrement();
}
@ -198,7 +198,7 @@ public class AnnotatedClassCacheableService implements CacheableService<Object>
}
@Override
@CachePut(value="primary", key="#result.id")
@CachePut(cacheNames = "primary", key = "#result.id")
public TestEntity putRefersToResult(TestEntity arg1) {
arg1.setId(Long.MIN_VALUE);
return arg1;

41
spring-context/src/test/java/org/springframework/cache/config/DefaultCacheableService.java vendored
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2014 the original author or authors.
* 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.
@ -53,83 +53,83 @@ public class DefaultCacheableService implements CacheableService<Long> {
}
@Override
@CacheEvict(value = "testCache", allEntries = true)
@CacheEvict(cacheNames = "testCache", allEntries = true)
public void evictAll(Object arg1) {
}
@Override
@CacheEvict(value = "testCache", beforeInvocation = true)
@CacheEvict(cacheNames = "testCache", beforeInvocation = true)
public void evictEarly(Object arg1) {
throw new RuntimeException("exception thrown - evict should still occur");
}
@Override
@CacheEvict(value = "testCache", key = "#p0")
@CacheEvict(cacheNames = "testCache", key = "#p0")
public void evict(Object arg1, Object arg2) {
}
@Override
@CacheEvict(value = "testCache", key = "#p0", beforeInvocation = true)
@CacheEvict(cacheNames = "testCache", key = "#p0", beforeInvocation = true)
public void invalidateEarly(Object arg1, Object arg2) {
throw new RuntimeException("exception thrown - evict should still occur");
}
@Override
@Cacheable(value = "testCache", condition = "#classField == 3")
@Cacheable(cacheNames = "testCache", condition = "#classField == 3")
public Long conditional(int classField) {
return counter.getAndIncrement();
}
@Override
@Cacheable(value = "testCache", unless = "#result > 10")
@Cacheable(cacheNames = "testCache", unless = "#result > 10")
public Long unless(int arg) {
return (long) arg;
}
@Override
@Cacheable(value = "testCache", key = "#p0")
@Cacheable(cacheNames = "testCache", key = "#p0")
public Long key(Object arg1, Object arg2) {
return counter.getAndIncrement();
}
@Override
@Cacheable(value = "testCache")
@Cacheable(cacheNames = "testCache")
public Long varArgsKey(Object... args) {
return counter.getAndIncrement();
}
@Override
@Cacheable(value = "testCache", key = "#root.methodName")
@Cacheable(cacheNames = "testCache", key = "#root.methodName")
public Long name(Object arg1) {
return counter.getAndIncrement();
}
@Override
@Cacheable(value = "testCache", key = "#root.methodName + #root.method.name + #root.targetClass + #root.target")
@Cacheable(cacheNames = "testCache", key = "#root.methodName + #root.method.name + #root.targetClass + #root.target")
public Long rootVars(Object arg1) {
return counter.getAndIncrement();
}
@Override
@Cacheable(value = "testCache", keyGenerator = "customKeyGenerator")
@Cacheable(cacheNames = "testCache", keyGenerator = "customKeyGenerator")
public Long customKeyGenerator(Object arg1) {
return counter.getAndIncrement();
}
@Override
@Cacheable(value = "testCache", keyGenerator = "unknownBeanName")
@Cacheable(cacheNames = "testCache", keyGenerator = "unknownBeanName")
public Long unknownCustomKeyGenerator(Object arg1) {
return counter.getAndIncrement();
}
@Override
@Cacheable(value = "testCache", cacheManager = "customCacheManager")
@Cacheable(cacheNames = "testCache", cacheManager = "customCacheManager")
public Long customCacheManager(Object arg1) {
return counter.getAndIncrement();
}
@Override
@Cacheable(value = "testCache", cacheManager = "unknownBeanName")
@Cacheable(cacheNames = "testCache", cacheManager = "unknownBeanName")
public Long unknownCustomCacheManager(Object arg1) {
return counter.getAndIncrement();
}
@ -141,7 +141,7 @@ public class DefaultCacheableService implements CacheableService<Long> {
}
@Override
@CachePut(value = "testCache", condition = "#arg.equals(3)")
@CachePut(cacheNames = "testCache", condition = "#arg.equals(3)")
public Long conditionalUpdate(Object arg) {
return Long.valueOf(arg.toString());
}
@ -179,19 +179,19 @@ public class DefaultCacheableService implements CacheableService<Long> {
}
@Override
@Caching(evict = { @CacheEvict("primary"), @CacheEvict(value = "secondary", key = "#p0"), @CacheEvict(value = "primary", key = "#p0 + 'A'") })
@Caching(evict = { @CacheEvict("primary"), @CacheEvict(cacheNames = "secondary", key = "#p0"), @CacheEvict(cacheNames = "primary", key = "#p0 + 'A'") })
public Long multiEvict(Object arg1) {
return counter.getAndIncrement();
}
@Override
@Caching(cacheable = { @Cacheable(value = "primary", key = "#root.methodName") }, evict = { @CacheEvict("secondary") })
@Caching(cacheable = { @Cacheable(cacheNames = "primary", key = "#root.methodName") }, evict = { @CacheEvict("secondary") })
public Long multiCacheAndEvict(Object arg1) {
return counter.getAndIncrement();
}
@Override
@Caching(cacheable = { @Cacheable(value = "primary", condition = "#p0 == 3") }, evict = { @CacheEvict("secondary") })
@Caching(cacheable = { @Cacheable(cacheNames = "primary", condition = "#p0 == 3") }, evict = { @CacheEvict("secondary") })
public Long multiConditionalCacheAndEvict(Object arg1) {
return counter.getAndIncrement();
}
@ -203,9 +203,10 @@ public class DefaultCacheableService implements CacheableService<Long> {
}
@Override
@CachePut(value="primary", key="#result.id")
@CachePut(cacheNames = "primary", key = "#result.id")
public TestEntity putRefersToResult(TestEntity arg1) {
arg1.setId(Long.MIN_VALUE);
return arg1;
}
}