diff --git a/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/support/JdbcRepositoryQuery.java b/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/support/JdbcRepositoryQuery.java index 800da87dc..af83ddfe1 100644 --- a/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/support/JdbcRepositoryQuery.java +++ b/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/support/JdbcRepositoryQuery.java @@ -26,7 +26,7 @@ import org.springframework.data.jdbc.core.convert.JdbcConverter; import org.springframework.data.jdbc.core.convert.JdbcValue; import org.springframework.data.jdbc.support.JdbcUtil; import org.springframework.data.mapping.callback.EntityCallbacks; -import org.springframework.data.relational.core.mapping.JdbcCompatibleTypes; +import org.springframework.data.relational.core.mapping.JdbcColumnTypes; import org.springframework.data.relational.core.mapping.RelationalMappingContext; import org.springframework.data.relational.core.mapping.RelationalPersistentEntity; import org.springframework.data.relational.core.mapping.event.AfterLoadCallback; @@ -93,7 +93,7 @@ class JdbcRepositoryQuery implements RepositoryQuery { this.queryMethod = queryMethod; this.operations = operations; - RowMapper rowMapper = determineRowMapper(defaultRowMapper); + RowMapper rowMapper = determineRowMapper(defaultRowMapper); executor = createExecutor( // queryMethod, // determineResultSetExtractor(rowMapper != defaultRowMapper ? rowMapper : null), // @@ -103,8 +103,8 @@ class JdbcRepositoryQuery implements RepositoryQuery { this.converter = converter; } - private QueryExecutor createExecutor(JdbcQueryMethod queryMethod, @Nullable ResultSetExtractor extractor, - RowMapper rowMapper) { + private QueryExecutor createExecutor(JdbcQueryMethod queryMethod, + @Nullable ResultSetExtractor extractor, RowMapper rowMapper) { String query = determineQuery(); @@ -132,15 +132,13 @@ class JdbcRepositoryQuery implements RepositoryQuery { return executor.execute(bindParameters(objects)); } - private QueryExecutor createObjectQueryExecutor(QueryExecutor executor) { + private QueryExecutor createObjectQueryExecutor(QueryExecutor executor) { return parameters -> { try { - Object result; - - result = executor.execute(parameters); + Object result = executor.execute(parameters); publishAfterLoad(result); @@ -228,7 +226,7 @@ class JdbcRepositoryQuery implements RepositoryQuery { String parameterName = p.getName().orElseThrow(() -> new IllegalStateException(PARAMETER_NEEDS_TO_BE_NAMED)); Class parameterType = queryMethod.getParameters().getParameter(p.getIndex()).getType(); - Class conversionTargetType = JdbcCompatibleTypes.INSTANCE.columnTypeForNonEntity(parameterType); + Class conversionTargetType = JdbcColumnTypes.INSTANCE.resolvePrimitiveType(parameterType); JdbcValue jdbcValue = converter.writeJdbcValue(value, conversionTargetType, JdbcUtil.sqlTypeFor(conversionTargetType)); @@ -237,16 +235,16 @@ class JdbcRepositoryQuery implements RepositoryQuery { if (jdbcType == null) { parameters.addValue(parameterName, jdbcValue.getValue()); - }else { + } else { parameters.addValue(parameterName, jdbcValue.getValue(), jdbcType.getVendorTypeNumber()); } } @Nullable - private ResultSetExtractor determineResultSetExtractor(@Nullable RowMapper rowMapper) { + @SuppressWarnings({ "rawtypes", "unchecked" }) + private ResultSetExtractor determineResultSetExtractor(@Nullable RowMapper rowMapper) { - Class resultSetExtractorClass = (Class) queryMethod - .getResultSetExtractorClass(); + Class resultSetExtractorClass = queryMethod.getResultSetExtractorClass(); if (isUnconfigured(resultSetExtractorClass, ResultSetExtractor.class)) { return null; @@ -262,15 +260,16 @@ class JdbcRepositoryQuery implements RepositoryQuery { return BeanUtils.instantiateClass(resultSetExtractorClass); } - private RowMapper determineRowMapper(RowMapper defaultMapper) { + @SuppressWarnings("unchecked") + private RowMapper determineRowMapper(RowMapper defaultMapper) { Class rowMapperClass = queryMethod.getRowMapperClass(); if (isUnconfigured(rowMapperClass, RowMapper.class)) { - return defaultMapper; + return (RowMapper) defaultMapper; } - return (RowMapper) BeanUtils.instantiateClass(rowMapperClass); + return (RowMapper) BeanUtils.instantiateClass(rowMapperClass); } private static boolean isUnconfigured(@Nullable Class configuredClass, Class defaultClass) { @@ -297,7 +296,6 @@ class JdbcRepositoryQuery implements RepositoryQuery { callbacks.callback(AfterLoadCallback.class, entity); } - } private interface QueryExecutor { diff --git a/spring-data-relational/src/main/java/org/springframework/data/relational/core/mapping/BasicRelationalPersistentProperty.java b/spring-data-relational/src/main/java/org/springframework/data/relational/core/mapping/BasicRelationalPersistentProperty.java index a160c4b7c..568cbc817 100644 --- a/spring-data-relational/src/main/java/org/springframework/data/relational/core/mapping/BasicRelationalPersistentProperty.java +++ b/spring-data-relational/src/main/java/org/springframework/data/relational/core/mapping/BasicRelationalPersistentProperty.java @@ -16,11 +16,6 @@ package org.springframework.data.relational.core.mapping; import java.lang.reflect.Array; -import java.time.ZonedDateTime; -import java.time.temporal.Temporal; -import java.util.Date; -import java.util.LinkedHashMap; -import java.util.Map; import java.util.Optional; import java.util.Set; @@ -35,7 +30,6 @@ import org.springframework.data.util.Lazy; import org.springframework.data.util.Optionals; import org.springframework.lang.Nullable; import org.springframework.util.Assert; -import org.springframework.util.ClassUtils; import org.springframework.util.StringUtils; /** @@ -161,16 +155,18 @@ public class BasicRelationalPersistentProperty extends AnnotationBasedPersistent private Class doGetColumnType() { if (isReference()) { - return columnTypeForReference(); + return getReferenceColumnType(); } - Class columnType = columnTypeIfEntity(getActualType()); + if (isEntity()) { + Class columnType = getEntityColumnType(getActualType()); - if (columnType != null) { - return columnType; + if (columnType != null) { + return columnType; + } } - Class componentColumnType = JdbcCompatibleTypes.INSTANCE.columnTypeForNonEntity(getActualType()); + Class componentColumnType = JdbcColumnTypes.INSTANCE.resolvePrimitiveType(getActualType()); while (componentColumnType.isArray()) { componentColumnType = componentColumnType.getComponentType(); @@ -222,7 +218,7 @@ public class BasicRelationalPersistentProperty extends AnnotationBasedPersistent Assert.isTrue(isQualified(), "The qualifier column type is only defined for properties that are qualified"); if (isMap()) { - return getTypeInformation().getComponentType().getType(); + return getTypeInformation().getRequiredComponentType().getType(); } // for lists and arrays @@ -261,7 +257,7 @@ public class BasicRelationalPersistentProperty extends AnnotationBasedPersistent } @Nullable - private Class columnTypeIfEntity(Class type) { + private Class getEntityColumnType(Class type) { RelationalPersistentEntity persistentEntity = context.getPersistentEntity(type); @@ -277,7 +273,7 @@ public class BasicRelationalPersistentProperty extends AnnotationBasedPersistent return idProperty.getColumnType(); } - private Class columnTypeForReference() { + private Class getReferenceColumnType() { Class componentType = getTypeInformation().getRequiredComponentType().getType(); RelationalPersistentEntity referencedEntity = context.getRequiredPersistentEntity(componentType); diff --git a/spring-data-relational/src/main/java/org/springframework/data/relational/core/mapping/JdbcCompatibleTypes.java b/spring-data-relational/src/main/java/org/springframework/data/relational/core/mapping/JdbcColumnTypes.java similarity index 68% rename from spring-data-relational/src/main/java/org/springframework/data/relational/core/mapping/JdbcCompatibleTypes.java rename to spring-data-relational/src/main/java/org/springframework/data/relational/core/mapping/JdbcColumnTypes.java index 1732386bf..96ca812ce 100644 --- a/spring-data-relational/src/main/java/org/springframework/data/relational/core/mapping/JdbcCompatibleTypes.java +++ b/spring-data-relational/src/main/java/org/springframework/data/relational/core/mapping/JdbcColumnTypes.java @@ -26,32 +26,33 @@ import org.springframework.util.ClassUtils; /** * Utility that determines the necessary type conversions between Java types used in the domain model and types * compatible with JDBC drivers. - * + * * @author Jens Schauder * @since 2.0 */ -public enum JdbcCompatibleTypes { +public enum JdbcColumnTypes { INSTANCE { - private final Map, Class> javaToDbType = new LinkedHashMap<>(); - - { - - javaToDbType.put(Enum.class, String.class); - javaToDbType.put(ZonedDateTime.class, String.class); - javaToDbType.put(Temporal.class, Date.class); - } - - public Class columnTypeForNonEntity(Class type) { + @SuppressWarnings({ "unchecked", "rawtypes" }) + public Class resolvePrimitiveType(Class type) { return javaToDbType.entrySet().stream() // .filter(e -> e.getKey().isAssignableFrom(type)) // - .map(e -> (Class) e.getValue()) // + .map(e -> (Class) e.getValue()) // .findFirst() // - .orElseGet(() -> ClassUtils.resolvePrimitiveIfNecessary(type)); + .orElseGet(() -> (Class) ClassUtils.resolvePrimitiveIfNecessary(type)); } }; - public abstract Class columnTypeForNonEntity(Class type); + private static final Map, Class> javaToDbType = new LinkedHashMap<>(); + + static { + + javaToDbType.put(Enum.class, String.class); + javaToDbType.put(ZonedDateTime.class, String.class); + javaToDbType.put(Temporal.class, Date.class); + } + + public abstract Class resolvePrimitiveType(Class type); }