JTX is all about: resources, resource managers, transactions and transaction managers.
Resources and Resource managers
Resource in JTX is anything that have transactions. Speaking programatically, resource is any class than encapsulates some transactional entity, for example: database session (for databases), messages manager (for message queues). Resource knows how to maintain a transaction.
Each resource (i.e. resource type) has its own resource manager. In
JTX, resource manager is responsible for managing transactions of the
resources of the same type. As seen in the code,
interface is fairly simple, two most important methods are
We can say that
JtxResourceManager serves as an adapter between
JTX framework and some transactional resource. For e.g. database that
would be an implementation that takes database session (or connection)
and creates a new transaction on it. Since it is an adapter, beginning
and rolling back the transactions can be now done through resource
manager, without touching the resource itself.
Transaction manager goes one step further. It's purpose is to control
all registered resource managers and to create/close transactions on all
acquired resources. JTX transaction manager also provides out-of-box
transaction propagation handling. Let's see more details of
As said, JTX transaction manager is used to start transactions. Actually, when needed transactions are requested from the JTX manager. Depending on transaction propagation, manager will return an existing transaction or a new one.
Requested transactions may be optionally scoped by context in which they exists. Only one transaction may be opened in the context. For example, context can be a class within the transactions are created, so only the first method of that class will create the transaction; if that method internally invoke other (transactional) methods, their requests will be ignored.
Transaction is an unit of work that is performed by one or more
resources. Great definition, huh:)? In JTX, transactions are
JtxTransaction class. The most important thing to
remember about it is that:
JtxTransaction is a 'transactional request'. Its existence
doesn't mean that real transaction is started on the resources(s).
We said that
JtxTransactions are requested from the
JtxTransactionManager. But only when a resource is requested from
the jtx transaction, a real transaction is started on the resource!
JTX supports several different resource types, i.e. a transaction can be started over several resources. When committed, a real transaction is committed on each resource, one by one. We are aware this is not the ideal scenario for transactions over multiple resources, but it is pragmatic; on the other hand JTX is usually used in one-resource-type environment, where the only resource is database.
JTX transaction goes through several statuses during it's usage; they
are very similar to JTA. On the very beginning, status is either
NO_TRANSACTION. As said, JTX transaction is an actual
transaction request, therefore even if a real transaction is not
required - e.g. as defined by propagation, there will be a
JtxTransaction object in state
Other statuses are self-explanatory and can be seen in javadoc or source.
Following attributes defines transaction mode.
Propagation behavior is used to define the transaction boundaries. It defines behavior if a transactional method is executed when a transaction context already exists.
JTX provides its own propagation management.
Isolation level has something to do with the concurrency control. When multiple transactions are running they may cause dirty reads, non repeatable reads and phantom reads. It is the degree of isolation one transaction has from the work of other transactions. For example, can this transaction see uncommitted writes from other transactions?
Isolation level is currently not supported by JTX. It is expected to be managed by transactional resource itself.
Defines how long this transaction may run before timing out. Currently, JTX only checks the length of the transaction; longer transaction will not be canceled after timeout period.
Read-only transaction does not modify any data. Transaction should fail on write attempt. JTX does not treat this flag, it just passes it to the resource manager i.e. resource.
Propagation behavior management
One very important feature provided by
propagation behavior management. This means that manager will handle
transaction propagation as defined by transaction mode attribute.
Following propagations are supported by JTX:
PROPAGATION_REQUIRED- Support a current transaction, create a new one if none exists;
PROPAGATION_SUPPORTS- Support a current transaction, execute non-transactionally if none exists;
PROPAGATION_MANDATORY- Support a current transaction, throw an exception if none exists;
PROPAGATION_REQUIRES_NEW- Create a new transaction, suspend the current transaction if one exists;
PROPAGATION_NOT_SUPPORTED- Execute non-transactionally, suspend the current transaction if one exists;
PROPAGATION_NEVER- Execute non-transactionally, throw an exception if a transaction exists.