I need to use nested transactions. Is that possible? Suppose I have something like this:



The call to deductMoney() in buyStuff() should not result i a new transaction, rather it should join the existing transaction that was started in buyStuff().
The API doc for Session.beginTransaction() indicates that it should work this way: "If a new underlying transaction is required, begin the transaction. Otherwise continue the new work in the context of the existing underlying transaction".
Using JDBCTransactionFactory I get "java.sql.SQLException: Can't call commit when autocommit=true".
Using JTATransactionFactory I get "java.lang.IllegalStateException: Can't commit outside of a transaction.
Either the UserTransaction.begin() is missing or the transaction has already been committed or rolled back."
For JTA I've just configured transaction.factory_class in the config file. Maybe there is something else I have to do to get JTA transactions to work? I'm using resin-ee 2.1 as application server.

If you use ThreadLocal transactions, you can start transactions wihtout care to this:

public class HibernateUtil {
...
private static final ThreadLocal threadTransaction = new ThreadLocal();

..
/**
* Start a new database transaction.
*/
public static void beginTransaction() throws InfrastructureException {
Transaction tx = (Transaction) threadTransaction.get();

try {
if (tx == null) {
tx = getSession().beginTransaction();
threadTransaction.set(tx);
}
} catch (HibernateException ex) {
throw new InfrastructureException(ex);
}
}

/**
* Commit the database transaction.
*/
public static void commitTransaction() throws InfrastructureException {
Transaction tx = (Transaction) threadTransaction.get();

try {
if ((tx != null) && !tx.wasCommitted() && !tx.wasRolledBack()) {
tx.commit();
}

threadTransaction.set(null);
} catch (HibernateException ex) {
rollbackTransaction();
throw new InfrastructureException(ex);
}
}

/**
* Commit the database transaction.
*/
public static void rollbackTransaction() throws InfrastructureException {
Transaction tx = (Transaction) threadTransaction.get();

try {
threadTransaction.set(null);

if ((tx != null) && !tx.wasCommitted() && !tx.wasRolledBack()) {
tx.rollback();
}
} catch (HibernateException ex) {
throw new InfrastructureException(ex);
} finally {
closeSession();
}
}

i don't like wasCommitted method because as said in the javadoc:


and i've tested it with Oracle, sometimes it returns true after a succesfull commit, sometimes not. ;(

I hoped that Hibernate would manage nested transactions for you, so you don't have to build the functionality yourself.

By the way, Will the code you posted work? The first encountered commitTransaction() will commit the transaction, and not the one that corresponds to the first beginTransaction(). I guess you have have to keep track of the nesting depth and only commit() when you are at the outer most transaction.

There are no nested transactions in Java, at least not in common systems. The ThreadLocal is just a nice way to give you the _same_ transaction object whenever you ask in the _same_ thread of execution.

This code is for the "session per request pattern" (right?), so when user perform a request, a filter will open the session(but anyway it is better to posticipate the opening of the session in your DAO), and at the end of the request the same filter will close the session, and commit transactions calling commit.
So you don't have to commit in your DAO or classes otherwise it will commit everything too early.

If you need to commit several times in the same request, I think you should keep track of the nesting level of the transaction, otherwise i think you don't need it.
What kind of application are you programming?
CaveatEmptor example implments this patterns.

p.s sorry for my english!