#406 - Allow configuring R2dbcEntityOperations bean reference in EnableR2dbcRepositories.

We now accept a bean reference to R2dbcEntityOperations so that a single application can scan for repositories that use different dialects/database systems.

Author: mp911de

src/main/asciidoc/reference/r2dbc-repositories.adoc

@@ -339,3 +339,42 @@ include::../{spring-data-commons-docs}/repository-projections.adoc[leveloffset=+
 include::../{spring-data-commons-docs}/entity-callbacks.adoc[leveloffset=+1]
 include::./r2dbc-entity-callbacks.adoc[leveloffset=+2]
 
+[[r2dbc.multiple-databases]]
+=== Working with multiple Databases
+
+When working with multiple, potentially different databases, your application will require a different approach to configuration.
+The provided `AbstractR2dbcConfiguration` support class assumes a single `ConnectionFactory` from which the `Dialect` gets derived.
+That being said, you need to define a few beans yourself to configure Spring Data R2DBC to work with multiple databases.
+
+R2DBC repositories require either a `DatabaseClient` and `ReactiveDataAccessStrategy` or `R2dbcEntityOperations` to implement repositories.
+A simple configuration to scan for repositories without using `AbstractR2dbcConfiguration` looks like:
+
+[source,java]
+----
+@Configuration
+@EnableR2dbcRepositories(basePackages = "com.acme.mysql", entityOperationsRef = "mysqlR2dbcEntityOperations")
+static class MySQLConfiguration {
+
+    @Bean
+    @Qualifier("mysql")
+    public ConnectionFactory mysqlConnectionFactory() {
+        return …;
+    }
+
+    @Bean
+    public R2dbcEntityOperations mysqlR2dbcEntityOperations(@Qualifier("mysql") ConnectionFactory connectionFactory) {
+
+        DefaultReactiveDataAccessStrategy strategy = new DefaultReactiveDataAccessStrategy(MySqlDialect.INSTANCE);
+        DatabaseClient databaseClient = DatabaseClient.builder()
+                .connectionFactory(connectionFactory)
+                .dataAccessStrategy(strategy)
+                .build();
+
+        return new R2dbcEntityTemplate(databaseClient, strategy);
+    }
+}
+----
+
+Note that `@EnableR2dbcRepositories` allows configuration either through `databaseClientRef` or `entityOperationsRef`.
+Using various `DatabaseClient` beans is useful when connecting to multiple databases of the same type.
+When using different database systems that differ in their dialect, use `@EnableR2dbcRepositories`(entityOperationsRef = …)` instead.

src/main/java/org/springframework/data/r2dbc/core/R2dbcEntityOperations.java

@@ -42,6 +42,15 @@ public interface R2dbcEntityOperations extends FluentR2dbcOperations {
 	 */
 	DatabaseClient getDatabaseClient();
 
+	/**
+	 * Expose the underlying {@link ReactiveDataAccessStrategy} encapsulating dialect specifics.
+	 *
+	 * @return the underlying {@link ReactiveDataAccessStrategy}.
+	 * @see ReactiveDataAccessStrategy
+	 * @since 1.1.3
+	 */
+	ReactiveDataAccessStrategy getDataAccessStrategy();
+
 	// -------------------------------------------------------------------------
 	// Methods dealing with org.springframework.data.r2dbc.query.Query
 	// -------------------------------------------------------------------------

src/main/java/org/springframework/data/r2dbc/core/R2dbcEntityTemplate.java

@@ -125,6 +125,15 @@ public DatabaseClient getDatabaseClient() {
 		return this.databaseClient;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.r2dbc.core.R2dbcEntityOperations#getDataAccessStrategy()
+	 */
+	@Override
+	public ReactiveDataAccessStrategy getDataAccessStrategy() {
+		return this.dataAccessStrategy;
+	}
+
 	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.beans.factory.BeanFactoryAware#setBeanFactory(org.springframework.beans.factory.BeanFactory)

src/main/java/org/springframework/data/r2dbc/repository/config/EnableR2dbcRepositories.java

@@ -121,9 +121,21 @@
 	 * repositories detected.
 	 *
 	 * @return
+	 * @see #entityOperationsRef()
 	 */
 	String databaseClientRef() default "r2dbcDatabaseClient";
 
+	/**
+	 * Configures the name of the {@link org.springframework.data.r2dbc.core.R2dbcEntityOperations} bean to be used with
+	 * the repositories detected. Used as alternative to {@link #databaseClientRef()} to configure an access strategy when
+	 * using repositories with different database systems/dialects. If this attribute is set, then
+	 * {@link #databaseClientRef()} is ignored.
+	 *
+	 * @return
+	 * @since 1.1.3
+	 */
+	String entityOperationsRef() default "";
+
 	/**
 	 * Configures whether nested repository-interfaces (e.g. defined as inner classes) should be discovered by the
 	 * repositories infrastructure.

src/main/java/org/springframework/data/r2dbc/repository/config/R2dbcRepositoryConfigurationExtension.java

@@ -29,6 +29,7 @@
 import org.springframework.data.repository.config.RepositoryConfigurationExtensionSupport;
 import org.springframework.data.repository.config.XmlRepositoryConfigurationSource;
 import org.springframework.data.repository.core.RepositoryMetadata;
+import org.springframework.util.StringUtils;
 
 /**
  * Reactive {@link RepositoryConfigurationExtension} for R2DBC.
@@ -97,8 +98,13 @@ public void postProcess(BeanDefinitionBuilder builder, AnnotationRepositoryConfi
 
 		AnnotationAttributes attributes = config.getAttributes();
 
-		builder.addPropertyReference("databaseClient", attributes.getString("databaseClientRef"));
-		builder.addPropertyReference("dataAccessStrategy", "reactiveDataAccessStrategy");
+		String entityOperationsRef = attributes.getString("entityOperationsRef");
+		if (StringUtils.hasText(entityOperationsRef)) {
+			builder.addPropertyReference("entityOperations", entityOperationsRef);
+		} else {
+			builder.addPropertyReference("databaseClient", attributes.getString("databaseClientRef"));
+			builder.addPropertyReference("dataAccessStrategy", "reactiveDataAccessStrategy");
+		}
 	}
 
 	/*

src/main/java/org/springframework/data/r2dbc/repository/support/R2dbcRepositoryFactory.java

@@ -22,6 +22,7 @@
 import org.springframework.data.projection.ProjectionFactory;
 import org.springframework.data.r2dbc.convert.R2dbcConverter;
 import org.springframework.data.r2dbc.core.DatabaseClient;
+import org.springframework.data.r2dbc.core.R2dbcEntityOperations;
 import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
 import org.springframework.data.r2dbc.core.ReactiveDataAccessStrategy;
 import org.springframework.data.r2dbc.repository.R2dbcRepository;
@@ -54,9 +55,9 @@ public class R2dbcRepositoryFactory extends ReactiveRepositoryFactorySupport {
 	private static final SpelExpressionParser EXPRESSION_PARSER = new SpelExpressionParser();
 
 	private final DatabaseClient databaseClient;
+	private final ReactiveDataAccessStrategy dataAccessStrategy;
 	private final MappingContext<? extends RelationalPersistentEntity<?>, ? extends RelationalPersistentProperty> mappingContext;
 	private final R2dbcConverter converter;
-	private final ReactiveDataAccessStrategy dataAccessStrategy;
 
 	/**
 	 * Creates a new {@link R2dbcRepositoryFactory} given {@link DatabaseClient} and {@link MappingContext}.
@@ -70,9 +71,25 @@ public R2dbcRepositoryFactory(DatabaseClient databaseClient, ReactiveDataAccessS
 		Assert.notNull(dataAccessStrategy, "ReactiveDataAccessStrategy must not be null!");
 
 		this.databaseClient = databaseClient;
+		this.dataAccessStrategy = dataAccessStrategy;
+		this.converter = dataAccessStrategy.getConverter();
+		this.mappingContext = this.converter.getMappingContext();
+	}
+
+	/**
+	 * Creates a new {@link R2dbcRepositoryFactory} given {@link R2dbcEntityOperations}.
+	 *
+	 * @param operations must not be {@literal null}.
+	 * @since 1.1.3
+	 */
+	public R2dbcRepositoryFactory(R2dbcEntityOperations operations) {
+
+		Assert.notNull(operations, "R2dbcEntityOperations must not be null!");
+
+		this.databaseClient = operations.getDatabaseClient();
+		this.dataAccessStrategy = operations.getDataAccessStrategy();
 		this.converter = dataAccessStrategy.getConverter();
 		this.mappingContext = this.converter.getMappingContext();
-		this.dataAccessStrategy = dataAccessStrategy;
 	}
 
 	/*

src/main/java/org/springframework/data/r2dbc/repository/support/R2dbcRepositoryFactoryBean.java

@@ -19,6 +19,7 @@
 
 import org.springframework.data.mapping.context.MappingContext;
 import org.springframework.data.r2dbc.core.DatabaseClient;
+import org.springframework.data.r2dbc.core.R2dbcEntityOperations;
 import org.springframework.data.r2dbc.core.ReactiveDataAccessStrategy;
 import org.springframework.data.repository.Repository;
 import org.springframework.data.repository.core.support.RepositoryFactoryBeanSupport;
@@ -28,7 +29,8 @@
 
 /**
  * {@link org.springframework.beans.factory.FactoryBean} to create
- * {@link org.springframework.data.r2dbc.repository.R2dbcRepository} instances.
+ * {@link org.springframework.data.r2dbc.repository.R2dbcRepository} instances. Can be either configured with
+ * {@link R2dbcEntityOperations} or {@link DatabaseClient} with {@link ReactiveDataAccessStrategy}.
  *
  * @author Mark Paluch
  * @author Christoph Strobl
@@ -39,6 +41,7 @@ public class R2dbcRepositoryFactoryBean<T extends Repository<S, ID>, S, ID exten
 
 	private @Nullable DatabaseClient client;
 	private @Nullable ReactiveDataAccessStrategy dataAccessStrategy;
+	private @Nullable R2dbcEntityOperations operations;
 
 	private boolean mappingContextConfigured = false;
 
@@ -56,26 +59,31 @@ public R2dbcRepositoryFactoryBean(Class<? extends T> repositoryInterface) {
 	 *
 	 * @param client the client to set
 	 */
-	public void setDatabaseClient(@Nullable DatabaseClient client) {
+	public void setDatabaseClient(DatabaseClient client) {
 		this.client = client;
 	}
 
+	public void setDataAccessStrategy(ReactiveDataAccessStrategy dataAccessStrategy) {
+		this.dataAccessStrategy = dataAccessStrategy;
+	}
+
+	/**
+	 * @param operations
+	 * @since 1.1.3
+	 */
+	public void setEntityOperations(R2dbcEntityOperations operations) {
+		this.operations = operations;
+	}
+
 	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.repository.core.support.RepositoryFactoryBeanSupport#setMappingContext(org.springframework.data.mapping.context.MappingContext)
 	 */
 	@Override
-	protected void setMappingContext(@Nullable MappingContext<?, ?> mappingContext) {
+	protected void setMappingContext(MappingContext<?, ?> mappingContext) {
 
+		this.mappingContextConfigured = true;
 		super.setMappingContext(mappingContext);
-
-		if (mappingContext != null) {
-			this.mappingContextConfigured = true;
-		}
-	}
-
-	public void setDataAccessStrategy(@Nullable ReactiveDataAccessStrategy dataAccessStrategy) {
-		this.dataAccessStrategy = dataAccessStrategy;
 	}
 
 	/*
@@ -84,7 +92,9 @@ public void setDataAccessStrategy(@Nullable ReactiveDataAccessStrategy dataAcces
 	 */
 	@Override
 	protected final RepositoryFactorySupport createRepositoryFactory() {
-		return getFactoryInstance(client, dataAccessStrategy);
+
+		return this.operations != null ? getFactoryInstance(this.operations)
+				: getFactoryInstance(this.client, this.dataAccessStrategy);
 	}
 
 	/**
@@ -99,15 +109,32 @@ protected RepositoryFactorySupport getFactoryInstance(DatabaseClient client,
 		return new R2dbcRepositoryFactory(client, dataAccessStrategy);
 	}
 
+	/**
+	 * Creates and initializes a {@link RepositoryFactorySupport} instance.
+	 *
+	 * @param operations must not be {@literal null}.
+	 * @return new instance of {@link RepositoryFactorySupport}.
+	 * @since 1.1.3
+	 */
+	protected RepositoryFactorySupport getFactoryInstance(R2dbcEntityOperations operations) {
+		return new R2dbcRepositoryFactory(operations);
+	}
+
 	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet()
 	 */
 	@Override
 	public void afterPropertiesSet() {
 
-		Assert.state(client != null, "DatabaseClient must not be null!");
-		Assert.state(dataAccessStrategy != null, "ReactiveDataAccessStrategy must not be null!");
+		if (operations == null) {
+
+			Assert.state(client != null, "DatabaseClient must not be null when R2dbcEntityOperations is not configured!");
+			Assert.state(dataAccessStrategy != null,
+					"ReactiveDataAccessStrategy must not be null when R2dbcEntityOperations is not configured!");
+		} else {
+			dataAccessStrategy = operations.getDataAccessStrategy();
+		}
 
 		if (!mappingContextConfigured) {
 			setMappingContext(dataAccessStrategy.getConverter().getMappingContext());

src/test/java/org/springframework/data/r2dbc/repository/config/Person.java

@@ -18,4 +18,4 @@
 /**
  * @author Mark Paluch
  */
-class Person {}
+public class Person {}