From 0ebb4a7799a105bce4b865235fed62e3be27f46e Mon Sep 17 00:00:00 2001 From: Jens Schauder Date: Wed, 18 Apr 2018 13:04:17 +0200 Subject: [PATCH] DATAJDBC-102 - Determine the EntityInstantiator to be used dynamically. Replaced the direct use of EntityInstantiator with EntityInstantiators. Moved it into the MappingContext because instantiation is part of the mapping process. Original pull request: #68. --- .../jdbc/core/DefaultDataAccessStrategy.java | 7 +++++-- .../data/jdbc/core/EntityRowMapper.java | 17 ++++++++------- .../mybatis/MyBatisDataAccessStrategy.java | 21 +++++++++++++------ .../support/JdbcQueryLookupStrategy.java | 13 ++++++++---- .../support/JdbcRepositoryFactory.java | 16 +++++++++++++- .../support/JdbcRepositoryFactoryBean.java | 14 ++++++++++++- .../DefaultDataAccessStrategyUnitTests.java | 13 ++++++++---- .../jdbc/core/EntityRowMapperUnitTests.java | 15 ++++++++----- .../SimpleJdbcRepositoryEventsUnitTests.java | 20 +++++++++++------- .../JdbcQueryLookupStrategyUnitTests.java | 9 +++++--- .../data/jdbc/testing/TestConfiguration.java | 3 ++- 11 files changed, 106 insertions(+), 42 deletions(-) diff --git a/src/main/java/org/springframework/data/jdbc/core/DefaultDataAccessStrategy.java b/src/main/java/org/springframework/data/jdbc/core/DefaultDataAccessStrategy.java index da530b54..10b95a26 100644 --- a/src/main/java/org/springframework/data/jdbc/core/DefaultDataAccessStrategy.java +++ b/src/main/java/org/springframework/data/jdbc/core/DefaultDataAccessStrategy.java @@ -27,6 +27,7 @@ import java.util.stream.StreamSupport; import org.springframework.dao.EmptyResultDataAccessException; import org.springframework.dao.InvalidDataAccessApiUsageException; import org.springframework.dao.NonTransientDataAccessException; +import org.springframework.data.convert.EntityInstantiators; import org.springframework.data.jdbc.core.mapping.JdbcMappingContext; import org.springframework.data.jdbc.core.mapping.JdbcPersistentEntity; import org.springframework.data.jdbc.core.mapping.JdbcPersistentProperty; @@ -58,6 +59,7 @@ public class DefaultDataAccessStrategy implements DataAccessStrategy { private final @NonNull SqlGeneratorSource sqlGeneratorSource; private final @NonNull JdbcMappingContext context; private final @NonNull NamedParameterJdbcOperations operations; + private final @NonNull EntityInstantiators instantiators; private final @NonNull DataAccessStrategy accessStrategy; /** @@ -65,11 +67,12 @@ public class DefaultDataAccessStrategy implements DataAccessStrategy { * Only suitable if this is the only access strategy in use. */ public DefaultDataAccessStrategy(SqlGeneratorSource sqlGeneratorSource, JdbcMappingContext context, - NamedParameterJdbcOperations operations) { + NamedParameterJdbcOperations operations, EntityInstantiators instantiators) { this.sqlGeneratorSource = sqlGeneratorSource; this.operations = operations; this.context = context; + this.instantiators = instantiators; this.accessStrategy = this; } @@ -321,7 +324,7 @@ public class DefaultDataAccessStrategy implements DataAccessStrategy { } public EntityRowMapper getEntityRowMapper(Class domainType) { - return new EntityRowMapper<>(getRequiredPersistentEntity(domainType), context, accessStrategy); + return new EntityRowMapper<>(getRequiredPersistentEntity(domainType), context, instantiators, accessStrategy); } private RowMapper getMapEntityRowMapper(JdbcPersistentProperty property) { diff --git a/src/main/java/org/springframework/data/jdbc/core/EntityRowMapper.java b/src/main/java/org/springframework/data/jdbc/core/EntityRowMapper.java index 644a41f9..653eac45 100644 --- a/src/main/java/org/springframework/data/jdbc/core/EntityRowMapper.java +++ b/src/main/java/org/springframework/data/jdbc/core/EntityRowMapper.java @@ -24,8 +24,7 @@ import java.util.Map; import org.springframework.core.convert.ConversionService; import org.springframework.core.convert.converter.Converter; -import org.springframework.data.convert.ClassGeneratingEntityInstantiator; -import org.springframework.data.convert.EntityInstantiator; +import org.springframework.data.convert.EntityInstantiators; import org.springframework.data.jdbc.core.mapping.JdbcMappingContext; import org.springframework.data.jdbc.core.mapping.JdbcPersistentEntity; import org.springframework.data.jdbc.core.mapping.JdbcPersistentProperty; @@ -49,18 +48,20 @@ public class EntityRowMapper implements RowMapper { private static final Converter, Map> ITERABLE_OF_ENTRY_TO_MAP_CONVERTER = new IterableOfEntryToMapConverter(); private final JdbcPersistentEntity entity; - private final EntityInstantiator instantiator = new ClassGeneratingEntityInstantiator(); + private final ConversionService conversions; private final JdbcMappingContext context; private final DataAccessStrategy accessStrategy; private final JdbcPersistentProperty idProperty; + private final EntityInstantiators instantiators; - public EntityRowMapper(JdbcPersistentEntity entity, JdbcMappingContext context, + public EntityRowMapper(JdbcPersistentEntity entity, JdbcMappingContext context, EntityInstantiators instantiators, DataAccessStrategy accessStrategy) { this.entity = entity; this.conversions = context.getConversions(); this.context = context; + this.instantiators = instantiators; this.accessStrategy = accessStrategy; idProperty = entity.getIdProperty(); @@ -97,7 +98,9 @@ public class EntityRowMapper implements RowMapper { } private T createInstance(ResultSet rs) { - return instantiator.createInstance(entity, new ResultSetParameterValueProvider(rs, entity, conversions, "")); + + return instantiators.getInstantiatorFor(entity) // + .createInstance(entity, new ResultSetParameterValueProvider(rs, entity, conversions, "")); } /** @@ -135,8 +138,8 @@ public class EntityRowMapper implements RowMapper { return null; } - S instance = instantiator.createInstance(entity, - new ResultSetParameterValueProvider(rs, entity, conversions, prefix)); + S instance = instantiators.getInstantiatorFor(entity) // + .createInstance(entity, new ResultSetParameterValueProvider(rs, entity, conversions, prefix)); PersistentPropertyAccessor accessor = entity.getPropertyAccessor(instance); ConvertingPropertyAccessor propertyAccessor = new ConvertingPropertyAccessor(accessor, conversions); diff --git a/src/main/java/org/springframework/data/jdbc/mybatis/MyBatisDataAccessStrategy.java b/src/main/java/org/springframework/data/jdbc/mybatis/MyBatisDataAccessStrategy.java index 3f79f1c5..55ffdbf7 100644 --- a/src/main/java/org/springframework/data/jdbc/mybatis/MyBatisDataAccessStrategy.java +++ b/src/main/java/org/springframework/data/jdbc/mybatis/MyBatisDataAccessStrategy.java @@ -22,6 +22,7 @@ import java.util.Map; import org.apache.ibatis.session.SqlSession; import org.mybatis.spring.SqlSessionTemplate; +import org.springframework.data.convert.EntityInstantiators; import org.springframework.data.jdbc.core.CascadingDataAccessStrategy; import org.springframework.data.jdbc.core.DataAccessStrategy; import org.springframework.data.jdbc.core.DefaultDataAccessStrategy; @@ -58,7 +59,8 @@ public class MyBatisDataAccessStrategy implements DataAccessStrategy { */ public static DataAccessStrategy createCombinedAccessStrategy(JdbcMappingContext context, NamedParameterJdbcOperations operations, SqlSession sqlSession) { - return createCombinedAccessStrategy(context, operations, sqlSession, NamespaceStrategy.DEFAULT_INSTANCE); + return createCombinedAccessStrategy(context, new EntityInstantiators(), operations, sqlSession, + NamespaceStrategy.DEFAULT_INSTANCE); } /** @@ -66,7 +68,8 @@ public class MyBatisDataAccessStrategy implements DataAccessStrategy { * uses a {@link DefaultDataAccessStrategy} */ public static DataAccessStrategy createCombinedAccessStrategy(JdbcMappingContext context, - NamedParameterJdbcOperations operations, SqlSession sqlSession, NamespaceStrategy namespaceStrategy) { + EntityInstantiators instantiators, NamedParameterJdbcOperations operations, SqlSession sqlSession, + NamespaceStrategy namespaceStrategy) { // the DefaultDataAccessStrategy needs a reference to the returned DataAccessStrategy. This creates a dependency // cycle. In order to create it, we need something that allows to defer closing the cycle until all the elements are @@ -79,8 +82,13 @@ public class MyBatisDataAccessStrategy implements DataAccessStrategy { asList(myBatisDataAccessStrategy, delegatingDataAccessStrategy)); SqlGeneratorSource sqlGeneratorSource = new SqlGeneratorSource(context); - DefaultDataAccessStrategy defaultDataAccessStrategy = new DefaultDataAccessStrategy(sqlGeneratorSource, context, - operations, cascadingDataAccessStrategy); + DefaultDataAccessStrategy defaultDataAccessStrategy = new DefaultDataAccessStrategy( // + sqlGeneratorSource, // + context, // + operations, // + instantiators, // + cascadingDataAccessStrategy // + ); delegatingDataAccessStrategy.setDelegate(defaultDataAccessStrategy); @@ -93,8 +101,9 @@ public class MyBatisDataAccessStrategy implements DataAccessStrategy { * Use a {@link SqlSessionTemplate} for {@link SqlSession} or a similar implementation tying the session to the proper * transaction. Note that the resulting {@link DataAccessStrategy} only handles MyBatis. It does not include the * functionality of the {@link org.springframework.data.jdbc.core.DefaultDataAccessStrategy} which one normally still - * wants. Use {@link #createCombinedAccessStrategy(JdbcMappingContext, SqlSession)} to create such a - * {@link DataAccessStrategy}. + * wants. Use + * {@link #createCombinedAccessStrategy(JdbcMappingContext, EntityInstantiators, NamedParameterJdbcOperations, SqlSession, NamespaceStrategy)} + * to create such a {@link DataAccessStrategy}. * * @param sqlSession Must be non {@literal null}. */ diff --git a/src/main/java/org/springframework/data/jdbc/repository/support/JdbcQueryLookupStrategy.java b/src/main/java/org/springframework/data/jdbc/repository/support/JdbcQueryLookupStrategy.java index 346d0dc5..ca292882 100644 --- a/src/main/java/org/springframework/data/jdbc/repository/support/JdbcQueryLookupStrategy.java +++ b/src/main/java/org/springframework/data/jdbc/repository/support/JdbcQueryLookupStrategy.java @@ -18,6 +18,7 @@ package org.springframework.data.jdbc.repository.support; import java.lang.reflect.Method; import org.springframework.core.convert.ConversionService; +import org.springframework.data.convert.EntityInstantiators; import org.springframework.data.jdbc.core.DataAccessStrategy; import org.springframework.data.jdbc.core.EntityRowMapper; import org.springframework.data.jdbc.core.mapping.JdbcMappingContext; @@ -43,27 +44,30 @@ import org.springframework.util.Assert; class JdbcQueryLookupStrategy implements QueryLookupStrategy { private final JdbcMappingContext context; + private final EntityInstantiators instantiators; private final DataAccessStrategy accessStrategy; private final RowMapperMap rowMapperMap; - private final ConversionService conversionService; private final NamedParameterJdbcOperations operations; + private final ConversionService conversionService; + /** * Creates a new {@link JdbcQueryLookupStrategy} for the given {@link JdbcMappingContext}, {@link DataAccessStrategy} * and {@link RowMapperMap}. - * + * * @param context must not be {@literal null}. * @param accessStrategy must not be {@literal null}. * @param rowMapperMap must not be {@literal null}. */ - JdbcQueryLookupStrategy(JdbcMappingContext context, DataAccessStrategy accessStrategy, RowMapperMap rowMapperMap, - NamedParameterJdbcOperations operations) { + JdbcQueryLookupStrategy(JdbcMappingContext context, EntityInstantiators instantiators, + DataAccessStrategy accessStrategy, RowMapperMap rowMapperMap, NamedParameterJdbcOperations operations) { Assert.notNull(context, "JdbcMappingContext must not be null!"); Assert.notNull(accessStrategy, "DataAccessStrategy must not be null!"); Assert.notNull(rowMapperMap, "RowMapperMap must not be null!"); this.context = context; + this.instantiators = instantiators; this.accessStrategy = accessStrategy; this.rowMapperMap = rowMapperMap; this.conversionService = context.getConversions(); @@ -104,6 +108,7 @@ class JdbcQueryLookupStrategy implements QueryLookupStrategy { ? new EntityRowMapper<>( // context.getRequiredPersistentEntity(domainType), // context, // + instantiators, // accessStrategy) // : typeMappedRowMapper; } diff --git a/src/main/java/org/springframework/data/jdbc/repository/support/JdbcRepositoryFactory.java b/src/main/java/org/springframework/data/jdbc/repository/support/JdbcRepositoryFactory.java index eb1586de..e711e1e7 100644 --- a/src/main/java/org/springframework/data/jdbc/repository/support/JdbcRepositoryFactory.java +++ b/src/main/java/org/springframework/data/jdbc/repository/support/JdbcRepositoryFactory.java @@ -18,6 +18,7 @@ package org.springframework.data.jdbc.repository.support; import java.util.Optional; import org.springframework.context.ApplicationEventPublisher; +import org.springframework.data.convert.EntityInstantiators; import org.springframework.data.jdbc.core.DataAccessStrategy; import org.springframework.data.jdbc.core.JdbcAggregateTemplate; import org.springframework.data.jdbc.core.mapping.JdbcMappingContext; @@ -49,6 +50,7 @@ public class JdbcRepositoryFactory extends RepositoryFactorySupport { private final NamedParameterJdbcOperations operations; private RowMapperMap rowMapperMap = RowMapperMap.EMPTY; + private EntityInstantiators instantiators = new EntityInstantiators(); /** * Creates a new {@link JdbcRepositoryFactory} for the given {@link DataAccessStrategy}, {@link JdbcMappingContext} @@ -82,6 +84,18 @@ public class JdbcRepositoryFactory extends RepositoryFactorySupport { this.rowMapperMap = rowMapperMap; } + /** + * Set the {@link EntityInstantiators} used for instantiating entity instances. + * + * @param instantiators Must not be {@code null}. + */ + public void setEntityInstantiators(EntityInstantiators instantiators) { + + Assert.notNull(instantiators, "EntityInstantiators must not be null."); + + this.instantiators = instantiators; + } + @SuppressWarnings("unchecked") @Override public EntityInformation getEntityInformation(Class aClass) { @@ -127,6 +141,6 @@ public class JdbcRepositoryFactory extends RepositoryFactorySupport { throw new IllegalArgumentException(String.format("Unsupported query lookup strategy %s!", key)); } - return Optional.of(new JdbcQueryLookupStrategy(context, accessStrategy, rowMapperMap, operations)); + return Optional.of(new JdbcQueryLookupStrategy(context, instantiators, accessStrategy, rowMapperMap, operations)); } } diff --git a/src/main/java/org/springframework/data/jdbc/repository/support/JdbcRepositoryFactoryBean.java b/src/main/java/org/springframework/data/jdbc/repository/support/JdbcRepositoryFactoryBean.java index 95c8ccd1..95caf7ee 100644 --- a/src/main/java/org/springframework/data/jdbc/repository/support/JdbcRepositoryFactoryBean.java +++ b/src/main/java/org/springframework/data/jdbc/repository/support/JdbcRepositoryFactoryBean.java @@ -20,6 +20,7 @@ import java.io.Serializable; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.ApplicationEventPublisher; import org.springframework.context.ApplicationEventPublisherAware; +import org.springframework.data.convert.EntityInstantiators; import org.springframework.data.jdbc.core.DataAccessStrategy; import org.springframework.data.jdbc.core.DefaultDataAccessStrategy; import org.springframework.data.jdbc.core.SqlGeneratorSource; @@ -49,6 +50,7 @@ public class JdbcRepositoryFactoryBean, S, ID extend private DataAccessStrategy dataAccessStrategy; private RowMapperMap rowMapperMap = RowMapperMap.EMPTY; private NamedParameterJdbcOperations operations; + private EntityInstantiators instantiators = new EntityInstantiators(); /** * Creates a new {@link JdbcRepositoryFactoryBean} for the given repository interface. @@ -115,6 +117,11 @@ public class JdbcRepositoryFactoryBean, S, ID extend this.operations = operations; } + @Autowired(required = false) + public void setInstantiators(EntityInstantiators instantiators) { + this.instantiators = instantiators; + } + /* * (non-Javadoc) * @see org.springframework.data.repository.core.support.RepositoryFactoryBeanSupport#afterPropertiesSet() @@ -127,13 +134,18 @@ public class JdbcRepositoryFactoryBean, S, ID extend if (dataAccessStrategy == null) { SqlGeneratorSource sqlGeneratorSource = new SqlGeneratorSource(mappingContext); - this.dataAccessStrategy = new DefaultDataAccessStrategy(sqlGeneratorSource, mappingContext, operations); + this.dataAccessStrategy = new DefaultDataAccessStrategy(sqlGeneratorSource, mappingContext, operations, + instantiators); } if (rowMapperMap == null) { this.rowMapperMap = RowMapperMap.EMPTY; } + if (instantiators == null) { + this.instantiators = new EntityInstantiators(); + } + super.afterPropertiesSet(); } } diff --git a/src/test/java/org/springframework/data/jdbc/core/DefaultDataAccessStrategyUnitTests.java b/src/test/java/org/springframework/data/jdbc/core/DefaultDataAccessStrategyUnitTests.java index 0cf7bd79..402df657 100644 --- a/src/test/java/org/springframework/data/jdbc/core/DefaultDataAccessStrategyUnitTests.java +++ b/src/test/java/org/springframework/data/jdbc/core/DefaultDataAccessStrategyUnitTests.java @@ -16,7 +16,8 @@ package org.springframework.data.jdbc.core; import static org.assertj.core.api.Assertions.*; -import static org.mockito.ArgumentMatchers.*; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.*; import lombok.RequiredArgsConstructor; @@ -26,8 +27,8 @@ import java.util.HashMap; import org.junit.Test; import org.mockito.ArgumentCaptor; import org.springframework.data.annotation.Id; +import org.springframework.data.convert.EntityInstantiators; import org.springframework.data.jdbc.core.mapping.JdbcMappingContext; -import org.springframework.data.jdbc.core.mapping.NamingStrategy; import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations; import org.springframework.jdbc.core.namedparam.SqlParameterSource; import org.springframework.jdbc.support.KeyHolder; @@ -47,8 +48,12 @@ public class DefaultDataAccessStrategyUnitTests { HashMap additionalParameters = new HashMap<>(); ArgumentCaptor paramSourceCaptor = ArgumentCaptor.forClass(SqlParameterSource.class); - DefaultDataAccessStrategy accessStrategy = new DefaultDataAccessStrategy(new SqlGeneratorSource(context), context, - jdbcOperations); + DefaultDataAccessStrategy accessStrategy = new DefaultDataAccessStrategy( // + new SqlGeneratorSource(context), // + context, // + jdbcOperations, // + new EntityInstantiators() // + ); @Test // DATAJDBC-146 public void additionalParameterForIdDoesNotLeadToDuplicateParameters() { diff --git a/src/test/java/org/springframework/data/jdbc/core/EntityRowMapperUnitTests.java b/src/test/java/org/springframework/data/jdbc/core/EntityRowMapperUnitTests.java index 159a6dfe..16d6c281 100644 --- a/src/test/java/org/springframework/data/jdbc/core/EntityRowMapperUnitTests.java +++ b/src/test/java/org/springframework/data/jdbc/core/EntityRowMapperUnitTests.java @@ -17,7 +17,8 @@ package org.springframework.data.jdbc.core; import static java.util.Arrays.*; import static org.assertj.core.api.Assertions.*; -import static org.mockito.ArgumentMatchers.*; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.*; import lombok.RequiredArgsConstructor; @@ -40,12 +41,12 @@ import org.mockito.stubbing.Answer; import org.springframework.core.convert.support.DefaultConversionService; import org.springframework.core.convert.support.GenericConversionService; import org.springframework.data.annotation.Id; +import org.springframework.data.convert.EntityInstantiators; import org.springframework.data.convert.Jsr310Converters; import org.springframework.data.jdbc.core.mapping.JdbcMappingContext; import org.springframework.data.jdbc.core.mapping.JdbcPersistentEntity; import org.springframework.data.jdbc.core.mapping.JdbcPersistentProperty; import org.springframework.data.jdbc.core.mapping.NamingStrategy; -import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations; import org.springframework.util.Assert; /** @@ -199,8 +200,12 @@ public class EntityRowMapperUnitTests { DefaultConversionService.addDefaultConverters(conversionService); Jsr310Converters.getConvertersToRegister().forEach(conversionService::addConverter); - return new EntityRowMapper<>((JdbcPersistentEntity) context.getRequiredPersistentEntity(type), context, - accessStrategy); + return new EntityRowMapper<>( // + (JdbcPersistentEntity) context.getRequiredPersistentEntity(type), // + context, // + new EntityInstantiators(), // + accessStrategy // + ); } private static ResultSet mockResultSet(List columns, Object... values) { @@ -212,7 +217,7 @@ public class EntityRowMapperUnitTests { "Number of values [%d] must be a multiple of the number of columns [%d]", // values.length, // columns.size() // - ) // + ) // ); List> result = convertValues(columns, values); diff --git a/src/test/java/org/springframework/data/jdbc/repository/SimpleJdbcRepositoryEventsUnitTests.java b/src/test/java/org/springframework/data/jdbc/repository/SimpleJdbcRepositoryEventsUnitTests.java index a90d62da..cf914113 100644 --- a/src/test/java/org/springframework/data/jdbc/repository/SimpleJdbcRepositoryEventsUnitTests.java +++ b/src/test/java/org/springframework/data/jdbc/repository/SimpleJdbcRepositoryEventsUnitTests.java @@ -17,7 +17,9 @@ package org.springframework.data.jdbc.repository; import static java.util.Arrays.*; import static org.assertj.core.api.Assertions.*; -import static org.mockito.ArgumentMatchers.*; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.*; import junit.framework.AssertionFailedError; @@ -34,6 +36,7 @@ import org.junit.Test; import org.mockito.stubbing.Answer; import org.springframework.context.ApplicationEventPublisher; import org.springframework.data.annotation.Id; +import org.springframework.data.convert.EntityInstantiators; import org.springframework.data.jdbc.core.DefaultDataAccessStrategy; import org.springframework.data.jdbc.core.SqlGeneratorSource; import org.springframework.data.jdbc.core.mapping.JdbcMappingContext; @@ -73,7 +76,8 @@ public class SimpleJdbcRepositoryEventsUnitTests { NamedParameterJdbcOperations operations = createIdGeneratingOperations(); SqlGeneratorSource generatorSource = new SqlGeneratorSource(context); - this.dataAccessStrategy = spy(new DefaultDataAccessStrategy(generatorSource, context, operations)); + this.dataAccessStrategy = spy( + new DefaultDataAccessStrategy(generatorSource, context, operations, new EntityInstantiators())); JdbcRepositoryFactory factory = new JdbcRepositoryFactory(dataAccessStrategy, context, publisher, operations); @@ -93,7 +97,7 @@ public class SimpleJdbcRepositoryEventsUnitTests { .containsExactly( // BeforeSaveEvent.class, // AfterSaveEvent.class // - ); + ); } @Test // DATAJDBC-99 @@ -112,7 +116,7 @@ public class SimpleJdbcRepositoryEventsUnitTests { AfterSaveEvent.class, // BeforeSaveEvent.class, // AfterSaveEvent.class // - ); + ); } @Test // DATAJDBC-99 @@ -143,7 +147,7 @@ public class SimpleJdbcRepositoryEventsUnitTests { .containsExactly( // BeforeDeleteEvent.class, // AfterDeleteEvent.class // - ); + ); } @Test // DATAJDBC-197 @@ -162,7 +166,7 @@ public class SimpleJdbcRepositoryEventsUnitTests { .containsExactly( // AfterLoadEvent.class, // AfterLoadEvent.class // - ); + ); } @Test // DATAJDBC-197 @@ -181,7 +185,7 @@ public class SimpleJdbcRepositoryEventsUnitTests { .containsExactly( // AfterLoadEvent.class, // AfterLoadEvent.class // - ); + ); } @Test // DATAJDBC-197 @@ -198,7 +202,7 @@ public class SimpleJdbcRepositoryEventsUnitTests { .extracting(e -> (Class) e.getClass()) // .containsExactly( // AfterLoadEvent.class // - ); + ); } private static NamedParameterJdbcOperations createIdGeneratingOperations() { diff --git a/src/test/java/org/springframework/data/jdbc/repository/support/JdbcQueryLookupStrategyUnitTests.java b/src/test/java/org/springframework/data/jdbc/repository/support/JdbcQueryLookupStrategyUnitTests.java index 8e872cd3..572641dd 100644 --- a/src/test/java/org/springframework/data/jdbc/repository/support/JdbcQueryLookupStrategyUnitTests.java +++ b/src/test/java/org/springframework/data/jdbc/repository/support/JdbcQueryLookupStrategyUnitTests.java @@ -15,7 +15,9 @@ */ package org.springframework.data.jdbc.repository.support; -import static org.mockito.ArgumentMatchers.*; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.*; import java.lang.reflect.Method; @@ -23,6 +25,7 @@ import java.text.NumberFormat; import org.junit.Before; import org.junit.Test; +import org.springframework.data.convert.EntityInstantiators; import org.springframework.data.jdbc.core.DataAccessStrategy; import org.springframework.data.jdbc.core.mapping.JdbcMappingContext; import org.springframework.data.jdbc.repository.RowMapperMap; @@ -76,8 +79,8 @@ public class JdbcQueryLookupStrategyUnitTests { private RepositoryQuery getRepositoryQuery(String name, RowMapperMap rowMapperMap) { - JdbcQueryLookupStrategy queryLookupStrategy = new JdbcQueryLookupStrategy(mappingContext, accessStrategy, - rowMapperMap, operations); + JdbcQueryLookupStrategy queryLookupStrategy = new JdbcQueryLookupStrategy(mappingContext, new EntityInstantiators(), + accessStrategy, rowMapperMap, operations); return queryLookupStrategy.resolveQuery(getMethod(name), metadata, projectionFactory, namedQueries); } diff --git a/src/test/java/org/springframework/data/jdbc/testing/TestConfiguration.java b/src/test/java/org/springframework/data/jdbc/testing/TestConfiguration.java index 8d03ff3c..3b8b1727 100644 --- a/src/test/java/org/springframework/data/jdbc/testing/TestConfiguration.java +++ b/src/test/java/org/springframework/data/jdbc/testing/TestConfiguration.java @@ -25,6 +25,7 @@ import org.springframework.context.ApplicationEventPublisher; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration; +import org.springframework.data.convert.EntityInstantiators; import org.springframework.data.jdbc.core.DataAccessStrategy; import org.springframework.data.jdbc.core.DefaultDataAccessStrategy; import org.springframework.data.jdbc.core.SqlGeneratorSource; @@ -71,7 +72,7 @@ public class TestConfiguration { @Bean DataAccessStrategy defaultDataAccessStrategy(JdbcMappingContext context) { - return new DefaultDataAccessStrategy(new SqlGeneratorSource(context), context, namedParameterJdbcTemplate()); + return new DefaultDataAccessStrategy(new SqlGeneratorSource(context), context, namedParameterJdbcTemplate(), new EntityInstantiators()); } @Bean