protected static Map sessionFactoryMap = new HashMap();
    protected static ThreadLocal threadedSessions = new ThreadLocal();
    protected static ThreadLocal threadTransaction = new ThreadLocal();
    protected static ThreadLocal threadInterceptor = new ThreadLocal();
    private static Log log = LogFactory.getLog(_BaseRootDAO.class);

    /**
     * Return the SessionFactory that is to be used by these DAOs.  Change this
     * and implement your own strategy if you, for example, want to pull the SessionFactory
     * from the JNDI tree.
     */
    protected SessionFactory getSessionFactory() {
        // Instead of a static variable, use JNDI:
        SessionFactory sessions = null;
        try {
            Context ctx = new InitialContext();
            String jndiName = "java:hibernate/HibernateFactory";
            sessions = (SessionFactory)ctx.lookup(jndiName);
        } catch (NamingException ex) {
            log.error(ex.getMessage());
            ex.printStackTrace();
        }
        return sessions;
    }


    /**
     * Return a new Session object that must be closed when the work has been completed.
     * @return the active Session
     */
    protected Session getSession() throws HibernateException {
        Session s = (Session) threadedSessions.get();
        try {
            if (s == null) {
                if (getInterceptor() != null) {
                    s = getSessionFactory().openSession(getInterceptor());
                } else {
                    s = getSessionFactory().openSession();
                }
                threadedSessions.set(s);
            }
        } catch (HibernateException ex) {
            log.error(ex.getMessage());
            throw ex;
        }
        return s;
    }

/**
     * Close the session
     */
    public void closeSession () throws HibernateException {
        try {
            Session s = (Session) threadedSessions.get();
            threadedSessions.set(null);
            if (s != null && s.isOpen()) {
                s.close();
            }
        } catch (HibernateException ex) {
            log.error(ex.getMessage());
            throw ex;
        }
    }

    /**
     * Start a new database transaction.
     */
    public void beginTransaction() throws HibernateException  {
        Transaction tx = (Transaction) threadTransaction.get();
        try {
            if (tx == null) {
                tx = getSession().beginTransaction();
                threadTransaction.set(tx);
            }
        } catch (HibernateException ex) {
            log.error(ex.getMessage());
            throw ex;
        }
    }

    /**
     * Commit the database transaction.
     */
    public void commitTransaction() throws HibernateException {
        Transaction tx = (Transaction) threadTransaction.get();
        try {
            if ( tx != null && !tx.wasCommitted()
                            && !tx.wasRolledBack() ) {
                tx.commit();
            }
            threadTransaction.set(null);
        } catch (HibernateException ex) {
            ex.printStackTrace();
            rollbackTransaction();
            throw ex;
            //ex.printStackTrace();
        }
    }

    /**
     * Commit the database transaction.
     */
    public void rollbackTransaction() throws HibernateException {
        System.out.println("Starting RollBack");
        Transaction tx = (Transaction) threadTransaction.get();
        try {
            threadTransaction.set(null);
            if ( tx != null && !tx.wasCommitted() && !tx.wasRolledBack() ) {
                tx.rollback();
            }
        } catch (HibernateException ex) {
            log.error(ex.getMessage());
            throw ex;
        } finally {
            try {
                closeSession();
            }
            catch (HibernateException e){
                log.error(e.getMessage());
                throw e;
            }
        }
    }

     * Used by the base DAO classes but here for your modification
     * Update the persistent state associated with the given identifier. An exception is thrown if there is a persistent
     * instance with the same identifier in the current session.
     * @param obj a transient instance containing updated state
     */
    protected void update(Object obj) throws HibernateException {
        Session s = null;
        try {
            s = getSession();
            beginTransaction();
            System.out.println("About to Update1 DAO");
            update(obj, s);
            commitTransaction();
        }
        catch (HibernateException e) {
            e.printStackTrace();
            this.rollbackTransaction();
            throw e;
        }
        finally {
            closeSession();
        }
    }

    /**
     * Used by the base DAO classes but here for your modification
     * Update the persistent state associated with the given identifier. An exception is thrown if there is a persistent
     * instance with the same identifier in the current session.
     * @param obj a transient instance containing updated state
     * @param s the Session
     */
    protected void update(Object obj, Session s) throws HibernateException {
        System.out.println("About to Update2 inside DAO");
        s.update(obj);
    }

    /**
     * Used by the base DAO classes but here for your modification
     * Remove a persistent instance from the datastore. The argument may be an instance associated with the receiving
     * Session or a transient instance with an identifier associated with existing persistent state.
     */
    protected void delete(Object obj) throws HibernateException {
        Session s = null;
        try {
            s = getSession();
            beginTransaction();
            System.out.println("About to delete1 inside DAO");
            delete(obj, s);
            commitTransaction();
        }
        catch (HibernateException e) {
            e.printStackTrace();
            this.rollbackTransaction();
            throw e;
        }
        finally {
            closeSession();
        }
    }

    /**
     * Used by the base DAO classes but here for your modification
     * Remove a persistent instance from the datastore. The argument may be an instance associated with the receiving
     * Session or a transient instance with an identifier associated with existing persistent state.
     */
    protected void delete(Object obj, Session s) throws HibernateException {
        System.out.println("About to Delete2 inside DAO");
        try {
            s.delete(obj);
        }
        catch (Exception e) {e.printStackTrace();}
    }

    @MethodPermissions({"Sales"})
    @TransactionAttribute(TransactionAttributeType.REQUIRES_NEW)
    private void updateBooking(Booking booking) {
        BookingDAO dao = new BookingDAO();
        booking.setLastAccessed(new Date());
        try {
            dao.update(booking);
            createAudit(booking.getId(), dif);
        }
        catch (Exception e) {log.error(e.getMessage());}
    } 

    @MethodPermissions({"Sales"})
     @TransactionAttribute(TransactionAttributeType.REQUIRED)
     private void createAudit(long bid, String comments) {
         BookingAuditDAO dao = new BookingAuditDAO();
         BookingAudit audit = new BookingAudit();
         audit.setEmployeeID(emp.getEmployee());
         audit.setCreateTime(new Date());
         audit.setBookingID(new Booking(bid));
         audit.setComments(comments);
         try {
             dao.save(audit);
         }
         catch (Exception e) {log.error(e.getMessage());}
     }

void updateBooking(Booking booking) {
    booking.setLastAccessed(new Date());

    Session s = null;
    Transaction txn = null;

    /////////////////////////////////////////////////////////////
    // analogous to your dao.update() call...
    /////////////////////////////////////////////////////////////
    try {
        s = getSession();
        txn = s.beginTransaction();
        s.update( booking );
        txn.commit();
    }
    catch (HibernateException e) {
        rollback( txn );
    }
    finally {
        release( session );
    }

    s = null;
    txn = null;

    /////////////////////////////////////////////////////////////
    // analogous to your createAudit() call...
    /////////////////////////////////////////////////////////////
    BookingAudit audit = new BookingAudit();
    audit.setEmployeeID( emp.getEmployee() );
    audit.setCreateTime( new Date() );
    audit.setBookingID( new Booking( booking.getId() ) );
    audit.setComments( dif );
    try {
        s = getSession();
        txn = s.beginTransaction();
        s.save( audit );
        txn.commit();
    }
    catch (HibernateException e) {
        rollback( txn );
    }
    finally {
        release( session );
    }

}

private void rollback(Transaction transaction) {
    if ( transaction != null ) {
        try {
            transaction.rollback();
        }
        catch( Throwable ignore ) {
            // don't really care; the cause for rolling back is more important
        }
    }
}

private void release(Session session) {
    if ( session != null ) {
        try {
            session.close();
        }
        catch( Throwable ignore ) {
        }
    }
}

<server>
- <mbean code="org.jboss.hibernate.jmx.Hibernate" name="jboss.har:service=Hibernate">
  <attribute name="DatasourceName">java:/MySqlDS</attribute>
  <attribute name="Dialect">org.hibernate.dialect.MySQLDialect</attribute>
  <attribute name="SessionFactoryName">java:/hibernate/HibernateFactory</attribute>
  <attribute name="CacheProviderClass">org.hibernate.cache.TreeCacheProvider</attribute>
  <attribute name="ShowSqlEnabled">false</attribute>
  </mbean>
  </server>