Use full type information for identifier and domain types exposed byRepositoryMetadata.

See #2518.

$ Conflicts:
$	src/test/java/org/springframework/data/repository/core/support/AbstractRepositoryMetadataUnitTests.java

Author: Alex Nistico

src/main/java/org/springframework/data/repository/core/RepositoryMetadata.java

@@ -27,29 +27,48 @@
  *
  * @author Oliver Gierke
  * @author Mark Paluch
+ * @author Alessandro Nistico
  */
 public interface RepositoryMetadata {
 
 	/**
-	 * Returns the id class the given class is declared for.
+	 * Returns the id {@link TypeInformation} the given class is declared for.
 	 *
-	 * @return the id class of the entity managed by the repository.
+	 * @return the {@link TypeInformation} class of the entity managed by the repository.
 	 */
-	Class<?> getIdType();
+	TypeInformation<?> getIdTypeInformation();
 
 	/**
-	 * Returns the domain class the repository is declared for.
+	 * Returns the domain {@link TypeInformation} the repository is declared for.
 	 *
 	 * @return the domain class the repository is handling.
 	 */
-	Class<?> getDomainType();
-
+	TypeInformation<?> getDomainTypeInformation();
+	
 	/**
 	 * Returns the repository interface.
 	 *
 	 * @return
 	 */
 	Class<?> getRepositoryInterface();
+	
+	/**
+	 * Returns the raw id class the given class is declared for.
+	 *
+	 * @return the raw id class of the entity managed by the repository.
+	 */
+	default Class<?> getIdType() {
+		return getIdTypeInformation().getType();
+	}
+	
+	/**
+	 * Returns the raw domain class the repository is declared for.
+	 *
+	 * @return the raw domain class the repository is handling.
+	 */
+	default Class<?> getDomainType() {
+		return getDomainTypeInformation().getType();
+	}
 
 	/**
 	 * Returns the type {@link Method} return type as it is declared in the repository. Considers suspended methods and

src/main/java/org/springframework/data/repository/core/support/AnnotationRepositoryMetadata.java

@@ -18,6 +18,8 @@
 import org.springframework.core.annotation.AnnotationUtils;
 import org.springframework.data.repository.RepositoryDefinition;
 import org.springframework.data.repository.core.RepositoryMetadata;
+import org.springframework.data.util.ClassTypeInformation;
+import org.springframework.data.util.TypeInformation;
 import org.springframework.util.Assert;
 
 /**
@@ -27,14 +29,15 @@
  * @author Oliver Gierke
  * @author Thomas Darimont
  * @author Xeno Amess
+ * @author Alessandro Nistico
  */
 public class AnnotationRepositoryMetadata extends AbstractRepositoryMetadata {
 
 	private static final String NO_ANNOTATION_FOUND = String.format("Interface %%s must be annotated with @%s!",
 			RepositoryDefinition.class.getName());
 
-	private final Class<?> idType;
-	private final Class<?> domainType;
+	private final TypeInformation<?> idType;
+	private final TypeInformation<?> domainType;
 
 	/**
 	 * Creates a new {@link AnnotationRepositoryMetadata} instance looking up repository types from a
@@ -58,7 +61,7 @@ public AnnotationRepositoryMetadata(Class<?> repositoryInterface) {
 	 * @see org.springframework.data.repository.core.RepositoryMetadata#getIdType()
 	 */
 	@Override
-	public Class<?> getIdType() {
+	public TypeInformation<?> getIdTypeInformation() {
 		return this.idType;
 	}
 
@@ -67,29 +70,29 @@ public Class<?> getIdType() {
 	 * @see org.springframework.data.repository.core.RepositoryMetadata#getDomainType()
 	 */
 	@Override
-	public Class<?> getDomainType() {
+	public TypeInformation<?> getDomainTypeInformation() {
 		return this.domainType;
 	}
 
-	private Class<?> resolveIdType(Class<?> repositoryInterface) {
+	private TypeInformation<?> resolveIdType(Class<?> repositoryInterface) {
 
 		RepositoryDefinition annotation = AnnotationUtils.findAnnotation(repositoryInterface, RepositoryDefinition.class);
 
 		if (annotation == null || annotation.idClass() == null) {
 			throw new IllegalArgumentException(String.format("Could not resolve id type of %s!", repositoryInterface));
 		}
 
-		return annotation.idClass();
+		return ClassTypeInformation.from(annotation.idClass());
 	}
 
-	private Class<?> resolveDomainType(Class<?> repositoryInterface) {
+	private TypeInformation<?> resolveDomainType(Class<?> repositoryInterface) {
 
 		RepositoryDefinition annotation = AnnotationUtils.findAnnotation(repositoryInterface, RepositoryDefinition.class);
 
 		if (annotation == null || annotation.domainClass() == null) {
 			throw new IllegalArgumentException(String.format("Could not resolve domain type of %s!", repositoryInterface));
 		}
 
-		return annotation.domainClass();
+		return ClassTypeInformation.from(annotation.domainClass());
 	}
 }

src/main/java/org/springframework/data/repository/core/support/DefaultRepositoryInformation.java

@@ -43,6 +43,7 @@
  * @author Thomas Darimont
  * @author Mark Paluch
  * @author Christoph Strobl
+ * @author Alessandro Nistico
  */
 class DefaultRepositoryInformation implements RepositoryInformation {
 
@@ -80,17 +81,17 @@ public DefaultRepositoryInformation(RepositoryMetadata metadata, Class<?> reposi
 	 * @see org.springframework.data.repository.support.RepositoryMetadata#getDomainClass()
 	 */
 	@Override
-	public Class<?> getDomainType() {
-		return metadata.getDomainType();
+	public TypeInformation<?> getDomainTypeInformation() {
+		return metadata.getDomainTypeInformation();
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.repository.support.RepositoryMetadata#getIdClass()
 	 */
 	@Override
-	public Class<?> getIdType() {
-		return metadata.getIdType();
+	public TypeInformation<?> getIdTypeInformation() {
+		return metadata.getIdTypeInformation();
 	}
 
 	/*

src/main/java/org/springframework/data/repository/core/support/DefaultRepositoryMetadata.java

@@ -30,14 +30,15 @@
  *
  * @author Oliver Gierke
  * @author Thomas Darimont
+ * @author Alessandro Nistico
  */
 public class DefaultRepositoryMetadata extends AbstractRepositoryMetadata {
 
 	private static final String MUST_BE_A_REPOSITORY = String.format("Given type must be assignable to %s!",
 			Repository.class);
 
-	private final Class<?> idType;
-	private final Class<?> domainType;
+	private final TypeInformation<?> idType;
+	private final TypeInformation<?> domainType;
 
 	/**
 	 * Creates a new {@link DefaultRepositoryMetadata} for the given repository interface.
@@ -49,31 +50,32 @@ public DefaultRepositoryMetadata(Class<?> repositoryInterface) {
 		super(repositoryInterface);
 		Assert.isTrue(Repository.class.isAssignableFrom(repositoryInterface), MUST_BE_A_REPOSITORY);
 
-		List<TypeInformation<?>> arguments = ClassTypeInformation.from(repositoryInterface) //
+		List<TypeInformation<?>> arguments = ClassTypeInformation.from(repositoryInterface)//
 				.getRequiredSuperTypeInformation(Repository.class)//
 				.getTypeArguments();
 
 		this.domainType = resolveTypeParameter(arguments, 0,
 				() -> String.format("Could not resolve domain type of %s!", repositoryInterface));
+		
 		this.idType = resolveTypeParameter(arguments, 1,
 				() -> String.format("Could not resolve id type of %s!", repositoryInterface));
 	}
 
-	private static Class<?> resolveTypeParameter(List<TypeInformation<?>> arguments, int index,
+	private static TypeInformation<?> resolveTypeParameter(List<TypeInformation<?>> arguments, int index,
 			Supplier<String> exceptionMessage) {
 
 		if (arguments.size() <= index || arguments.get(index) == null) {
 			throw new IllegalArgumentException(exceptionMessage.get());
 		}
 
-		return arguments.get(index).getType();
+		return arguments.get(index).getGenericTypeInformation();
 	}
 
-	public Class<?> getIdType() {
+	public TypeInformation<?> getIdTypeInformation() {
 		return this.idType;
 	}
 
-	public Class<?> getDomainType() {
+	public TypeInformation<?> getDomainTypeInformation() {
 		return this.domainType;
 	}
 }

src/main/java/org/springframework/data/repository/core/support/MethodLookups.java

@@ -45,6 +45,7 @@
  *
  * @author Mark Paluch
  * @author Oliver Gierke
+ * @author Alessandro Nistico
  * @since 2.0
  */
 interface MethodLookups {
@@ -120,8 +121,8 @@ public RepositoryAwareMethodLookup(RepositoryMetadata repositoryMetadata) {
 
 			Assert.notNull(repositoryMetadata, "Repository metadata must not be null!");
 
-			this.entityType = ResolvableType.forClass(repositoryMetadata.getDomainType());
-			this.idType = ResolvableType.forClass(repositoryMetadata.getIdType());
+			this.entityType = ResolvableType.forType(repositoryMetadata.getDomainTypeInformation().getGenericType());
+			this.idType = ResolvableType.forType(repositoryMetadata.getIdTypeInformation().getGenericType());
 			this.repositoryInterface = repositoryMetadata.getRepositoryInterface();
 		}
 

src/main/java/org/springframework/data/repository/support/DomainClassConverter.java

@@ -21,6 +21,7 @@
 
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.ApplicationContextAware;
+import org.springframework.core.ResolvableType;
 import org.springframework.core.convert.ConversionService;
 import org.springframework.core.convert.TypeDescriptor;
 import org.springframework.core.convert.converter.ConditionalGenericConverter;
@@ -29,6 +30,7 @@
 import org.springframework.data.repository.core.EntityInformation;
 import org.springframework.data.repository.core.RepositoryInformation;
 import org.springframework.data.util.Lazy;
+import org.springframework.data.util.TypeInformation;
 import org.springframework.lang.NonNull;
 import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
@@ -42,6 +44,7 @@
  *
  * @author Oliver Gierke
  * @author Thomas Darimont
+ * @author Alessandro Nistico
  */
 public class DomainClassConverter<T extends ConversionService & ConverterRegistry>
 		implements ConditionalGenericConverter, ApplicationContextAware {
@@ -117,6 +120,12 @@ public void setApplicationContext(ApplicationContext context) {
 			return repositories;
 		});
 	}
+	
+	
+	private static TypeDescriptor getIdTypeDescriptor(RepositoryInformation information) {
+		TypeInformation<?> idType = information.getIdTypeInformation();
+		return new TypeDescriptor(ResolvableType.forType(idType.getGenericType()), null, idType.getType().getAnnotations());
+	}
 
 	/**
 	 * Converter to create domain types from any source that can be converted into the domain types identifier type.
@@ -172,8 +181,9 @@ public Object convert(@Nullable Object source, TypeDescriptor sourceType, TypeDe
 			Class<?> domainType = targetType.getType();
 			RepositoryInvoker invoker = repositoryInvokerFactory.getInvokerFor(domainType);
 			RepositoryInformation information = repositories.getRequiredRepositoryInformation(domainType);
+			TypeDescriptor idTypeDescriptor = getIdTypeDescriptor(information);
 
-			Object id = conversionService.convert(source, information.getIdType());
+			Object id = conversionService.convert(source, sourceType, idTypeDescriptor);
 
 			return id == null ? null : invoker.invokeFindById(id).orElse(null);
 		}
@@ -199,10 +209,10 @@ public boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType) {
 
 			return repositoryInformation.map(it -> {
 
-				Class<?> rawIdType = it.getIdType();
+				TypeDescriptor idTypeDescriptor = getIdTypeDescriptor(it);
 
-				return sourceType.equals(TypeDescriptor.valueOf(rawIdType))
-						|| conversionService.canConvert(sourceType.getType(), rawIdType);
+				return sourceType.equals(idTypeDescriptor)
+						|| conversionService.canConvert(sourceType, idTypeDescriptor);
 			}).orElseThrow(
 					() -> new IllegalStateException(String.format("Couldn't find RepositoryInformation for %s!", domainType)));
 		}
@@ -254,8 +264,8 @@ public Object convert(@Nullable Object source, TypeDescriptor sourceType, TypeDe
 			Class<?> domainType = sourceType.getType();
 
 			EntityInformation<Object, ?> entityInformation = repositories.getEntityInformationFor(domainType);
-
-			return conversionService.convert(entityInformation.getId(source), targetType.getType());
+			Object id = entityInformation.getId(source);
+			return conversionService.convert(id, TypeDescriptor.forObject(id), targetType);
 		}
 
 		/*
@@ -279,10 +289,10 @@ public boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType) {
 
 			return information.map(it -> {
 
-				Class<?> rawIdType = it.getIdType();
+				TypeDescriptor idTypeDescriptor = getIdTypeDescriptor(it);
 
-				return targetType.equals(TypeDescriptor.valueOf(rawIdType))
-						|| conversionService.canConvert(rawIdType, targetType.getType());
+				return targetType.equals(idTypeDescriptor)
+						|| conversionService.canConvert(idTypeDescriptor, targetType);
 
 			}).orElseThrow(
 					() -> new IllegalStateException(String.format("Couldn't find RepositoryInformation for %s!", domainType)));

src/main/java/org/springframework/data/repository/support/ReflectionRepositoryInvoker.java

@@ -21,6 +21,7 @@
 import java.util.Optional;
 
 import org.springframework.core.MethodParameter;
+import org.springframework.core.ResolvableType;
 import org.springframework.core.convert.ConversionException;
 import org.springframework.core.convert.ConversionService;
 import org.springframework.core.convert.TypeDescriptor;
@@ -30,6 +31,7 @@
 import org.springframework.data.repository.core.RepositoryMetadata;
 import org.springframework.data.repository.query.Param;
 import org.springframework.data.repository.util.QueryExecutionConverters;
+import org.springframework.data.util.TypeInformation;
 import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
@@ -41,6 +43,7 @@
  * Base {@link RepositoryInvoker} using reflection to invoke methods on Spring Data Repositories.
  *
  * @author Oliver Gierke
+ * @author Alessandro Nistico
  * @since 1.10
  */
 class ReflectionRepositoryInvoker implements RepositoryInvoker {
@@ -50,7 +53,7 @@ class ReflectionRepositoryInvoker implements RepositoryInvoker {
 
 	private final Object repository;
 	private final CrudMethods methods;
-	private final Class<?> idType;
+	private final TypeDescriptor idTypeDescriptor;
 	private final ConversionService conversionService;
 
 	/**
@@ -70,7 +73,8 @@ public ReflectionRepositoryInvoker(Object repository, RepositoryMetadata metadat
 
 		this.repository = repository;
 		this.methods = metadata.getCrudMethods();
-		this.idType = metadata.getIdType();
+		TypeInformation<?> idType = metadata.getIdTypeInformation();
+		this.idTypeDescriptor = new TypeDescriptor(ResolvableType.forType(idType.getGenericType()), null, idType.getType().getAnnotations());
 		this.conversionService = conversionService;
 	}
 
@@ -285,16 +289,17 @@ private <T> Optional<T> returnAsOptional(@Nullable Object source) {
 	protected Object convertId(Object id) {
 
 		Assert.notNull(id, "Id must not be null!");
+        TypeDescriptor idDescriptor = TypeDescriptor.forObject(id);
 
-		if (idType.isInstance(id)) {
+		if (idDescriptor.isAssignableTo(idTypeDescriptor)) {
 			return id;
 		}
 
-		Object result = conversionService.convert(id, idType);
+		Object result = conversionService.convert(id, idDescriptor, idTypeDescriptor);
 
 		if (result == null) {
 			throw new IllegalStateException(
-					String.format("Identifier conversion of %s to %s unexpectedly returned null!", id, idType));
+					String.format("Identifier conversion of %s to %s unexpectedly returned null!", id, idTypeDescriptor.getType()));
 		}
 
 		return result;