java.lang.Object
- org.hibernate.resource.transaction.backend.jta.internal.JtaTransactionCoordinatorImpl

所有已实现的接口:

SynchronizationCallbackTarget, TransactionCoordinator
```
public class JtaTransactionCoordinatorImpl
extends Object
implements TransactionCoordinator, SynchronizationCallbackTarget
```
An implementation of TransactionCoordinator based on managing a transaction through the JTA API (either TM or UT)

作者:

Steve Ebersole

嵌套类概要

嵌套类
修饰符和类型类说明

class JtaTransactionCoordinatorImpl.TransactionDriverControlImpl
Implementation of the LocalInflow for this TransactionCoordinator.
- 从接口继承的嵌套类/接口 org.hibernate.resource.transaction.spi.TransactionCoordinator
  TransactionCoordinator.TransactionDriver

构造器概要

构造器
构造器	说明
`JtaTransactionCoordinatorImpl(TransactionCoordinatorBuilder transactionCoordinatorBuilder, TransactionCoordinatorOwner owner, boolean autoJoinTransactions, JtaPlatform jtaPlatform, boolean preferUserTransactions, boolean performJtaThreadTracking, TransactionObserver... observers)`

方法概要

所有方法实例方法具体方法
修饰符和类型	方法	说明
`void`	`addObserver(TransactionObserver observer)`	Adds an observer to the coordinator.
`void`	`afterCompletion(boolean successful, boolean delayed)`	Callback of after-completion.
`void`	`beforeCompletion()`	Callback of before-completion.
`IsolationDelegate`	`createIsolationDelegate()`	Retrieve an isolation delegate appropriate for this transaction strategy.
`void`	`explicitJoin()`	Indicates an explicit request to join a transaction.
`JpaCompliance`	`getJpaCompliance()`
`SynchronizationRegistry`	`getLocalSynchronizations()`	Get access to the local registry of Synchronization instances
`SynchronizationCallbackCoordinator`	`getSynchronizationCallbackCoordinator()`
`int`	`getTimeOut()`
`TransactionCoordinatorBuilder`	`getTransactionCoordinatorBuilder()`	Access to the builder that generated this coordinator
`TransactionCoordinatorOwner`	`getTransactionCoordinatorOwner()`
`TransactionCoordinator.TransactionDriver`	`getTransactionDriverControl()`	Get the delegate used by the local transaction driver to control the underlying transaction
`void`	`invalidate()`
`boolean`	`isActive()`	Is this transaction still active?
`boolean`	`isJoined()`	Determine if there is an active transaction that this coordinator is already joined to.
`boolean`	`isJtaTransactionCurrentlyActive()`
`boolean`	`isSynchronizationRegistered()`	Is the RegisteredSynchronization used by Hibernate for unified JTA Synchronization callbacks registered for this coordinator?
`void`	`pulse()`	Used by owner of the JdbcSession as a means to indicate that implicit joining should be done if needed.
`void`	`removeObserver(TransactionObserver observer)`	Removed an observer from the coordinator.
`void`	`setTimeOut(int seconds)`

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

从接口继承的方法 org.hibernate.resource.transaction.spi.TransactionCoordinator
isTransactionActive, isTransactionActive

- 构造器详细资料
  - JtaTransactionCoordinatorImpl
```
public JtaTransactionCoordinatorImpl(TransactionCoordinatorBuilder transactionCoordinatorBuilder,
                                     TransactionCoordinatorOwner owner,
                                     boolean autoJoinTransactions,
                                     JtaPlatform jtaPlatform,
                                     boolean preferUserTransactions,
                                     boolean performJtaThreadTracking,
                                     TransactionObserver... observers)
```
- 方法详细资料
  - getSynchronizationCallbackCoordinator
```
public SynchronizationCallbackCoordinator getSynchronizationCallbackCoordinator()
```
  - pulse
```
public void pulse()
```
    从接口复制的说明: TransactionCoordinator
    
    Used by owner of the JdbcSession as a means to indicate that implicit joining should be done if needed.
    
    指定者:
    
    pulse 在接口中 TransactionCoordinator
  - explicitJoin
```
public void explicitJoin()
```
    从接口复制的说明: TransactionCoordinator
    
    Indicates an explicit request to join a transaction. This is mainly intended to handle the JPA requirement around EntityManager.joinTransaction(), and generally speaking only has an impact in JTA environments
    
    指定者:
    
    explicitJoin 在接口中 TransactionCoordinator
  - isJoined
```
public boolean isJoined()
```
    从接口复制的说明: TransactionCoordinator
    
    Determine if there is an active transaction that this coordinator is already joined to.
    
    指定者:
    
    isJoined 在接口中 TransactionCoordinator
    
    返回:
    
    true if there is an active transaction this coordinator is already joined to; false otherwise.
  - isSynchronizationRegistered
```
public boolean isSynchronizationRegistered()
```
    Is the RegisteredSynchronization used by Hibernate for unified JTA Synchronization callbacks registered for this coordinator?
    
    返回:
    
    true indicates that a RegisteredSynchronization is currently registered for this coordinator; false indicates it is not (yet) registered.
  - getTransactionCoordinatorOwner
```
public TransactionCoordinatorOwner getTransactionCoordinatorOwner()
```
  - getJpaCompliance
```
public JpaCompliance getJpaCompliance()
```
    指定者:
    
    getJpaCompliance 在接口中 TransactionCoordinator
  - getTransactionDriverControl
```
public TransactionCoordinator.TransactionDriver getTransactionDriverControl()
```
    从接口复制的说明: TransactionCoordinator
    
    Get the delegate used by the local transaction driver to control the underlying transaction
    
    指定者:
    
    getTransactionDriverControl 在接口中 TransactionCoordinator
    
    返回:
    
    The control delegate.
  - getLocalSynchronizations
```
public SynchronizationRegistry getLocalSynchronizations()
```
    从接口复制的说明: TransactionCoordinator
    
    Get access to the local registry of Synchronization instances
    
    指定者:
    
    getLocalSynchronizations 在接口中 TransactionCoordinator
    
    返回:
    
    The local Synchronization registry
  - isActive
```
public boolean isActive()
```
    从接口复制的说明: TransactionCoordinator
    
    Is this transaction still active?
    Answers on a best effort basis. For example, in the case of JDBC based transactions we cannot know that a transaction is active when it is initiated directly through the JDBC Connection, only when it is initiated from here.
    
    指定者:
    
    isActive 在接口中 SynchronizationCallbackTarget
    
    指定者:
    
    isActive 在接口中 TransactionCoordinator
    
    返回:
    
    true if the transaction is still active; false otherwise.
  - isJtaTransactionCurrentlyActive
```
public boolean isJtaTransactionCurrentlyActive()
```
  - createIsolationDelegate
```
public IsolationDelegate createIsolationDelegate()
```
    从接口复制的说明: TransactionCoordinator
    
    Retrieve an isolation delegate appropriate for this transaction strategy.
    
    指定者:
    
    createIsolationDelegate 在接口中 TransactionCoordinator
    
    返回:
    
    An isolation delegate.
  - getTransactionCoordinatorBuilder
```
public TransactionCoordinatorBuilder getTransactionCoordinatorBuilder()
```
    从接口复制的说明: TransactionCoordinator
    
    Access to the builder that generated this coordinator
    
    指定者:
    
    getTransactionCoordinatorBuilder 在接口中 TransactionCoordinator
  - setTimeOut
```
public void setTimeOut(int seconds)
```
    指定者:
    
    setTimeOut 在接口中 TransactionCoordinator
  - getTimeOut
```
public int getTimeOut()
```
    指定者:
    
    getTimeOut 在接口中 TransactionCoordinator
  - invalidate
```
public void invalidate()
```
    指定者:
    
    invalidate 在接口中 TransactionCoordinator
  - beforeCompletion
```
public void beforeCompletion()
```
    从接口复制的说明: SynchronizationCallbackTarget
    
    Callback of before-completion.
    
    指定者:
    
    beforeCompletion 在接口中 SynchronizationCallbackTarget
    
    另请参阅:
    
    Synchronization.beforeCompletion()
  - afterCompletion
```
public void afterCompletion(boolean successful,
                            boolean delayed)
```
    从接口复制的说明: SynchronizationCallbackTarget
    
    Callback of after-completion.
    
    指定者:
    
    afterCompletion 在接口中 SynchronizationCallbackTarget
    
    参数:
    
    successful - Was the transaction successful?
    
    另请参阅:
    
    Synchronization.afterCompletion(int)
  - addObserver
```
public void addObserver(TransactionObserver observer)
```
    从接口复制的说明: TransactionCoordinator
    
    Adds an observer to the coordinator.
    observers are not to be cleared on transaction completion.
    
    指定者:
    
    addObserver 在接口中 TransactionCoordinator
    
    参数:
    
    observer - The observer to add.
  - removeObserver
```
public void removeObserver(TransactionObserver observer)
```
    从接口复制的说明: TransactionCoordinator
    
    Removed an observer from the coordinator.
    
    指定者:
    
    removeObserver 在接口中 TransactionCoordinator
    
    参数:
    
    observer - The observer to remove.

类 JtaTransactionCoordinatorImpl

嵌套类概要

从接口继承的嵌套类/接口 org.hibernate.resource.transaction.spi.TransactionCoordinator

构造器概要

方法概要

从类继承的方法 java.lang.Object

从接口继承的方法 org.hibernate.resource.transaction.spi.TransactionCoordinator

构造器详细资料

JtaTransactionCoordinatorImpl

方法详细资料

getSynchronizationCallbackCoordinator

pulse

explicitJoin

isJoined

isSynchronizationRegistered

getTransactionCoordinatorOwner

getJpaCompliance

getTransactionDriverControl

getLocalSynchronizations

isActive

isJtaTransactionCurrentlyActive

createIsolationDelegate

getTransactionCoordinatorBuilder

setTimeOut

getTimeOut

invalidate

beforeCompletion

afterCompletion

addObserver

removeObserver