From 380c61d7397123927b3a83aa06bd7443384ff41c Mon Sep 17 00:00:00 2001 From: Tomohiko Ozawa Date: Tue, 13 Jul 2021 17:47:08 +0900 Subject: [PATCH 1/3] recommit --- .../config/EnableJdbcRepositories.java | 8 +++++ .../config/JdbcRepositoryConfigExtension.java | 4 +++ ...nableJdbcRepositoriesIntegrationTests.java | 29 ++++++++++++++++++- .../data/jdbc/testing/TestConfiguration.java | 3 +- 4 files changed, 42 insertions(+), 2 deletions(-) diff --git a/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/config/EnableJdbcRepositories.java b/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/config/EnableJdbcRepositories.java index dd60dd7dd6..2be982656e 100644 --- a/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/config/EnableJdbcRepositories.java +++ b/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/config/EnableJdbcRepositories.java @@ -39,6 +39,7 @@ * @author Mark Paluch * @author Fei Dong * @author Antoine Sauray + * @author Tomohiko Ozawa * @see AbstractJdbcConfiguration */ @Target(ElementType.TYPE) @@ -131,4 +132,11 @@ */ String transactionManagerRef() default "transactionManager"; + /** + * Configures the name of the {@link org.springframework.data.jdbc.core.convert.JdbcConverter} bean definition to be + * used to create repositories discovered through this annotation. Defaults to {@code converter}. + * + * @since 2.3 + */ + String jdbcConverterRef() default "converter"; } diff --git a/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/config/JdbcRepositoryConfigExtension.java b/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/config/JdbcRepositoryConfigExtension.java index e201910a3c..9ad85ce7cb 100644 --- a/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/config/JdbcRepositoryConfigExtension.java +++ b/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/config/JdbcRepositoryConfigExtension.java @@ -36,6 +36,7 @@ * @author Fei Dong * @author Mark Paluch * @author Antoine Sauray + * @author Tomohiko Ozawa */ public class JdbcRepositoryConfigExtension extends RepositoryConfigurationExtensionSupport { @@ -85,6 +86,9 @@ public void postProcess(BeanDefinitionBuilder builder, RepositoryConfigurationSo Optional transactionManagerRef = source.getAttribute("transactionManagerRef"); builder.addPropertyValue("transactionManager", transactionManagerRef.orElse(DEFAULT_TRANSACTION_MANAGER_BEAN_NAME)); + + source.getAttribute("jdbcConverterRef").filter(StringUtils::hasText) // + .ifPresent(s -> builder.addPropertyReference("converter", s)); } /** diff --git a/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/repository/config/EnableJdbcRepositoriesIntegrationTests.java b/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/repository/config/EnableJdbcRepositoriesIntegrationTests.java index 6cc7918060..96196889b5 100644 --- a/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/repository/config/EnableJdbcRepositoriesIntegrationTests.java +++ b/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/repository/config/EnableJdbcRepositoriesIntegrationTests.java @@ -33,17 +33,23 @@ import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.FilterType; +import org.springframework.context.annotation.Lazy; import org.springframework.data.annotation.Id; import org.springframework.data.jdbc.core.JdbcAggregateTemplate; +import org.springframework.data.jdbc.core.convert.BasicJdbcConverter; import org.springframework.data.jdbc.core.convert.DataAccessStrategy; import org.springframework.data.jdbc.core.convert.DefaultDataAccessStrategy; +import org.springframework.data.jdbc.core.convert.DefaultJdbcTypeFactory; import org.springframework.data.jdbc.core.convert.JdbcConverter; +import org.springframework.data.jdbc.core.convert.JdbcCustomConversions; import org.springframework.data.jdbc.core.convert.SqlGeneratorSource; +import org.springframework.data.jdbc.core.mapping.JdbcMappingContext; import org.springframework.data.jdbc.repository.QueryMappingConfiguration; import org.springframework.data.jdbc.repository.config.EnableJdbcRepositoriesIntegrationTests.TestConfiguration; import org.springframework.data.jdbc.repository.support.JdbcRepositoryFactoryBean; import org.springframework.data.mapping.PersistentEntity; import org.springframework.data.relational.core.dialect.Dialect; +import org.springframework.data.relational.core.mapping.NamingStrategy; import org.springframework.data.relational.core.mapping.RelationalMappingContext; import org.springframework.data.repository.CrudRepository; import org.springframework.jdbc.core.RowMapper; @@ -60,6 +66,7 @@ * @author Greg Turnquist * @author Evgeni Dimitrov * @author Fei Dong + * @author Tomohiko Ozawa */ @ExtendWith(SpringExtension.class) @ContextConfiguration(classes = TestConfiguration.class) @@ -70,6 +77,7 @@ public class EnableJdbcRepositoriesIntegrationTests { static final Field OPERATIONS = ReflectionUtils.findField(JdbcRepositoryFactoryBean.class, "operations"); static final Field DATA_ACCESS_STRATEGY = ReflectionUtils.findField(JdbcRepositoryFactoryBean.class, "dataAccessStrategy"); + static final Field CONVERTER = ReflectionUtils.findField(JdbcRepositoryFactoryBean.class, "converter"); public static final RowMapper DUMMY_ENTITY_ROW_MAPPER = mock(RowMapper.class); public static final RowMapper STRING_ROW_MAPPER = mock(RowMapper.class); @@ -77,8 +85,10 @@ public class EnableJdbcRepositoriesIntegrationTests { @Autowired DummyRepository repository; @Autowired @Qualifier("namedParameterJdbcTemplate") NamedParameterJdbcOperations defaultOperations; @Autowired @Qualifier("defaultDataAccessStrategy") DataAccessStrategy defaultDataAccessStrategy; + @Autowired @Qualifier("converter") JdbcConverter defaultJdbcConverter; @Autowired @Qualifier("qualifierJdbcOperations") NamedParameterJdbcOperations qualifierJdbcOperations; @Autowired @Qualifier("qualifierDataAccessStrategy") DataAccessStrategy qualifierDataAccessStrategy; + @Autowired @Qualifier("qualifierJdbcConverter") JdbcConverter qualifierJdbcConverter; @BeforeAll public static void setup() { @@ -86,6 +96,7 @@ public static void setup() { MAPPER_MAP.setAccessible(true); OPERATIONS.setAccessible(true); DATA_ACCESS_STRATEGY.setAccessible(true); + CONVERTER.setAccessible(true); } @Test // DATAJDBC-100 @@ -118,6 +129,9 @@ public void jdbcOperationsRef() { DataAccessStrategy dataAccessStrategy = (DataAccessStrategy) ReflectionUtils.getField(DATA_ACCESS_STRATEGY, factoryBean); assertThat(dataAccessStrategy).isNotSameAs(defaultDataAccessStrategy).isSameAs(qualifierDataAccessStrategy); + + JdbcConverter converter = (JdbcConverter) ReflectionUtils.getField(CONVERTER, factoryBean); + assertThat(converter).isNotSameAs(defaultJdbcConverter).isSameAs(qualifierJdbcConverter); } interface DummyRepository extends CrudRepository { @@ -133,7 +147,7 @@ static class DummyEntity { @EnableJdbcRepositories(considerNestedRepositories = true, includeFilters = @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = DummyRepository.class), jdbcOperationsRef = "qualifierJdbcOperations", dataAccessStrategyRef = "qualifierDataAccessStrategy", - repositoryBaseClass = DummyRepositoryBaseClass.class) + jdbcConverterRef = "qualifierJdbcConverter", repositoryBaseClass = DummyRepositoryBaseClass.class) static class TestConfiguration { @Bean @@ -166,6 +180,19 @@ DataAccessStrategy defaultDataAccessStrategy( Dialect jdbcDialect(@Qualifier("qualifierJdbcOperations") NamedParameterJdbcOperations operations) { return DialectResolver.getDialect(operations.getJdbcOperations()); } + + @Bean("qualifierJdbcConverter") + JdbcConverter qualifierJdbcConverter(Optional namingStrategy, + @Qualifier("qualifierJdbcOperations") NamedParameterJdbcOperations operations, + @Lazy @Qualifier("qualifierDataAccessStrategy") DataAccessStrategy dataAccessStrategy) { + JdbcCustomConversions conversions = new JdbcCustomConversions(); + JdbcMappingContext mappingContext = new JdbcMappingContext(namingStrategy.orElse(NamingStrategy.INSTANCE)); + mappingContext.setSimpleTypeHolder(conversions.getSimpleTypeHolder()); + DefaultJdbcTypeFactory jdbcTypeFactory = new DefaultJdbcTypeFactory(operations.getJdbcOperations()); + Dialect dialect = DialectResolver.getDialect(operations.getJdbcOperations()); + return new BasicJdbcConverter(mappingContext, dataAccessStrategy, conversions, jdbcTypeFactory, + dialect.getIdentifierProcessing()); + } } private static class DummyRepositoryBaseClass implements CrudRepository { diff --git a/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/testing/TestConfiguration.java b/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/testing/TestConfiguration.java index c1804f217c..6007cc2ee8 100644 --- a/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/testing/TestConfiguration.java +++ b/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/testing/TestConfiguration.java @@ -66,6 +66,7 @@ * @author Fei Dong * @author Myeonghyeon Lee * @author Christoph Strobl + * @author Tomohiko Ozawa */ @Configuration @ComponentScan // To pick up configuration classes (per activated profile) @@ -135,7 +136,7 @@ private List storeConverters(Dialect dialect) { } @Bean - JdbcConverter relationalConverter(RelationalMappingContext mappingContext, @Lazy RelationResolver relationResolver, + JdbcConverter converter(RelationalMappingContext mappingContext, @Lazy RelationResolver relationResolver, CustomConversions conversions, @Qualifier("namedParameterJdbcTemplate") NamedParameterJdbcOperations template, Dialect dialect) { From 97d637012a7f3f81b9660427836e36186cc7bf14 Mon Sep 17 00:00:00 2001 From: Tomohiko Ozawa Date: Thu, 4 Nov 2021 01:38:37 +0900 Subject: [PATCH 2/3] review ref --- .../data/jdbc/core/JdbcAggregateTemplate.java | 28 ++++++++++- .../config/AbstractJdbcConfiguration.java | 10 ++-- .../config/EnableJdbcRepositories.java | 7 ++- .../config/JdbcRepositoryConfigExtension.java | 6 ++- .../support/JdbcRepositoryFactory.java | 20 +++++++- .../support/JdbcRepositoryFactoryBean.java | 17 +++++-- ...AggregateTemplateHsqlIntegrationTests.java | 13 ------ ...JdbcAggregateTemplateIntegrationTests.java | 10 ---- ...gregateTemplateSchemaIntegrationTests.java | 10 ---- .../core/JdbcAggregateTemplateUnitTests.java | 4 +- ...nableJdbcRepositoriesIntegrationTests.java | 46 +++++++++++-------- .../data/jdbc/testing/TestConfiguration.java | 16 ++++++- 12 files changed, 117 insertions(+), 70 deletions(-) diff --git a/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/JdbcAggregateTemplate.java b/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/JdbcAggregateTemplate.java index eab91a0d97..5a121b9589 100644 --- a/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/JdbcAggregateTemplate.java +++ b/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/JdbcAggregateTemplate.java @@ -39,6 +39,7 @@ import org.springframework.data.relational.core.mapping.RelationalPersistentEntity; import org.springframework.data.relational.core.mapping.event.*; import org.springframework.data.support.PageableExecutionUtils; +import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations; import org.springframework.lang.Nullable; import org.springframework.util.Assert; @@ -54,6 +55,18 @@ */ public class JdbcAggregateTemplate implements JdbcAggregateOperations { + public RelationalMappingContext getContext() { + return context; + } + + public DataAccessStrategy getAccessStrategy() { + return accessStrategy; + } + + public NamedParameterJdbcOperations getNamedParameterJdbcOperations() { + return operations; + } + private final ApplicationEventPublisher publisher; private final RelationalMappingContext context; @@ -62,8 +75,15 @@ public class JdbcAggregateTemplate implements JdbcAggregateOperations { private final RelationalEntityUpdateWriter jdbcEntityUpdateWriter; private final DataAccessStrategy accessStrategy; + private final NamedParameterJdbcOperations operations; private final AggregateChangeExecutor executor; + public JdbcConverter getConverter() { + return converter; + } + + private final JdbcConverter converter; + private EntityCallbacks entityCallbacks = EntityCallbacks.create(); /** @@ -76,7 +96,7 @@ public class JdbcAggregateTemplate implements JdbcAggregateOperations { * @since 1.1 */ public JdbcAggregateTemplate(ApplicationContext publisher, RelationalMappingContext context, JdbcConverter converter, - DataAccessStrategy dataAccessStrategy) { + DataAccessStrategy dataAccessStrategy, NamedParameterJdbcOperations operations) { Assert.notNull(publisher, "ApplicationContext must not be null!"); Assert.notNull(context, "RelationalMappingContext must not be null!"); @@ -85,7 +105,9 @@ public JdbcAggregateTemplate(ApplicationContext publisher, RelationalMappingCont this.publisher = publisher; this.context = context; + this.converter = converter; this.accessStrategy = dataAccessStrategy; + this.operations = operations; this.jdbcEntityInsertWriter = new RelationalEntityInsertWriter(context); this.jdbcEntityUpdateWriter = new RelationalEntityUpdateWriter(context); @@ -105,7 +127,7 @@ public JdbcAggregateTemplate(ApplicationContext publisher, RelationalMappingCont * @param dataAccessStrategy must not be {@literal null}. */ public JdbcAggregateTemplate(ApplicationEventPublisher publisher, RelationalMappingContext context, - JdbcConverter converter, DataAccessStrategy dataAccessStrategy) { + JdbcConverter converter, DataAccessStrategy dataAccessStrategy, NamedParameterJdbcOperations operations) { Assert.notNull(publisher, "ApplicationEventPublisher must not be null!"); Assert.notNull(context, "RelationalMappingContext must not be null!"); @@ -114,7 +136,9 @@ public JdbcAggregateTemplate(ApplicationEventPublisher publisher, RelationalMapp this.publisher = publisher; this.context = context; + this.converter = converter; this.accessStrategy = dataAccessStrategy; + this.operations = operations; this.jdbcEntityInsertWriter = new RelationalEntityInsertWriter(context); this.jdbcEntityUpdateWriter = new RelationalEntityUpdateWriter(context); diff --git a/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/config/AbstractJdbcConfiguration.java b/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/config/AbstractJdbcConfiguration.java index 13ca2e865f..8d52125731 100644 --- a/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/config/AbstractJdbcConfiguration.java +++ b/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/config/AbstractJdbcConfiguration.java @@ -22,7 +22,6 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; - import org.springframework.beans.BeansException; import org.springframework.beans.factory.NoSuchBeanDefinitionException; import org.springframework.context.ApplicationContext; @@ -102,8 +101,7 @@ public JdbcConverter jdbcConverter(JdbcMappingContext mappingContext, NamedParam JdbcArrayColumns arrayColumns = dialect instanceof JdbcDialect ? ((JdbcDialect) dialect).getArraySupport() : JdbcArrayColumns.DefaultSupport.INSTANCE; - DefaultJdbcTypeFactory jdbcTypeFactory = new DefaultJdbcTypeFactory(operations.getJdbcOperations(), - arrayColumns); + DefaultJdbcTypeFactory jdbcTypeFactory = new DefaultJdbcTypeFactory(operations.getJdbcOperations(), arrayColumns); return new BasicJdbcConverter(mappingContext, relationResolver, conversions, jdbcTypeFactory, dialect.getIdentifierProcessing()); @@ -156,13 +154,15 @@ private List storeConverters(Dialect dialect) { * @param applicationContext for publishing events. Must not be {@literal null}. * @param mappingContext the mapping context to be used. Must not be {@literal null}. * @param converter the conversions used when reading and writing from/to the database. Must not be {@literal null}. + * @param operations the {@link NamedParameterJdbcOperations} allowing access to a {@link java.sql.Connection}. * @return a {@link JdbcAggregateTemplate}. Will never be {@literal null}. */ @Bean public JdbcAggregateTemplate jdbcAggregateTemplate(ApplicationContext applicationContext, - JdbcMappingContext mappingContext, JdbcConverter converter, DataAccessStrategy dataAccessStrategy) { + JdbcMappingContext mappingContext, JdbcConverter converter, DataAccessStrategy dataAccessStrategy, + NamedParameterJdbcOperations operations) { - return new JdbcAggregateTemplate(applicationContext, mappingContext, converter, dataAccessStrategy); + return new JdbcAggregateTemplate(applicationContext, mappingContext, converter, dataAccessStrategy, operations); } /** diff --git a/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/config/EnableJdbcRepositories.java b/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/config/EnableJdbcRepositories.java index 2be982656e..6fa321c8bb 100644 --- a/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/config/EnableJdbcRepositories.java +++ b/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/config/EnableJdbcRepositories.java @@ -28,7 +28,6 @@ import org.springframework.data.jdbc.repository.support.JdbcRepositoryFactoryBean; import org.springframework.data.repository.config.DefaultRepositoryBaseClass; import org.springframework.jdbc.datasource.DataSourceTransactionManager; -import org.springframework.transaction.PlatformTransactionManager; /** * Annotation to enable JDBC repositories. Will scan the package of the annotated configuration class for Spring Data @@ -133,10 +132,10 @@ String transactionManagerRef() default "transactionManager"; /** - * Configures the name of the {@link org.springframework.data.jdbc.core.convert.JdbcConverter} bean definition to be - * used to create repositories discovered through this annotation. Defaults to {@code converter}. + * Configures the name of the {@link org.springframework.data.jdbc.core.JdbcAggregateTemplate} bean definition to be + * used to create repositories discovered through this annotation. * * @since 2.3 */ - String jdbcConverterRef() default "converter"; + String jdbcAggregateTemplateRef() default ""; } diff --git a/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/config/JdbcRepositoryConfigExtension.java b/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/config/JdbcRepositoryConfigExtension.java index 9ad85ce7cb..67b866eb1a 100644 --- a/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/config/JdbcRepositoryConfigExtension.java +++ b/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/config/JdbcRepositoryConfigExtension.java @@ -87,8 +87,10 @@ public void postProcess(BeanDefinitionBuilder builder, RepositoryConfigurationSo Optional transactionManagerRef = source.getAttribute("transactionManagerRef"); builder.addPropertyValue("transactionManager", transactionManagerRef.orElse(DEFAULT_TRANSACTION_MANAGER_BEAN_NAME)); - source.getAttribute("jdbcConverterRef").filter(StringUtils::hasText) // - .ifPresent(s -> builder.addPropertyReference("converter", s)); + source.getAttribute("jdbcAggregateTemplateRef") + .filter(StringUtils::hasText) + .ifPresent(s -> builder.addPropertyReference("jdbcAggregateTemplate", s)); + } /** diff --git a/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/support/JdbcRepositoryFactory.java b/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/support/JdbcRepositoryFactory.java index 36558f64ba..921f4787bb 100644 --- a/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/support/JdbcRepositoryFactory.java +++ b/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/support/JdbcRepositoryFactory.java @@ -23,6 +23,7 @@ import org.springframework.data.jdbc.core.convert.DataAccessStrategy; import org.springframework.data.jdbc.core.convert.JdbcConverter; import org.springframework.data.jdbc.repository.QueryMappingConfiguration; +import org.springframework.data.jdbc.repository.config.DialectResolver; import org.springframework.data.mapping.callback.EntityCallbacks; import org.springframework.data.relational.core.dialect.Dialect; import org.springframework.data.relational.core.mapping.RelationalMappingContext; @@ -89,6 +90,22 @@ public JdbcRepositoryFactory(DataAccessStrategy dataAccessStrategy, RelationalMa this.operations = operations; } + /** + * Creates a new {@link JdbcRepositoryFactory} for the given {@link JdbcAggregateTemplate} and + * {@link ApplicationEventPublisher}. + * + * @param template + * @param publisher + */ + public JdbcRepositoryFactory(JdbcAggregateTemplate template, ApplicationEventPublisher publisher) { + this.publisher = publisher; + this.context = template.getContext(); + this.converter = template.getConverter(); + this.dialect = DialectResolver.getDialect(template.getNamedParameterJdbcOperations().getJdbcOperations()); + this.accessStrategy = template.getAccessStrategy(); + this.operations = template.getNamedParameterJdbcOperations(); + } + /** * @param queryMappingConfiguration must not be {@literal null} consider {@link QueryMappingConfiguration#EMPTY} * instead. @@ -116,7 +133,8 @@ public EntityInformation getEntityInformation(Class aClass) { @Override protected Object getTargetRepository(RepositoryInformation repositoryInformation) { - JdbcAggregateTemplate template = new JdbcAggregateTemplate(publisher, context, converter, accessStrategy); + JdbcAggregateTemplate template = new JdbcAggregateTemplate(publisher, context, converter, accessStrategy, + operations); if (entityCallbacks != null) { template.setEntityCallbacks(entityCallbacks); diff --git a/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/support/JdbcRepositoryFactoryBean.java b/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/support/JdbcRepositoryFactoryBean.java index f52efa84e6..1f7ba75f70 100644 --- a/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/support/JdbcRepositoryFactoryBean.java +++ b/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/support/JdbcRepositoryFactoryBean.java @@ -21,6 +21,7 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.ApplicationEventPublisher; import org.springframework.context.ApplicationEventPublisherAware; +import org.springframework.data.jdbc.core.JdbcAggregateTemplate; import org.springframework.data.jdbc.core.convert.DataAccessStrategy; import org.springframework.data.jdbc.core.convert.DefaultDataAccessStrategy; import org.springframework.data.jdbc.core.convert.JdbcConverter; @@ -59,6 +60,12 @@ public class JdbcRepositoryFactoryBean, S, ID extend private EntityCallbacks entityCallbacks; private Dialect dialect; + public void setJdbcAggregateTemplate(JdbcAggregateTemplate jdbcAggregateTemplate) { + this.jdbcAggregateTemplate = jdbcAggregateTemplate; + } + + private JdbcAggregateTemplate jdbcAggregateTemplate; + /** * Creates a new {@link JdbcRepositoryFactoryBean} for the given repository interface. * @@ -85,9 +92,13 @@ public void setApplicationEventPublisher(ApplicationEventPublisher publisher) { */ @Override protected RepositoryFactorySupport doCreateRepositoryFactory() { - - JdbcRepositoryFactory jdbcRepositoryFactory = new JdbcRepositoryFactory(dataAccessStrategy, mappingContext, - converter, dialect, publisher, operations); + JdbcRepositoryFactory jdbcRepositoryFactory; + if (jdbcAggregateTemplate != null) { + jdbcRepositoryFactory = new JdbcRepositoryFactory(jdbcAggregateTemplate, publisher); + } else { + jdbcRepositoryFactory = new JdbcRepositoryFactory(dataAccessStrategy, mappingContext, + converter, dialect, publisher, operations); + } jdbcRepositoryFactory.setQueryMappingConfiguration(queryMappingConfiguration); jdbcRepositoryFactory.setEntityCallbacks(entityCallbacks); jdbcRepositoryFactory.setBeanFactory(beanFactory); diff --git a/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/ImmutableAggregateTemplateHsqlIntegrationTests.java b/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/ImmutableAggregateTemplateHsqlIntegrationTests.java index f5d8479bb5..9fdd48e548 100644 --- a/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/ImmutableAggregateTemplateHsqlIntegrationTests.java +++ b/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/ImmutableAggregateTemplateHsqlIntegrationTests.java @@ -22,24 +22,17 @@ import lombok.With; import org.assertj.core.api.SoftAssertions; - import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.context.ApplicationEventPublisher; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Import; import org.springframework.data.annotation.Id; -import org.springframework.data.jdbc.core.convert.DataAccessStrategy; -import org.springframework.data.jdbc.core.convert.JdbcConverter; import org.springframework.data.jdbc.testing.TestConfiguration; -import org.springframework.data.relational.core.mapping.RelationalMappingContext; import org.springframework.test.context.ActiveProfiles; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit.jupiter.SpringExtension; -import org.springframework.test.context.junit4.rules.SpringClassRule; -import org.springframework.test.context.junit4.rules.SpringMethodRule; import org.springframework.transaction.annotation.Transactional; /** @@ -325,11 +318,5 @@ static class Config { Class testClass() { return ImmutableAggregateTemplateHsqlIntegrationTests.class; } - - @Bean - JdbcAggregateOperations operations(ApplicationEventPublisher publisher, RelationalMappingContext context, - DataAccessStrategy dataAccessStrategy, JdbcConverter converter) { - return new JdbcAggregateTemplate(publisher, context, converter, dataAccessStrategy); - } } } diff --git a/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/JdbcAggregateTemplateIntegrationTests.java b/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/JdbcAggregateTemplateIntegrationTests.java index 52d848a8f0..3b24c6106c 100644 --- a/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/JdbcAggregateTemplateIntegrationTests.java +++ b/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/JdbcAggregateTemplateIntegrationTests.java @@ -42,7 +42,6 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.context.ApplicationEventPublisher; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Import; @@ -53,15 +52,12 @@ import org.springframework.data.annotation.Version; import org.springframework.data.domain.PageRequest; import org.springframework.data.domain.Sort; -import org.springframework.data.jdbc.core.convert.DataAccessStrategy; -import org.springframework.data.jdbc.core.convert.JdbcConverter; import org.springframework.data.jdbc.testing.AssumeFeatureTestExecutionListener; import org.springframework.data.jdbc.testing.EnabledOnFeature; import org.springframework.data.jdbc.testing.TestConfiguration; import org.springframework.data.jdbc.testing.TestDatabaseFeatures; import org.springframework.data.relational.core.conversion.DbActionExecutionException; import org.springframework.data.relational.core.mapping.Column; -import org.springframework.data.relational.core.mapping.RelationalMappingContext; import org.springframework.data.relational.core.mapping.Table; import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations; import org.springframework.test.context.ContextConfiguration; @@ -1262,11 +1258,5 @@ static class Config { Class testClass() { return JdbcAggregateTemplateIntegrationTests.class; } - - @Bean - JdbcAggregateOperations operations(ApplicationEventPublisher publisher, RelationalMappingContext context, - DataAccessStrategy dataAccessStrategy, JdbcConverter converter) { - return new JdbcAggregateTemplate(publisher, context, converter, dataAccessStrategy); - } } } diff --git a/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/JdbcAggregateTemplateSchemaIntegrationTests.java b/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/JdbcAggregateTemplateSchemaIntegrationTests.java index f0b41ca4ec..2461fc8f12 100644 --- a/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/JdbcAggregateTemplateSchemaIntegrationTests.java +++ b/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/JdbcAggregateTemplateSchemaIntegrationTests.java @@ -22,18 +22,14 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.context.ApplicationEventPublisher; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Import; import org.springframework.data.annotation.Id; -import org.springframework.data.jdbc.core.convert.DataAccessStrategy; -import org.springframework.data.jdbc.core.convert.JdbcConverter; import org.springframework.data.jdbc.testing.AssumeFeatureTestExecutionListener; import org.springframework.data.jdbc.testing.EnabledOnFeature; import org.springframework.data.jdbc.testing.TestConfiguration; import org.springframework.data.relational.core.mapping.NamingStrategy; -import org.springframework.data.relational.core.mapping.RelationalMappingContext; import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.TestExecutionListeners; @@ -96,12 +92,6 @@ Class testClass() { return JdbcAggregateTemplateSchemaIntegrationTests.class; } - @Bean - JdbcAggregateOperations operations(ApplicationEventPublisher publisher, RelationalMappingContext context, - DataAccessStrategy dataAccessStrategy, JdbcConverter converter) { - return new JdbcAggregateTemplate(publisher, context, converter, dataAccessStrategy); - } - @Bean NamingStrategy namingStrategy() { return new NamingStrategy() { diff --git a/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/JdbcAggregateTemplateUnitTests.java b/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/JdbcAggregateTemplateUnitTests.java index 2362db6243..53236581f7 100644 --- a/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/JdbcAggregateTemplateUnitTests.java +++ b/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/JdbcAggregateTemplateUnitTests.java @@ -48,6 +48,7 @@ import org.springframework.data.relational.core.mapping.event.BeforeConvertCallback; import org.springframework.data.relational.core.mapping.event.BeforeDeleteCallback; import org.springframework.data.relational.core.mapping.event.BeforeSaveCallback; +import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations; /** * Unit tests for {@link JdbcAggregateTemplate}. @@ -65,6 +66,7 @@ public class JdbcAggregateTemplateUnitTests { @Mock ApplicationEventPublisher eventPublisher; @Mock RelationResolver relationResolver; @Mock EntityCallbacks callbacks; + @Mock NamedParameterJdbcOperations operations; @BeforeEach public void setUp() { @@ -72,7 +74,7 @@ public void setUp() { RelationalMappingContext mappingContext = new RelationalMappingContext(NamingStrategy.INSTANCE); JdbcConverter converter = new BasicJdbcConverter(mappingContext, relationResolver); - template = new JdbcAggregateTemplate(eventPublisher, mappingContext, converter, dataAccessStrategy); + template = new JdbcAggregateTemplate(eventPublisher, mappingContext, converter, dataAccessStrategy, operations); ((JdbcAggregateTemplate) template).setEntityCallbacks(callbacks); } diff --git a/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/repository/config/EnableJdbcRepositoriesIntegrationTests.java b/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/repository/config/EnableJdbcRepositoriesIntegrationTests.java index 96196889b5..c7144efd08 100644 --- a/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/repository/config/EnableJdbcRepositoriesIntegrationTests.java +++ b/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/repository/config/EnableJdbcRepositoriesIntegrationTests.java @@ -30,6 +30,7 @@ import org.junit.jupiter.api.extension.ExtendWith; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.context.ApplicationContext; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.FilterType; @@ -42,14 +43,13 @@ import org.springframework.data.jdbc.core.convert.DefaultJdbcTypeFactory; import org.springframework.data.jdbc.core.convert.JdbcConverter; import org.springframework.data.jdbc.core.convert.JdbcCustomConversions; +import org.springframework.data.jdbc.core.convert.RelationResolver; import org.springframework.data.jdbc.core.convert.SqlGeneratorSource; -import org.springframework.data.jdbc.core.mapping.JdbcMappingContext; import org.springframework.data.jdbc.repository.QueryMappingConfiguration; import org.springframework.data.jdbc.repository.config.EnableJdbcRepositoriesIntegrationTests.TestConfiguration; import org.springframework.data.jdbc.repository.support.JdbcRepositoryFactoryBean; import org.springframework.data.mapping.PersistentEntity; import org.springframework.data.relational.core.dialect.Dialect; -import org.springframework.data.relational.core.mapping.NamingStrategy; import org.springframework.data.relational.core.mapping.RelationalMappingContext; import org.springframework.data.repository.CrudRepository; import org.springframework.jdbc.core.RowMapper; @@ -77,7 +77,8 @@ public class EnableJdbcRepositoriesIntegrationTests { static final Field OPERATIONS = ReflectionUtils.findField(JdbcRepositoryFactoryBean.class, "operations"); static final Field DATA_ACCESS_STRATEGY = ReflectionUtils.findField(JdbcRepositoryFactoryBean.class, "dataAccessStrategy"); - static final Field CONVERTER = ReflectionUtils.findField(JdbcRepositoryFactoryBean.class, "converter"); + static final Field AGGREGATE_TEMPLATE = ReflectionUtils.findField(JdbcRepositoryFactoryBean.class, + "jdbcAggregateTemplate"); public static final RowMapper DUMMY_ENTITY_ROW_MAPPER = mock(RowMapper.class); public static final RowMapper STRING_ROW_MAPPER = mock(RowMapper.class); @@ -85,10 +86,10 @@ public class EnableJdbcRepositoriesIntegrationTests { @Autowired DummyRepository repository; @Autowired @Qualifier("namedParameterJdbcTemplate") NamedParameterJdbcOperations defaultOperations; @Autowired @Qualifier("defaultDataAccessStrategy") DataAccessStrategy defaultDataAccessStrategy; - @Autowired @Qualifier("converter") JdbcConverter defaultJdbcConverter; + @Autowired @Qualifier("jdbcAggregateTemplate") JdbcAggregateTemplate defaultJdbcAggregateTemplate; @Autowired @Qualifier("qualifierJdbcOperations") NamedParameterJdbcOperations qualifierJdbcOperations; @Autowired @Qualifier("qualifierDataAccessStrategy") DataAccessStrategy qualifierDataAccessStrategy; - @Autowired @Qualifier("qualifierJdbcConverter") JdbcConverter qualifierJdbcConverter; + @Autowired @Qualifier("qualifierJdbcAggregateTemplate") JdbcAggregateTemplate qualifierJdbcAggregateTemplate; @BeforeAll public static void setup() { @@ -96,7 +97,7 @@ public static void setup() { MAPPER_MAP.setAccessible(true); OPERATIONS.setAccessible(true); DATA_ACCESS_STRATEGY.setAccessible(true); - CONVERTER.setAccessible(true); + AGGREGATE_TEMPLATE.setAccessible(true); } @Test // DATAJDBC-100 @@ -130,8 +131,9 @@ public void jdbcOperationsRef() { factoryBean); assertThat(dataAccessStrategy).isNotSameAs(defaultDataAccessStrategy).isSameAs(qualifierDataAccessStrategy); - JdbcConverter converter = (JdbcConverter) ReflectionUtils.getField(CONVERTER, factoryBean); - assertThat(converter).isNotSameAs(defaultJdbcConverter).isSameAs(qualifierJdbcConverter); + JdbcAggregateTemplate aggregateTemplate = (JdbcAggregateTemplate) ReflectionUtils.getField(AGGREGATE_TEMPLATE, + factoryBean); + assertThat(aggregateTemplate).isNotSameAs(defaultJdbcAggregateTemplate).isSameAs(qualifierJdbcAggregateTemplate); } interface DummyRepository extends CrudRepository { @@ -147,7 +149,7 @@ static class DummyEntity { @EnableJdbcRepositories(considerNestedRepositories = true, includeFilters = @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = DummyRepository.class), jdbcOperationsRef = "qualifierJdbcOperations", dataAccessStrategyRef = "qualifierDataAccessStrategy", - jdbcConverterRef = "qualifierJdbcConverter", repositoryBaseClass = DummyRepositoryBaseClass.class) + jdbcAggregateTemplateRef = "qualifierJdbcAggregateTemplate", repositoryBaseClass = DummyRepositoryBaseClass.class) static class TestConfiguration { @Bean @@ -181,17 +183,25 @@ Dialect jdbcDialect(@Qualifier("qualifierJdbcOperations") NamedParameterJdbcOper return DialectResolver.getDialect(operations.getJdbcOperations()); } - @Bean("qualifierJdbcConverter") - JdbcConverter qualifierJdbcConverter(Optional namingStrategy, - @Qualifier("qualifierJdbcOperations") NamedParameterJdbcOperations operations, - @Lazy @Qualifier("qualifierDataAccessStrategy") DataAccessStrategy dataAccessStrategy) { - JdbcCustomConversions conversions = new JdbcCustomConversions(); - JdbcMappingContext mappingContext = new JdbcMappingContext(namingStrategy.orElse(NamingStrategy.INSTANCE)); - mappingContext.setSimpleTypeHolder(conversions.getSimpleTypeHolder()); - DefaultJdbcTypeFactory jdbcTypeFactory = new DefaultJdbcTypeFactory(operations.getJdbcOperations()); + @Bean("qualifierJdbcAggregateTemplate") + public JdbcAggregateTemplate jdbcAggregateTemplate(ApplicationContext applicationContext, + @Lazy RelationResolver relationResolver, + @Qualifier("qualifierJdbcOperations") NamedParameterJdbcOperations operations) { + + RelationalMappingContext relationalMappingContext = new RelationalMappingContext(); Dialect dialect = DialectResolver.getDialect(operations.getJdbcOperations()); - return new BasicJdbcConverter(mappingContext, dataAccessStrategy, conversions, jdbcTypeFactory, + + JdbcConverter jdbcConverter = new BasicJdbcConverter(new RelationalMappingContext(), relationResolver, + new JdbcCustomConversions(), new DefaultJdbcTypeFactory(operations.getJdbcOperations()), dialect.getIdentifierProcessing()); + + DataAccessStrategy dataAccessStrategy = new DefaultDataAccessStrategy( + new SqlGeneratorSource(relationalMappingContext, jdbcConverter, + DialectResolver.getDialect(operations.getJdbcOperations())), + relationalMappingContext, jdbcConverter, operations); + + return new JdbcAggregateTemplate(applicationContext, relationalMappingContext, jdbcConverter, dataAccessStrategy, + operations); } } diff --git a/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/testing/TestConfiguration.java b/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/testing/TestConfiguration.java index 6007cc2ee8..2f29c3a39b 100644 --- a/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/testing/TestConfiguration.java +++ b/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/testing/TestConfiguration.java @@ -23,16 +23,17 @@ import javax.sql.DataSource; import org.apache.ibatis.session.SqlSessionFactory; - import org.springframework.beans.factory.BeanFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.context.ApplicationContext; 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.context.annotation.Lazy; import org.springframework.data.convert.CustomConversions; +import org.springframework.data.jdbc.core.JdbcAggregateTemplate; import org.springframework.data.jdbc.core.convert.BasicJdbcConverter; import org.springframework.data.jdbc.core.convert.DataAccessStrategy; import org.springframework.data.jdbc.core.convert.DefaultDataAccessStrategy; @@ -161,4 +162,17 @@ Dialect jdbcDialect(NamedParameterJdbcOperations operations) { TestDatabaseFeatures features(NamedParameterJdbcOperations operations) { return new TestDatabaseFeatures(operations.getJdbcOperations()); } + + @Bean JdbcAggregateTemplate jdbcAggregateTemplate( + ApplicationContext applicationContext, + @Qualifier("converter") JdbcConverter jdbcConverter, + @Qualifier("defaultDataAccessStrategy") DataAccessStrategy dataAccessStrategy, + @Qualifier("namedParameterJdbcTemplate") NamedParameterJdbcOperations operations) { + return new JdbcAggregateTemplate( + applicationContext, + new RelationalMappingContext(), + jdbcConverter, + dataAccessStrategy, + operations); + } } From f67b5dd748fd80b4d90f606560a6d92177510d71 Mon Sep 17 00:00:00 2001 From: Tomohiko Ozawa Date: Thu, 4 Nov 2021 01:58:11 +0900 Subject: [PATCH 3/3] use interface --- .../jdbc/core/JdbcAggregateOperations.java | 12 +++++++ .../data/jdbc/core/JdbcAggregateTemplate.java | 31 ++++++++++--------- .../config/EnableJdbcRepositories.java | 4 +-- .../config/JdbcRepositoryConfigExtension.java | 4 +-- .../support/JdbcRepositoryFactory.java | 15 ++++----- .../support/JdbcRepositoryFactoryBean.java | 16 +++++----- ...nableJdbcRepositoriesIntegrationTests.java | 21 +++++++------ .../data/jdbc/testing/TestConfiguration.java | 3 +- 8 files changed, 61 insertions(+), 45 deletions(-) diff --git a/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/JdbcAggregateOperations.java b/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/JdbcAggregateOperations.java index 73cc729525..3ec79fd57b 100644 --- a/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/JdbcAggregateOperations.java +++ b/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/JdbcAggregateOperations.java @@ -18,6 +18,10 @@ import org.springframework.data.domain.Page; import org.springframework.data.domain.Pageable; import org.springframework.data.domain.Sort; +import org.springframework.data.jdbc.core.convert.DataAccessStrategy; +import org.springframework.data.jdbc.core.convert.JdbcConverter; +import org.springframework.data.relational.core.mapping.RelationalMappingContext; +import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations; import org.springframework.lang.Nullable; /** @@ -29,6 +33,14 @@ */ public interface JdbcAggregateOperations { + RelationalMappingContext getRelationalMappingContext(); + + DataAccessStrategy getDataAccessStrategy(); + + JdbcConverter getJdbcConverter(); + + NamedParameterJdbcOperations getNamedParameterJdbcOperations(); + /** * Saves an instance of an aggregate, including all the members of the aggregate. * diff --git a/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/JdbcAggregateTemplate.java b/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/JdbcAggregateTemplate.java index 5a121b9589..499b5bf4ce 100644 --- a/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/JdbcAggregateTemplate.java +++ b/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/JdbcAggregateTemplate.java @@ -55,17 +55,6 @@ */ public class JdbcAggregateTemplate implements JdbcAggregateOperations { - public RelationalMappingContext getContext() { - return context; - } - - public DataAccessStrategy getAccessStrategy() { - return accessStrategy; - } - - public NamedParameterJdbcOperations getNamedParameterJdbcOperations() { - return operations; - } private final ApplicationEventPublisher publisher; private final RelationalMappingContext context; @@ -78,10 +67,6 @@ public NamedParameterJdbcOperations getNamedParameterJdbcOperations() { private final NamedParameterJdbcOperations operations; private final AggregateChangeExecutor executor; - public JdbcConverter getConverter() { - return converter; - } - private final JdbcConverter converter; private EntityCallbacks entityCallbacks = EntityCallbacks.create(); @@ -146,6 +131,22 @@ public JdbcAggregateTemplate(ApplicationEventPublisher publisher, RelationalMapp this.executor = new AggregateChangeExecutor(converter, accessStrategy); } + public RelationalMappingContext getRelationalMappingContext() { + return context; + } + + public DataAccessStrategy getDataAccessStrategy() { + return accessStrategy; + } + + public NamedParameterJdbcOperations getNamedParameterJdbcOperations() { + return operations; + } + + public JdbcConverter getJdbcConverter() { + return converter; + } + /** * @param entityCallbacks * @since 1.1 diff --git a/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/config/EnableJdbcRepositories.java b/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/config/EnableJdbcRepositories.java index 6fa321c8bb..bb9c3a5e56 100644 --- a/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/config/EnableJdbcRepositories.java +++ b/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/config/EnableJdbcRepositories.java @@ -132,10 +132,10 @@ String transactionManagerRef() default "transactionManager"; /** - * Configures the name of the {@link org.springframework.data.jdbc.core.JdbcAggregateTemplate} bean definition to be + * Configures the name of the {@link org.springframework.data.jdbc.core.JdbcAggregateOperations} bean definition to be * used to create repositories discovered through this annotation. * * @since 2.3 */ - String jdbcAggregateTemplateRef() default ""; + String jdbcAggregateOperationsRef() default ""; } diff --git a/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/config/JdbcRepositoryConfigExtension.java b/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/config/JdbcRepositoryConfigExtension.java index 67b866eb1a..2daa3a55a3 100644 --- a/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/config/JdbcRepositoryConfigExtension.java +++ b/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/config/JdbcRepositoryConfigExtension.java @@ -87,9 +87,9 @@ public void postProcess(BeanDefinitionBuilder builder, RepositoryConfigurationSo Optional transactionManagerRef = source.getAttribute("transactionManagerRef"); builder.addPropertyValue("transactionManager", transactionManagerRef.orElse(DEFAULT_TRANSACTION_MANAGER_BEAN_NAME)); - source.getAttribute("jdbcAggregateTemplateRef") + source.getAttribute("jdbcAggregateOperationsRef") .filter(StringUtils::hasText) - .ifPresent(s -> builder.addPropertyReference("jdbcAggregateTemplate", s)); + .ifPresent(s -> builder.addPropertyReference("jdbcAggregateOperations", s)); } diff --git a/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/support/JdbcRepositoryFactory.java b/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/support/JdbcRepositoryFactory.java index 921f4787bb..98d4b723a8 100644 --- a/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/support/JdbcRepositoryFactory.java +++ b/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/support/JdbcRepositoryFactory.java @@ -19,6 +19,7 @@ import org.springframework.beans.factory.BeanFactory; import org.springframework.context.ApplicationEventPublisher; +import org.springframework.data.jdbc.core.JdbcAggregateOperations; import org.springframework.data.jdbc.core.JdbcAggregateTemplate; import org.springframework.data.jdbc.core.convert.DataAccessStrategy; import org.springframework.data.jdbc.core.convert.JdbcConverter; @@ -94,16 +95,16 @@ public JdbcRepositoryFactory(DataAccessStrategy dataAccessStrategy, RelationalMa * Creates a new {@link JdbcRepositoryFactory} for the given {@link JdbcAggregateTemplate} and * {@link ApplicationEventPublisher}. * - * @param template + * @param operations * @param publisher */ - public JdbcRepositoryFactory(JdbcAggregateTemplate template, ApplicationEventPublisher publisher) { + public JdbcRepositoryFactory(JdbcAggregateOperations operations, ApplicationEventPublisher publisher) { this.publisher = publisher; - this.context = template.getContext(); - this.converter = template.getConverter(); - this.dialect = DialectResolver.getDialect(template.getNamedParameterJdbcOperations().getJdbcOperations()); - this.accessStrategy = template.getAccessStrategy(); - this.operations = template.getNamedParameterJdbcOperations(); + this.context = operations.getRelationalMappingContext(); + this.converter = operations.getJdbcConverter(); + this.dialect = DialectResolver.getDialect(operations.getNamedParameterJdbcOperations().getJdbcOperations()); + this.accessStrategy = operations.getDataAccessStrategy(); + this.operations = operations.getNamedParameterJdbcOperations(); } /** diff --git a/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/support/JdbcRepositoryFactoryBean.java b/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/support/JdbcRepositoryFactoryBean.java index 1f7ba75f70..8250c5f445 100644 --- a/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/support/JdbcRepositoryFactoryBean.java +++ b/spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/support/JdbcRepositoryFactoryBean.java @@ -21,6 +21,7 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.ApplicationEventPublisher; import org.springframework.context.ApplicationEventPublisherAware; +import org.springframework.data.jdbc.core.JdbcAggregateOperations; import org.springframework.data.jdbc.core.JdbcAggregateTemplate; import org.springframework.data.jdbc.core.convert.DataAccessStrategy; import org.springframework.data.jdbc.core.convert.DefaultDataAccessStrategy; @@ -59,12 +60,7 @@ public class JdbcRepositoryFactoryBean, S, ID extend private NamedParameterJdbcOperations operations; private EntityCallbacks entityCallbacks; private Dialect dialect; - - public void setJdbcAggregateTemplate(JdbcAggregateTemplate jdbcAggregateTemplate) { - this.jdbcAggregateTemplate = jdbcAggregateTemplate; - } - - private JdbcAggregateTemplate jdbcAggregateTemplate; + private JdbcAggregateOperations jdbcAggregateOperations; /** * Creates a new {@link JdbcRepositoryFactoryBean} for the given repository interface. @@ -87,14 +83,18 @@ public void setApplicationEventPublisher(ApplicationEventPublisher publisher) { this.publisher = publisher; } + public void setJdbcAggregateOperations(JdbcAggregateOperations jdbcAggregateOperations) { + this.jdbcAggregateOperations = jdbcAggregateOperations; + } + /** * Creates the actual {@link RepositoryFactorySupport} instance. */ @Override protected RepositoryFactorySupport doCreateRepositoryFactory() { JdbcRepositoryFactory jdbcRepositoryFactory; - if (jdbcAggregateTemplate != null) { - jdbcRepositoryFactory = new JdbcRepositoryFactory(jdbcAggregateTemplate, publisher); + if (jdbcAggregateOperations != null) { + jdbcRepositoryFactory = new JdbcRepositoryFactory(jdbcAggregateOperations, publisher); } else { jdbcRepositoryFactory = new JdbcRepositoryFactory(dataAccessStrategy, mappingContext, converter, dialect, publisher, operations); diff --git a/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/repository/config/EnableJdbcRepositoriesIntegrationTests.java b/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/repository/config/EnableJdbcRepositoriesIntegrationTests.java index c7144efd08..c97b3586df 100644 --- a/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/repository/config/EnableJdbcRepositoriesIntegrationTests.java +++ b/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/repository/config/EnableJdbcRepositoriesIntegrationTests.java @@ -36,6 +36,7 @@ import org.springframework.context.annotation.FilterType; import org.springframework.context.annotation.Lazy; import org.springframework.data.annotation.Id; +import org.springframework.data.jdbc.core.JdbcAggregateOperations; import org.springframework.data.jdbc.core.JdbcAggregateTemplate; import org.springframework.data.jdbc.core.convert.BasicJdbcConverter; import org.springframework.data.jdbc.core.convert.DataAccessStrategy; @@ -77,8 +78,8 @@ public class EnableJdbcRepositoriesIntegrationTests { static final Field OPERATIONS = ReflectionUtils.findField(JdbcRepositoryFactoryBean.class, "operations"); static final Field DATA_ACCESS_STRATEGY = ReflectionUtils.findField(JdbcRepositoryFactoryBean.class, "dataAccessStrategy"); - static final Field AGGREGATE_TEMPLATE = ReflectionUtils.findField(JdbcRepositoryFactoryBean.class, - "jdbcAggregateTemplate"); + static final Field AGGREGATE_OPERATIONS = ReflectionUtils.findField(JdbcRepositoryFactoryBean.class, + "jdbcAggregateOperations"); public static final RowMapper DUMMY_ENTITY_ROW_MAPPER = mock(RowMapper.class); public static final RowMapper STRING_ROW_MAPPER = mock(RowMapper.class); @@ -86,10 +87,10 @@ public class EnableJdbcRepositoriesIntegrationTests { @Autowired DummyRepository repository; @Autowired @Qualifier("namedParameterJdbcTemplate") NamedParameterJdbcOperations defaultOperations; @Autowired @Qualifier("defaultDataAccessStrategy") DataAccessStrategy defaultDataAccessStrategy; - @Autowired @Qualifier("jdbcAggregateTemplate") JdbcAggregateTemplate defaultJdbcAggregateTemplate; + @Autowired @Qualifier("jdbcAggregateOperations") JdbcAggregateOperations defaultJdbcAggregateOperations; @Autowired @Qualifier("qualifierJdbcOperations") NamedParameterJdbcOperations qualifierJdbcOperations; @Autowired @Qualifier("qualifierDataAccessStrategy") DataAccessStrategy qualifierDataAccessStrategy; - @Autowired @Qualifier("qualifierJdbcAggregateTemplate") JdbcAggregateTemplate qualifierJdbcAggregateTemplate; + @Autowired @Qualifier("qualifierJdbcAggregateOperations") JdbcAggregateOperations qualifierJdbcAggregateOperations; @BeforeAll public static void setup() { @@ -97,7 +98,7 @@ public static void setup() { MAPPER_MAP.setAccessible(true); OPERATIONS.setAccessible(true); DATA_ACCESS_STRATEGY.setAccessible(true); - AGGREGATE_TEMPLATE.setAccessible(true); + AGGREGATE_OPERATIONS.setAccessible(true); } @Test // DATAJDBC-100 @@ -131,9 +132,9 @@ public void jdbcOperationsRef() { factoryBean); assertThat(dataAccessStrategy).isNotSameAs(defaultDataAccessStrategy).isSameAs(qualifierDataAccessStrategy); - JdbcAggregateTemplate aggregateTemplate = (JdbcAggregateTemplate) ReflectionUtils.getField(AGGREGATE_TEMPLATE, + JdbcAggregateTemplate aggregateTemplate = (JdbcAggregateTemplate) ReflectionUtils.getField(AGGREGATE_OPERATIONS, factoryBean); - assertThat(aggregateTemplate).isNotSameAs(defaultJdbcAggregateTemplate).isSameAs(qualifierJdbcAggregateTemplate); + assertThat(aggregateTemplate).isNotSameAs(defaultJdbcAggregateOperations).isSameAs(qualifierJdbcAggregateOperations); } interface DummyRepository extends CrudRepository { @@ -149,7 +150,7 @@ static class DummyEntity { @EnableJdbcRepositories(considerNestedRepositories = true, includeFilters = @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = DummyRepository.class), jdbcOperationsRef = "qualifierJdbcOperations", dataAccessStrategyRef = "qualifierDataAccessStrategy", - jdbcAggregateTemplateRef = "qualifierJdbcAggregateTemplate", repositoryBaseClass = DummyRepositoryBaseClass.class) + jdbcAggregateOperationsRef = "qualifierJdbcAggregateOperations", repositoryBaseClass = DummyRepositoryBaseClass.class) static class TestConfiguration { @Bean @@ -183,8 +184,8 @@ Dialect jdbcDialect(@Qualifier("qualifierJdbcOperations") NamedParameterJdbcOper return DialectResolver.getDialect(operations.getJdbcOperations()); } - @Bean("qualifierJdbcAggregateTemplate") - public JdbcAggregateTemplate jdbcAggregateTemplate(ApplicationContext applicationContext, + @Bean("qualifierJdbcAggregateOperations") + public JdbcAggregateOperations jdbcAggregateOperations(ApplicationContext applicationContext, @Lazy RelationResolver relationResolver, @Qualifier("qualifierJdbcOperations") NamedParameterJdbcOperations operations) { diff --git a/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/testing/TestConfiguration.java b/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/testing/TestConfiguration.java index 2f29c3a39b..af5ecbe144 100644 --- a/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/testing/TestConfiguration.java +++ b/spring-data-jdbc/src/test/java/org/springframework/data/jdbc/testing/TestConfiguration.java @@ -33,6 +33,7 @@ import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Lazy; import org.springframework.data.convert.CustomConversions; +import org.springframework.data.jdbc.core.JdbcAggregateOperations; import org.springframework.data.jdbc.core.JdbcAggregateTemplate; import org.springframework.data.jdbc.core.convert.BasicJdbcConverter; import org.springframework.data.jdbc.core.convert.DataAccessStrategy; @@ -163,7 +164,7 @@ TestDatabaseFeatures features(NamedParameterJdbcOperations operations) { return new TestDatabaseFeatures(operations.getJdbcOperations()); } - @Bean JdbcAggregateTemplate jdbcAggregateTemplate( + @Bean JdbcAggregateOperations jdbcAggregateOperations( ApplicationContext applicationContext, @Qualifier("converter") JdbcConverter jdbcConverter, @Qualifier("defaultDataAccessStrategy") DataAccessStrategy dataAccessStrategy,