Add jdbcConverterRef to @EnableJdbcRepositories

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.
 	 *

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,7 @@
  */
 public class JdbcAggregateTemplate implements JdbcAggregateOperations {
 
+
 	private final ApplicationEventPublisher publisher;
 	private final RelationalMappingContext context;
 
@@ -62,8 +64,11 @@ public class JdbcAggregateTemplate implements JdbcAggregateOperations {
 	private final RelationalEntityUpdateWriter jdbcEntityUpdateWriter;
 
 	private final DataAccessStrategy accessStrategy;
+	private final NamedParameterJdbcOperations operations;
 	private final AggregateChangeExecutor executor;
 
+	private final JdbcConverter converter;
+
 	private EntityCallbacks entityCallbacks = EntityCallbacks.create();
 
 	/**
@@ -76,7 +81,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 +90,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 +112,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,14 +121,32 @@ 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);
 		this.jdbcEntityDeleteWriter = new RelationalEntityDeleteWriter(context);
 		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

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<Object> 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);
 	}
 
 	/**

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
@@ -39,6 +38,7 @@
  * @author Mark Paluch
  * @author Fei Dong
  * @author Antoine Sauray
+ * @author Tomohiko Ozawa
  * @see AbstractJdbcConfiguration
  */
 @Target(ElementType.TYPE)
@@ -131,4 +131,11 @@
 	 */
 	String transactionManagerRef() default "transactionManager";
 
+	/**
+	 * 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 jdbcAggregateOperationsRef() default "";
 }

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,11 @@ public void postProcess(BeanDefinitionBuilder builder, RepositoryConfigurationSo
 
 		Optional<String> transactionManagerRef = source.getAttribute("transactionManagerRef");
 		builder.addPropertyValue("transactionManager", transactionManagerRef.orElse(DEFAULT_TRANSACTION_MANAGER_BEAN_NAME));
+
+		source.getAttribute("jdbcAggregateOperationsRef")
+				.filter(StringUtils::hasText)
+				.ifPresent(s -> builder.addPropertyReference("jdbcAggregateOperations", s));
+
 	}
 
 	/**

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/support/JdbcRepositoryFactory.java

@@ -19,10 +19,12 @@
 
 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;
 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 +91,22 @@ public JdbcRepositoryFactory(DataAccessStrategy dataAccessStrategy, RelationalMa
 		this.operations = operations;
 	}
 
+	/**
+	 * Creates a new {@link JdbcRepositoryFactory} for the given {@link JdbcAggregateTemplate} and
+	 * {@link ApplicationEventPublisher}.
+	 * 
+	 * @param operations
+	 * @param publisher
+	 */
+	public JdbcRepositoryFactory(JdbcAggregateOperations operations, ApplicationEventPublisher publisher) {
+		this.publisher = publisher;
+		this.context = operations.getRelationalMappingContext();
+		this.converter = operations.getJdbcConverter();
+		this.dialect = DialectResolver.getDialect(operations.getNamedParameterJdbcOperations().getJdbcOperations());
+		this.accessStrategy = operations.getDataAccessStrategy();
+		this.operations = operations.getNamedParameterJdbcOperations();
+	}
+
 	/**
 	 * @param queryMappingConfiguration must not be {@literal null} consider {@link QueryMappingConfiguration#EMPTY}
 	 *          instead.
@@ -116,7 +134,8 @@ public <T, ID> EntityInformation<T, ID> getEntityInformation(Class<T> 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);

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/support/JdbcRepositoryFactoryBean.java

@@ -21,6 +21,8 @@
 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;
 import org.springframework.data.jdbc.core.convert.JdbcConverter;
@@ -58,6 +60,7 @@ public class JdbcRepositoryFactoryBean<T extends Repository<S, ID>, S, ID extend
 	private NamedParameterJdbcOperations operations;
 	private EntityCallbacks entityCallbacks;
 	private Dialect dialect;
+	private JdbcAggregateOperations jdbcAggregateOperations;
 
 	/**
 	 * Creates a new {@link JdbcRepositoryFactoryBean} for the given repository interface.
@@ -80,14 +83,22 @@ 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 = new JdbcRepositoryFactory(dataAccessStrategy, mappingContext,
-				converter, dialect, publisher, operations);
+		JdbcRepositoryFactory  jdbcRepositoryFactory;
+		if (jdbcAggregateOperations != null) {
+			jdbcRepositoryFactory = new JdbcRepositoryFactory(jdbcAggregateOperations, publisher);
+		} else {
+			jdbcRepositoryFactory = new JdbcRepositoryFactory(dataAccessStrategy, mappingContext,
+					converter, dialect, publisher, operations);
+		}
 		jdbcRepositoryFactory.setQueryMappingConfiguration(queryMappingConfiguration);
 		jdbcRepositoryFactory.setEntityCallbacks(entityCallbacks);
 		jdbcRepositoryFactory.setBeanFactory(beanFactory);

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);
-		}
 	}
 }

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);
-		}
 	}
 }

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() {