| Methods Summary |
|---|
| public static javax.transaction.TransactionSynchronizationRegistry | getInstance()
return _instance;
|
| public java.lang.Object | getResource(java.lang.Object key)Get an object from the map of resources being managed for
the current transaction. The key must have been supplied earlier
by a call to putResouce in the same transaction. If the key
cannot be found in the current resource map, null is returned.
try {
J2EETransaction tran = (J2EETransaction)Switch.getSwitch().
getTransactionManager().getTransaction();
if (tran == null)
throw new IllegalStateException(
sm.getString("enterprise_distributedtx.no_transaction"));
return tran.getUserResource(key);
} catch (SystemException ex) {
throw new IllegalStateException(
sm.getString("enterprise_distributedtx.no_transaction"));
}
|
| public boolean | getRollbackOnly()Get the rollbackOnly status of the transaction bound to the
current thread.
{
int status = getTransactionStatus();
if ( status == Status.STATUS_NO_TRANSACTION ) {
throw new IllegalStateException(
sm.getString("enterprise_distributedtx.no_transaction"));
}
if ( status == Status.STATUS_MARKED_ROLLBACK
|| status == Status.STATUS_ROLLING_BACK )
return true;
else
return false;
}
|
| public java.lang.Object | getTransactionKey()Return an opaque object to represent the transaction bound to the
current thread at the time this method is called. The returned object
overrides hashCode and equals methods to allow
its use as the key in a java.util.HashMap for use by the
caller. If there is no transaction currently active, null is returned.
The returned object will return the same hashCode and
compare equal to all other objects returned by calling this method
from any component executing in the same transaction context in the
same application server.
The toString method returns a String
that might be usable by a human reader to usefully understand the
transaction context. The result of the toString method
is otherwise not defined. Specifically, there is no forward or backward
compatibility guarantee for the result returned by the
toString method.
The object is not necessarily serializable, and is not useful
outside the virtual machine from which it was obtained.
try {
return Switch.getSwitch().getTransactionManager().getTransaction();
} catch (SystemException ex) {
return null;
}
|
| public int | getTransactionStatus()Returns the status of the transaction bound to the current thread.
This is the result of executing getStatus method on the
TransactionManager, in the current transaction context.
try {
return Switch.getSwitch().getTransactionManager().getStatus();
} catch (SystemException ex) {
return Status.STATUS_NO_TRANSACTION;
}
|
| public void | putResource(java.lang.Object key, java.lang.Object value)Add an object to the map of resources being managed for
the current transaction. The supplied key must be of a caller-
defined class so as not to conflict with other users. The class
of the key must guarantee that the hashCode and
equals methods are suitable for keys in a map.
The key and value are not examined or used by the implementation.
try {
J2EETransaction tran = (J2EETransaction)Switch.getSwitch().
getTransactionManager().getTransaction();
if (tran == null)
throw new IllegalStateException(
sm.getString("enterprise_distributedtx.no_transaction"));
tran.putUserResource(key, value);
} catch (SystemException ex) {
throw new IllegalStateException(
sm.getString("enterprise_distributedtx.no_transaction"));
}
|
| public void | registerInterposedSynchronization(javax.transaction.Synchronization sync)Register a Synchronization instance with special ordering
semantics. The beforeCompletion method on the registered
Synchronization will be called after all user and
system component beforeCompletion callbacks, but before
the 2-phase commit process starts. This allows user and system components to
flush state changes to the caching manager, during their
SessionSynchronization callbacks, and allows managers
to flush state changes to Connectors, during the callbacks
registered with this method. Similarly, the afterCompletion
callback will be called after 2-phase commit completes but before
any user and system afterCompletion callbacks.
The beforeCompletion callback will be invoked in the
transaction context of the current transaction bound to the thread
of the caller of this method, which is the same transaction context
active at the time this method is called. Allowable methods include
access to resources, for example, Connectors. No access is allowed to
user components, for example, timer services or bean methods,
as these might change the state of POJOs, or plain old Java objects,
being managed by the caching manager.
The afterCompletion callback will be invoked in an
undefined transaction context. No access is permitted to resources or
user components as defined above. Resources can be closed, but
no transactional work can be performed with them.
Other than the transaction context, no component J2EE context is
active during either of the callbacks.
try {
J2EETransaction tran = (J2EETransaction)Switch.getSwitch().
getTransactionManager().getTransaction();
if (tran == null)
throw new IllegalStateException(
sm.getString("enterprise_distributedtx.no_transaction"));
tran.registerInterposedSynchronization(sync);
} catch (SystemException ex) {
throw new IllegalStateException(
sm.getString("enterprise_distributedtx.no_transaction"));
}
|
| public void | setRollbackOnly()Set the rollbackOnly status of the transaction bound to the
current thread.
try {
Switch.getSwitch().getTransactionManager().setRollbackOnly();
} catch (SystemException ex) {
throw new IllegalStateException(
sm.getString("enterprise_distributedtx.no_transaction"));
}
|
