Question

I’m using a hibernate session per request model for my web application. My jdbc transaction begins at the beginning of each web request and commited at the end.

// Non-managed environment idiom

Session sess = factory.openSession();
Transaction tx = null;
try {
    tx = sess.beginTransaction();

    // do some work
    ...

    tx.commit();
}
catch (RuntimeException e) {
    if (tx != null) tx.rollback();
    throw e; // or display error message
}
finally {
    sess.close();
}

I’m faced with the problem where I am testing for existence of an entity (A) based on several parameters and doing an insert only if it doesn’t exist.

public synchronized myMethod(param1, param2) {
    MyEntityA entity = MyEntityADAO.findEntity(param1, param2)
    if (entity == null) {
        entity = .../create entity
        MyEntityADAO.save(entity);
    }
}

the problem is that synchronization does not help because the call to MyEntityADAO.save() does not actually write to the database when the currently running thread exits the method and releases the lock, the write to the database occurs after the transaction is commited which is generally what I need for my application except for a few scenarios. The code above causes multiple records saved with same parameters in a multithreaded environment.

I’ve tried to execute the save code in its own new session and transaction:

public synchronized myMethod(param1, param2) {
    MyEntityA entity = MyEntityADAO.findEntity(param1, param2)
    if (entity == null) {
        entity = .../create entity
        Session session = HibernateUtil.createSession();
        MyEntityADAO.save(entity);
        Transaction t = session.beginTransaction();

   }
}

the above causes problems with 2 open sessions loading the same collection with hibernate in some instances.

Should I enclose every DAO call in its own transaction and use transaction propagation with JTA? Is there a way to avoid JTA? Is it alright to commit transaction associated with the main session after the call to MyEntityADAO.save() and call beginTransaction on the main session right after and have the transaction commited at the end of the request as it does now?

Answer 1

The solution that worked for me and my particular app requirements trying to avoid JTA and nested transactions:

Using ManagedSessionContext because org.hibernate.context.ThreadLocalSessionContext will close and create a new session for each transaction. You will run into problems with entities that have collections associated if you load those entities in multiple open sessions (when you will create multiple transactions for one request).

• I open a hibernate session and bind it to the context in the beginning of my web request
• Any service layer method that needs test for existence prior to insert is marked synchronized, the global transaction is commited with the insert statement and a new transaction is started

• At the end the request the transaction bound to the session is commited

  public synchronized myMethod(param1, param2) {

   MyEntityA entity = MyEntityADAO.findEntity(param1, param2)
   if (entity == null) {
        entity = .../create entity
  
        MyEntityADAO.save(entity);
        HibernateUtil.getCurrentSession().getTransaction().commit();
        HibernateUtil.getCurrentSession().getTransaction().begin();
  
  
   }
  

  }

I know its ugly and will not work for everybody in every scenerio, but after doing a very intense search on transaction management, isolation levels, locking, versioning that is the only solution I have found that worked for me. I am not using Spring, and I’m not using a Java EE container, using Tomcat 6.