Spring/spring-framework
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Consistent early eviction tests in regular and transactional scenarios

Browse Source 
See gh-23192
This commit is contained in:
Juergen Hoeller
2019-07-20 15:05:07 +02:00
parent be65bef91b
commit 8aa0b07768
11 changed files with 290 additions and 243 deletions
Download Patch File Download Diff File Expand all files Collapse all files

313
spring-context/src/test/java/org/springframework/cache/config/AbstractCacheAnnotationTests.java vendored
View File

@@ -79,7 +79,7 @@ public abstract class AbstractCacheAnnotationTests {
}
public void testCacheable(CacheableService<?> service) throws Exception {
public void testCacheable(CacheableService<?> service) {
Object o1 = new Object();
Object r1 = service.cache(o1);
@@ -90,9 +90,9 @@ public abstract class AbstractCacheAnnotationTests {
assertThat(r3).isSameAs(r1);
}
public void testCacheableNull(CacheableService<?> service) throws Exception {
public void testCacheableNull(CacheableService<?> service) {
Object o1 = new Object();
assertThat((Object) this.cm.getCache("testCache").get(o1)).isNull();
assertThat(this.cm.getCache("testCache").get(o1)).isNull();
Object r1 = service.cacheNull(o1);
Object r2 = service.cacheNull(o1);
@@ -105,7 +105,7 @@ public abstract class AbstractCacheAnnotationTests {
assertThat(r3).as("Cached value should be null").isNull();
}
public void testCacheableSync(CacheableService<?> service) throws Exception {
public void testCacheableSync(CacheableService<?> service) {
Object o1 = new Object();
Object r1 = service.cacheSync(o1);
@@ -116,9 +116,9 @@ public abstract class AbstractCacheAnnotationTests {
assertThat(r3).isSameAs(r1);
}
public void testCacheableSyncNull(CacheableService<?> service) throws Exception {
public void testCacheableSyncNull(CacheableService<?> service) {
Object o1 = new Object();
assertThat((Object) this.cm.getCache("testCache").get(o1)).isNull();
assertThat(this.cm.getCache("testCache").get(o1)).isNull();
Object r1 = service.cacheSyncNull(o1);
Object r2 = service.cacheSyncNull(o1);
@@ -131,47 +131,53 @@ public abstract class AbstractCacheAnnotationTests {
assertThat(r3).as("Cached value should be null").isNull();
}
public void testEvict(CacheableService<?> service) throws Exception {
public void testEvict(CacheableService<?> service, boolean successExpected) {
Cache cache = this.cm.getCache("testCache");
Object o1 = new Object();
cache.putIfAbsent(o1, -1L);
Object r1 = service.cache(o1);
Object r2 = service.cache(o1);
assertThat(r2).isSameAs(r1);
service.invalidate(o1);
Object r3 = service.cache(o1);
Object r4 = service.cache(o1);
assertThat(r3).isNotSameAs(r1);
assertThat(r4).isSameAs(r3);
service.evict(o1, null);
if (successExpected) {
assertThat(cache.get(o1)).isNull();
}
else {
assertThat(cache.get(o1)).isNotNull();
}
Object r2 = service.cache(o1);
if (successExpected) {
assertThat(r2).isNotSameAs(r1);
}
else {
assertThat(r2).isSameAs(r1);
}
}
public void testEvictEarly(CacheableService<?> service) throws Exception {
public void testEvictEarly(CacheableService<?> service) {
Cache cache = this.cm.getCache("testCache");
Object o1 = new Object();
cache.putIfAbsent(o1, -1L);
Object r1 = service.cache(o1);
Object r2 = service.cache(o1);
assertThat(r2).isSameAs(r1);
try {
service.evictEarly(o1);
}
catch (RuntimeException ex) {
// expected
}
assertThat(cache.get(o1)).isNull();
Object r3 = service.cache(o1);
Object r4 = service.cache(o1);
assertThat(r3).isNotSameAs(r1);
assertThat(r4).isSameAs(r3);
Object r2 = service.cache(o1);
assertThat(r2).isNotSameAs(r1);
}
public void testEvictException(CacheableService<?> service) throws Exception {
public void testEvictException(CacheableService<?> service) {
Object o1 = new Object();
Object r1 = service.cache(o1);
Object r2 = service.cache(o1);
assertThat(r2).isSameAs(r1);
try {
service.evictWithException(o1);
}
@@ -179,67 +185,95 @@ public abstract class AbstractCacheAnnotationTests {
// expected
}
// exception occurred, eviction skipped, data should still be in the cache
Object r3 = service.cache(o1);
assertThat(r3).isSameAs(r1);
Object r2 = service.cache(o1);
assertThat(r2).isSameAs(r1);
}
public void testEvictWKey(CacheableService<?> service) throws Exception {
public void testEvictWithKey(CacheableService<?> service) {
Object o1 = new Object();
Object r1 = service.cache(o1);
Object r2 = service.cache(o1);
assertThat(r2).isSameAs(r1);
service.evict(o1, null);
Object r3 = service.cache(o1);
Object r4 = service.cache(o1);
assertThat(r3).isNotSameAs(r1);
assertThat(r4).isSameAs(r3);
Object r2 = service.cache(o1);
assertThat(r2).isNotSameAs(r1);
}
public void testEvictWKeyEarly(CacheableService<?> service) throws Exception {
public void testEvictWithKeyEarly(CacheableService<?> service) {
Object o1 = new Object();
Object r1 = service.cache(o1);
Object r2 = service.cache(o1);
assertThat(r2).isSameAs(r1);
try {
service.invalidateEarly(o1, null);
service.evictEarly(o1);
}
catch (Exception ex) {
// expected
}
Object r3 = service.cache(o1);
Object r4 = service.cache(o1);
assertThat(r3).isNotSameAs(r1);
assertThat(r4).isSameAs(r3);
Object r2 = service.cache(o1);
assertThat(r2).isNotSameAs(r1);
}
public void testEvictAll(CacheableService<?> service) throws Exception {
public void testEvictAll(CacheableService<?> service, boolean successExpected) {
Cache cache = this.cm.getCache("testCache");
Object o1 = new Object();
Object o2 = new Object();
cache.putIfAbsent(o1, -1L);
cache.putIfAbsent(o2, -2L);
Object r1 = service.cache(o1);
Object r2 = service.cache(o1);
Object r2 = service.cache(o2);
assertThat(r2).isNotSameAs(r1);
Object o2 = new Object();
Object r10 = service.cache(o2);
assertThat(r2).isSameAs(r1);
assertThat(r10).isNotSameAs(r1);
service.evictAll(new Object());
Cache cache = this.cm.getCache("testCache");
assertThat((Object) cache.get(o1)).isNull();
assertThat((Object) cache.get(o2)).isNull();
if (successExpected) {
assertThat(cache.get(o1)).isNull();
assertThat(cache.get(o2)).isNull();
}
else {
assertThat(cache.get(o1)).isNotNull();
assertThat(cache.get(o2)).isNotNull();
}
Object r3 = service.cache(o1);
Object r4 = service.cache(o1);
assertThat(r3).isNotSameAs(r1);
assertThat(r4).isSameAs(r3);
Object r4 = service.cache(o2);
if (successExpected) {
assertThat(r3).isNotSameAs(r1);
assertThat(r4).isNotSameAs(r2);
}
else {
assertThat(r3).isSameAs(r1);
assertThat(r4).isSameAs(r2);
}
}
public void testConditionalExpression(CacheableService<?> service) throws Exception {
public void testEvictAllEarly(CacheableService<?> service) {
Cache cache = this.cm.getCache("testCache");
Object o1 = new Object();
Object o2 = new Object();
cache.putIfAbsent(o1, -1L);
cache.putIfAbsent(o2, -2L);
Object r1 = service.cache(o1);
Object r2 = service.cache(o2);
assertThat(r2).isNotSameAs(r1);
try {
service.evictAllEarly(new Object());
}
catch (Exception ex) {
// expected
}
assertThat(cache.get(o1)).isNull();
assertThat(cache.get(o2)).isNull();
Object r3 = service.cache(o1);
Object r4 = service.cache(o2);
assertThat(r3).isNotSameAs(r1);
assertThat(r4).isNotSameAs(r2);
}
public void testConditionalExpression(CacheableService<?> service) {
Object r1 = service.conditional(4);
Object r2 = service.conditional(4);
@@ -251,7 +285,7 @@ public abstract class AbstractCacheAnnotationTests {
assertThat(r4).isSameAs(r3);
}
public void testConditionalExpressionSync(CacheableService<?> service) throws Exception {
public void testConditionalExpressionSync(CacheableService<?> service) {
Object r1 = service.conditionalSync(4);
Object r2 = service.conditionalSync(4);
@@ -263,7 +297,7 @@ public abstract class AbstractCacheAnnotationTests {
assertThat(r4).isSameAs(r3);
}
public void testUnlessExpression(CacheableService<?> service) throws Exception {
public void testUnlessExpression(CacheableService<?> service) {
Cache cache = this.cm.getCache("testCache");
cache.clear();
service.unless(10);
@@ -272,7 +306,7 @@ public abstract class AbstractCacheAnnotationTests {
assertThat(cache.get(11)).isNull();
}
public void testKeyExpression(CacheableService<?> service) throws Exception {
public void testKeyExpression(CacheableService<?> service) {
Object r1 = service.key(5, 1);
Object r2 = service.key(5, 2);
@@ -284,7 +318,7 @@ public abstract class AbstractCacheAnnotationTests {
assertThat(r4).isNotSameAs(r3);
}
public void testVarArgsKey(CacheableService<?> service) throws Exception {
public void testVarArgsKey(CacheableService<?> service) {
Object r1 = service.varArgsKey(1, 2, 3);
Object r2 = service.varArgsKey(1, 2, 3);
@@ -297,7 +331,7 @@ public abstract class AbstractCacheAnnotationTests {
}
public void testNullValue(CacheableService<?> service) throws Exception {
public void testNullValue(CacheableService<?> service) {
Object key = new Object();
assertThat(service.nullValue(key)).isNull();
int nr = service.nullInvocations().intValue();
@@ -307,7 +341,7 @@ public abstract class AbstractCacheAnnotationTests {
assertThat(service.nullInvocations().intValue()).isEqualTo(nr + 1);
}
public void testMethodName(CacheableService<?> service, String keyName) throws Exception {
public void testMethodName(CacheableService<?> service, String keyName) {
Object key = new Object();
Object r1 = service.name(key);
assertThat(service.name(key)).isSameAs(r1);
@@ -326,27 +360,27 @@ public abstract class AbstractCacheAnnotationTests {
assertThat(cache.get(expectedKey)).isNotNull();
}
public void testCheckedThrowable(CacheableService<?> service) throws Exception {
public void testCheckedThrowable(CacheableService<?> service) {
String arg = UUID.randomUUID().toString();
assertThatIOException().isThrownBy(() ->
service.throwChecked(arg))
.withMessage(arg);
}
public void testUncheckedThrowable(CacheableService<?> service) throws Exception {
public void testUncheckedThrowable(CacheableService<?> service) {
assertThatExceptionOfType(UnsupportedOperationException.class).isThrownBy(() ->
service.throwUnchecked(1L))
.withMessage("1");
}
public void testCheckedThrowableSync(CacheableService<?> service) throws Exception {
public void testCheckedThrowableSync(CacheableService<?> service) {
String arg = UUID.randomUUID().toString();
assertThatIOException().isThrownBy(() ->
service.throwCheckedSync(arg))
.withMessage(arg);
}
public void testUncheckedThrowableSync(CacheableService<?> service) throws Exception {
public void testUncheckedThrowableSync(CacheableService<?> service) {
assertThatExceptionOfType(UnsupportedOperationException.class).isThrownBy(() ->
service.throwUncheckedSync(1L))
.withMessage("1");
@@ -360,12 +394,12 @@ public abstract class AbstractCacheAnnotationTests {
public void testCacheUpdate(CacheableService<?> service) {
Object o = new Object();
Cache cache = this.cm.getCache("testCache");
assertThat((Object) cache.get(o)).isNull();
assertThat(cache.get(o)).isNull();
Object r1 = service.update(o);
assertThat(cache.get(o).get()).isSameAs(r1);
o = new Object();
assertThat((Object) cache.get(o)).isNull();
assertThat(cache.get(o)).isNull();
Object r2 = service.update(o);
assertThat(cache.get(o).get()).isSameAs(r2);
}
@@ -389,8 +423,8 @@ public abstract class AbstractCacheAnnotationTests {
Cache primary = this.cm.getCache("primary");
Cache secondary = this.cm.getCache("secondary");
assertThat((Object) primary.get(o1)).isNull();
assertThat((Object) secondary.get(o1)).isNull();
assertThat(primary.get(o1)).isNull();
assertThat(secondary.get(o1)).isNull();
Object r1 = service.multiCache(o1);
assertThat(primary.get(o1).get()).isSameAs(r1);
assertThat(secondary.get(o1).get()).isSameAs(r1);
@@ -401,8 +435,8 @@ public abstract class AbstractCacheAnnotationTests {
assertThat(r2).isSameAs(r1);
assertThat(r3).isSameAs(r1);
assertThat((Object) primary.get(o2)).isNull();
assertThat((Object) secondary.get(o2)).isNull();
assertThat(primary.get(o2)).isNull();
assertThat(secondary.get(o2)).isNull();
Object r4 = service.multiCache(o2);
assertThat(primary.get(o2).get()).isSameAs(r4);
assertThat(secondary.get(o2).get()).isSameAs(r4);
@@ -425,9 +459,9 @@ public abstract class AbstractCacheAnnotationTests {
assertThat(secondary.get(o1).get()).isSameAs(r1);
service.multiEvict(o1);
assertThat((Object) primary.get(o1)).isNull();
assertThat((Object) secondary.get(o1)).isNull();
assertThat((Object) primary.get(o2)).isNull();
assertThat(primary.get(o1)).isNull();
assertThat(secondary.get(o1)).isNull();
assertThat(primary.get(o2)).isNull();
Object r3 = service.multiCache(o1);
Object r4 = service.multiCache(o1);
@@ -444,26 +478,26 @@ public abstract class AbstractCacheAnnotationTests {
Cache primary = this.cm.getCache("primary");
Cache secondary = this.cm.getCache("secondary");
assertThat((Object) primary.get(o)).isNull();
assertThat((Object) secondary.get(o)).isNull();
assertThat(primary.get(o)).isNull();
assertThat(secondary.get(o)).isNull();
Object r1 = service.multiUpdate(o);
assertThat(primary.get(o).get()).isSameAs(r1);
assertThat(secondary.get(o).get()).isSameAs(r1);
o = 2;
assertThat((Object) primary.get(o)).isNull();
assertThat((Object) secondary.get(o)).isNull();
assertThat(primary.get(o)).isNull();
assertThat(secondary.get(o)).isNull();
Object r2 = service.multiUpdate(o);
assertThat(primary.get(o).get()).isSameAs(r2);
assertThat(secondary.get(o).get()).isSameAs(r2);
}
public void testPutRefersToResult(CacheableService<?> service) throws Exception {
public void testPutRefersToResult(CacheableService<?> service) {
Long id = Long.MIN_VALUE;
TestEntity entity = new TestEntity();
Cache primary = this.cm.getCache("primary");
assertThat((Object) primary.get(id)).isNull();
assertThat((Object) entity.getId()).isNull();
assertThat(primary.get(id)).isNull();
assertThat(entity.getId()).isNull();
service.putRefersToResult(entity);
assertThat(primary.get(id).get()).isSameAs(entity);
}
@@ -503,7 +537,7 @@ public abstract class AbstractCacheAnnotationTests {
Object r3 = service.multiConditionalCacheAndEvict(key);
assertThat(!r1.equals(r3)).isTrue();
assertThat((Object) primary.get(key)).isNull();
assertThat(primary.get(key)).isNull();
Object key2 = 3;
Object r2 = service.multiConditionalCacheAndEvict(key2);
@@ -515,127 +549,132 @@ public abstract class AbstractCacheAnnotationTests {
}
@Test
public void testCacheable() throws Exception {
public void testCacheable() {
testCacheable(this.cs);
}
@Test
public void testCacheableNull() throws Exception {
public void testCacheableNull() {
testCacheableNull(this.cs);
}
@Test
public void testCacheableSync() throws Exception {
public void testCacheableSync() {
testCacheableSync(this.cs);
}
@Test
public void testCacheableSyncNull() throws Exception {
public void testCacheableSyncNull() {
testCacheableSyncNull(this.cs);
}
@Test
public void testInvalidate() throws Exception {
testEvict(this.cs);
public void testEvict() {
testEvict(this.cs, true);
}
@Test
public void testEarlyInvalidate() throws Exception {
public void testEvictEarly() {
testEvictEarly(this.cs);
}
@Test
public void testEvictWithException() throws Exception {
public void testEvictWithException() {
testEvictException(this.cs);
}
@Test
public void testEvictAll() throws Exception {
testEvictAll(this.cs);
public void testEvictAll() {
testEvictAll(this.cs, true);
}
@Test
public void testInvalidateWithKey() throws Exception {
testEvictWKey(this.cs);
public void testEvictAllEarly() {
testEvictAllEarly(this.cs);
}
@Test
public void testEarlyInvalidateWithKey() throws Exception {
testEvictWKeyEarly(this.cs);
public void testEvictWithKey() {
testEvictWithKey(this.cs);
}
@Test
public void testConditionalExpression() throws Exception {
public void testEvictWithKeyEarly() {
testEvictWithKeyEarly(this.cs);
}
@Test
public void testConditionalExpression() {
testConditionalExpression(this.cs);
}
@Test
public void testConditionalExpressionSync() throws Exception {
public void testConditionalExpressionSync() {
testConditionalExpressionSync(this.cs);
}
@Test
public void testUnlessExpression() throws Exception {
public void testUnlessExpression() {
testUnlessExpression(this.cs);
}
@Test
public void testClassCacheUnlessExpression() throws Exception {
public void testClassCacheUnlessExpression() {
testUnlessExpression(this.cs);
}
@Test
public void testKeyExpression() throws Exception {
public void testKeyExpression() {
testKeyExpression(this.cs);
}
@Test
public void testVarArgsKey() throws Exception {
public void testVarArgsKey() {
testVarArgsKey(this.cs);
}
@Test
public void testClassCacheCacheable() throws Exception {
public void testClassCacheCacheable() {
testCacheable(this.ccs);
}
@Test
public void testClassCacheInvalidate() throws Exception {
testEvict(this.ccs);
public void testClassCacheEvict() {
testEvict(this.ccs, true);
}
@Test
public void testClassEarlyInvalidate() throws Exception {
public void testClassEvictEarly() {
testEvictEarly(this.ccs);
}
@Test
public void testClassEvictAll() throws Exception {
testEvictAll(this.ccs);
public void testClassEvictAll() {
testEvictAll(this.ccs, true);
}
@Test
public void testClassEvictWithException() throws Exception {
public void testClassEvictWithException() {
testEvictException(this.ccs);
}
@Test
public void testClassCacheInvalidateWKey() throws Exception {
testEvictWKey(this.ccs);
public void testClassCacheEvictWithWKey() {
testEvictWithKey(this.ccs);
}
@Test
public void testClassEarlyInvalidateWithKey() throws Exception {
testEvictWKeyEarly(this.ccs);
public void testClassEvictWithKeyEarly() {
testEvictWithKeyEarly(this.ccs);
}
@Test
public void testNullValue() throws Exception {
public void testNullValue() {
testNullValue(this.cs);
}
@Test
public void testClassNullValue() throws Exception {
public void testClassNullValue() {
Object key = new Object();
assertThat(this.ccs.nullValue(key)).isNull();
int nr = this.ccs.nullInvocations().intValue();
@@ -648,22 +687,22 @@ public abstract class AbstractCacheAnnotationTests {
}
@Test
public void testMethodName() throws Exception {
public void testMethodName() {
testMethodName(this.cs, "name");
}
@Test
public void testClassMethodName() throws Exception {
public void testClassMethodName() {
testMethodName(this.ccs, "nametestCache");
}
@Test
public void testRootVars() throws Exception {
public void testRootVars() {
testRootVars(this.cs);
}
@Test
public void testClassRootVars() throws Exception {
public void testClassRootVars() {
testRootVars(this.ccs);
}
@@ -704,52 +743,52 @@ public abstract class AbstractCacheAnnotationTests {
}
@Test
public void testNullArg() throws Exception {
public void testNullArg() {
testNullArg(this.cs);
}
@Test
public void testClassNullArg() throws Exception {
public void testClassNullArg() {
testNullArg(this.ccs);
}
@Test
public void testCheckedException() throws Exception {
public void testCheckedException() {
testCheckedThrowable(this.cs);
}
@Test
public void testClassCheckedException() throws Exception {
public void testClassCheckedException() {
testCheckedThrowable(this.ccs);
}
@Test
public void testCheckedExceptionSync() throws Exception {
public void testCheckedExceptionSync() {
testCheckedThrowableSync(this.cs);
}
@Test
public void testClassCheckedExceptionSync() throws Exception {
public void testClassCheckedExceptionSync() {
testCheckedThrowableSync(this.ccs);
}
@Test
public void testUncheckedException() throws Exception {
public void testUncheckedException() {
testUncheckedThrowable(this.cs);
}
@Test
public void testClassUncheckedException() throws Exception {
public void testClassUncheckedException() {
testUncheckedThrowable(this.ccs);
}
@Test
public void testUncheckedExceptionSync() throws Exception {
public void testUncheckedExceptionSync() {
testUncheckedThrowableSync(this.cs);
}
@Test
public void testClassUncheckedExceptionSync() throws Exception {
public void testClassUncheckedExceptionSync() {
testUncheckedThrowableSync(this.ccs);
}
@@ -804,12 +843,12 @@ public abstract class AbstractCacheAnnotationTests {
}
@Test
public void testPutRefersToResult() throws Exception {
public void testPutRefersToResult() {
testPutRefersToResult(this.cs);
}
@Test
public void testClassPutRefersToResult() throws Exception {
public void testClassPutRefersToResult() {
testPutRefersToResult(this.ccs);
}

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

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2016 the original author or authors.
* Copyright 2002-2019 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.
@@ -36,6 +36,7 @@ public class AnnotatedClassCacheableService implements CacheableService<Object>
public static final AtomicLong nullInvocations = new AtomicLong();
@Override
public Object cache(Object arg1) {
return this.counter.getAndIncrement();
@@ -75,8 +76,8 @@ public class AnnotatedClassCacheableService implements CacheableService<Object>
}
@Override
@CacheEvict("testCache")
public void invalidate(Object arg1) {
@CacheEvict(cacheNames = "testCache", key = "#p0")
public void evict(Object arg1, Object arg2) {
}
@Override
@@ -85,11 +86,6 @@ public class AnnotatedClassCacheableService implements CacheableService<Object>
throw new RuntimeException("exception thrown - evict should NOT occur");
}
@Override
@CacheEvict(cacheNames = "testCache", allEntries = true)
public void evictAll(Object arg1) {
}
@Override
@CacheEvict(cacheNames = "testCache", beforeInvocation = true)
public void evictEarly(Object arg1) {
@@ -97,13 +93,13 @@ public class AnnotatedClassCacheableService implements CacheableService<Object>
}
@Override
@CacheEvict(cacheNames = "testCache", key = "#p0")
public void evict(Object arg1, Object arg2) {
@CacheEvict(cacheNames = "testCache", allEntries = true)
public void evictAll(Object arg1) {
}
@Override
@CacheEvict(cacheNames = "testCache", key = "#p0", beforeInvocation = true)
public void invalidateEarly(Object arg1, Object arg2) {
@CacheEvict(cacheNames = "testCache", allEntries = true, beforeInvocation = true)
public void evictAllEarly(Object arg1) {
throw new RuntimeException("exception thrown - evict should still occur");
}
@@ -238,4 +234,5 @@ public class AnnotatedClassCacheableService implements CacheableService<Object>
arg1.setId(Long.MIN_VALUE);
return arg1;
}
}

2
spring-context/src/test/java/org/springframework/cache/config/CacheAdviceNamespaceTests.java vendored
View File

@@ -37,7 +37,7 @@ public class CacheAdviceNamespaceTests extends AbstractCacheAnnotationTests {
}
@Test
public void testKeyStrategy() throws Exception {
public void testKeyStrategy() {
CacheInterceptor bean = this.ctx.getBean("cacheAdviceClass", CacheInterceptor.class);
assertThat(bean.getKeyGenerator()).isSameAs(this.ctx.getBean("keyGenerator"));
}

12
spring-context/src/test/java/org/springframework/cache/config/CacheableService.java vendored
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2017 the original author or authors.
* Copyright 2002-2019 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,17 +33,15 @@ public interface CacheableService<T> {
T cacheSyncNull(Object arg1);
void invalidate(Object arg1);
void evict(Object arg1, Object arg2);
void evictWithException(Object arg1);
void evictEarly(Object arg1);
void evictAll(Object arg1);
void evictWithException(Object arg1);
void evict(Object arg1, Object arg2);
void invalidateEarly(Object arg1, Object arg2);
void evictAllEarly(Object arg1);
T conditional(int field);

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

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2017 the original author or authors.
* Copyright 2002-2019 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.
@@ -63,8 +63,8 @@ public class DefaultCacheableService implements CacheableService<Long> {
}
@Override
@CacheEvict("testCache")
public void invalidate(Object arg1) {
@CacheEvict(cacheNames = "testCache", key = "#p0")
public void evict(Object arg1, Object arg2) {
}
@Override
@@ -73,11 +73,6 @@ public class DefaultCacheableService implements CacheableService<Long> {
throw new RuntimeException("exception thrown - evict should NOT occur");
}
@Override
@CacheEvict(cacheNames = "testCache", allEntries = true)
public void evictAll(Object arg1) {
}
@Override
@CacheEvict(cacheNames = "testCache", beforeInvocation = true)
public void evictEarly(Object arg1) {
@@ -85,13 +80,13 @@ public class DefaultCacheableService implements CacheableService<Long> {
}
@Override
@CacheEvict(cacheNames = "testCache", key = "#p0")
public void evict(Object arg1, Object arg2) {
@CacheEvict(cacheNames = "testCache", allEntries = true)
public void evictAll(Object arg1) {
}
@Override
@CacheEvict(cacheNames = "testCache", key = "#p0", beforeInvocation = true)
public void invalidateEarly(Object arg1, Object arg2) {
@CacheEvict(cacheNames = "testCache", allEntries = true, beforeInvocation = true)
public void evictAllEarly(Object arg1) {
throw new RuntimeException("exception thrown - evict should still occur");
}