#107 - Polishing.

Extract method references for better readability. Add missing tests and update documentation.
Add delay for transactional MySql tests to avoid failures due to potentially delayed transaction id storage within the database.

Original Pull Request: #107

Author: christophstrobl

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

@@ -4,62 +4,84 @@
 A common pattern when using relational databases is grouping multiple queries within a unit of work that is guarded by a transaction.
 Relational databases typically associate a transaction with a single transport connection.
 Using different connections hence results in utilizing different transactions.
-Spring Data R2DBC includes transaction-awareness in `DatabaseClient` that allows you to group multiple statements within the same transaction using https://docs.spring.io/spring/docs/current/spring-framework-reference/data-access.html#transaction[Spring's Transaction Management].
+Spring Data R2DBC includes transaction-awareness in `DatabaseClient` that allows you to group multiple statements within
+the same transaction using https://docs.spring.io/spring/docs/current/spring-framework-reference/data-access.html#transaction[Spring's Transaction Management].
 Spring Data R2DBC provides a implementation for `ReactiveTransactionManager` with `ConnectionFactoryTransactionManager`.
 See <<r2dbc.connections.ConnectionFactoryTransactionManager>> for further details.
 
 .Programmatic Transaction Management
 ====
 [source,java]
 ----
-ConnectionFactoryTransactionManager tm = new ConnectionFactoryTransactionManager(connectionFactory);
-TransactionalOperator operator = TransactionalOperator.create(tm);
-DatabaseClient db = DatabaseClient.create(connectionFactory);
+ReactiveTransactionManager tm = new ConnectionFactoryTransactionManager(connectionFactory);
+TransactionalOperator operator = TransactionalOperator.create(tm); <1>
 
-Mono<Void> atomicOperation = db.execute().sql("INSERT INTO person (id, name, age) VALUES(:id, :name, :age)")
-            .bind("id", "joe")
-            .bind("name", "Joe")
-            .bind("age", 34)
-            .fetch().rowsUpdated()
-            .then(db.execute().sql("INSERT INTO contacts (id, name) VALUES(:id, :name)")
-                    .bind("id", "joe")
-                    .bind("name", "Joe")
-                    .fetch().rowsUpdated())
-            .then()
-            .as(operator::transactional);
+DatabaseClient client = DatabaseClient.create(connectionFactory);
+
+Mono<Void> atomicOperation = client.execute().sql("INSERT INTO person (id, name, age) VALUES(:id, :name, :age)")
+  .bind("id", "joe")
+  .bind("name", "Joe")
+  .bind("age", 34)
+  .fetch().rowsUpdated()
+  .then(client.execute().sql("INSERT INTO contacts (id, name) VALUES(:id, :name)")
+    .bind("id", "joe")
+    .bind("name", "Joe")
+    .fetch().rowsUpdated())
+  .then()
+  .as(operator::transactional); <2>
 });
 ----
+<1> Associate the `TransactionalOperator` with the `ReactiveTransactionManager`.
+<2> Bind the operation to the `TransactionalOperator`.
 ====
 
-https://docs.spring.io/spring/docs/current/spring-framework-reference/data-access.html#transaction-declarative[Spring's declarative Transaction Management] is a less invasive, annotation-based approach to transaction demarcation.
+https://docs.spring.io/spring/docs/current/spring-framework-reference/data-access.html#transaction-declarative[Spring's declarative Transaction Management]
+is a less invasive, annotation-based approach to transaction demarcation.
 
 .Declarative Transaction Management
 ====
 [source,java]
 ----
-class MyService {
+@Configuration
+@EnableTransactionManagement                                              <1>
+class Config extends AbstractR2dbcConfiguration {
 
-  private final DatabaseClient db;
+  @Override
+  public ConnectionFactory connectionFactory() {
+    return // ...
+  }
 
-  MyService(DatabaseClient db) {
-    this.db = db;
+  @Bean
+  ReactiveTransactionManager txMgr(ConnectionFactory connectionFactory) { <2>
+    return new ConnectionFactoryTransactionManager(connectionFactory);
   }
+}
 
+@Service
+class MyService {
+
+  private final DatabaseClient client;
+
+  MyService(DatabaseClient client) {
+    this.client = client;
+  }
 
   @Transactional
   public Mono<Void> insertPerson() {
 
-    return db.execute().sql("INSERT INTO person (id, name, age) VALUES(:id, :name, :age)")
+    return client.execute().sql("INSERT INTO person (id, name, age) VALUES(:id, :name, :age)")
       .bind("id", "joe")
       .bind("name", "Joe")
       .bind("age", 34)
       .fetch().rowsUpdated()
-      .then(db.execute().sql("INSERT INTO contacts (id, name) VALUES(:id, :name)")
-                    .bind("id", "joe")
-                    .bind("name", "Joe")
-                    .fetch().rowsUpdated())
-            .then();
+      .then(client.execute().sql("INSERT INTO contacts (id, name) VALUES(:id, :name)")
+        .bind("id", "joe")
+        .bind("name", "Joe")
+        .fetch().rowsUpdated())
+      .then();
   }
 }
 ----
+<1> Enable declarative transaction management.
+<2> Provide a `ReactiveTransactionManager` implementation to back reactive tansaction features.
 ====

src/main/java/org/springframework/data/r2dbc/function/connectionfactory/ConnectionFactoryTransactionManager.java

@@ -5,7 +5,7 @@
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,