R2dbcTransactionManager (Spring Framework API)

java.lang.ObjectSE
- org.springframework.transaction.reactive.AbstractReactiveTransactionManager
- - org.springframework.r2dbc.connection.R2dbcTransactionManager

実装されたすべてのインターフェース:
SerializableSE, InitializingBean, ReactiveTransactionManager, TransactionManager
```
public class R2dbcTransactionManager
extends AbstractReactiveTransactionManager
implements InitializingBean
```
単一の R2DBC ConnectionFactory の ReactiveTransactionManager 実装。このクラスは、セットアップで Connection ファクトリメカニズムとして ConnectionFactory を使用している限り、任意の R2DBC ドライバーを使用する任意の環境で機能します。R2DBC Connection を指定された ConnectionFactory から現在のサブスクライバーコンテキストにバインドし、ConnectionFactory ごとに 1 つのコンテキストバインド Connection を許可する可能性があります。
注: このトランザクションマネージャーが動作する ConnectionFactory は、独立した Connection を返す必要があります。Connection はプールから取得できますが（一般的なケース）、ConnectionFactory はスコープスコープの Connection などを返してはなりません。このトランザクションマネージャーは、指定された伝播動作に従って、Connection をコンテキストバインドされたトランザクション自体に関連付けます。進行中のトランザクション中でも、個別の独立した Connection を取得できることを前提としています。
標準の R2DBC スタイルの ConnectionFactory.create() 呼び出しではなく、ConnectionFactoryUtils.getConnection(ConnectionFactory) を介して R2DBC 接続を取得するには、アプリケーションコードが必要です。DatabaseClient などの Spring クラスは、この戦略を暗黙的に使用します。このトランザクションマネージャーと組み合わせて使用しない場合、ConnectionFactoryUtils ルックアップ戦略はネイティブ ConnectionFactory ルックアップとまったく同じように動作します。ポータブルな方法で使用できます。
または、アプリケーションコードが標準の R2DBC ルックアップパターン ConnectionFactory.create() で動作するようにすることもできます。たとえば、Spring をまったく認識しないコードの場合です。その場合、ターゲット ConnectionFactory の TransactionAwareConnectionFactoryProxy を定義し、そのプロキシ ConnectionFactory を DAO に渡します。DAO は、アクセス時に Spring 管理のトランザクションに自動的に参加します。
このトランザクションマネージャーは、基盤となる R2DBC Connection で動作しているリソースを想定して、登録されたトランザクション同期でフラッシュコールバックをトリガーします（同期が一般的にアクティブな場合）。
導入:
5.3
作成者:
Mark Paluch
関連事項:
ConnectionFactoryUtils.getConnection(ConnectionFactory), ConnectionFactoryUtils.releaseConnection(io.r2dbc.spi.Connection, io.r2dbc.spi.ConnectionFactory), TransactionAwareConnectionFactoryProxy, 直列化された形式

ネストされたクラスのサマリー
- クラス org.springframework.transaction.reactive.AbstractReactiveTransactionManager から継承されたネストクラス / インターフェース
  AbstractReactiveTransactionManager.SuspendedResourcesHolder

フィールドのサマリー
- クラス org.springframework.transaction.reactive.AbstractReactiveTransactionManager から継承されたフィールド
  logger

コンストラクターの概要

コンストラクター
コンストラクターと説明
`R2dbcTransactionManager()` 新しい `R2dbcTransactionManager` インスタンスを作成します。
`R2dbcTransactionManager(io.r2dbc.spi.ConnectionFactory connectionFactory)` 新しい `R2dbcTransactionManager` インスタンスを作成します。

メソッドのサマリー

すべてのメソッドインスタンスメソッド具象メソッド
修飾子と型	メソッドと説明
`void`	`afterPropertiesSet()` すべての Bean プロパティを設定し、`BeanFactoryAware`、`ApplicationContextAware` などを満たした後、包含 `BeanFactory` によって呼び出されます。
`protected DurationSE`	`determineTimeout(TransactionDefinition definition)` 特定の定義に使用する実際のタイムアウトを決定します。
`protected reactor.core.publisher.Mono<VoidSE>`	`doBegin(TransactionSynchronizationManager synchronizationManager, ObjectSE transaction, TransactionDefinition definition)` 指定されたトランザクション定義に従って、セマンティクスで新しいトランザクションを開始します。
`protected reactor.core.publisher.Mono<VoidSE>`	`doCleanupAfterCompletion(TransactionSynchronizationManager synchronizationManager, ObjectSE transaction)` トランザクション完了後にリソースをクリーンアップします。
`protected reactor.core.publisher.Mono<VoidSE>`	`doCommit(TransactionSynchronizationManager TransactionSynchronizationManager, GenericReactiveTransaction status)` 指定されたトランザクションの実際のコミットを実行します。
`protected ObjectSE`	`doGetTransaction(TransactionSynchronizationManager synchronizationManager)` 現在のトランザクション状態のトランザクションオブジェクトを返します。
`protected reactor.core.publisher.Mono<VoidSE>`	`doResume(TransactionSynchronizationManager synchronizationManager, ObjectSE transaction, ObjectSE suspendedResources)` 現在のトランザクションのリソースを再開します。
`protected reactor.core.publisher.Mono<VoidSE>`	`doRollback(TransactionSynchronizationManager TransactionSynchronizationManager, GenericReactiveTransaction status)` 指定されたトランザクションの実際のロールバックを実行します。
`protected reactor.core.publisher.Mono<VoidSE>`	`doSetRollbackOnly(TransactionSynchronizationManager synchronizationManager, GenericReactiveTransaction status)` 指定されたトランザクションをロールバックのみに設定します。
`protected reactor.core.publisher.Mono<ObjectSE>`	`doSuspend(TransactionSynchronizationManager synchronizationManager, ObjectSE transaction)` 現在のトランザクションのリソースを一時停止します。
`io.r2dbc.spi.ConnectionFactory`	`getConnectionFactory()` このインスタンスがトランザクションを管理する R2DBC `ConnectionFactory` を返します。
`boolean`	`isEnforceReadOnly()` トランザクション接続で明示的なステートメントを使用して、トランザクションの読み取り専用の性質を強制するかどうかを返します。
`protected boolean`	`isExistingTransaction(ObjectSE transaction)` 指定されたトランザクションオブジェクトが既存のトランザクション（つまり、すでに開始されているトランザクション）を示しているかどうかを確認します。
`protected io.r2dbc.spi.ConnectionFactory`	`obtainConnectionFactory()` `ConnectionFactory` を入手して実際に使用してください。
`protected reactor.core.publisher.Mono<VoidSE>`	`prepareTransactionalConnection(io.r2dbc.spi.Connection con, TransactionDefinition definition, ObjectSE transaction)` トランザクション開始直後にトランザクション `Connection` を準備します。
`protected io.r2dbc.spi.IsolationLevel`	`resolveIsolationLevel(int isolationLevel)` 分離レベル定数を R2DBC `IsolationLevel` に解決します。
`void`	`setConnectionFactory(io.r2dbc.spi.ConnectionFactory connectionFactory)` このインスタンスがトランザクションを管理する必要がある R2DBC `ConnectionFactory` を設定します。
`void`	`setEnforceReadOnly(boolean enforceReadOnly)` トランザクションの読み取り専用の性質を強制するかどうかを指定します（トランザクション接続の明示的なステートメントを通じて `TransactionDefinition.isReadOnly()` で示されるように: Oracle、MySQL、Postgres が理解できる "SET TRANSACTION READ ONLY"。
`protected RuntimeExceptionSE`	`translateException(StringSE task, io.r2dbc.spi.R2dbcException ex)` 指定された R2DBC コミット / ロールバック例外を一般的な Spring 例外に変換して、`AbstractReactiveTransactionManager.commit(org.springframework.transaction.ReactiveTransaction)`/`AbstractReactiveTransactionManager.rollback(org.springframework.transaction.ReactiveTransaction)` 呼び出しから伝達します。

クラス org.springframework.transaction.reactive.AbstractReactiveTransactionManager から継承されたメソッド
commit, getReactiveTransaction, prepareForCommit, registerAfterCompletionWithExistingTransaction, rollback

クラス java.lang.ObjectSE から継承されたメソッド
cloneSE, equalsSE, finalizeSE, getClassSE, hashCodeSE, notifySE, notifyAllSE, toStringSE, waitSE, waitSE, waitSE

- コンストラクターの詳細
  - R2dbcTransactionManager
```
public R2dbcTransactionManager()
```
    新しい R2dbcTransactionManager インスタンスを作成します。ConnectionFactory を使用するには、ConnectionFactory を設定する必要があります。
    関連事項:
    setConnectionFactory(io.r2dbc.spi.ConnectionFactory)
  - R2dbcTransactionManager
```
public R2dbcTransactionManager(io.r2dbc.spi.ConnectionFactory connectionFactory)
```
    新しい R2dbcTransactionManager インスタンスを作成します。
    パラメーター:
    connectionFactory - トランザクションを管理する R2DBC ConnectionFactory
- メソッドの詳細
  - setConnectionFactory
```
public void setConnectionFactory(@Nullable
                                 io.r2dbc.spi.ConnectionFactory connectionFactory)
```
    このインスタンスがトランザクションを管理する必要がある R2DBC ConnectionFactory を設定します。
    これは通常、接続プールなど、ローカルで定義された ConnectionFactory になります。
    ここで渡される ConnectionFactory は、独立した Connection を返す必要があります。Connection はプールから取得できますが（一般的なケース）、ConnectionFactory はスコープ付き Connection などを返してはなりません。
    関連事項:
    TransactionAwareConnectionFactoryProxy
  - getConnectionFactory
```
@Nullable
public io.r2dbc.spi.ConnectionFactory getConnectionFactory()
```
    このインスタンスがトランザクションを管理する R2DBC ConnectionFactory を返します。
  - obtainConnectionFactory
```
protected io.r2dbc.spi.ConnectionFactory obtainConnectionFactory()
```
    ConnectionFactory を入手して実際に使用してください。
    戻り値:
    ConnectionFactory (非 null)
    例外:
    IllegalStateExceptionSE - ConnectionFactory セットがない場合
  - setEnforceReadOnly
```
public void setEnforceReadOnly(boolean enforceReadOnly)
```
    トランザクションの読み取り専用の性質を強制するかどうかを指定します（トランザクション接続の明示的なステートメントを通じて TransactionDefinition.isReadOnly() で示されるように: Oracle、MySQL、Postgres が理解できる "SET TRANSACTION READ ONLY"。
    接続で実行される SQL ステートメントを含む正確な処理は、prepareTransactionalConnection(io.r2dbc.spi.Connection, org.springframework.transaction.TransactionDefinition, java.lang.Object) を介してカスタマイズできます。
    関連事項:
    prepareTransactionalConnection(io.r2dbc.spi.Connection, org.springframework.transaction.TransactionDefinition, java.lang.Object)
  - isEnforceReadOnly
```
public boolean isEnforceReadOnly()
```
    トランザクション接続で明示的なステートメントを使用して、トランザクションの読み取り専用の性質を強制するかどうかを返します。
    関連事項:
    setEnforceReadOnly(boolean)
  - afterPropertiesSet
```
public void afterPropertiesSet()
```
    インターフェースからコピーされた説明: InitializingBean
    すべての Bean プロパティを設定し、BeanFactoryAware、ApplicationContextAware などを満たした後、包含 BeanFactory によって呼び出されます。
    このメソッドにより、Bean インスタンスは、すべての Bean プロパティが設定されたときに、その全体的な構成の検証と最終的な初期化を実行できます。
    次で指定:
    インターフェース InitializingBean の afterPropertiesSet
  - doGetTransaction
```
protected ObjectSE doGetTransaction(TransactionSynchronizationManager synchronizationManager)
                           throws TransactionException
```
    クラスからコピーされた説明: AbstractReactiveTransactionManager
    現在のトランザクション状態のトランザクションオブジェクトを返します。
    返されるオブジェクトは通常、具体的なトランザクションマネージャーの実装に固有のものであり、対応するトランザクション状態を変更可能な形式で保持します。このオブジェクトは、他のテンプレートメソッド (doBegin や doCommit など) に直接、または DefaultReactiveTransactionStatus インスタンスの一部として渡されます。
    返されるオブジェクトには、既存のトランザクション、つまり、トランザクションマネージャーでの現在の getTransaction 呼び出しの前にすでに開始されているトランザクションに関する情報が含まれている必要があります。その結果、doGetTransaction 実装は通常、既存のトランザクションを探し、返されたトランザクションオブジェクトに対応する状態を格納します。
    次で指定:
    クラス AbstractReactiveTransactionManager の doGetTransaction
    パラメーター:
    synchronizationManager - 現在のトランザクションにバインドされた同期マネージャー
    戻り値:
    現在のトランザクションオブジェクト
    例外:
    CannotCreateTransactionException - トランザクションサポートが利用できない場合
    TransactionException - ルックアップまたはシステムエラーの場合
    関連事項:
    AbstractReactiveTransactionManager.doBegin(org.springframework.transaction.reactive.TransactionSynchronizationManager, java.lang.Object, org.springframework.transaction.TransactionDefinition), AbstractReactiveTransactionManager.doCommit(org.springframework.transaction.reactive.TransactionSynchronizationManager, org.springframework.transaction.reactive.GenericReactiveTransaction), AbstractReactiveTransactionManager.doRollback(org.springframework.transaction.reactive.TransactionSynchronizationManager, org.springframework.transaction.reactive.GenericReactiveTransaction), GenericReactiveTransaction.getTransaction()
  - isExistingTransaction
```
protected boolean isExistingTransaction(ObjectSE transaction)
```
    クラスからコピーされた説明: AbstractReactiveTransactionManager
    指定されたトランザクションオブジェクトが既存のトランザクション（つまり、すでに開始されているトランザクション）を示しているかどうかを確認します。
    結果は、新しいトランザクションに対して指定された伝播動作に従って評価されます。既存のトランザクションが中断される（PROPAGATION_REQUIRES_NEW の場合）か、新しいトランザクションが既存のトランザクションに参加する可能性があります（PROPAGATION_REQUIRED の場合）。
    デフォルト実装は false を返しますが、既存のトランザクションへの参加は一般にサポートされていないと想定しています。もちろん、サブクラスはそのようなサポートを提供することをお勧めします。
    オーバーライド:
    クラス AbstractReactiveTransactionManager の isExistingTransaction
    パラメーター:
    transaction - doGetTransaction によって返されるトランザクションオブジェクト
    戻り値:
    既存のトランザクションがある場合
    関連事項:
    AbstractReactiveTransactionManager.doGetTransaction(org.springframework.transaction.reactive.TransactionSynchronizationManager)
  - doBegin
```
protected reactor.core.publisher.Mono<VoidSE> doBegin(TransactionSynchronizationManager synchronizationManager,
                                                    ObjectSE transaction,
                                                    TransactionDefinition definition)
                                             throws TransactionException
```
    クラスからコピーされた説明: AbstractReactiveTransactionManager
    指定されたトランザクション定義に従って、セマンティクスで新しいトランザクションを開始します。伝播動作の適用を気にする必要はありません。これは、この抽象マネージャーによってすでに処理されているためです。
    このメソッドは、トランザクションマネージャーが実際に新しいトランザクションを開始することを決定したときに呼び出されます。以前にトランザクションがなかったか、前のトランザクションが中断されています。
    特別なシナリオはネストされたトランザクションです。このメソッドは、必要に応じてネストされたトランザクションを開始するために呼び出されます。このようなコンテキストでは、アクティブなトランザクションがあります。このメソッドの実装はこれを検出し、適切なネストされたトランザクションを開始する必要があります。
    次で指定:
    クラス AbstractReactiveTransactionManager の doBegin
    パラメーター:
    synchronizationManager - 新しいトランザクションにバインドされた同期マネージャー
    transaction - doGetTransaction によって返されるトランザクションオブジェクト
    definition - 伝播動作、分離レベル、読み取り専用フラグ、タイムアウト、トランザクション名を記述する TransactionDefinition インスタンス
    例外:
    TransactionException - 作成またはシステムエラーの場合
    NestedTransactionNotSupportedException - 基になるトランザクションがネストをサポートしていない場合 (たとえばセーブポイント経由)
  - determineTimeout
```
protected DurationSE determineTimeout(TransactionDefinition definition)
```
    特定の定義に使用する実際のタイムアウトを決定します。トランザクション定義でデフォルト以外の値が指定されていない場合、このマネージャーのデフォルトのタイムアウトにフォールバックします。
    パラメーター:
    definition - トランザクション定義
    戻り値:
    使用する実際のタイムアウト
    関連事項:
    TransactionDefinition.getTimeout()
  - doSuspend
```
protected reactor.core.publisher.Mono<ObjectSE> doSuspend(TransactionSynchronizationManager synchronizationManager,
                                                        ObjectSE transaction)
                                                 throws TransactionException
```
    クラスからコピーされた説明: AbstractReactiveTransactionManager
    現在のトランザクションのリソースを一時停止します。トランザクションの同期はすでに中断されています。
    トランザクションの一時停止が一般的にサポートされていないと仮定すると、デフォルトの実装は TransactionSuspensionNotSupportedException をスローします。
    オーバーライド:
    クラス AbstractReactiveTransactionManager の doSuspend
    パラメーター:
    synchronizationManager - 現在のトランザクションにバインドされた同期マネージャー
    transaction - doGetTransaction によって返されるトランザクションオブジェクト
    戻り値:
    中断されたリソースを保持するオブジェクト (doResume に渡すために検査されないままになります)
    例外:
    TransactionSuspensionNotSupportedException - トランザクションマネージャーの実装が中断をサポートしていない場合
    TransactionException - システムエラーの場合
    関連事項:
    AbstractReactiveTransactionManager.doResume(org.springframework.transaction.reactive.TransactionSynchronizationManager, java.lang.Object, java.lang.Object)
  - doResume
```
protected reactor.core.publisher.Mono<VoidSE> doResume(TransactionSynchronizationManager synchronizationManager,
                                                     @Nullable
                                                     ObjectSE transaction,
                                                     ObjectSE suspendedResources)
                                              throws TransactionException
```
    クラスからコピーされた説明: AbstractReactiveTransactionManager
    現在のトランザクションのリソースを再開します。トランザクションの同期はその後再開されます。
    トランザクションの一時停止が一般的にサポートされていないと仮定すると、デフォルトの実装は TransactionSuspensionNotSupportedException をスローします。
    オーバーライド:
    クラス AbstractReactiveTransactionManager の doResume
    パラメーター:
    synchronizationManager - 現在のトランザクションにバインドされた同期マネージャー
    transaction - doGetTransaction によって返されるトランザクションオブジェクト
    suspendedResources - doSuspend によって返される、中断されたリソースを保持するオブジェクト
    例外:
    TransactionSuspensionNotSupportedException - トランザクションマネージャーの実装が中断をサポートしていない場合
    TransactionException - システムエラーの場合
    関連事項:
    AbstractReactiveTransactionManager.doSuspend(org.springframework.transaction.reactive.TransactionSynchronizationManager, java.lang.Object)
  - doCommit
```
protected reactor.core.publisher.Mono<VoidSE> doCommit(TransactionSynchronizationManager TransactionSynchronizationManager,
                                                     GenericReactiveTransaction status)
                                              throws TransactionException
```
    クラスからコピーされた説明: AbstractReactiveTransactionManager
    指定されたトランザクションの実際のコミットを実行します。
    実装では、「新規トランザクション」フラグまたはロールバック専用フラグを確認する必要はありません。これはすでに以前に処理されています。通常、渡されたステータスに含まれるトランザクションオブジェクトに対してストレートコミットが実行されます。
    次で指定:
    クラス AbstractReactiveTransactionManager の doCommit
    パラメーター:
    TransactionSynchronizationManager - 現在のトランザクションにバインドされた同期マネージャー
    status - トランザクションのステータス表現
    例外:
    TransactionException - コミットまたはシステムエラーの場合
    関連事項:
    GenericReactiveTransaction.getTransaction()
  - doRollback
```
protected reactor.core.publisher.Mono<VoidSE> doRollback(TransactionSynchronizationManager TransactionSynchronizationManager,
                                                       GenericReactiveTransaction status)
                                                throws TransactionException
```
    クラスからコピーされた説明: AbstractReactiveTransactionManager
    指定されたトランザクションの実際のロールバックを実行します。
    実装では、「新しいトランザクション」フラグを確認する必要はありません。これはすでに以前に処理されています。通常、渡されたステータスに含まれるトランザクションオブジェクトに対してストレートロールバックが実行されます。
    次で指定:
    クラス AbstractReactiveTransactionManager の doRollback
    パラメーター:
    TransactionSynchronizationManager - 現在のトランザクションにバインドされた同期マネージャー
    status - トランザクションのステータス表現
    例外:
    TransactionException - システムエラーの場合
    関連事項:
    GenericReactiveTransaction.getTransaction()
  - doSetRollbackOnly
```
protected reactor.core.publisher.Mono<VoidSE> doSetRollbackOnly(TransactionSynchronizationManager synchronizationManager,
                                                              GenericReactiveTransaction status)
                                                       throws TransactionException
```
    クラスからコピーされた説明: AbstractReactiveTransactionManager
    指定されたトランザクションをロールバックのみに設定します。現在のトランザクションが既存のトランザクションに参加している場合にのみ、ロールバック時に呼び出されます。
    既存のトランザクションへの参加は一般にサポートされていないと想定して、デフォルトの実装は IllegalTransactionStateException をスローします。もちろん、サブクラスはそのようなサポートを提供することをお勧めします。
    オーバーライド:
    クラス AbstractReactiveTransactionManager の doSetRollbackOnly
    パラメーター:
    synchronizationManager - 現在のトランザクションにバインドされた同期マネージャー
    status - トランザクションのステータス表現
    例外:
    TransactionException - システムエラーの場合
  - doCleanupAfterCompletion
```
protected reactor.core.publisher.Mono<VoidSE> doCleanupAfterCompletion(TransactionSynchronizationManager synchronizationManager,
                                                                     ObjectSE transaction)
```
    クラスからコピーされた説明: AbstractReactiveTransactionManager
    トランザクション完了後にリソースをクリーンアップします。
    doCommit および doRollback の実行後に、結果について呼び出されます。デフォルトの実装は何もしません。
    例外をスローするべきではなく、エラーに対して警告を発行するだけです。
    オーバーライド:
    クラス AbstractReactiveTransactionManager の doCleanupAfterCompletion
    パラメーター:
    synchronizationManager - 現在のトランザクションにバインドされた同期マネージャー
    transaction - doGetTransaction によって返されるトランザクションオブジェクト
  - prepareTransactionalConnection
```
protected reactor.core.publisher.Mono<VoidSE> prepareTransactionalConnection(io.r2dbc.spi.Connection con,
                                                                           TransactionDefinition definition,
                                                                           ObjectSE transaction)
```
    トランザクション開始直後にトランザクション Connection を準備します。
    "enforceReadOnly" フラグが true に設定され、トランザクション定義が読み取り専用トランザクションを示している場合、デフォルトの実装は "SET TRANSACTION READ ONLY" ステートメントを実行します。
    "SET TRANSACTION READ ONLY" は Oracle、MySQL、Postgres によって理解され、他のデータベースでも機能する場合があります。この処理を適用する場合は、それに応じてこのメソッドをオーバーライドします。
    パラメーター:
    con - トランザクション R2DBC 接続
    definition - 現在のトランザクション定義
    transaction - トランザクションオブジェクト
    関連事項:
    setEnforceReadOnly(boolean)
  - resolveIsolationLevel
```
@Nullable
protected io.r2dbc.spi.IsolationLevel resolveIsolationLevel(int isolationLevel)
```
    分離レベル定数を R2DBC IsolationLevel に解決します。ベンダー固有の IsolationLevel の分離レベル変換を継承する場合は、それに応じてこのメソッドをオーバーライドします。
    パラメーター:
    isolationLevel - 変換する分離レベル。
    戻り値:
    解決された分離レベル。解決できない場合、または分離レベルを default のままにする必要がある場合は、null にすることができます。
    関連事項:
    TransactionDefinition.getIsolationLevel()
  - translateException
```
protected RuntimeExceptionSE translateException(StringSE task,
                                              io.r2dbc.spi.R2dbcException ex)
```
    指定された R2DBC コミット / ロールバック例外を一般的な Spring 例外に変換して、AbstractReactiveTransactionManager.commit(org.springframework.transaction.ReactiveTransaction)/AbstractReactiveTransactionManager.rollback(org.springframework.transaction.ReactiveTransaction) 呼び出しから伝達します。
    パラメーター:
    task - タスクの説明（コミットまたはロールバック）。
    ex - コミット / ロールバックからスローされる SQLException。
    戻り値:
    放出する変換された例外

クラス R2dbcTransactionManager

ネストされたクラスのサマリー

クラス org.springframework.transaction.reactive.AbstractReactiveTransactionManager から継承されたネストクラス / インターフェース

フィールドのサマリー

クラス org.springframework.transaction.reactive.AbstractReactiveTransactionManager から継承されたフィールド

コンストラクターの概要

メソッドのサマリー

クラス org.springframework.transaction.reactive.AbstractReactiveTransactionManager から継承されたメソッド

クラス java.lang.ObjectSE から継承されたメソッド

コンストラクターの詳細

R2dbcTransactionManager

R2dbcTransactionManager

メソッドの詳細

setConnectionFactory

getConnectionFactory

obtainConnectionFactory

setEnforceReadOnly

isEnforceReadOnly

afterPropertiesSet

doGetTransaction

isExistingTransaction

doBegin

determineTimeout

doSuspend

doResume

doCommit

doRollback

doSetRollbackOnly

doCleanupAfterCompletion

prepareTransactionalConnection

resolveIsolationLevel

translateException