Consistently use instanceof pattern variable.

arefbehboudi · mp911de · commit 85434a3ceb50 · 2024-08-20T10:25:47.000+02:00
Closes #2967 Original pull request: #2971
diff --git a/src/test/java/org/springframework/data/redis/connection/AbstractConnectionUnitTestBase.java b/src/test/java/org/springframework/data/redis/connection/AbstractConnectionUnitTestBase.java
@@ -55,8 +55,7 @@ private Class<T> resolveReturnedClassFromGernericType() {
 	private ParameterizedType resolveReturnedClassFromGernericType(Class<?> clazz) {
 
 		Object genericSuperclass = clazz.getGenericSuperclass();
-		if (genericSuperclass instanceof ParameterizedType) {
-			ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass;
+		if (genericSuperclass instanceof ParameterizedType parameterizedType) {
 			Type rawtype = parameterizedType.getRawType();
 			if (AbstractConnectionUnitTestBase.class.equals(rawtype)) {
 				return parameterizedType;
diff --git a/src/test/java/org/springframework/data/redis/connection/lettuce/LettuceReactiveClusterTestSupport.java b/src/test/java/org/springframework/data/redis/connection/lettuce/LettuceReactiveClusterTestSupport.java
@@ -52,12 +52,12 @@ public void tearDown() {
 		if (nativeCommands != null) {
 			nativeCommands.flushall();
 
-			if (nativeCommands instanceof RedisCommands) {
-				((RedisCommands) nativeCommands).getStatefulConnection().close();
+			if (nativeCommands instanceof RedisCommands redisCommands) {
+				redisCommands.getStatefulConnection().close();
 			}
 
-			if (nativeCommands instanceof RedisAdvancedClusterCommands) {
-				((RedisAdvancedClusterCommands) nativeCommands).getStatefulConnection().close();
+			if (nativeCommands instanceof RedisAdvancedClusterCommands redisAdvancedClusterCommands) {
+				redisAdvancedClusterCommands.getStatefulConnection().close();
 			}
 		}
 
diff --git a/src/test/java/org/springframework/data/redis/connection/lettuce/LettuceReactiveCommandsTestSupport.java b/src/test/java/org/springframework/data/redis/connection/lettuce/LettuceReactiveCommandsTestSupport.java
@@ -155,16 +155,16 @@ public String toString() {
 		public void close() throws IOException {
 
 			try {
-				if (connectionProvider instanceof DisposableBean) {
-					((DisposableBean) connectionProvider).destroy();
+				if (connectionProvider instanceof DisposableBean disposableBean) {
+					disposableBean.destroy();
 				}
 
-				if (nativeConnectionProvider instanceof DisposableBean) {
-					((DisposableBean) nativeConnectionProvider).destroy();
+				if (nativeConnectionProvider instanceof DisposableBean disposableBean) {
+					disposableBean.destroy();
 				}
 
-				if (nativeBinaryConnectionProvider instanceof DisposableBean) {
-					((DisposableBean) nativeBinaryConnectionProvider).destroy();
+				if (nativeBinaryConnectionProvider instanceof DisposableBean disposableBean) {
+					disposableBean.destroy();
 				}
 			} catch (Exception ex) {
 				throw new RuntimeException(ex);
@@ -198,21 +198,21 @@ public void tearDown() {
 		if (nativeCommands != null) {
 			flushAll();
 
-			if (nativeCommands instanceof RedisCommands) {
-				nativeConnectionProvider.release(((RedisCommands) nativeCommands).getStatefulConnection());
+			if (nativeCommands instanceof RedisCommands redisCommands) {
+				nativeConnectionProvider.release((redisCommands).getStatefulConnection());
 			}
 
-			if (nativeCommands instanceof RedisAdvancedClusterCommands) {
-				nativeConnectionProvider.release(((RedisAdvancedClusterCommands) nativeCommands).getStatefulConnection());
+			if (nativeCommands instanceof RedisAdvancedClusterCommands redisAdvancedClusterCommands) {
+				nativeConnectionProvider.release((redisAdvancedClusterCommands).getStatefulConnection());
 			}
 
-			if (nativeBinaryCommands instanceof RedisCommands) {
-				nativeBinaryConnectionProvider.release(((RedisCommands) nativeBinaryCommands).getStatefulConnection());
+			if (nativeBinaryCommands instanceof RedisCommands redisCommands) {
+				nativeBinaryConnectionProvider.release((redisCommands).getStatefulConnection());
 			}
 
-			if (nativeBinaryCommands instanceof RedisAdvancedClusterCommands) {
+			if (nativeBinaryCommands instanceof RedisAdvancedClusterCommands redisAdvancedClusterCommands) {
 				nativeBinaryConnectionProvider
-						.release(((RedisAdvancedClusterCommands) nativeBinaryCommands).getStatefulConnection());
+						.release((redisAdvancedClusterCommands).getStatefulConnection());
 			}
 		}
 
diff --git a/src/test/java/org/springframework/data/redis/core/convert/DefaultRedisTypeMapperUnitTests.java b/src/test/java/org/springframework/data/redis/core/convert/DefaultRedisTypeMapperUnitTests.java
@@ -215,7 +215,7 @@ private void writesTypeToField(Bucket bucket, Class<?> type, @Nullable Object va
 			assertThat(bucket.keySet()).isEmpty();
 		} else {
 
-			byte[] expected = value instanceof Class ? ((Class) value).getName().getBytes() : value.toString().getBytes();
+			byte[] expected = value instanceof Class javaClass ? javaClass.getName().getBytes() : value.toString().getBytes();
 
 			assertThat(bucket.asMap()).containsKey(DefaultRedisTypeMapper.DEFAULT_TYPE_KEY);
 			assertThat(bucket.get(DefaultRedisTypeMapper.DEFAULT_TYPE_KEY)).isEqualTo(expected);
diff --git a/src/test/java/org/springframework/data/redis/listener/PubSubAwaitUtil.java b/src/test/java/org/springframework/data/redis/listener/PubSubAwaitUtil.java
@@ -87,8 +87,8 @@ public static void runAndAwaitChannelSubscription(RedisConnectionFactory connect
 
 	private static long numPat(RedisConnection connection) {
 
-		if (connection instanceof LettuceConnection) {
-			return ((Number) ((LettuceConnection) connection).execute("PUBSUB", new IntegerOutput<>(ByteArrayCodec.INSTANCE),
+		if (connection instanceof LettuceConnection lettuceConnection) {
+			return ((Number) lettuceConnection.execute("PUBSUB", new IntegerOutput<>(ByteArrayCodec.INSTANCE),
 					"NUMPAT".getBytes())).longValue();
 		}
 
@@ -98,8 +98,8 @@ private static long numPat(RedisConnection connection) {
 	private static long numSub(RedisConnection connection, String channel) {
 
 		List<?> pubsub;
-		if (connection instanceof LettuceConnection) {
-			pubsub = (List<?>) ((LettuceConnection) connection).execute("PUBSUB", new ArrayOutput<>(ByteArrayCodec.INSTANCE),
+		if (connection instanceof LettuceConnection lettuceConnection) {
+			pubsub = (List<?>) lettuceConnection.execute("PUBSUB", new ArrayOutput<>(ByteArrayCodec.INSTANCE),
 					"NUMSUB".getBytes(), channel.getBytes());
 		} else {
 			pubsub = (List<?>) connection.execute("PUBSUB", "NUMSUB".getBytes(), channel.getBytes());
diff --git a/src/test/java/org/springframework/data/redis/listener/PubSubResubscribeTests.java b/src/test/java/org/springframework/data/redis/listener/PubSubResubscribeTests.java
@@ -236,10 +236,10 @@ private static boolean clusterAvailable() {
 
 	private static boolean isClusterAware(RedisConnectionFactory connectionFactory) {
 
-		if (connectionFactory instanceof LettuceConnectionFactory) {
-			return ((LettuceConnectionFactory) connectionFactory).isClusterAware();
-		} else if (connectionFactory instanceof JedisConnectionFactory) {
-			return ((JedisConnectionFactory) connectionFactory).isRedisClusterAware();
+		if (connectionFactory instanceof LettuceConnectionFactory lettuceConnectionFactory) {
+			return lettuceConnectionFactory.isClusterAware();
+		} else if (connectionFactory instanceof JedisConnectionFactory jedisConnectionFactory) {
+			return jedisConnectionFactory.isRedisClusterAware();
 		}
 		return false;
 	}
diff --git a/src/test/java/org/springframework/data/redis/listener/PubSubTests.java b/src/test/java/org/springframework/data/redis/listener/PubSubTests.java
@@ -170,10 +170,10 @@ void testStartListenersToNoSpecificChannelTest() {
 
 	private static boolean isClusterAware(RedisConnectionFactory connectionFactory) {
 
-		if (connectionFactory instanceof LettuceConnectionFactory) {
-			return ((LettuceConnectionFactory) connectionFactory).isClusterAware();
-		} else if (connectionFactory instanceof JedisConnectionFactory) {
-			return ((JedisConnectionFactory) connectionFactory).isRedisClusterAware();
+		if (connectionFactory instanceof LettuceConnectionFactory lettuceConnectionFactory) {
+			return lettuceConnectionFactory.isClusterAware();
+		} else if (connectionFactory instanceof JedisConnectionFactory jedisConnectionFactory) {
+			return jedisConnectionFactory.isRedisClusterAware();
 		}
 		return false;
 	}
diff --git a/src/test/java/org/springframework/data/redis/mapping/Jackson2HashMapperIntegrationTests.java b/src/test/java/org/springframework/data/redis/mapping/Jackson2HashMapperIntegrationTests.java
@@ -54,8 +54,8 @@ public class Jackson2HashMapperIntegrationTests {
 	public Jackson2HashMapperIntegrationTests(RedisConnectionFactory factory) throws Exception {
 
 		this.factory = factory;
-		if (factory instanceof InitializingBean) {
-			((InitializingBean) factory).afterPropertiesSet();
+		if (factory instanceof InitializingBean initializingBean) {
+			initializingBean.afterPropertiesSet();
 		}
 	}
 
diff --git a/src/test/java/org/springframework/data/redis/repository/cdi/Person.java b/src/test/java/org/springframework/data/redis/repository/cdi/Person.java
@@ -50,11 +50,9 @@ public void setName(String name) {
 	public boolean equals(@Nullable Object o) {
 		if (this == o)
 			return true;
-		if (!(o instanceof Person))
+		if (!(o instanceof Person person))
 			return false;
 
-		Person person = (Person) o;
-
 		if (id != null ? !id.equals(person.id) : person.id != null)
 			return false;
 		return name != null ? name.equals(person.name) : person.name == null;
diff --git a/src/test/java/org/springframework/data/redis/repository/cdi/RedisCdiDependenciesProducer.java b/src/test/java/org/springframework/data/redis/repository/cdi/RedisCdiDependenciesProducer.java
@@ -63,8 +63,8 @@ public RedisOperations<byte[], byte[]> redisOperationsProducerQualified(RedisOpe
 
 	public void closeRedisOperations(@Disposes RedisOperations<byte[], byte[]> redisOperations) throws Exception {
 
-		if (redisOperations instanceof DisposableBean) {
-			((DisposableBean) redisOperations).destroy();
+		if (redisOperations instanceof DisposableBean disposableBean) {
+			disposableBean.destroy();
 		}
 	}
 
diff --git a/src/test/java/org/springframework/data/redis/serializer/GenericJackson2JsonRedisSerializerUnitTests.java b/src/test/java/org/springframework/data/redis/serializer/GenericJackson2JsonRedisSerializerUnitTests.java
@@ -572,10 +572,9 @@ public boolean equals(@Nullable Object obj) {
 			if (obj == null) {
 				return false;
 			}
-			if (!(obj instanceof SimpleObject)) {
+			if (!(obj instanceof SimpleObject other)) {
 				return false;
 			}
-			SimpleObject other = (SimpleObject) obj;
 			return nullSafeEquals(this.longValue, other.longValue);
 		}
 	}
diff --git a/src/test/java/org/springframework/data/redis/stream/AbstractStreamMessageListenerContainerIntegrationTests.java b/src/test/java/org/springframework/data/redis/stream/AbstractStreamMessageListenerContainerIntegrationTests.java
@@ -395,9 +395,9 @@ private int getNumberOfPending(String stream, String group) {
 
 		RedisConnection connection = connectionFactory.getConnection();
 
-		if (connection instanceof LettuceConnection) {
+		if (connection instanceof LettuceConnection lettuceConnection) {
 
-			String value = ((List) ((LettuceConnection) connectionFactory.getConnection()).execute("XPENDING",
+			String value = ((List) lettuceConnection.execute("XPENDING",
 					new NestedMultiOutput<>(StringCodec.UTF8), new byte[][] { stream.getBytes(), group.getBytes() })).get(0)
 							.toString();
 			return NumberUtils.parseNumber(value, Integer.class);
diff --git a/src/test/java/org/springframework/data/redis/support/BoundKeyOperationsIntegrationTests.java b/src/test/java/org/springframework/data/redis/support/BoundKeyOperationsIntegrationTests.java
@@ -119,14 +119,14 @@ void testPersist() throws Exception {
 
 	@SuppressWarnings({ "unchecked", "rawtypes" })
 	private void populateBoundKey() {
-		if (keyOps instanceof Collection) {
-			((Collection) keyOps).add("dummy");
-		} else if (keyOps instanceof Map) {
-			((Map) keyOps).put("dummy", "dummy");
-		} else if (keyOps instanceof RedisAtomicInteger) {
-			((RedisAtomicInteger) keyOps).set(42);
-		} else if (keyOps instanceof RedisAtomicLong) {
-			((RedisAtomicLong) keyOps).set(42L);
+		if (keyOps instanceof Collection collection) {
+			collection.add("dummy");
+		} else if (keyOps instanceof Map map) {
+			map.put("dummy", "dummy");
+		} else if (keyOps instanceof RedisAtomicInteger redisAtomicInteger) {
+			redisAtomicInteger.set(42);
+		} else if (keyOps instanceof RedisAtomicLong redisAtomicLong) {
+			redisAtomicLong.set(42L);
 		}
 	}
 }
diff --git a/src/test/java/org/springframework/data/redis/test/util/CollectionAwareComparator.java b/src/test/java/org/springframework/data/redis/test/util/CollectionAwareComparator.java
@@ -34,10 +34,7 @@ public enum CollectionAwareComparator implements Comparator<Object> {
 	@Override
 	public int compare(Object o1, Object o2) {
 
-		if (o1 instanceof Collection && o2 instanceof Collection) {
-
-			Collection<?> c1 = (Collection<?>) o1;
-			Collection<?> c2 = (Collection<?>) o2;
+		if (o1 instanceof Collection<?> c1 && o2 instanceof Collection<?> c2) {
 
 			if (c1.size() != c2.size()) {
 				return 1;

Original file line number	Diff line number	Diff line change
`@@ -52,12 +52,12 @@ public void tearDown() {`
`52`	`52`	`if (nativeCommands != null) {`
`53`	`53`	`nativeCommands.flushall();`
`54`	`54`
`55`		`- if (nativeCommands instanceof RedisCommands) {`
`56`		`- ((RedisCommands) nativeCommands).getStatefulConnection().close();`
	`55`	`+ if (nativeCommands instanceof RedisCommands redisCommands) {`
	`56`	`+ redisCommands.getStatefulConnection().close();`
`57`	`57`	`}`
`58`	`58`
`59`		`- if (nativeCommands instanceof RedisAdvancedClusterCommands) {`
`60`		`- ((RedisAdvancedClusterCommands) nativeCommands).getStatefulConnection().close();`
	`59`	`+ if (nativeCommands instanceof RedisAdvancedClusterCommands redisAdvancedClusterCommands) {`
	`60`	`+ redisAdvancedClusterCommands.getStatefulConnection().close();`
`61`	`61`	`}`
`62`	`62`	`}`
`63`	`63`
Original file line number	Diff line number	Diff line change
`@@ -155,16 +155,16 @@ public String toString() {`
`155`	`155`	`public void close() throws IOException {`
`156`	`156`
`157`	`157`	`try {`
`158`		`- if (connectionProvider instanceof DisposableBean) {`
`159`		`- ((DisposableBean) connectionProvider).destroy();`
	`158`	`+ if (connectionProvider instanceof DisposableBean disposableBean) {`
	`159`	`+ disposableBean.destroy();`
`160`	`160`	`}`
`161`	`161`
`162`		`- if (nativeConnectionProvider instanceof DisposableBean) {`
`163`		`- ((DisposableBean) nativeConnectionProvider).destroy();`
	`162`	`+ if (nativeConnectionProvider instanceof DisposableBean disposableBean) {`
	`163`	`+ disposableBean.destroy();`
`164`	`164`	`}`
`165`	`165`
`166`		`- if (nativeBinaryConnectionProvider instanceof DisposableBean) {`
`167`		`- ((DisposableBean) nativeBinaryConnectionProvider).destroy();`
	`166`	`+ if (nativeBinaryConnectionProvider instanceof DisposableBean disposableBean) {`
	`167`	`+ disposableBean.destroy();`
`168`	`168`	`}`
`169`	`169`	`} catch (Exception ex) {`
`170`	`170`	`throw new RuntimeException(ex);`
`@@ -198,21 +198,21 @@ public void tearDown() {`
`198`	`198`	`if (nativeCommands != null) {`
`199`	`199`	`flushAll();`
`200`	`200`
`201`		`- if (nativeCommands instanceof RedisCommands) {`
`202`		`- nativeConnectionProvider.release(((RedisCommands) nativeCommands).getStatefulConnection());`
	`201`	`+ if (nativeCommands instanceof RedisCommands redisCommands) {`
	`202`	`+ nativeConnectionProvider.release((redisCommands).getStatefulConnection());`
`203`	`203`	`}`
`204`	`204`
`205`		`- if (nativeCommands instanceof RedisAdvancedClusterCommands) {`
`206`		`- nativeConnectionProvider.release(((RedisAdvancedClusterCommands) nativeCommands).getStatefulConnection());`
	`205`	`+ if (nativeCommands instanceof RedisAdvancedClusterCommands redisAdvancedClusterCommands) {`
	`206`	`+ nativeConnectionProvider.release((redisAdvancedClusterCommands).getStatefulConnection());`
`207`	`207`	`}`
`208`	`208`
`209`		`- if (nativeBinaryCommands instanceof RedisCommands) {`
`210`		`- nativeBinaryConnectionProvider.release(((RedisCommands) nativeBinaryCommands).getStatefulConnection());`
	`209`	`+ if (nativeBinaryCommands instanceof RedisCommands redisCommands) {`
	`210`	`+ nativeBinaryConnectionProvider.release((redisCommands).getStatefulConnection());`
`211`	`211`	`}`
`212`	`212`
`213`		`- if (nativeBinaryCommands instanceof RedisAdvancedClusterCommands) {`
	`213`	`+ if (nativeBinaryCommands instanceof RedisAdvancedClusterCommands redisAdvancedClusterCommands) {`
`214`	`214`	`nativeBinaryConnectionProvider`
`215`		`- .release(((RedisAdvancedClusterCommands) nativeBinaryCommands).getStatefulConnection());`
	`215`	`+ .release((redisAdvancedClusterCommands).getStatefulConnection());`
`216`	`216`	`}`
`217`	`217`	`}`
`218`	`218`
Original file line number	Diff line number	Diff line change
`@@ -236,10 +236,10 @@ private static boolean clusterAvailable() {`
`236`	`236`
`237`	`237`	`private static boolean isClusterAware(RedisConnectionFactory connectionFactory) {`
`238`	`238`
`239`		`- if (connectionFactory instanceof LettuceConnectionFactory) {`
`240`		`- return ((LettuceConnectionFactory) connectionFactory).isClusterAware();`
`241`		`- } else if (connectionFactory instanceof JedisConnectionFactory) {`
`242`		`- return ((JedisConnectionFactory) connectionFactory).isRedisClusterAware();`
	`239`	`+ if (connectionFactory instanceof LettuceConnectionFactory lettuceConnectionFactory) {`
	`240`	`+ return lettuceConnectionFactory.isClusterAware();`
	`241`	`+ } else if (connectionFactory instanceof JedisConnectionFactory jedisConnectionFactory) {`
	`242`	`+ return jedisConnectionFactory.isRedisClusterAware();`
`243`	`243`	`}`
`244`	`244`	`return false;`
`245`	`245`	`}`
Original file line number	Diff line number	Diff line change
`@@ -170,10 +170,10 @@ void testStartListenersToNoSpecificChannelTest() {`
`170`	`170`
`171`	`171`	`private static boolean isClusterAware(RedisConnectionFactory connectionFactory) {`
`172`	`172`
`173`		`- if (connectionFactory instanceof LettuceConnectionFactory) {`
`174`		`- return ((LettuceConnectionFactory) connectionFactory).isClusterAware();`
`175`		`- } else if (connectionFactory instanceof JedisConnectionFactory) {`
`176`		`- return ((JedisConnectionFactory) connectionFactory).isRedisClusterAware();`
	`173`	`+ if (connectionFactory instanceof LettuceConnectionFactory lettuceConnectionFactory) {`
	`174`	`+ return lettuceConnectionFactory.isClusterAware();`
	`175`	`+ } else if (connectionFactory instanceof JedisConnectionFactory jedisConnectionFactory) {`
	`176`	`+ return jedisConnectionFactory.isRedisClusterAware();`
`177`	`177`	`}`
`178`	`178`	`return false;`
`179`	`179`	`}`
Original file line number	Diff line number	Diff line change
`@@ -54,8 +54,8 @@ public class Jackson2HashMapperIntegrationTests {`
`54`	`54`	`public Jackson2HashMapperIntegrationTests(RedisConnectionFactory factory) throws Exception {`
`55`	`55`
`56`	`56`	`this.factory = factory;`
`57`		`- if (factory instanceof InitializingBean) {`
`58`		`- ((InitializingBean) factory).afterPropertiesSet();`
	`57`	`+ if (factory instanceof InitializingBean initializingBean) {`
	`58`	`+ initializingBean.afterPropertiesSet();`
`59`	`59`	`}`
`60`	`60`	`}`
`61`	`61`
Original file line number	Diff line number	Diff line change
`@@ -63,8 +63,8 @@ public RedisOperations<byte[], byte[]> redisOperationsProducerQualified(RedisOpe`
`63`	`63`
`64`	`64`	`public void closeRedisOperations(@Disposes RedisOperations<byte[], byte[]> redisOperations) throws Exception {`
`65`	`65`
`66`		`- if (redisOperations instanceof DisposableBean) {`
`67`		`- ((DisposableBean) redisOperations).destroy();`
	`66`	`+ if (redisOperations instanceof DisposableBean disposableBean) {`
	`67`	`+ disposableBean.destroy();`
`68`	`68`	`}`
`69`	`69`	`}`
`70`	`70`