From db535863dd990466f208bafa5e138aca2cdd90ec Mon Sep 17 00:00:00 2001 From: Sam Brannen <104798+sbrannen@users.noreply.github.com> Date: Tue, 30 Jan 2024 15:15:47 +0100 Subject: [PATCH] Consistently use class literals for primitive types To improve consistency and avoid confusion regarding primitive types and their wrapper types, this commit ensures that we always use class literals for primitive types. For example, instead of using the `Void.TYPE` constant, we now consistently use `void.class`. --- .../support/BeanFactoryTypeConverter.java | 4 +- .../aop/framework/CglibAopProxy.java | 4 +- .../aop/framework/JdkDynamicAopProxy.java | 4 +- .../aop/support/Pointcuts.java | 6 +- .../beans/PropertyDescriptorUtils.java | 12 +- .../aop/framework/ProxyFactoryBeanTests.java | 2 +- .../hint/BindingReflectionHintsRegistrar.java | 4 +- .../core/annotation/AnnotatedMethod.java | 2 +- .../core/MethodParameterTests.java | 8 +- .../SynthesizingMethodParameterTests.java | 8 +- .../core/convert/TypeDescriptorTests.java | 8 +- .../expression/spel/CodeFlow.java | 20 +-- .../expression/spel/ast/Indexer.java | 16 +- .../expression/spel/ast/TypeCode.java | 18 +- .../expression/spel/ast/TypeReference.java | 18 +- .../support/ReflectivePropertyAccessor.java | 6 +- .../spel/AbstractExpressionTests.java | 4 +- .../expression/spel/EvaluationTests.java | 84 ++++----- .../spel/SpelCompilationCoverageTests.java | 166 +++++++++--------- .../spel/SpelCompilationPerformanceTests.java | 10 +- .../expression/spel/TestScenarioCreator.java | 6 +- .../spel/support/ReflectionHelperTests.java | 10 +- ...tractNamedValueMethodArgumentResolver.java | 4 +- ...tractNamedValueMethodArgumentResolver.java | 4 +- .../reactive/InvocableHandlerMethod.java | 4 +- .../oxm/jaxb/Jaxb2Marshaller.java | 6 +- .../oxm/xstream/XStreamMarshallerTests.java | 6 +- ...tationTransactionAttributeSourceTests.java | 2 +- ...tractNamedValueMethodArgumentResolver.java | 4 +- .../WebArgumentResolverAdapterTests.java | 4 +- .../AbstractNamedValueArgumentResolver.java | 4 +- .../HttpEntityMethodProcessorMockTests.java | 2 +- ...tResponseBodyMethodProcessorMockTests.java | 2 +- 33 files changed, 231 insertions(+), 231 deletions(-) diff --git a/integration-tests/src/test/java/org/springframework/expression/spel/support/BeanFactoryTypeConverter.java b/integration-tests/src/test/java/org/springframework/expression/spel/support/BeanFactoryTypeConverter.java index 63174d2d33..b2800bb607 100644 --- a/integration-tests/src/test/java/org/springframework/expression/spel/support/BeanFactoryTypeConverter.java +++ b/integration-tests/src/test/java/org/springframework/expression/spel/support/BeanFactoryTypeConverter.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2012 the original author or authors. + * Copyright 2002-2024 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. @@ -94,7 +94,7 @@ class BeanFactoryTypeConverter implements TypeConverter, BeanFactoryAware { @Override public Object convertValue(Object value, TypeDescriptor sourceType, TypeDescriptor targetType) { - if (targetType.getType() == Void.class || targetType.getType() == Void.TYPE) { + if (targetType.getType() == Void.class || targetType.getType() == void.class) { return null; } if (conversionService.canConvert(sourceType, targetType)) { diff --git a/spring-aop/src/main/java/org/springframework/aop/framework/CglibAopProxy.java b/spring-aop/src/main/java/org/springframework/aop/framework/CglibAopProxy.java index 5230f0fc63..bbfcfed956 100644 --- a/spring-aop/src/main/java/org/springframework/aop/framework/CglibAopProxy.java +++ b/spring-aop/src/main/java/org/springframework/aop/framework/CglibAopProxy.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2023 the original author or authors. + * Copyright 2002-2024 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. @@ -417,7 +417,7 @@ class CglibAopProxy implements AopProxy, Serializable { returnValue = proxy; } Class returnType = method.getReturnType(); - if (returnValue == null && returnType != Void.TYPE && returnType.isPrimitive()) { + if (returnValue == null && returnType != void.class && returnType.isPrimitive()) { throw new AopInvocationException( "Null return value from advice does not match primitive return type for: " + method); } diff --git a/spring-aop/src/main/java/org/springframework/aop/framework/JdkDynamicAopProxy.java b/spring-aop/src/main/java/org/springframework/aop/framework/JdkDynamicAopProxy.java index ee21283232..c9dd7443fa 100644 --- a/spring-aop/src/main/java/org/springframework/aop/framework/JdkDynamicAopProxy.java +++ b/spring-aop/src/main/java/org/springframework/aop/framework/JdkDynamicAopProxy.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2023 the original author or authors. + * Copyright 2002-2024 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. @@ -230,7 +230,7 @@ final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializa // a reference to itself in another returned object. retVal = proxy; } - else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) { + else if (retVal == null && returnType != void.class && returnType.isPrimitive()) { throw new AopInvocationException( "Null return value from advice does not match primitive return type for: " + method); } diff --git a/spring-aop/src/main/java/org/springframework/aop/support/Pointcuts.java b/spring-aop/src/main/java/org/springframework/aop/support/Pointcuts.java index 50e997266b..35f3f644f5 100644 --- a/spring-aop/src/main/java/org/springframework/aop/support/Pointcuts.java +++ b/spring-aop/src/main/java/org/springframework/aop/support/Pointcuts.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2023 the original author or authors. + * Copyright 2002-2024 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. @@ -101,7 +101,7 @@ public abstract class Pointcuts { public boolean matches(Method method, Class targetClass) { return (method.getName().startsWith("set") && method.getParameterCount() == 1 && - method.getReturnType() == Void.TYPE); + method.getReturnType() == void.class); } private Object readResolve() { @@ -127,7 +127,7 @@ public abstract class Pointcuts { public boolean matches(Method method, Class targetClass) { return (method.getName().startsWith("get") && method.getParameterCount() == 0 && - method.getReturnType() != Void.TYPE); + method.getReturnType() != void.class); } private Object readResolve() { diff --git a/spring-beans/src/main/java/org/springframework/beans/PropertyDescriptorUtils.java b/spring-beans/src/main/java/org/springframework/beans/PropertyDescriptorUtils.java index 9eb05f99d8..90c2aef902 100644 --- a/spring-beans/src/main/java/org/springframework/beans/PropertyDescriptorUtils.java +++ b/spring-beans/src/main/java/org/springframework/beans/PropertyDescriptorUtils.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2023 the original author or authors. + * Copyright 2002-2024 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. @@ -68,7 +68,7 @@ abstract class PropertyDescriptorUtils { setter = true; nameIndex = 3; } - else if (methodName.startsWith("get") && method.getParameterCount() == 0 && method.getReturnType() != Void.TYPE) { + else if (methodName.startsWith("get") && method.getParameterCount() == 0 && method.getReturnType() != void.class) { setter = false; nameIndex = 3; } @@ -152,7 +152,7 @@ abstract class PropertyDescriptorUtils { throw new IntrospectionException("Bad read method arg count: " + readMethod); } propertyType = readMethod.getReturnType(); - if (propertyType == Void.TYPE) { + if (propertyType == void.class) { throw new IntrospectionException("Read method returns void: " + readMethod); } } @@ -197,11 +197,11 @@ abstract class PropertyDescriptorUtils { if (params.length != 1) { throw new IntrospectionException("Bad indexed read method arg count: " + indexedReadMethod); } - if (params[0] != Integer.TYPE) { + if (params[0] != int.class) { throw new IntrospectionException("Non int index to indexed read method: " + indexedReadMethod); } indexedPropertyType = indexedReadMethod.getReturnType(); - if (indexedPropertyType == Void.TYPE) { + if (indexedPropertyType == void.class) { throw new IntrospectionException("Indexed read method returns void: " + indexedReadMethod); } } @@ -211,7 +211,7 @@ abstract class PropertyDescriptorUtils { if (params.length != 2) { throw new IntrospectionException("Bad indexed write method arg count: " + indexedWriteMethod); } - if (params[0] != Integer.TYPE) { + if (params[0] != int.class) { throw new IntrospectionException("Non int index to indexed write method: " + indexedWriteMethod); } if (indexedPropertyType != null) { diff --git a/spring-context/src/test/java/org/springframework/aop/framework/ProxyFactoryBeanTests.java b/spring-context/src/test/java/org/springframework/aop/framework/ProxyFactoryBeanTests.java index bf02628d6d..481fe6e591 100644 --- a/spring-context/src/test/java/org/springframework/aop/framework/ProxyFactoryBeanTests.java +++ b/spring-context/src/test/java/org/springframework/aop/framework/ProxyFactoryBeanTests.java @@ -698,7 +698,7 @@ class ProxyFactoryBeanTests { setPointcut(new DynamicMethodMatcherPointcut() { @Override public boolean matches(Method m, @Nullable Class targetClass, Object... args) { - return m.getReturnType() == Void.TYPE; + return m.getReturnType() == void.class; } }); } diff --git a/spring-core/src/main/java/org/springframework/aot/hint/BindingReflectionHintsRegistrar.java b/spring-core/src/main/java/org/springframework/aot/hint/BindingReflectionHintsRegistrar.java index c36e9797cc..181dc1c497 100644 --- a/spring-core/src/main/java/org/springframework/aot/hint/BindingReflectionHintsRegistrar.java +++ b/spring-core/src/main/java/org/springframework/aot/hint/BindingReflectionHintsRegistrar.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2023 the original author or authors. + * Copyright 2002-2024 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. @@ -107,7 +107,7 @@ public class BindingReflectionHintsRegistrar { if (methodName.startsWith("set") && method.getParameterCount() == 1) { registerPropertyHints(hints, seen, method, 0); } - else if ((methodName.startsWith("get") && method.getParameterCount() == 0 && method.getReturnType() != Void.TYPE) || + else if ((methodName.startsWith("get") && method.getParameterCount() == 0 && method.getReturnType() != void.class) || (methodName.startsWith("is") && method.getParameterCount() == 0 && method.getReturnType() == boolean.class)) { registerPropertyHints(hints, seen, method, -1); } diff --git a/spring-core/src/main/java/org/springframework/core/annotation/AnnotatedMethod.java b/spring-core/src/main/java/org/springframework/core/annotation/AnnotatedMethod.java index 87ba2faf6b..12be91e817 100644 --- a/spring-core/src/main/java/org/springframework/core/annotation/AnnotatedMethod.java +++ b/spring-core/src/main/java/org/springframework/core/annotation/AnnotatedMethod.java @@ -137,7 +137,7 @@ public class AnnotatedMethod { * Return {@code true} if the method's return type is void, {@code false} otherwise. */ public boolean isVoid() { - return Void.TYPE.equals(getReturnType().getParameterType()); + return (getReturnType().getParameterType() == void.class); } /** diff --git a/spring-core/src/test/java/org/springframework/core/MethodParameterTests.java b/spring-core/src/test/java/org/springframework/core/MethodParameterTests.java index a2293a6a0e..e01f0275ce 100644 --- a/spring-core/src/test/java/org/springframework/core/MethodParameterTests.java +++ b/spring-core/src/test/java/org/springframework/core/MethodParameterTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2023 the original author or authors. + * Copyright 2002-2024 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,7 +52,7 @@ class MethodParameterTests { @BeforeEach void setup() throws NoSuchMethodException { - method = getClass().getMethod("method", String.class, Long.TYPE); + method = getClass().getMethod("method", String.class, long.class); stringParameter = new MethodParameter(method, 0); longParameter = new MethodParameter(method, 1); intReturnType = new MethodParameter(method, -1); @@ -72,7 +72,7 @@ class MethodParameterTests { assertThat(intReturnType).isNotEqualTo(stringParameter); assertThat(intReturnType).isNotEqualTo(longParameter); - Method method = getClass().getMethod("method", String.class, Long.TYPE); + Method method = getClass().getMethod("method", String.class, long.class); MethodParameter methodParameter = new MethodParameter(method, 0); assertThat(methodParameter).isEqualTo(stringParameter); assertThat(stringParameter).isEqualTo(methodParameter); @@ -86,7 +86,7 @@ class MethodParameterTests { assertThat(longParameter.hashCode()).isEqualTo(longParameter.hashCode()); assertThat(intReturnType.hashCode()).isEqualTo(intReturnType.hashCode()); - Method method = getClass().getMethod("method", String.class, Long.TYPE); + Method method = getClass().getMethod("method", String.class, long.class); MethodParameter methodParameter = new MethodParameter(method, 0); assertThat(methodParameter.hashCode()).isEqualTo(stringParameter.hashCode()); assertThat(methodParameter.hashCode()).isNotEqualTo(longParameter.hashCode()); diff --git a/spring-core/src/test/java/org/springframework/core/annotation/SynthesizingMethodParameterTests.java b/spring-core/src/test/java/org/springframework/core/annotation/SynthesizingMethodParameterTests.java index e3cf7076dc..24090c49e2 100644 --- a/spring-core/src/test/java/org/springframework/core/annotation/SynthesizingMethodParameterTests.java +++ b/spring-core/src/test/java/org/springframework/core/annotation/SynthesizingMethodParameterTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2023 the original author or authors. + * Copyright 2002-2024 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. @@ -43,7 +43,7 @@ class SynthesizingMethodParameterTests { @BeforeEach void setUp() throws NoSuchMethodException { - method = getClass().getMethod("method", String.class, Long.TYPE); + method = getClass().getMethod("method", String.class, long.class); stringParameter = new SynthesizingMethodParameter(method, 0); longParameter = new SynthesizingMethodParameter(method, 1); intReturnType = new SynthesizingMethodParameter(method, -1); @@ -63,7 +63,7 @@ class SynthesizingMethodParameterTests { assertThat(intReturnType).isNotEqualTo(stringParameter); assertThat(intReturnType).isNotEqualTo(longParameter); - Method method = getClass().getMethod("method", String.class, Long.TYPE); + Method method = getClass().getMethod("method", String.class, long.class); MethodParameter methodParameter = new SynthesizingMethodParameter(method, 0); assertThat(methodParameter).isEqualTo(stringParameter); assertThat(stringParameter).isEqualTo(methodParameter); @@ -83,7 +83,7 @@ class SynthesizingMethodParameterTests { assertThat(longParameter.hashCode()).isEqualTo(longParameter.hashCode()); assertThat(intReturnType.hashCode()).isEqualTo(intReturnType.hashCode()); - Method method = getClass().getMethod("method", String.class, Long.TYPE); + Method method = getClass().getMethod("method", String.class, long.class); SynthesizingMethodParameter methodParameter = new SynthesizingMethodParameter(method, 0); assertThat(methodParameter.hashCode()).isEqualTo(stringParameter.hashCode()); assertThat(methodParameter.hashCode()).isNotEqualTo(longParameter.hashCode()); diff --git a/spring-core/src/test/java/org/springframework/core/convert/TypeDescriptorTests.java b/spring-core/src/test/java/org/springframework/core/convert/TypeDescriptorTests.java index eb3c7e37aa..ac097a382f 100644 --- a/spring-core/src/test/java/org/springframework/core/convert/TypeDescriptorTests.java +++ b/spring-core/src/test/java/org/springframework/core/convert/TypeDescriptorTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2023 the original author or authors. + * Copyright 2002-2024 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. @@ -303,7 +303,7 @@ class TypeDescriptorTests { void fieldArray() throws Exception { TypeDescriptor typeDescriptor = new TypeDescriptor(TypeDescriptorTests.class.getDeclaredField("intArray")); assertThat(typeDescriptor.isArray()).isTrue(); - assertThat(typeDescriptor.getElementTypeDescriptor().getType()).isEqualTo(Integer.TYPE); + assertThat(typeDescriptor.getElementTypeDescriptor().getType()).isEqualTo(int.class); assertThat(typeDescriptor.toString()).isEqualTo("int[]"); } @@ -359,7 +359,7 @@ class TypeDescriptorTests { assertThat(typeDescriptor.isArray()).isFalse(); assertThat(typeDescriptor.isCollection()).isFalse(); assertThat(typeDescriptor.isMap()).isFalse(); - assertThat(typeDescriptor.getType()).isEqualTo(Integer.TYPE); + assertThat(typeDescriptor.getType()).isEqualTo(int.class); assertThat(typeDescriptor.getObjectType()).isEqualTo(Integer.class); } @@ -369,7 +369,7 @@ class TypeDescriptorTests { assertThat(typeDescriptor.isArray()).isTrue(); assertThat(typeDescriptor.isCollection()).isFalse(); assertThat(typeDescriptor.isMap()).isFalse(); - assertThat(typeDescriptor.getElementTypeDescriptor().getType()).isEqualTo(Integer.TYPE); + assertThat(typeDescriptor.getElementTypeDescriptor().getType()).isEqualTo(int.class); } @Test diff --git a/spring-expression/src/main/java/org/springframework/expression/spel/CodeFlow.java b/spring-expression/src/main/java/org/springframework/expression/spel/CodeFlow.java index 09518a0787..e6b57a3135 100644 --- a/spring-expression/src/main/java/org/springframework/expression/spel/CodeFlow.java +++ b/spring-expression/src/main/java/org/springframework/expression/spel/CodeFlow.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2023 the original author or authors. + * Copyright 2002-2024 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. @@ -454,31 +454,31 @@ public class CodeFlow implements Opcodes { } } if (clazz.isPrimitive()) { - if (clazz == Boolean.TYPE) { + if (clazz == boolean.class) { sb.append('Z'); } - else if (clazz == Byte.TYPE) { + else if (clazz == byte.class) { sb.append('B'); } - else if (clazz == Character.TYPE) { + else if (clazz == char.class) { sb.append('C'); } - else if (clazz == Double.TYPE) { + else if (clazz == double.class) { sb.append('D'); } - else if (clazz == Float.TYPE) { + else if (clazz == float.class) { sb.append('F'); } - else if (clazz == Integer.TYPE) { + else if (clazz == int.class) { sb.append('I'); } - else if (clazz == Long.TYPE) { + else if (clazz == long.class) { sb.append('J'); } - else if (clazz == Short.TYPE) { + else if (clazz == short.class) { sb.append('S'); } - else if (clazz == Void.TYPE) { + else if (clazz == void.class) { sb.append('V'); } } diff --git a/spring-expression/src/main/java/org/springframework/expression/spel/ast/Indexer.java b/spring-expression/src/main/java/org/springframework/expression/spel/ast/Indexer.java index e93e151aa0..e3f703fb0b 100644 --- a/spring-expression/src/main/java/org/springframework/expression/spel/ast/Indexer.java +++ b/spring-expression/src/main/java/org/springframework/expression/spel/ast/Indexer.java @@ -385,49 +385,49 @@ public class Indexer extends SpelNodeImpl { private Object accessArrayElement(Object ctx, int idx) throws SpelEvaluationException { Class arrayComponentType = ctx.getClass().componentType(); - if (arrayComponentType == Boolean.TYPE) { + if (arrayComponentType == boolean.class) { boolean[] array = (boolean[]) ctx; checkAccess(array.length, idx); this.exitTypeDescriptor = "Z"; return array[idx]; } - else if (arrayComponentType == Byte.TYPE) { + else if (arrayComponentType == byte.class) { byte[] array = (byte[]) ctx; checkAccess(array.length, idx); this.exitTypeDescriptor = "B"; return array[idx]; } - else if (arrayComponentType == Character.TYPE) { + else if (arrayComponentType == char.class) { char[] array = (char[]) ctx; checkAccess(array.length, idx); this.exitTypeDescriptor = "C"; return array[idx]; } - else if (arrayComponentType == Double.TYPE) { + else if (arrayComponentType == double.class) { double[] array = (double[]) ctx; checkAccess(array.length, idx); this.exitTypeDescriptor = "D"; return array[idx]; } - else if (arrayComponentType == Float.TYPE) { + else if (arrayComponentType == float.class) { float[] array = (float[]) ctx; checkAccess(array.length, idx); this.exitTypeDescriptor = "F"; return array[idx]; } - else if (arrayComponentType == Integer.TYPE) { + else if (arrayComponentType == int.class) { int[] array = (int[]) ctx; checkAccess(array.length, idx); this.exitTypeDescriptor = "I"; return array[idx]; } - else if (arrayComponentType == Long.TYPE) { + else if (arrayComponentType == long.class) { long[] array = (long[]) ctx; checkAccess(array.length, idx); this.exitTypeDescriptor = "J"; return array[idx]; } - else if (arrayComponentType == Short.TYPE) { + else if (arrayComponentType == short.class) { short[] array = (short[]) ctx; checkAccess(array.length, idx); this.exitTypeDescriptor = "S"; diff --git a/spring-expression/src/main/java/org/springframework/expression/spel/ast/TypeCode.java b/spring-expression/src/main/java/org/springframework/expression/spel/ast/TypeCode.java index 0347ecddd3..9702d8a873 100644 --- a/spring-expression/src/main/java/org/springframework/expression/spel/ast/TypeCode.java +++ b/spring-expression/src/main/java/org/springframework/expression/spel/ast/TypeCode.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2023 the original author or authors. + * Copyright 2002-2024 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,42 +33,42 @@ public enum TypeCode { /** * A {@code boolean}. */ - BOOLEAN(Boolean.TYPE), + BOOLEAN(boolean.class), /** * A {@code char}. */ - CHAR(Character.TYPE), + CHAR(char.class), /** * A {@code byte}. */ - BYTE(Byte.TYPE), + BYTE(byte.class), /** * A {@code short}. */ - SHORT(Short.TYPE), + SHORT(short.class), /** * An {@code int}. */ - INT(Integer.TYPE), + INT(int.class), /** * A {@code long}. */ - LONG(Long.TYPE), + LONG(long.class), /** * A {@code float}. */ - FLOAT(Float.TYPE), + FLOAT(float.class), /** * A {@code double}. */ - DOUBLE(Double.TYPE); + DOUBLE(double.class); private final Class type; diff --git a/spring-expression/src/main/java/org/springframework/expression/spel/ast/TypeReference.java b/spring-expression/src/main/java/org/springframework/expression/spel/ast/TypeReference.java index 5f09958fbe..3effcf1858 100644 --- a/spring-expression/src/main/java/org/springframework/expression/spel/ast/TypeReference.java +++ b/spring-expression/src/main/java/org/springframework/expression/spel/ast/TypeReference.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2023 the original author or authors. + * Copyright 2002-2024 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. @@ -102,28 +102,28 @@ public class TypeReference extends SpelNodeImpl { // TODO Future optimization - if followed by a static method call, skip generating code here Assert.state(this.type != null, "No type available"); if (this.type.isPrimitive()) { - if (this.type == Boolean.TYPE) { + if (this.type == boolean.class) { mv.visitFieldInsn(GETSTATIC, "java/lang/Boolean", "TYPE", "Ljava/lang/Class;"); } - else if (this.type == Byte.TYPE) { + else if (this.type == byte.class) { mv.visitFieldInsn(GETSTATIC, "java/lang/Byte", "TYPE", "Ljava/lang/Class;"); } - else if (this.type == Character.TYPE) { + else if (this.type == char.class) { mv.visitFieldInsn(GETSTATIC, "java/lang/Character", "TYPE", "Ljava/lang/Class;"); } - else if (this.type == Double.TYPE) { + else if (this.type == double.class) { mv.visitFieldInsn(GETSTATIC, "java/lang/Double", "TYPE", "Ljava/lang/Class;"); } - else if (this.type == Float.TYPE) { + else if (this.type == float.class) { mv.visitFieldInsn(GETSTATIC, "java/lang/Float", "TYPE", "Ljava/lang/Class;"); } - else if (this.type == Integer.TYPE) { + else if (this.type == int.class) { mv.visitFieldInsn(GETSTATIC, "java/lang/Integer", "TYPE", "Ljava/lang/Class;"); } - else if (this.type == Long.TYPE) { + else if (this.type == long.class) { mv.visitFieldInsn(GETSTATIC, "java/lang/Long", "TYPE", "Ljava/lang/Class;"); } - else if (this.type == Short.TYPE) { + else if (this.type == short.class) { mv.visitFieldInsn(GETSTATIC, "java/lang/Short", "TYPE", "Ljava/lang/Class;"); } } diff --git a/spring-expression/src/main/java/org/springframework/expression/spel/support/ReflectivePropertyAccessor.java b/spring-expression/src/main/java/org/springframework/expression/spel/support/ReflectivePropertyAccessor.java index 87737e65c8..a05ee3679b 100644 --- a/spring-expression/src/main/java/org/springframework/expression/spel/support/ReflectivePropertyAccessor.java +++ b/spring-expression/src/main/java/org/springframework/expression/spel/support/ReflectivePropertyAccessor.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2023 the original author or authors. + * Copyright 2002-2024 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. @@ -73,7 +73,7 @@ public class ReflectivePropertyAccessor implements PropertyAccessor { private static final Set> ANY_TYPES = Collections.emptySet(); - private static final Set> BOOLEAN_TYPES = Set.of(Boolean.class, Boolean.TYPE); + private static final Set> BOOLEAN_TYPES = Set.of(Boolean.class, boolean.class); private final boolean allowWrite; @@ -338,7 +338,7 @@ public class ReflectivePropertyAccessor implements PropertyAccessor { Class type = (target instanceof Class clazz ? clazz : target.getClass()); if (type.isArray() && name.equals("length")) { - return TypeDescriptor.valueOf(Integer.TYPE); + return TypeDescriptor.valueOf(int.class); } PropertyCacheKey cacheKey = new PropertyCacheKey(type, name, target instanceof Class); TypeDescriptor typeDescriptor = this.typeDescriptorCache.get(cacheKey); diff --git a/spring-expression/src/test/java/org/springframework/expression/spel/AbstractExpressionTests.java b/spring-expression/src/test/java/org/springframework/expression/spel/AbstractExpressionTests.java index 7f6097e453..48e0b06211 100644 --- a/spring-expression/src/test/java/org/springframework/expression/spel/AbstractExpressionTests.java +++ b/spring-expression/src/test/java/org/springframework/expression/spel/AbstractExpressionTests.java @@ -260,7 +260,7 @@ public abstract class AbstractExpressionTests { StringBuilder sb = new StringBuilder(); if (value.getClass().componentType().isPrimitive()) { Class primitiveType = value.getClass().componentType(); - if (primitiveType == Integer.TYPE) { + if (primitiveType == int.class) { int[] l = (int[]) value; sb.append("int[").append(l.length).append("]{"); for (int j = 0; j < l.length; j++) { @@ -271,7 +271,7 @@ public abstract class AbstractExpressionTests { } sb.append('}'); } - else if (primitiveType == Long.TYPE) { + else if (primitiveType == long.class) { long[] l = (long[]) value; sb.append("long[").append(l.length).append("]{"); for (int j = 0; j < l.length; j++) { diff --git a/spring-expression/src/test/java/org/springframework/expression/spel/EvaluationTests.java b/spring-expression/src/test/java/org/springframework/expression/spel/EvaluationTests.java index 293ec505aa..62b2a53e89 100644 --- a/spring-expression/src/test/java/org/springframework/expression/spel/EvaluationTests.java +++ b/spring-expression/src/test/java/org/springframework/expression/spel/EvaluationTests.java @@ -894,38 +894,38 @@ class EvaluationTests extends AbstractExpressionTests { // double e = parser.parseExpression("ddd++"); assertThat((float) helper.ddd).isCloseTo((float) 2.0d, within((float) 0d)); - double return_ddd = e.getValue(ctx, Double.TYPE); + double return_ddd = e.getValue(ctx, double.class); assertThat((float) return_ddd).isCloseTo((float) 2.0d, within((float) 0d)); assertThat((float) helper.ddd).isCloseTo((float) 3.0d, within((float) 0d)); // float e = parser.parseExpression("fff++"); assertThat(helper.fff).isCloseTo(3.0f, within((float) 0d)); - float return_fff = e.getValue(ctx, Float.TYPE); + float return_fff = e.getValue(ctx, float.class); assertThat(return_fff).isCloseTo(3.0f, within((float) 0d)); assertThat(helper.fff).isCloseTo(4.0f, within((float) 0d)); // long e = parser.parseExpression("lll++"); assertThat(helper.lll).isEqualTo(66666L); - long return_lll = e.getValue(ctx, Long.TYPE); + long return_lll = e.getValue(ctx, long.class); assertThat(return_lll).isEqualTo(66666L); assertThat(helper.lll).isEqualTo(66667L); // int e = parser.parseExpression("iii++"); assertThat(helper.iii).isEqualTo(42); - int return_iii = e.getValue(ctx, Integer.TYPE); + int return_iii = e.getValue(ctx, int.class); assertThat(return_iii).isEqualTo(42); assertThat(helper.iii).isEqualTo(43); - return_iii = e.getValue(ctx, Integer.TYPE); + return_iii = e.getValue(ctx, int.class); assertThat(return_iii).isEqualTo(43); assertThat(helper.iii).isEqualTo(44); // short e = parser.parseExpression("sss++"); assertThat(helper.sss).isEqualTo((short) 15); - short return_sss = e.getValue(ctx, Short.TYPE); + short return_sss = e.getValue(ctx, short.class); assertThat(return_sss).isEqualTo((short) 15); assertThat(helper.sss).isEqualTo((short) 16); } @@ -947,31 +947,31 @@ class EvaluationTests extends AbstractExpressionTests { // double e = parser.parseExpression("++ddd"); assertThat((float) helper.ddd).isCloseTo((float) 2.0d, within((float) 0d)); - double return_ddd = e.getValue(ctx, Double.TYPE); + double return_ddd = e.getValue(ctx, double.class); assertThat((float) return_ddd).isCloseTo((float) 3.0d, within((float) 0d)); assertThat((float) helper.ddd).isCloseTo((float) 3.0d, within((float) 0d)); // float e = parser.parseExpression("++fff"); assertThat(helper.fff).isCloseTo(3.0f, within((float) 0d)); - float return_fff = e.getValue(ctx, Float.TYPE); + float return_fff = e.getValue(ctx, float.class); assertThat(return_fff).isCloseTo(4.0f, within((float) 0d)); assertThat(helper.fff).isCloseTo(4.0f, within((float) 0d)); // long e = parser.parseExpression("++lll"); assertThat(helper.lll).isEqualTo(66666L); - long return_lll = e.getValue(ctx, Long.TYPE); + long return_lll = e.getValue(ctx, long.class); assertThat(return_lll).isEqualTo(66667L); assertThat(helper.lll).isEqualTo(66667L); // int e = parser.parseExpression("++iii"); assertThat(helper.iii).isEqualTo(42); - int return_iii = e.getValue(ctx, Integer.TYPE); + int return_iii = e.getValue(ctx, int.class); assertThat(return_iii).isEqualTo(43); assertThat(helper.iii).isEqualTo(43); - return_iii = e.getValue(ctx, Integer.TYPE); + return_iii = e.getValue(ctx, int.class); assertThat(return_iii).isEqualTo(44); assertThat(helper.iii).isEqualTo(44); @@ -991,12 +991,12 @@ class EvaluationTests extends AbstractExpressionTests { Expression e1 = parser.parseExpression("m()++"); assertThatExceptionOfType(SpelEvaluationException.class) - .isThrownBy(() -> e1.getValue(ctx, Double.TYPE)) + .isThrownBy(() -> e1.getValue(ctx, double.class)) .satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.OPERAND_NOT_INCREMENTABLE)); Expression e2 = parser.parseExpression("++m()"); assertThatExceptionOfType(SpelEvaluationException.class) - .isThrownBy(() -> e2.getValue(ctx, Double.TYPE)) + .isThrownBy(() -> e2.getValue(ctx, double.class)) .satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.OPERAND_NOT_INCREMENTABLE)); } @@ -1007,11 +1007,11 @@ class EvaluationTests extends AbstractExpressionTests { ExpressionParser parser = new SpelExpressionParser(new SpelParserConfiguration(true, true)); Expression e1 = parser.parseExpression("++1"); assertThatExceptionOfType(SpelEvaluationException.class) - .isThrownBy(() -> e1.getValue(ctx, Double.TYPE)) + .isThrownBy(() -> e1.getValue(ctx, double.class)) .satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.NOT_ASSIGNABLE)); Expression e2 = parser.parseExpression("1++"); assertThatExceptionOfType(SpelEvaluationException.class) - .isThrownBy(() -> e2.getValue(ctx, Double.TYPE)) + .isThrownBy(() -> e2.getValue(ctx, double.class)) .satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.NOT_ASSIGNABLE)); } @@ -1044,38 +1044,38 @@ class EvaluationTests extends AbstractExpressionTests { // double e = parser.parseExpression("ddd--"); assertThat((float) helper.ddd).isCloseTo((float) 2.0d, within((float) 0d)); - double return_ddd = e.getValue(ctx, Double.TYPE); + double return_ddd = e.getValue(ctx, double.class); assertThat((float) return_ddd).isCloseTo((float) 2.0d, within((float) 0d)); assertThat((float) helper.ddd).isCloseTo((float) 1.0d, within((float) 0d)); // float e = parser.parseExpression("fff--"); assertThat(helper.fff).isCloseTo(3.0f, within((float) 0d)); - float return_fff = e.getValue(ctx, Float.TYPE); + float return_fff = e.getValue(ctx, float.class); assertThat(return_fff).isCloseTo(3.0f, within((float) 0d)); assertThat(helper.fff).isCloseTo(2.0f, within((float) 0d)); // long e = parser.parseExpression("lll--"); assertThat(helper.lll).isEqualTo(66666L); - long return_lll = e.getValue(ctx, Long.TYPE); + long return_lll = e.getValue(ctx, long.class); assertThat(return_lll).isEqualTo(66666L); assertThat(helper.lll).isEqualTo(66665L); // int e = parser.parseExpression("iii--"); assertThat(helper.iii).isEqualTo(42); - int return_iii = e.getValue(ctx, Integer.TYPE); + int return_iii = e.getValue(ctx, int.class); assertThat(return_iii).isEqualTo(42); assertThat(helper.iii).isEqualTo(41); - return_iii = e.getValue(ctx, Integer.TYPE); + return_iii = e.getValue(ctx, int.class); assertThat(return_iii).isEqualTo(41); assertThat(helper.iii).isEqualTo(40); // short e = parser.parseExpression("sss--"); assertThat(helper.sss).isEqualTo((short) 15); - short return_sss = e.getValue(ctx, Short.TYPE); + short return_sss = e.getValue(ctx, short.class); assertThat(return_sss).isEqualTo((short) 15); assertThat(helper.sss).isEqualTo((short) 14); } @@ -1097,31 +1097,31 @@ class EvaluationTests extends AbstractExpressionTests { // double e = parser.parseExpression("--ddd"); assertThat((float) helper.ddd).isCloseTo((float) 2.0d, within((float) 0d)); - double return_ddd = e.getValue(ctx, Double.TYPE); + double return_ddd = e.getValue(ctx, double.class); assertThat((float) return_ddd).isCloseTo((float) 1.0d, within((float) 0d)); assertThat((float) helper.ddd).isCloseTo((float) 1.0d, within((float) 0d)); // float e = parser.parseExpression("--fff"); assertThat(helper.fff).isCloseTo(3.0f, within((float) 0d)); - float return_fff = e.getValue(ctx, Float.TYPE); + float return_fff = e.getValue(ctx, float.class); assertThat(return_fff).isCloseTo(2.0f, within((float) 0d)); assertThat(helper.fff).isCloseTo(2.0f, within((float) 0d)); // long e = parser.parseExpression("--lll"); assertThat(helper.lll).isEqualTo(66666L); - long return_lll = e.getValue(ctx, Long.TYPE); + long return_lll = e.getValue(ctx, long.class); assertThat(return_lll).isEqualTo(66665L); assertThat(helper.lll).isEqualTo(66665L); // int e = parser.parseExpression("--iii"); assertThat(helper.iii).isEqualTo(42); - int return_iii = e.getValue(ctx, Integer.TYPE); + int return_iii = e.getValue(ctx, int.class); assertThat(return_iii).isEqualTo(41); assertThat(helper.iii).isEqualTo(41); - return_iii = e.getValue(ctx, Integer.TYPE); + return_iii = e.getValue(ctx, int.class); assertThat(return_iii).isEqualTo(40); assertThat(helper.iii).isEqualTo(40); @@ -1141,12 +1141,12 @@ class EvaluationTests extends AbstractExpressionTests { Expression e1 = parser.parseExpression("m()--"); assertThatExceptionOfType(SpelEvaluationException.class) - .isThrownBy(() -> e1.getValue(ctx, Double.TYPE)) + .isThrownBy(() -> e1.getValue(ctx, double.class)) .satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.OPERAND_NOT_DECREMENTABLE)); Expression e2 = parser.parseExpression("--m()"); assertThatExceptionOfType(SpelEvaluationException.class) - .isThrownBy(() -> e2.getValue(ctx, Double.TYPE)) + .isThrownBy(() -> e2.getValue(ctx, double.class)) .satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.OPERAND_NOT_DECREMENTABLE)); } @@ -1349,26 +1349,26 @@ class EvaluationTests extends AbstractExpressionTests { // iii=42 e = parser.parseExpression("iii=iii++"); assertThat(helper.iii).isEqualTo(42); - int return_iii = e.getValue(ctx, Integer.TYPE); + int return_iii = e.getValue(ctx, int.class); assertThat(helper.iii).isEqualTo(42); assertThat(return_iii).isEqualTo(42); // Identifier e = parser.parseExpression("iii++"); assertThat(helper.iii).isEqualTo(42); - return_iii = e.getValue(ctx, Integer.TYPE); + return_iii = e.getValue(ctx, int.class); assertThat(return_iii).isEqualTo(42); assertThat(helper.iii).isEqualTo(43); e = parser.parseExpression("--iii"); assertThat(helper.iii).isEqualTo(43); - return_iii = e.getValue(ctx, Integer.TYPE); + return_iii = e.getValue(ctx, int.class); assertThat(return_iii).isEqualTo(42); assertThat(helper.iii).isEqualTo(42); e = parser.parseExpression("iii=99"); assertThat(helper.iii).isEqualTo(42); - return_iii = e.getValue(ctx, Integer.TYPE); + return_iii = e.getValue(ctx, int.class); assertThat(return_iii).isEqualTo(99); assertThat(helper.iii).isEqualTo(99); @@ -1376,19 +1376,19 @@ class EvaluationTests extends AbstractExpressionTests { // foo.iii == 99 e = parser.parseExpression("foo.iii++"); assertThat(helper.foo.iii).isEqualTo(99); - int return_foo_iii = e.getValue(ctx, Integer.TYPE); + int return_foo_iii = e.getValue(ctx, int.class); assertThat(return_foo_iii).isEqualTo(99); assertThat(helper.foo.iii).isEqualTo(100); e = parser.parseExpression("--foo.iii"); assertThat(helper.foo.iii).isEqualTo(100); - return_foo_iii = e.getValue(ctx, Integer.TYPE); + return_foo_iii = e.getValue(ctx, int.class); assertThat(return_foo_iii).isEqualTo(99); assertThat(helper.foo.iii).isEqualTo(99); e = parser.parseExpression("foo.iii=999"); assertThat(helper.foo.iii).isEqualTo(99); - return_foo_iii = e.getValue(ctx, Integer.TYPE); + return_foo_iii = e.getValue(ctx, int.class); assertThat(return_foo_iii).isEqualTo(999); assertThat(helper.foo.iii).isEqualTo(999); @@ -1408,7 +1408,7 @@ class EvaluationTests extends AbstractExpressionTests { expectFailSetValueNotSupported(parser, ctx, "('abc' matches '^a..')=('abc' matches '^a..')"); // Selection - ctx.registerFunction("isEven", Spr9751.class.getDeclaredMethod("isEven", Integer.TYPE)); + ctx.registerFunction("isEven", Spr9751.class.getDeclaredMethod("isEven", int.class)); expectFailNotIncrementable(parser, ctx, "({1,2,3}.?[#isEven(#this)])++"); expectFailNotDecrementable(parser, ctx, "--({1,2,3}.?[#isEven(#this)])"); @@ -1440,19 +1440,19 @@ class EvaluationTests extends AbstractExpressionTests { ctx.setVariable("wobble", 3); e = parser.parseExpression("#wobble++"); assertThat(((Integer) ctx.lookupVariable("wobble"))).isEqualTo(3); - int r = e.getValue(ctx, Integer.TYPE); + int r = e.getValue(ctx, int.class); assertThat(r).isEqualTo(3); assertThat(((Integer) ctx.lookupVariable("wobble"))).isEqualTo(4); e = parser.parseExpression("--#wobble"); assertThat(((Integer) ctx.lookupVariable("wobble"))).isEqualTo(4); - r = e.getValue(ctx, Integer.TYPE); + r = e.getValue(ctx, int.class); assertThat(r).isEqualTo(3); assertThat(((Integer) ctx.lookupVariable("wobble"))).isEqualTo(3); e = parser.parseExpression("#wobble=34"); assertThat(((Integer) ctx.lookupVariable("wobble"))).isEqualTo(3); - r = e.getValue(ctx, Integer.TYPE); + r = e.getValue(ctx, int.class); assertThat(r).isEqualTo(34); assertThat(((Integer) ctx.lookupVariable("wobble"))).isEqualTo(34); @@ -1487,19 +1487,19 @@ class EvaluationTests extends AbstractExpressionTests { helper.iii = 42; e = parser.parseExpression("iii++"); assertThat(helper.iii).isEqualTo(42); - r = e.getValue(ctx, Integer.TYPE); + r = e.getValue(ctx, int.class); assertThat(r).isEqualTo(42); assertThat(helper.iii).isEqualTo(43); e = parser.parseExpression("--iii"); assertThat(helper.iii).isEqualTo(43); - r = e.getValue(ctx, Integer.TYPE); + r = e.getValue(ctx, int.class); assertThat(r).isEqualTo(42); assertThat(helper.iii).isEqualTo(42); e = parser.parseExpression("iii=100"); assertThat(helper.iii).isEqualTo(42); - r = e.getValue(ctx, Integer.TYPE); + r = e.getValue(ctx, int.class); assertThat(r).isEqualTo(100); assertThat(helper.iii).isEqualTo(100); } diff --git a/spring-expression/src/test/java/org/springframework/expression/spel/SpelCompilationCoverageTests.java b/spring-expression/src/test/java/org/springframework/expression/spel/SpelCompilationCoverageTests.java index 3dc3aac474..9765586a84 100644 --- a/spring-expression/src/test/java/org/springframework/expression/spel/SpelCompilationCoverageTests.java +++ b/spring-expression/src/test/java/org/springframework/expression/spel/SpelCompilationCoverageTests.java @@ -156,44 +156,44 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertThat(expression.getValue()).isEqualTo(int[][].class); expression = parse("T(int)"); - assertThat(expression.getValue()).isEqualTo(Integer.TYPE); + assertThat(expression.getValue()).isEqualTo(int.class); assertCanCompile(expression); - assertThat(expression.getValue()).isEqualTo(Integer.TYPE); + assertThat(expression.getValue()).isEqualTo(int.class); expression = parse("T(byte)"); - assertThat(expression.getValue()).isEqualTo(Byte.TYPE); + assertThat(expression.getValue()).isEqualTo(byte.class); assertCanCompile(expression); - assertThat(expression.getValue()).isEqualTo(Byte.TYPE); + assertThat(expression.getValue()).isEqualTo(byte.class); expression = parse("T(char)"); - assertThat(expression.getValue()).isEqualTo(Character.TYPE); + assertThat(expression.getValue()).isEqualTo(char.class); assertCanCompile(expression); - assertThat(expression.getValue()).isEqualTo(Character.TYPE); + assertThat(expression.getValue()).isEqualTo(char.class); expression = parse("T(short)"); - assertThat(expression.getValue()).isEqualTo(Short.TYPE); + assertThat(expression.getValue()).isEqualTo(short.class); assertCanCompile(expression); - assertThat(expression.getValue()).isEqualTo(Short.TYPE); + assertThat(expression.getValue()).isEqualTo(short.class); expression = parse("T(long)"); - assertThat(expression.getValue()).isEqualTo(Long.TYPE); + assertThat(expression.getValue()).isEqualTo(long.class); assertCanCompile(expression); - assertThat(expression.getValue()).isEqualTo(Long.TYPE); + assertThat(expression.getValue()).isEqualTo(long.class); expression = parse("T(float)"); - assertThat(expression.getValue()).isEqualTo(Float.TYPE); + assertThat(expression.getValue()).isEqualTo(float.class); assertCanCompile(expression); - assertThat(expression.getValue()).isEqualTo(Float.TYPE); + assertThat(expression.getValue()).isEqualTo(float.class); expression = parse("T(double)"); - assertThat(expression.getValue()).isEqualTo(Double.TYPE); + assertThat(expression.getValue()).isEqualTo(double.class); assertCanCompile(expression); - assertThat(expression.getValue()).isEqualTo(Double.TYPE); + assertThat(expression.getValue()).isEqualTo(double.class); expression = parse("T(boolean)"); - assertThat(expression.getValue()).isEqualTo(Boolean.TYPE); + assertThat(expression.getValue()).isEqualTo(boolean.class); assertCanCompile(expression); - assertThat(expression.getValue()).isEqualTo(Boolean.TYPE); + assertThat(expression.getValue()).isEqualTo(boolean.class); expression = parse("T(Missing)"); assertGetValueFail(expression); @@ -326,9 +326,9 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { @Test void realLiteral() { expression = parser.parseExpression("3.4d"); - double resultI = expression.getValue(new TestClass1(), Double.TYPE); + double resultI = expression.getValue(new TestClass1(), double.class); assertCanCompile(expression); - double resultC = expression.getValue(new TestClass1(), Double.TYPE); + double resultC = expression.getValue(new TestClass1(), double.class); assertThat(resultI).isCloseTo(3.4d, within(0.1d)); assertThat(resultC).isCloseTo(3.4d, within(0.1d)); @@ -454,9 +454,9 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { @Test void intLiteral() { expression = parser.parseExpression("42"); - int resultI = expression.getValue(new TestClass1(), Integer.TYPE); + int resultI = expression.getValue(new TestClass1(), int.class); assertCanCompile(expression); - int resultC = expression.getValue(new TestClass1(), Integer.TYPE); + int resultC = expression.getValue(new TestClass1(), int.class); assertThat(resultI).isEqualTo(42); assertThat(resultC).isEqualTo(42); @@ -485,9 +485,9 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { @Test void longLiteral() { expression = parser.parseExpression("99L"); - long resultI = expression.getValue(new TestClass1(), Long.TYPE); + long resultI = expression.getValue(new TestClass1(), long.class); assertCanCompile(expression); - long resultC = expression.getValue(new TestClass1(), Long.TYPE); + long resultC = expression.getValue(new TestClass1(), long.class); assertThat(resultI).isEqualTo(99L); assertThat(resultC).isEqualTo(99L); } @@ -495,26 +495,26 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { @Test void booleanLiteral() { expression = parser.parseExpression("true"); - boolean resultI = expression.getValue(1, Boolean.TYPE); + boolean resultI = expression.getValue(1, boolean.class); assertThat(resultI).isTrue(); assertThat(SpelCompiler.compile(expression)).isTrue(); - boolean resultC = expression.getValue(1, Boolean.TYPE); + boolean resultC = expression.getValue(1, boolean.class); assertThat(resultC).isTrue(); expression = parser.parseExpression("false"); - resultI = expression.getValue(1, Boolean.TYPE); + resultI = expression.getValue(1, boolean.class); assertThat(resultI).isFalse(); assertThat(SpelCompiler.compile(expression)).isTrue(); - resultC = expression.getValue(1, Boolean.TYPE); + resultC = expression.getValue(1, boolean.class); assertThat(resultC).isFalse(); } @Test void floatLiteral() { expression = parser.parseExpression("3.4f"); - float resultI = expression.getValue(new TestClass1(), Float.TYPE); + float resultI = expression.getValue(new TestClass1(), float.class); assertCanCompile(expression); - float resultC = expression.getValue(new TestClass1(), Float.TYPE); + float resultC = expression.getValue(new TestClass1(), float.class); assertThat(resultI).isCloseTo(3.4f, within(0.1f)); assertThat(resultC).isCloseTo(3.4f, within(0.1f)); @@ -525,54 +525,54 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { @Test void opOr() { Expression expression = parser.parseExpression("false or false"); - boolean resultI = expression.getValue(1, Boolean.TYPE); + boolean resultI = expression.getValue(1, boolean.class); SpelCompiler.compile(expression); - boolean resultC = expression.getValue(1, Boolean.TYPE); + boolean resultC = expression.getValue(1, boolean.class); assertThat(resultI).isFalse(); assertThat(resultC).isFalse(); expression = parser.parseExpression("false or true"); - resultI = expression.getValue(1, Boolean.TYPE); + resultI = expression.getValue(1, boolean.class); assertCanCompile(expression); - resultC = expression.getValue(1, Boolean.TYPE); + resultC = expression.getValue(1, boolean.class); assertThat(resultI).isTrue(); assertThat(resultC).isTrue(); expression = parser.parseExpression("true or false"); - resultI = expression.getValue(1, Boolean.TYPE); + resultI = expression.getValue(1, boolean.class); assertCanCompile(expression); - resultC = expression.getValue(1, Boolean.TYPE); + resultC = expression.getValue(1, boolean.class); assertThat(resultI).isTrue(); assertThat(resultC).isTrue(); expression = parser.parseExpression("true or true"); - resultI = expression.getValue(1, Boolean.TYPE); + resultI = expression.getValue(1, boolean.class); assertCanCompile(expression); - resultC = expression.getValue(1, Boolean.TYPE); + resultC = expression.getValue(1, boolean.class); assertThat(resultI).isTrue(); assertThat(resultC).isTrue(); TestClass4 tc = new TestClass4(); expression = parser.parseExpression("getfalse() or gettrue()"); - resultI = expression.getValue(tc, Boolean.TYPE); + resultI = expression.getValue(tc, boolean.class); assertCanCompile(expression); - resultC = expression.getValue(tc, Boolean.TYPE); + resultC = expression.getValue(tc, boolean.class); assertThat(resultI).isTrue(); assertThat(resultC).isTrue(); // Can't compile this as we aren't going down the getfalse() branch in our evaluation expression = parser.parseExpression("gettrue() or getfalse()"); - resultI = expression.getValue(tc, Boolean.TYPE); + resultI = expression.getValue(tc, boolean.class); assertCantCompile(expression); expression = parser.parseExpression("getA() or getB()"); tc.a = true; tc.b = true; - resultI = expression.getValue(tc, Boolean.TYPE); + resultI = expression.getValue(tc, boolean.class); assertCantCompile(expression); // Haven't yet been into second branch tc.a = false; tc.b = true; - resultI = expression.getValue(tc, Boolean.TYPE); + resultI = expression.getValue(tc, boolean.class); assertCanCompile(expression); // Now been down both assertThat(resultI).isTrue(); @@ -587,30 +587,30 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { @Test void opAnd() { Expression expression = parser.parseExpression("false and false"); - boolean resultI = expression.getValue(1, Boolean.TYPE); + boolean resultI = expression.getValue(1, boolean.class); SpelCompiler.compile(expression); - boolean resultC = expression.getValue(1, Boolean.TYPE); + boolean resultC = expression.getValue(1, boolean.class); assertThat(resultI).isFalse(); assertThat(resultC).isFalse(); expression = parser.parseExpression("false and true"); - resultI = expression.getValue(1, Boolean.TYPE); + resultI = expression.getValue(1, boolean.class); SpelCompiler.compile(expression); - resultC = expression.getValue(1, Boolean.TYPE); + resultC = expression.getValue(1, boolean.class); assertThat(resultI).isFalse(); assertThat(resultC).isFalse(); expression = parser.parseExpression("true and false"); - resultI = expression.getValue(1, Boolean.TYPE); + resultI = expression.getValue(1, boolean.class); SpelCompiler.compile(expression); - resultC = expression.getValue(1, Boolean.TYPE); + resultC = expression.getValue(1, boolean.class); assertThat(resultI).isFalse(); assertThat(resultC).isFalse(); expression = parser.parseExpression("true and true"); - resultI = expression.getValue(1, Boolean.TYPE); + resultI = expression.getValue(1, boolean.class); SpelCompiler.compile(expression); - resultC = expression.getValue(1, Boolean.TYPE); + resultC = expression.getValue(1, boolean.class); assertThat(resultI).isTrue(); assertThat(resultC).isTrue(); @@ -618,22 +618,22 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { // Can't compile this as we aren't going down the gettrue() branch in our evaluation expression = parser.parseExpression("getfalse() and gettrue()"); - resultI = expression.getValue(tc, Boolean.TYPE); + resultI = expression.getValue(tc, boolean.class); assertCantCompile(expression); expression = parser.parseExpression("getA() and getB()"); tc.a = false; tc.b = false; - resultI = expression.getValue(tc, Boolean.TYPE); + resultI = expression.getValue(tc, boolean.class); assertCantCompile(expression); // Haven't yet been into second branch tc.a = true; tc.b = false; - resultI = expression.getValue(tc, Boolean.TYPE); + resultI = expression.getValue(tc, boolean.class); assertCanCompile(expression); // Now been down both assertThat(resultI).isFalse(); tc.a = true; tc.b = true; - resultI = expression.getValue(tc, Boolean.TYPE); + resultI = expression.getValue(tc, boolean.class); assertThat(resultI).isTrue(); boolean b = true; @@ -1021,7 +1021,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { ctx.setVariable("b", "boo"); assertThat(expression.getValue(ctx)).isEqualTo("fooboo"); - m = Math.class.getDeclaredMethod("pow", Double.TYPE, Double.TYPE); + m = Math.class.getDeclaredMethod("pow", double.class, double.class); ctx.setVariable("kapow",m); expression = parser.parseExpression("#kapow(2.0d,2.0d)"); assertThat(expression.getValue(ctx).toString()).isEqualTo("4.0"); @@ -1109,7 +1109,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { void functionReferenceNonCompilableArguments_SPR12359() throws Exception { StandardEvaluationContext context = new StandardEvaluationContext(new Object[] {"1"}); context.registerFunction("negate", SomeCompareMethod2.class.getDeclaredMethod( - "negate", Integer.TYPE)); + "negate", int.class)); context.setVariable("arg", "2"); int[] ints = new int[] {1,2,3}; context.setVariable("ints",ints); @@ -3242,11 +3242,11 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { assertThat(expression.getValue()).isEqualTo(0); expression = parse("payload%2==0"); - assertThat(expression.getValue(new GenericMessageTestHelper<>(4), Boolean.TYPE)).isTrue(); - assertThat(expression.getValue(new GenericMessageTestHelper<>(5), Boolean.TYPE)).isFalse(); + assertThat(expression.getValue(new GenericMessageTestHelper<>(4), boolean.class)).isTrue(); + assertThat(expression.getValue(new GenericMessageTestHelper<>(5), boolean.class)).isFalse(); assertCanCompile(expression); - assertThat(expression.getValue(new GenericMessageTestHelper<>(4), Boolean.TYPE)).isTrue(); - assertThat(expression.getValue(new GenericMessageTestHelper<>(5), Boolean.TYPE)).isFalse(); + assertThat(expression.getValue(new GenericMessageTestHelper<>(4), boolean.class)).isTrue(); + assertThat(expression.getValue(new GenericMessageTestHelper<>(5), boolean.class)).isFalse(); expression = parse("8%3"); assertThat(expression.getValue()).isEqualTo(2); @@ -4198,9 +4198,9 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { @Test void methodReference_staticMethod() { Expression expression = parser.parseExpression("T(Integer).valueOf(42)"); - int resultI = expression.getValue(new TestClass1(), Integer.TYPE); + int resultI = expression.getValue(new TestClass1(), int.class); assertCanCompile(expression); - int resultC = expression.getValue(new TestClass1(), Integer.TYPE); + int resultC = expression.getValue(new TestClass1(), int.class); assertThat(resultI).isEqualTo(42); assertThat(resultC).isEqualTo(42); } @@ -4228,19 +4228,19 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { @Test void methodReference_simpleInstanceMethodNoArgReturnPrimitive() { expression = parser.parseExpression("intValue()"); - int resultI = expression.getValue(42, Integer.TYPE); + int resultI = expression.getValue(42, int.class); assertThat(resultI).isEqualTo(42); assertCanCompile(expression); - int resultC = expression.getValue(42, Integer.TYPE); + int resultC = expression.getValue(42, int.class); assertThat(resultC).isEqualTo(42); } @Test void methodReference_simpleInstanceMethodOneArgReturnPrimitive1() { Expression expression = parser.parseExpression("indexOf('b')"); - int resultI = expression.getValue("abc", Integer.TYPE); + int resultI = expression.getValue("abc", int.class); assertCanCompile(expression); - int resultC = expression.getValue("abc", Integer.TYPE); + int resultC = expression.getValue("abc", int.class); assertThat(resultI).isEqualTo(1); assertThat(resultC).isEqualTo(1); } @@ -4248,10 +4248,10 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { @Test void methodReference_simpleInstanceMethodOneArgReturnPrimitive2() { expression = parser.parseExpression("charAt(2)"); - char resultI = expression.getValue("abc", Character.TYPE); + char resultI = expression.getValue("abc", char.class); assertThat(resultI).isEqualTo('c'); assertCanCompile(expression); - char resultC = expression.getValue("abc", Character.TYPE); + char resultC = expression.getValue("abc", char.class); assertThat(resultC).isEqualTo('c'); } @@ -4877,44 +4877,44 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests { @Test void compilerWithGenerics_12040_3() { expression = parser.parseExpression("payload >= 2"); - assertThat(expression.getValue(new GenericMessageTestHelper2<>(4), Boolean.TYPE)).isTrue(); + assertThat(expression.getValue(new GenericMessageTestHelper2<>(4), boolean.class)).isTrue(); assertCanCompile(expression); - assertThat(expression.getValue(new GenericMessageTestHelper2<>(1), Boolean.TYPE)).isFalse(); + assertThat(expression.getValue(new GenericMessageTestHelper2<>(1), boolean.class)).isFalse(); expression = parser.parseExpression("2 >= payload"); - assertThat(expression.getValue(new GenericMessageTestHelper2<>(5), Boolean.TYPE)).isFalse(); + assertThat(expression.getValue(new GenericMessageTestHelper2<>(5), boolean.class)).isFalse(); assertCanCompile(expression); - assertThat(expression.getValue(new GenericMessageTestHelper2<>(1), Boolean.TYPE)).isTrue(); + assertThat(expression.getValue(new GenericMessageTestHelper2<>(1), boolean.class)).isTrue(); expression = parser.parseExpression("payload > 2"); - assertThat(expression.getValue(new GenericMessageTestHelper2<>(4), Boolean.TYPE)).isTrue(); + assertThat(expression.getValue(new GenericMessageTestHelper2<>(4), boolean.class)).isTrue(); assertCanCompile(expression); - assertThat(expression.getValue(new GenericMessageTestHelper2<>(1), Boolean.TYPE)).isFalse(); + assertThat(expression.getValue(new GenericMessageTestHelper2<>(1), boolean.class)).isFalse(); expression = parser.parseExpression("2 > payload"); - assertThat(expression.getValue(new GenericMessageTestHelper2<>(5), Boolean.TYPE)).isFalse(); + assertThat(expression.getValue(new GenericMessageTestHelper2<>(5), boolean.class)).isFalse(); assertCanCompile(expression); - assertThat(expression.getValue(new GenericMessageTestHelper2<>(1), Boolean.TYPE)).isTrue(); + assertThat(expression.getValue(new GenericMessageTestHelper2<>(1), boolean.class)).isTrue(); expression = parser.parseExpression("payload <=2"); - assertThat(expression.getValue(new GenericMessageTestHelper2<>(1), Boolean.TYPE)).isTrue(); + assertThat(expression.getValue(new GenericMessageTestHelper2<>(1), boolean.class)).isTrue(); assertCanCompile(expression); - assertThat(expression.getValue(new GenericMessageTestHelper2<>(6), Boolean.TYPE)).isFalse(); + assertThat(expression.getValue(new GenericMessageTestHelper2<>(6), boolean.class)).isFalse(); expression = parser.parseExpression("2 <= payload"); - assertThat(expression.getValue(new GenericMessageTestHelper2<>(1), Boolean.TYPE)).isFalse(); + assertThat(expression.getValue(new GenericMessageTestHelper2<>(1), boolean.class)).isFalse(); assertCanCompile(expression); - assertThat(expression.getValue(new GenericMessageTestHelper2<>(6), Boolean.TYPE)).isTrue(); + assertThat(expression.getValue(new GenericMessageTestHelper2<>(6), boolean.class)).isTrue(); expression = parser.parseExpression("payload < 2"); - assertThat(expression.getValue(new GenericMessageTestHelper2<>(1), Boolean.TYPE)).isTrue(); + assertThat(expression.getValue(new GenericMessageTestHelper2<>(1), boolean.class)).isTrue(); assertCanCompile(expression); - assertThat(expression.getValue(new GenericMessageTestHelper2<>(6), Boolean.TYPE)).isFalse(); + assertThat(expression.getValue(new GenericMessageTestHelper2<>(6), boolean.class)).isFalse(); expression = parser.parseExpression("2 < payload"); - assertThat(expression.getValue(new GenericMessageTestHelper2<>(1), Boolean.TYPE)).isFalse(); + assertThat(expression.getValue(new GenericMessageTestHelper2<>(1), boolean.class)).isFalse(); assertCanCompile(expression); - assertThat(expression.getValue(new GenericMessageTestHelper2<>(6), Boolean.TYPE)).isTrue(); + assertThat(expression.getValue(new GenericMessageTestHelper2<>(6), boolean.class)).isTrue(); } @Test diff --git a/spring-expression/src/test/java/org/springframework/expression/spel/SpelCompilationPerformanceTests.java b/spring-expression/src/test/java/org/springframework/expression/spel/SpelCompilationPerformanceTests.java index fb96e4a6ec..24ac8e8e01 100644 --- a/spring-expression/src/test/java/org/springframework/expression/spel/SpelCompilationPerformanceTests.java +++ b/spring-expression/src/test/java/org/springframework/expression/spel/SpelCompilationPerformanceTests.java @@ -274,14 +274,14 @@ public class SpelCompilationPerformanceTests extends AbstractExpressionTests { // warmup for (int i = 0; i < count; i++) { - b = expression.getValue(payload, Boolean.TYPE); + b = expression.getValue(payload, boolean.class); } log("timing interpreted: "); for (int i = 0; i < iterations; i++) { long stime = System.currentTimeMillis(); for (int j = 0; j < count; j++) { - b = expression.getValue(payload, Boolean.TYPE); + b = expression.getValue(payload, boolean.class); } long etime = System.currentTimeMillis(); long interpretedSpeed = (etime - stime); @@ -292,12 +292,12 @@ public class SpelCompilationPerformanceTests extends AbstractExpressionTests { compile(expression); boolean bc = false; - expression.getValue(payload, Boolean.TYPE); + expression.getValue(payload, boolean.class); log("timing compiled: "); for (int i = 0; i < iterations; i++) { long stime = System.currentTimeMillis(); for (int j = 0; j < count; j++) { - bc = expression.getValue(payload, Boolean.TYPE); + bc = expression.getValue(payload, boolean.class); } long etime = System.currentTimeMillis(); long compiledSpeed = (etime - stime); @@ -316,7 +316,7 @@ public class SpelCompilationPerformanceTests extends AbstractExpressionTests { // Verify if the input changes, the result changes payload.DR[0].DRFixedSection.duration = 0.04d; - bc = expression.getValue(payload, Boolean.TYPE); + bc = expression.getValue(payload, boolean.class); assertThat(bc).isTrue(); } diff --git a/spring-expression/src/test/java/org/springframework/expression/spel/TestScenarioCreator.java b/spring-expression/src/test/java/org/springframework/expression/spel/TestScenarioCreator.java index 4f13310b7e..ca36cc706e 100644 --- a/spring-expression/src/test/java/org/springframework/expression/spel/TestScenarioCreator.java +++ b/spring-expression/src/test/java/org/springframework/expression/spel/TestScenarioCreator.java @@ -57,15 +57,15 @@ class TestScenarioCreator { private static void populateFunctions(StandardEvaluationContext testContext) { try { testContext.registerFunction("isEven", - TestScenarioCreator.class.getDeclaredMethod("isEven", Integer.TYPE)); + TestScenarioCreator.class.getDeclaredMethod("isEven", int.class)); testContext.registerFunction("reverseInt", - TestScenarioCreator.class.getDeclaredMethod("reverseInt", Integer.TYPE, Integer.TYPE, Integer.TYPE)); + TestScenarioCreator.class.getDeclaredMethod("reverseInt", int.class, int.class, int.class)); testContext.registerFunction("reverseString", TestScenarioCreator.class.getDeclaredMethod("reverseString", String.class)); testContext.registerFunction("varargsFunction", TestScenarioCreator.class.getDeclaredMethod("varargsFunction", String[].class)); testContext.registerFunction("varargsFunction2", - TestScenarioCreator.class.getDeclaredMethod("varargsFunction2", Integer.TYPE, String[].class)); + TestScenarioCreator.class.getDeclaredMethod("varargsFunction2", int.class, String[].class)); } catch (Exception ex) { throw new IllegalStateException(ex); diff --git a/spring-expression/src/test/java/org/springframework/expression/spel/support/ReflectionHelperTests.java b/spring-expression/src/test/java/org/springframework/expression/spel/support/ReflectionHelperTests.java index 77b9b2ff9e..6e1b9c08cc 100644 --- a/spring-expression/src/test/java/org/springframework/expression/spel/support/ReflectionHelperTests.java +++ b/spring-expression/src/test/java/org/springframework/expression/spel/support/ReflectionHelperTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2023 the original author or authors. + * Copyright 2002-2024 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. @@ -128,16 +128,16 @@ class ReflectionHelperTests extends AbstractExpressionTests { StandardTypeConverter tc = new StandardTypeConverter(); // Calling foo(String,int) with (String,Integer) requires boxing conversion of argument one - checkMatch(new Class[] {String.class, Integer.TYPE}, new Class[] {String.class,Integer.class},tc, ArgumentsMatchKind.CLOSE); + checkMatch(new Class[] {String.class, int.class}, new Class[] {String.class,Integer.class},tc, ArgumentsMatchKind.CLOSE); // Passing (int,String) on call to foo(Integer,String) requires boxing conversion of argument zero - checkMatch(new Class[] {Integer.TYPE, String.class}, new Class[] {Integer.class, String.class},tc, ArgumentsMatchKind.CLOSE); + checkMatch(new Class[] {int.class, String.class}, new Class[] {Integer.class, String.class},tc, ArgumentsMatchKind.CLOSE); // Passing (int,Sub) on call to foo(Integer,Super) requires boxing conversion of argument zero - checkMatch(new Class[] {Integer.TYPE, Sub.class}, new Class[] {Integer.class, Super.class}, tc, ArgumentsMatchKind.CLOSE); + checkMatch(new Class[] {int.class, Sub.class}, new Class[] {Integer.class, Super.class}, tc, ArgumentsMatchKind.CLOSE); // Passing (int,Sub,boolean) on call to foo(Integer,Super,Boolean) requires boxing conversion of arguments zero and two - // TODO checkMatch(new Class[] {Integer.TYPE, Sub.class, Boolean.TYPE}, new Class[] {Integer.class, Super.class, Boolean.class}, tc, ArgsMatchKind.REQUIRES_CONVERSION); + // TODO checkMatch(new Class[] {int.class, Sub.class, boolean.class}, new Class[] {Integer.class, Super.class, Boolean.class}, tc, ArgsMatchKind.REQUIRES_CONVERSION); } @Test diff --git a/spring-messaging/src/main/java/org/springframework/messaging/handler/annotation/reactive/AbstractNamedValueMethodArgumentResolver.java b/spring-messaging/src/main/java/org/springframework/messaging/handler/annotation/reactive/AbstractNamedValueMethodArgumentResolver.java index c834c4ee16..054a976204 100644 --- a/spring-messaging/src/main/java/org/springframework/messaging/handler/annotation/reactive/AbstractNamedValueMethodArgumentResolver.java +++ b/spring-messaging/src/main/java/org/springframework/messaging/handler/annotation/reactive/AbstractNamedValueMethodArgumentResolver.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2023 the original author or authors. + * Copyright 2002-2024 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. @@ -207,7 +207,7 @@ public abstract class AbstractNamedValueMethodArgumentResolver implements SyncHa @Nullable private Object handleNullValue(String name, @Nullable Object value, Class paramType) { if (value == null) { - if (Boolean.TYPE.equals(paramType)) { + if (paramType == boolean.class) { return Boolean.FALSE; } else if (paramType.isPrimitive()) { diff --git a/spring-messaging/src/main/java/org/springframework/messaging/handler/annotation/support/AbstractNamedValueMethodArgumentResolver.java b/spring-messaging/src/main/java/org/springframework/messaging/handler/annotation/support/AbstractNamedValueMethodArgumentResolver.java index 2dc230cbc5..8f2febc4fa 100644 --- a/spring-messaging/src/main/java/org/springframework/messaging/handler/annotation/support/AbstractNamedValueMethodArgumentResolver.java +++ b/spring-messaging/src/main/java/org/springframework/messaging/handler/annotation/support/AbstractNamedValueMethodArgumentResolver.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2023 the original author or authors. + * Copyright 2002-2024 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. @@ -219,7 +219,7 @@ public abstract class AbstractNamedValueMethodArgumentResolver implements Handle @Nullable private Object handleNullValue(String name, @Nullable Object value, Class paramType) { if (value == null) { - if (Boolean.TYPE.equals(paramType)) { + if (paramType == boolean.class) { return Boolean.FALSE; } else if (paramType.isPrimitive()) { diff --git a/spring-messaging/src/main/java/org/springframework/messaging/handler/invocation/reactive/InvocableHandlerMethod.java b/spring-messaging/src/main/java/org/springframework/messaging/handler/invocation/reactive/InvocableHandlerMethod.java index 7cc7697e7b..e1dc2f4aad 100644 --- a/spring-messaging/src/main/java/org/springframework/messaging/handler/invocation/reactive/InvocableHandlerMethod.java +++ b/spring-messaging/src/main/java/org/springframework/messaging/handler/invocation/reactive/InvocableHandlerMethod.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2021 the original author or authors. + * Copyright 2002-2024 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. @@ -214,7 +214,7 @@ public class InvocableHandlerMethod extends HandlerMethod { } Method method = returnType.getMethod(); return method != null && KotlinDetector.isSuspendingFunction(method) && - Void.TYPE.equals(returnType.getParameterType()); + (returnType.getParameterType() == void.class); } } diff --git a/spring-oxm/src/main/java/org/springframework/oxm/jaxb/Jaxb2Marshaller.java b/spring-oxm/src/main/java/org/springframework/oxm/jaxb/Jaxb2Marshaller.java index 28ecbaa0c8..9ed4a30a7c 100644 --- a/spring-oxm/src/main/java/org/springframework/oxm/jaxb/Jaxb2Marshaller.java +++ b/spring-oxm/src/main/java/org/springframework/oxm/jaxb/Jaxb2Marshaller.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2023 the original author or authors. + * Copyright 2002-2024 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. @@ -619,12 +619,12 @@ public class Jaxb2Marshaller implements MimeMarshaller, MimeUnmarshaller, Generi parameterizedType.getActualTypeArguments().length == 1) { Type typeArgument = parameterizedType.getActualTypeArguments()[0]; if (typeArgument instanceof Class classArgument) { - return ((classArgument.isArray() && Byte.TYPE == classArgument.componentType()) || + return ((classArgument.isArray() && byte.class == classArgument.componentType()) || isPrimitiveWrapper(classArgument) || isStandardClass(classArgument) || supportsInternal(classArgument, false)); } else if (typeArgument instanceof GenericArrayType arrayType) { - return (Byte.TYPE == arrayType.getGenericComponentType()); + return (byte.class == arrayType.getGenericComponentType()); } } } diff --git a/spring-oxm/src/test/java/org/springframework/oxm/xstream/XStreamMarshallerTests.java b/spring-oxm/src/test/java/org/springframework/oxm/xstream/XStreamMarshallerTests.java index 9bb1ea0579..bd35899395 100644 --- a/spring-oxm/src/test/java/org/springframework/oxm/xstream/XStreamMarshallerTests.java +++ b/spring-oxm/src/test/java/org/springframework/oxm/xstream/XStreamMarshallerTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2023 the original author or authors. + * Copyright 2002-2024 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. @@ -230,7 +230,7 @@ class XStreamMarshallerTests { @Test void useAttributesFor() throws Exception { - marshaller.setUseAttributeForTypes(Long.TYPE); + marshaller.setUseAttributeForTypes(long.class); Writer writer = new StringWriter(); marshaller.marshal(flight, new StreamResult(writer)); String expected = ""; @@ -239,7 +239,7 @@ class XStreamMarshallerTests { @Test void useAttributesForStringClassMap() throws Exception { - marshaller.setUseAttributeFor(Collections.singletonMap("flightNumber", Long.TYPE)); + marshaller.setUseAttributeFor(Collections.singletonMap("flightNumber", long.class)); Writer writer = new StringWriter(); marshaller.marshal(flight, new StreamResult(writer)); String expected = ""; diff --git a/spring-tx/src/test/java/org/springframework/transaction/annotation/AnnotationTransactionAttributeSourceTests.java b/spring-tx/src/test/java/org/springframework/transaction/annotation/AnnotationTransactionAttributeSourceTests.java index c72ebd5864..d24ebd9b38 100644 --- a/spring-tx/src/test/java/org/springframework/transaction/annotation/AnnotationTransactionAttributeSourceTests.java +++ b/spring-tx/src/test/java/org/springframework/transaction/annotation/AnnotationTransactionAttributeSourceTests.java @@ -203,7 +203,7 @@ class AnnotationTransactionAttributeSourceTests { assertThat(actual.getLabels()).containsOnly("retryable", "long-running"); - method = TestBean11.class.getMethod("setAge", Integer.TYPE); + method = TestBean11.class.getMethod("setAge", int.class); actual = atas.getTransactionAttribute(method, method.getDeclaringClass()); assertThat(actual.getLabels()).containsOnly("short-running"); diff --git a/spring-web/src/main/java/org/springframework/web/method/annotation/AbstractNamedValueMethodArgumentResolver.java b/spring-web/src/main/java/org/springframework/web/method/annotation/AbstractNamedValueMethodArgumentResolver.java index 666c45e034..18f6c805f4 100644 --- a/spring-web/src/main/java/org/springframework/web/method/annotation/AbstractNamedValueMethodArgumentResolver.java +++ b/spring-web/src/main/java/org/springframework/web/method/annotation/AbstractNamedValueMethodArgumentResolver.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2023 the original author or authors. + * Copyright 2002-2024 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. @@ -263,7 +263,7 @@ public abstract class AbstractNamedValueMethodArgumentResolver implements Handle @Nullable private Object handleNullValue(String name, @Nullable Object value, Class paramType) { if (value == null) { - if (Boolean.TYPE.equals(paramType)) { + if (paramType == boolean.class) { return Boolean.FALSE; } else if (paramType.isPrimitive()) { diff --git a/spring-web/src/test/java/org/springframework/web/method/annotation/WebArgumentResolverAdapterTests.java b/spring-web/src/test/java/org/springframework/web/method/annotation/WebArgumentResolverAdapterTests.java index bbd987b7c8..27ca14d6ac 100644 --- a/spring-web/src/test/java/org/springframework/web/method/annotation/WebArgumentResolverAdapterTests.java +++ b/spring-web/src/test/java/org/springframework/web/method/annotation/WebArgumentResolverAdapterTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2023 the original author or authors. + * Copyright 2002-2024 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,7 +53,7 @@ class WebArgumentResolverAdapterTests { @BeforeEach void setUp() throws Exception { - parameter = new MethodParameter(getClass().getMethod("handle", Integer.TYPE), 0); + parameter = new MethodParameter(getClass().getMethod("handle", int.class), 0); // Expose request to the current thread (for SpEL expressions) RequestContextHolder.setRequestAttributes(webRequest); diff --git a/spring-webflux/src/main/java/org/springframework/web/reactive/result/method/annotation/AbstractNamedValueArgumentResolver.java b/spring-webflux/src/main/java/org/springframework/web/reactive/result/method/annotation/AbstractNamedValueArgumentResolver.java index c014ee74f4..6535158825 100644 --- a/spring-webflux/src/main/java/org/springframework/web/reactive/result/method/annotation/AbstractNamedValueArgumentResolver.java +++ b/spring-webflux/src/main/java/org/springframework/web/reactive/result/method/annotation/AbstractNamedValueArgumentResolver.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2023 the original author or authors. + * Copyright 2002-2024 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. @@ -272,7 +272,7 @@ public abstract class AbstractNamedValueArgumentResolver extends HandlerMethodAr @Nullable private Object handleNullValue(String name, @Nullable Object value, Class paramType) { if (value == null) { - if (Boolean.TYPE.equals(paramType)) { + if (paramType == boolean.class) { return Boolean.FALSE; } else if (paramType.isPrimitive()) { diff --git a/spring-webmvc/src/test/java/org/springframework/web/servlet/mvc/method/annotation/HttpEntityMethodProcessorMockTests.java b/spring-webmvc/src/test/java/org/springframework/web/servlet/mvc/method/annotation/HttpEntityMethodProcessorMockTests.java index 2a72be5b8b..b2e698e195 100644 --- a/spring-webmvc/src/test/java/org/springframework/web/servlet/mvc/method/annotation/HttpEntityMethodProcessorMockTests.java +++ b/spring-webmvc/src/test/java/org/springframework/web/servlet/mvc/method/annotation/HttpEntityMethodProcessorMockTests.java @@ -160,7 +160,7 @@ class HttpEntityMethodProcessorMockTests { stringHttpMessageConverter, resourceMessageConverter, resourceRegionMessageConverter, jsonMessageConverter)); Method handle1 = getClass().getMethod("handle1", HttpEntity.class, ResponseEntity.class, - Integer.TYPE, RequestEntity.class); + int.class, RequestEntity.class); paramHttpEntity = new MethodParameter(handle1, 0); paramRequestEntity = new MethodParameter(handle1, 3); diff --git a/spring-webmvc/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestResponseBodyMethodProcessorMockTests.java b/spring-webmvc/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestResponseBodyMethodProcessorMockTests.java index d1c3cf2edb..3b23dc21ab 100644 --- a/spring-webmvc/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestResponseBodyMethodProcessorMockTests.java +++ b/spring-webmvc/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestResponseBodyMethodProcessorMockTests.java @@ -121,7 +121,7 @@ class RequestResponseBodyMethodProcessorMockTests { servletRequest.setMethod("POST"); - Method methodHandle1 = getClass().getMethod("handle1", String.class, Integer.TYPE); + Method methodHandle1 = getClass().getMethod("handle1", String.class, int.class); paramRequestBodyString = new MethodParameter(methodHandle1, 0); paramInt = new MethodParameter(methodHandle1, 1); paramValidBean = new MethodParameter(getClass().getMethod("handle2", SimpleBean.class), 0);