Using ConnectionFactory

Spring establishes an R2DBC connection to the database via ConnectionFactory. ConnectionFactory is part of the R2DBC specification and provides a common entry point for drivers. It allows the container or framework to hide the problems of connection pooling and transaction management from the application code. As a developer, you don't need to know in detail about how to connect to a database. This is the responsibility of the administrator who installs ConnectionFactory. You likely play both roles as you develop and test code, but you don't necessarily need to know how the production data source is configured.

If you are using the R2DBC layer from Spring, you can configure your own using a connection pooling implementation provided by a third party. A popular implementation is the R2DBC pool (r2dbc-pool). The implementations in the Spring distribution are for testing purposes only and do not provide pooling.

To configure ConnectionFactory:

  1. Establish a connection to the ConnectionFactory in the same way you would normally obtain a ConnectionFactory from R2DBC.

  2. Specify the R2DBC URL (check your driver documentation for the correct value).

The following example shows how to configure ConnectionFactory:

ConnectionFactory factory = ConnectionFactories.get("r2dbc:h2:mem:///test?options=DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE");
val factory = ConnectionFactories.get("r2dbc:h2:mem:///test?options=DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE");

Using ConnectionFactoryUtils

The ConnectionFactoryUtils class is a convenient and full-featured helper class that provides static methods for establishing connections from ConnectionFactory and closing connections (if necessary).

It supports connections bound to the Context of the subscriber, such as R2dbcTransactionManager.

Using SingleConnectionFactory

The SingleConnectionFactory class is an implementation of the DelegatingConnectionFactory interface that wraps a single Connection that is not closed after each use.

If any client code calls close under the assumption that a connection pool exists (as when using persistence support tools), you should set the suppressClose property to true. This parameter returns a proxy that suppresses closures that wraps the physical connection. Note that you can no longer cast it to a native Connection or similar object.

SingleConnectionFactory is primarily a test class and can be used for specific requirements such as pipelining if your R2DBC driver allows such use. Unlike a ConnectionFactory pool, it allows you to reuse the same connection all the time, which avoids over-creation of physical connections.

Using TransactionAwareConnectionFactoryProxy

TransactionAwareConnectionFactoryProxy is a proxy for the target ConnectionFactory. The proxy wraps this target ConnectionFactory to improve compatibility with Spring-managed transactions.

Using this class is required if you are using an R2DBC client that is not otherwise integrated with Spring's R2DBC support. In this case, you can continue to use this client and at the same time have this client participate in Spring-managed transactions. It is generally preferable to integrate an R2DBC client with proper access to ConnectionFactoryUtils for resource management.

For more information, see the javadoc at TransactionAwareConnectionFactoryProxy.

Using R2dbcTransactionManager

The Class R2dbcTransactionManager is an implementation of the ReactiveTransactionManager for individual R2DBC data sources. It binds an R2DBC connection from the specified connection factory to the Context of the subscriber, potentially allowing one subscriber connection per connection factory.

Application code is required to obtain an R2DBC connection via ConnectionFactoryUtils.getConnection(ConnectionFactory) instead of the standard R2DBC ConnectionFactory.create().

All framework classes (for example, DatabaseClient) use this strategy implicitly. If the search strategy is not used with this transaction manager, then it behaves exactly the same as a regular one. Thus, it can be used in any case.

The R2dbcTransactionManager class supports custom isolation levels that are applied to the connection.