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

Refactor ObjectToObjectConverter to use Executable instead of Member

This commit is contained in:
Sam Brannen 2022-06-13 18:01:54 +02:00
parent 73f3860bb7
commit 97854d9fec
1 changed files with 27 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
spring-core/src/main/java/org/springframework/core/convert/support/ObjectToObjectConverter.java
View File

@ -17,8 +17,8 @@
package org.springframework.core.convert.support;
import java.lang.reflect.Constructor;
import java.lang.reflect.Executable;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Member;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Collections;
@ -71,8 +71,9 @@ import org.springframework.util.ReflectionUtils;
*/
final class ObjectToObjectConverter implements ConditionalGenericConverter {
// Cache for the latest to-method resolved on a given Class
private static final Map<Class<?>, Member> conversionMemberCache =
// Cache for the latest to-method, static factory method, or factory constructor
// resolved on a given Class
private static final Map<Class<?>, Executable> conversionExecutableCache =
new ConcurrentReferenceHashMap<>(32);
@ -95,11 +96,11 @@ final class ObjectToObjectConverter implements ConditionalGenericConverter {
}
Class<?> sourceClass = sourceType.getType();
Class<?> targetClass = targetType.getType();
Member member = getValidatedMember(targetClass, sourceClass);
Executable executable = getValidatedExecutable(targetClass, sourceClass);
try {
if (member instanceof Method) {
Method method = (Method) member;
if (executable instanceof Method) {
Method method = (Method) executable;
ReflectionUtils.makeAccessible(method);
if (!Modifier.isStatic(method.getModifiers())) {
return method.invoke(source);
@ -108,8 +109,8 @@ final class ObjectToObjectConverter implements ConditionalGenericConverter {
return method.invoke(null, source);
}
}
else if (member instanceof Constructor) {
Constructor<?> ctor = (Constructor<?>) member;
else if (executable instanceof Constructor) {
Constructor<?> ctor = (Constructor<?>) executable;
ReflectionUtils.makeAccessible(ctor);
return ctor.newInstance(source);
}
@ -130,42 +131,41 @@ final class ObjectToObjectConverter implements ConditionalGenericConverter {
}
static boolean hasConversionMethodOrConstructor(Class<?> targetClass, Class<?> sourceClass) {
return (getValidatedMember(targetClass, sourceClass) != null);
return (getValidatedExecutable(targetClass, sourceClass) != null);
}
@Nullable
private static Member getValidatedMember(Class<?> targetClass, Class<?> sourceClass) {
Member member = conversionMemberCache.get(targetClass);
if (isApplicable(member, sourceClass)) {
return member;
private static Executable getValidatedExecutable(Class<?> targetClass, Class<?> sourceClass) {
Executable executable = conversionExecutableCache.get(targetClass);
if (isApplicable(executable, sourceClass)) {
return executable;
}
member = determineToMethod(targetClass, sourceClass);
if (member == null) {
member = determineFactoryMethod(targetClass, sourceClass);
if (member == null) {
member = determineFactoryConstructor(targetClass, sourceClass);
if (member == null) {
executable = determineToMethod(targetClass, sourceClass);
if (executable == null) {
executable = determineFactoryMethod(targetClass, sourceClass);
if (executable == null) {
executable = determineFactoryConstructor(targetClass, sourceClass);
if (executable == null) {
return null;
}
}
}
conversionMemberCache.put(targetClass, member);
return member;
conversionExecutableCache.put(targetClass, executable);
return executable;
}
private static boolean isApplicable(Member member, Class<?> sourceClass) {
if (member instanceof Method) {
Method method = (Method) member;
private static boolean isApplicable(Executable executable, Class<?> sourceClass) {
if (executable instanceof Method) {
Method method = (Method) executable;
return (!Modifier.isStatic(method.getModifiers()) ?
ClassUtils.isAssignable(method.getDeclaringClass(), sourceClass) :
method.getParameterTypes()[0] == sourceClass);
}
else if (member instanceof Constructor) {
Constructor<?> ctor = (Constructor<?>) member;
else if (executable instanceof Constructor) {
Constructor<?> ctor = (Constructor<?>) executable;
return (ctor.getParameterTypes()[0] == sourceClass);
}
else {