Merge branch '5.2.x'

# Conflicts:
#	spring-jdbc/src/test/java/org/springframework/jdbc/core/JdbcTemplateQueryTests.java
#	spring-jdbc/src/test/java/org/springframework/jdbc/core/namedparam/NamedParameterJdbcTemplateTests.java

spring-context/src/main/java/org/springframework/cache/concurrent/ConcurrentMapCache.java

@@ -16,9 +16,6 @@
 
 package org.springframework.cache.concurrent;
 
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
 import java.util.concurrent.Callable;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
@@ -45,6 +42,7 @@ import org.springframework.util.Assert;
  * @author Juergen Hoeller
  * @author Stephane Nicoll
  * @since 3.1
+ * @see ConcurrentMapCacheManager
  */
 public class ConcurrentMapCache extends AbstractValueAdaptingCache {
 
@@ -190,7 +188,7 @@ public class ConcurrentMapCache extends AbstractValueAdaptingCache {
 		Object storeValue = super.toStoreValue(userValue);
 		if (this.serialization != null) {
 			try {
-				return serializeValue(this.serialization, storeValue);
+				return this.serialization.serializeToByteArray(storeValue);
 			}
 			catch (Throwable ex) {
 				throw new IllegalArgumentException("Failed to serialize cache value '" + userValue +
@@ -202,17 +200,11 @@ public class ConcurrentMapCache extends AbstractValueAdaptingCache {
 		}
 	}
 
-	private static Object serializeValue(SerializationDelegate serialization, Object storeValue) throws IOException {
-		ByteArrayOutputStream out = new ByteArrayOutputStream();
-		serialization.serialize(storeValue, out);
-		return out.toByteArray();
-	}
-
 	@Override
 	protected Object fromStoreValue(@Nullable Object storeValue) {
 		if (storeValue != null && this.serialization != null) {
 			try {
-				return super.fromStoreValue(deserializeValue(this.serialization, storeValue));
+				return super.fromStoreValue(this.serialization.deserializeFromByteArray((byte[]) storeValue));
 			}
 			catch (Throwable ex) {
 				throw new IllegalArgumentException("Failed to deserialize cache value '" + storeValue + "'", ex);
@@ -221,12 +213,6 @@ public class ConcurrentMapCache extends AbstractValueAdaptingCache {
 		else {
 			return super.fromStoreValue(storeValue);
 		}
-
-	}
-
-	private static Object deserializeValue(SerializationDelegate serialization, Object storeValue) throws IOException {
-		ByteArrayInputStream in = new ByteArrayInputStream((byte[]) storeValue);
-		return serialization.deserialize(in);
 	}
 
 }

spring-context/src/main/java/org/springframework/cache/concurrent/ConcurrentMapCacheManager.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 the original author or authors.
+ * Copyright 2002-2020 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.
@@ -190,9 +190,7 @@ public class ConcurrentMapCacheManager implements CacheManager, BeanClassLoaderA
 	 */
 	protected Cache createConcurrentMapCache(String name) {
 		SerializationDelegate actualSerialization = (isStoreByValue() ? this.serialization : null);
-		return new ConcurrentMapCache(name, new ConcurrentHashMap<>(256),
-				isAllowNullValues(), actualSerialization);
-
+		return new ConcurrentMapCache(name, new ConcurrentHashMap<>(256), isAllowNullValues(), actualSerialization);
 	}
 
 }

spring-context/src/main/java/org/springframework/cache/interceptor/CacheAspectSupport.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2019 the original author or authors.
+ * Copyright 2002-2020 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,6 +52,7 @@ import org.springframework.util.CollectionUtils;
 import org.springframework.util.LinkedMultiValueMap;
 import org.springframework.util.MultiValueMap;
 import org.springframework.util.ObjectUtils;
+import org.springframework.util.ReflectionUtils;
 import org.springframework.util.StringUtils;
 import org.springframework.util.function.SingletonSupplier;
 import org.springframework.util.function.SupplierUtils;
@@ -382,9 +383,9 @@ public abstract class CacheAspectSupport extends AbstractCacheInvoker
 					return wrapCacheValue(method, cache.get(key, () -> unwrapReturnValue(invokeOperation(invoker))));
 				}
 				catch (Cache.ValueRetrievalException ex) {
-					// The invoker wraps any Throwable in a ThrowableWrapper instance so we
-					// can just make sure that one bubbles up the stack.
-					throw (CacheOperationInvoker.ThrowableWrapper) ex.getCause();
+					// Directly propagate ThrowableWrapper from the invoker,
+					// or potentially also an IllegalArgumentException etc.
+					ReflectionUtils.rethrowRuntimeException(ex.getCause());
 				}
 			}
 			else {

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2019 the original author or authors.
+ * Copyright 2002-2020 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.
@@ -30,6 +30,7 @@ import org.springframework.util.Assert;
  * @author Costin Leau
  * @author Stephane Nicoll
  * @since 4.3.4
+ * @see NoOpCacheManager
  */
 public class NoOpCache implements Cache {
 

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2016 the original author or authors.
+ * Copyright 2002-2020 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.
@@ -37,7 +37,7 @@ import org.springframework.lang.Nullable;
  * @author Costin Leau
  * @author Stephane Nicoll
  * @since 3.1
- * @see CompositeCacheManager
+ * @see NoOpCache
  */
 public class NoOpCacheManager implements CacheManager {
 

spring-context/src/test/java/org/springframework/cache/CacheReproTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2019 the original author or authors.
+ * Copyright 2002-2020 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.
@@ -393,7 +393,6 @@ public class CacheReproTests {
 		public TestBean insertItem(TestBean item) {
 			return item;
 		}
-
 	}
 
 

spring-context/src/test/java/org/springframework/cache/concurrent/ConcurrentMapCacheManagerTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2019 the original author or authors.
+ * Copyright 2002-2020 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,18 +33,15 @@ public class ConcurrentMapCacheManagerTests {
 	public void testDynamicMode() {
 		CacheManager cm = new ConcurrentMapCacheManager();
 		Cache cache1 = cm.getCache("c1");
-		boolean condition2 = cache1 instanceof ConcurrentMapCache;
-		assertThat(condition2).isTrue();
+		assertThat(cache1 instanceof ConcurrentMapCache).isTrue();
 		Cache cache1again = cm.getCache("c1");
 		assertThat(cache1).isSameAs(cache1again);
 		Cache cache2 = cm.getCache("c2");
-		boolean condition1 = cache2 instanceof ConcurrentMapCache;
-		assertThat(condition1).isTrue();
+		assertThat(cache2 instanceof ConcurrentMapCache).isTrue();
 		Cache cache2again = cm.getCache("c2");
 		assertThat(cache2).isSameAs(cache2again);
 		Cache cache3 = cm.getCache("c3");
-		boolean condition = cache3 instanceof ConcurrentMapCache;
-		assertThat(condition).isTrue();
+		assertThat(cache3 instanceof ConcurrentMapCache).isTrue();
 		Cache cache3again = cm.getCache("c3");
 		assertThat(cache3).isSameAs(cache3again);
 
@@ -74,13 +71,11 @@ public class ConcurrentMapCacheManagerTests {
 	public void testStaticMode() {
 		ConcurrentMapCacheManager cm = new ConcurrentMapCacheManager("c1", "c2");
 		Cache cache1 = cm.getCache("c1");
-		boolean condition3 = cache1 instanceof ConcurrentMapCache;
-		assertThat(condition3).isTrue();
+		assertThat(cache1 instanceof ConcurrentMapCache).isTrue();
 		Cache cache1again = cm.getCache("c1");
 		assertThat(cache1).isSameAs(cache1again);
 		Cache cache2 = cm.getCache("c2");
-		boolean condition2 = cache2 instanceof ConcurrentMapCache;
-		assertThat(condition2).isTrue();
+		assertThat(cache2 instanceof ConcurrentMapCache).isTrue();
 		Cache cache2again = cm.getCache("c2");
 		assertThat(cache2).isSameAs(cache2again);
 		Cache cache3 = cm.getCache("c3");
@@ -97,12 +92,10 @@ public class ConcurrentMapCacheManagerTests {
 
 		cm.setAllowNullValues(false);
 		Cache cache1x = cm.getCache("c1");
-		boolean condition1 = cache1x instanceof ConcurrentMapCache;
-		assertThat(condition1).isTrue();
+		assertThat(cache1x instanceof ConcurrentMapCache).isTrue();
 		assertThat(cache1x != cache1).isTrue();
 		Cache cache2x = cm.getCache("c2");
-		boolean condition = cache2x instanceof ConcurrentMapCache;
-		assertThat(condition).isTrue();
+		assertThat(cache2x instanceof ConcurrentMapCache).isTrue();
 		assertThat(cache2x != cache2).isTrue();
 		Cache cache3x = cm.getCache("c3");
 		assertThat(cache3x).isNull();
@@ -126,16 +119,14 @@ public class ConcurrentMapCacheManagerTests {
 		ConcurrentMapCacheManager cm = new ConcurrentMapCacheManager("c1", "c2");
 		assertThat(cm.isStoreByValue()).isFalse();
 		Cache cache1 = cm.getCache("c1");
-		boolean condition1 = cache1 instanceof ConcurrentMapCache;
-		assertThat(condition1).isTrue();
-		assertThat(((ConcurrentMapCache)cache1).isStoreByValue()).isFalse();
+		assertThat(cache1 instanceof ConcurrentMapCache).isTrue();
+		assertThat(((ConcurrentMapCache) cache1).isStoreByValue()).isFalse();
 		cache1.put("key", "value");
 
 		cm.setStoreByValue(true);
 		assertThat(cm.isStoreByValue()).isTrue();
 		Cache cache1x = cm.getCache("c1");
-		boolean condition = cache1x instanceof ConcurrentMapCache;
-		assertThat(condition).isTrue();
+		assertThat(cache1x instanceof ConcurrentMapCache).isTrue();
 		assertThat(cache1x != cache1).isTrue();
 		assertThat(cache1x.get("key")).isNull();
 	}

spring-context/src/test/java/org/springframework/cache/concurrent/ConcurrentMapCacheTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2019 the original author or authors.
+ * Copyright 2002-2020 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,8 +36,7 @@ import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException
  * @author Juergen Hoeller
  * @author Stephane Nicoll
  */
-public class ConcurrentMapCacheTests
-		extends AbstractValueAdaptingCacheTests<ConcurrentMapCache> {
+public class ConcurrentMapCacheTests extends AbstractValueAdaptingCacheTests<ConcurrentMapCache> {
 
 	protected ConcurrentMap<Object, Object> nativeCache;
 
@@ -49,12 +48,11 @@ public class ConcurrentMapCacheTests
 
 
 	@BeforeEach
-	public void setUp() throws Exception {
+	public void setup() {
 		this.nativeCache = new ConcurrentHashMap<>();
 		this.cache = new ConcurrentMapCache(CACHE_NAME, this.nativeCache, true);
 		this.nativeCacheNoNull = new ConcurrentHashMap<>();
-		this.cacheNoNull = new ConcurrentMapCache(CACHE_NAME_NO_NULL,
-				this.nativeCacheNoNull, false);
+		this.cacheNoNull = new ConcurrentMapCache(CACHE_NAME_NO_NULL, this.nativeCacheNoNull, false);
 		this.cache.clear();
 	}
 
@@ -73,6 +71,7 @@ public class ConcurrentMapCacheTests
 		return this.nativeCache;
 	}
 
+
 	@Test
 	public void testIsStoreByReferenceByDefault() {
 		assertThat(this.cache.isStoreByValue()).isFalse();