Example usage for org.hibernate FlushMode AUTO

List of usage examples for org.hibernate FlushMode AUTO

  1. HOME
  2. Java
  3. org.hibernate
  4. org.hibernate.*
  5. FlushMode
  6. AUTO

Introduction

In this page you can find the example usage for org.hibernate FlushMode AUTO.

Prototype

FlushMode AUTO

To view the source code for org.hibernate FlushMode AUTO.

Click Source Link

Document

The Session is sometimes flushed before query execution in order to ensure that queries never return stale state.

Usage

From source file:org.springframework.orm.hibernate3.HibernateTemplateTests.java

License:Apache License

@Test
public void testDeleteWithEntityNameAndLockMode() throws HibernateException {
    TestBean tb = new TestBean();
    given(session.getFlushMode()).willReturn(FlushMode.AUTO);
    hibernateTemplate.delete("myEntity", tb, LockMode.UPGRADE);
    verify(session).lock("myEntity", tb, LockMode.UPGRADE);
    verify(session).delete("myEntity", tb);
    verify(session).flush();//from  www .j av  a 2  s. c om
    verify(session).close();
}

From source file:org.springframework.orm.hibernate3.HibernateTemplateTests.java

License:Apache License

@Test
public void testDeleteAll() throws HibernateException {
    TestBean tb1 = new TestBean();
    TestBean tb2 = new TestBean();
    given(session.getFlushMode()).willReturn(FlushMode.AUTO);
    List tbs = new ArrayList();
    tbs.add(tb1);/*from  www .  j a va2s  . co m*/
    tbs.add(tb2);
    hibernateTemplate.deleteAll(tbs);
    verify(session).delete(same(tb1));
    verify(session).delete(same(tb2));
    verify(session).flush();
    verify(session).close();
}

From source file:org.springframework.orm.hibernate3.HibernateTransactionManager.java

License:Apache License

@Override
@SuppressWarnings("deprecation")
protected void doBegin(Object transaction, TransactionDefinition definition) {
    HibernateTransactionObject txObject = (HibernateTransactionObject) transaction;

    if (txObject.hasConnectionHolder() && !txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
        throw new IllegalTransactionStateException(
                "Pre-bound JDBC Connection found! HibernateTransactionManager does not support "
                        + "running within DataSourceTransactionManager if told to manage the DataSource itself. "
                        + "It is recommended to use a single HibernateTransactionManager for all transactions "
                        + "on a single DataSource, no matter whether Hibernate or JDBC access.");
    }/*from  w  w w .j  a v a2 s.  c  om*/

    Session session = null;

    try {
        if (txObject.getSessionHolder() == null
                || txObject.getSessionHolder().isSynchronizedWithTransaction()) {
            Interceptor entityInterceptor = getEntityInterceptor();
            Session newSession = (entityInterceptor != null ? getSessionFactory().openSession(entityInterceptor)
                    : getSessionFactory().openSession());
            if (logger.isDebugEnabled()) {
                logger.debug("Opened new Session [" + SessionFactoryUtils.toString(newSession)
                        + "] for Hibernate transaction");
            }
            txObject.setSession(newSession);
        }

        session = txObject.getSessionHolder().getSession();

        if (this.prepareConnection && isSameConnectionForEntireSession(session)) {
            // We're allowed to change the transaction settings of the JDBC Connection.
            if (logger.isDebugEnabled()) {
                logger.debug("Preparing JDBC Connection of Hibernate Session ["
                        + SessionFactoryUtils.toString(session) + "]");
            }
            Connection con = session.connection();
            Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);
            txObject.setPreviousIsolationLevel(previousIsolationLevel);
        } else {
            // Not allowed to change the transaction settings of the JDBC Connection.
            if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {
                // We should set a specific isolation level but are not allowed to...
                throw new InvalidIsolationLevelException(
                        "HibernateTransactionManager is not allowed to support custom isolation levels: "
                                + "make sure that its 'prepareConnection' flag is on (the default) and that the "
                                + "Hibernate connection release mode is set to 'on_close' (SpringTransactionFactory's default). "
                                + "Make sure that your LocalSessionFactoryBean actually uses SpringTransactionFactory: Your "
                                + "Hibernate properties should *not* include a 'hibernate.transaction.factory_class' property!");
            }
            if (logger.isDebugEnabled()) {
                logger.debug("Not preparing JDBC Connection of Hibernate Session ["
                        + SessionFactoryUtils.toString(session) + "]");
            }
        }

        if (definition.isReadOnly() && txObject.isNewSession()) {
            // Just set to MANUAL in case of a new Session for this transaction.
            session.setFlushMode(FlushMode.MANUAL);
        }

        if (!definition.isReadOnly() && !txObject.isNewSession()) {
            // We need AUTO or COMMIT for a non-read-only transaction.
            FlushMode flushMode = session.getFlushMode();
            if (flushMode.lessThan(FlushMode.COMMIT)) {
                session.setFlushMode(FlushMode.AUTO);
                txObject.getSessionHolder().setPreviousFlushMode(flushMode);
            }
        }

        Transaction hibTx;

        // Register transaction timeout.
        int timeout = determineTimeout(definition);
        if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
            // Use Hibernate's own transaction timeout mechanism on Hibernate 3.1+
            // Applies to all statements, also to inserts, updates and deletes!
            hibTx = session.getTransaction();
            hibTx.setTimeout(timeout);
            hibTx.begin();
        } else {
            // Open a plain Hibernate transaction without specified timeout.
            hibTx = session.beginTransaction();
        }

        // Add the Hibernate transaction to the session holder.
        txObject.getSessionHolder().setTransaction(hibTx);

        // Register the Hibernate Session's JDBC Connection for the DataSource, if set.
        if (getDataSource() != null) {
            Connection con = session.connection();
            ConnectionHolder conHolder = new ConnectionHolder(con);
            if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
                conHolder.setTimeoutInSeconds(timeout);
            }
            if (logger.isDebugEnabled()) {
                logger.debug("Exposing Hibernate transaction as JDBC transaction [" + con + "]");
            }
            TransactionSynchronizationManager.bindResource(getDataSource(), conHolder);
            txObject.setConnectionHolder(conHolder);
        }

        // Bind the session holder to the thread.
        if (txObject.isNewSessionHolder()) {
            TransactionSynchronizationManager.bindResource(getSessionFactory(), txObject.getSessionHolder());
        }
        txObject.getSessionHolder().setSynchronizedWithTransaction(true);
    }

    catch (Throwable ex) {
        if (txObject.isNewSession()) {
            try {
                if (session.getTransaction().isActive()) {
                    session.getTransaction().rollback();
                }
            } catch (Throwable ex2) {
                logger.debug("Could not rollback Session after failed transaction begin", ex);
            } finally {
                SessionFactoryUtils.closeSession(session);
                txObject.setSessionHolder(null);
            }
        }
        throw new CannotCreateTransactionException("Could not open Hibernate Session for transaction", ex);
    }
}

From source file:org.springframework.orm.hibernate3.HibernateTransactionManagerTests.java

License:Apache License

@Test
public void testTransactionRollbackOnly() throws Exception {
    Connection con = mock(Connection.class);
    final SessionFactory sf = mock(SessionFactory.class);
    Session session = mock(Session.class);
    Transaction tx = mock(Transaction.class);

    given(sf.openSession()).willReturn(session);
    given(session.beginTransaction()).willReturn(tx);
    given(session.isOpen()).willReturn(true);
    given(session.getFlushMode()).willReturn(FlushMode.AUTO);
    given(session.isConnected()).willReturn(true);
    given(session.connection()).willReturn(con);

    PlatformTransactionManager tm = new HibernateTransactionManager(sf);
    TransactionTemplate tt = new TransactionTemplate(tm);
    assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));

    tt.execute(new TransactionCallback() {
        @Override//from w  w w .  j av  a  2s .c  om
        public Object doInTransaction(TransactionStatus status) {
            assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
            HibernateTemplate ht = new HibernateTemplate(sf);
            ht.setFlushMode(HibernateTemplate.FLUSH_EAGER);
            ht.execute(new HibernateCallback() {
                @Override
                public Object doInHibernate(org.hibernate.Session session) {
                    return null;
                }
            });
            status.setRollbackOnly();
            return null;
        }
    });

    assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
    verify(session).flush();
    verify(session).close();
    verify(tx).rollback();
}

From source file:org.springframework.orm.hibernate3.HibernateTransactionManagerTests.java

License:Apache License

@Test
public void testTransactionCommitWithEarlyFlush() throws Exception {
    final DataSource ds = mock(DataSource.class);
    Connection con = mock(Connection.class);
    final SessionFactory sf = mock(SessionFactory.class);
    final Session session = mock(Session.class);
    Transaction tx = mock(Transaction.class);
    Query query = mock(Query.class);

    final List list = new ArrayList();
    list.add("test");
    given(con.getTransactionIsolation()).willReturn(Connection.TRANSACTION_READ_COMMITTED);
    given(sf.openSession()).willReturn(session);
    given(session.getTransaction()).willReturn(tx);
    given(session.connection()).willReturn(con);
    given(session.isOpen()).willReturn(true);
    given(session.createQuery("some query string")).willReturn(query);
    given(query.list()).willReturn(list);
    given(session.getFlushMode()).willReturn(FlushMode.AUTO);
    given(session.isConnected()).willReturn(true);

    LocalSessionFactoryBean lsfb = new LocalSessionFactoryBean() {
        @Override/*from w  w  w  .  java 2 s  .c  o  m*/
        protected SessionFactory newSessionFactory(Configuration config) throws HibernateException {
            return sf;
        }
    };
    lsfb.afterPropertiesSet();
    final SessionFactory sfProxy = lsfb.getObject();

    HibernateTransactionManager tm = new HibernateTransactionManager();
    tm.setJdbcExceptionTranslator(new SQLStateSQLExceptionTranslator());
    tm.setSessionFactory(sfProxy);
    tm.setDataSource(ds);
    tm.setEarlyFlushBeforeCommit(true);
    TransactionTemplate tt = new TransactionTemplate(tm);
    tt.setIsolationLevel(TransactionDefinition.ISOLATION_SERIALIZABLE);
    tt.setTimeout(10);
    assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sfProxy));
    assertTrue("Hasn't thread connection", !TransactionSynchronizationManager.hasResource(ds));
    assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());

    Object result = tt.execute(new TransactionCallback() {
        @Override
        public Object doInTransaction(TransactionStatus status) {
            assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sfProxy));
            assertTrue("Has thread connection", TransactionSynchronizationManager.hasResource(ds));
            assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
            assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
            HibernateTemplate ht = new HibernateTemplate(sfProxy);
            return ht.find("some query string");
        }
    });
    assertTrue("Correct result list", result == list);

    assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sfProxy));
    assertTrue("Hasn't thread connection", !TransactionSynchronizationManager.hasResource(ds));
    assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
    InOrder ordered = inOrder(con);
    ordered.verify(con).setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
    ordered.verify(con).setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
    verify(tx).setTimeout(10);
    verify(tx).begin();
    verify(session).flush();
    verify(session).setFlushMode(FlushMode.MANUAL);
    verify(tx).commit();
    verify(session).close();
}

From source file:org.springframework.orm.hibernate3.HibernateTransactionManagerTests.java

License:Apache License

@Test
public void testParticipatingTransactionWithCommit() throws Exception {
    Connection con = mock(Connection.class);
    final SessionFactory sf = mock(SessionFactory.class);
    final Session session = mock(Session.class);
    Transaction tx = mock(Transaction.class);

    given(sf.openSession()).willReturn(session);
    given(session.beginTransaction()).willReturn(tx);
    given(session.isOpen()).willReturn(true);
    given(session.getFlushMode()).willReturn(FlushMode.AUTO);
    given(session.isConnected()).willReturn(true);
    given(session.connection()).willReturn(con);

    LocalSessionFactoryBean lsfb = new LocalSessionFactoryBean() {
        @Override/*from  www . j a v  a2 s.  c  o  m*/
        protected SessionFactory newSessionFactory(Configuration config) throws HibernateException {
            return sf;
        }
    };
    lsfb.afterPropertiesSet();
    final SessionFactory sfProxy = lsfb.getObject();

    PlatformTransactionManager tm = new HibernateTransactionManager(sfProxy);
    final TransactionTemplate tt = new TransactionTemplate(tm);
    final List l = new ArrayList();
    l.add("test");

    Object result = tt.execute(new TransactionCallback() {
        @Override
        public Object doInTransaction(TransactionStatus status) {
            return tt.execute(new TransactionCallback() {
                @Override
                public Object doInTransaction(TransactionStatus status) {
                    HibernateTemplate ht = new HibernateTemplate(sfProxy);
                    ht.setFlushMode(HibernateTemplate.FLUSH_EAGER);
                    return ht.executeFind(new HibernateCallback() {
                        @Override
                        public Object doInHibernate(org.hibernate.Session session) {
                            return l;
                        }
                    });
                }
            });
        }
    });
    assertTrue("Correct result list", result == l);

    verify(session).flush();
    verify(session).close();
    verify(tx).commit();
}

From source file:org.springframework.orm.hibernate3.HibernateTransactionManagerTests.java

License:Apache License

@Test
public void testParticipatingTransactionWithRollback() throws Exception {
    Connection con = mock(Connection.class);
    final SessionFactory sf = mock(SessionFactory.class);
    Session session = mock(Session.class);
    Transaction tx = mock(Transaction.class);

    given(sf.openSession()).willReturn(session);
    given(session.beginTransaction()).willReturn(tx);
    given(session.isOpen()).willReturn(true);
    given(session.getFlushMode()).willReturn(FlushMode.AUTO);
    given(session.isConnected()).willReturn(true);
    given(session.connection()).willReturn(con);

    PlatformTransactionManager tm = new HibernateTransactionManager(sf);
    final TransactionTemplate tt = new TransactionTemplate(tm);
    try {//w  w  w  .  j  a v a  2  s  .  c  o m
        tt.execute(new TransactionCallback() {
            @Override
            public Object doInTransaction(TransactionStatus status) {
                return tt.execute(new TransactionCallback() {
                    @Override
                    public Object doInTransaction(TransactionStatus status) {
                        HibernateTemplate ht = new HibernateTemplate(sf);
                        ht.setFlushMode(HibernateTemplate.FLUSH_EAGER);
                        return ht.executeFind(new HibernateCallback() {
                            @Override
                            public Object doInHibernate(org.hibernate.Session session) {
                                throw new RuntimeException("application exception");
                            }
                        });
                    }
                });
            }
        });
        fail("Should have thrown RuntimeException");
    } catch (RuntimeException ex) {
        // expected
    }

    verify(session).close();
    verify(tx).rollback();
}

From source file:org.springframework.orm.hibernate3.HibernateTransactionManagerTests.java

License:Apache License

@Test
public void testParticipatingTransactionWithRequiresNew() throws Exception {
    final SessionFactory sf = mock(SessionFactory.class);
    Session session1 = mock(Session.class);
    Session session2 = mock(Session.class);
    Connection con = mock(Connection.class);
    Transaction tx = mock(Transaction.class);

    given(sf.openSession()).willReturn(session1, session2);
    given(session1.beginTransaction()).willReturn(tx);
    given(session1.isOpen()).willReturn(true);
    given(session2.beginTransaction()).willReturn(tx);
    given(session2.isOpen()).willReturn(true);
    given(session2.getFlushMode()).willReturn(FlushMode.AUTO);
    given(session1.isConnected()).willReturn(true);
    given(session1.connection()).willReturn(con);
    given(session2.isConnected()).willReturn(true);
    given(session2.connection()).willReturn(con);

    PlatformTransactionManager tm = new HibernateTransactionManager(sf);
    final TransactionTemplate tt = new TransactionTemplate(tm);
    tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);

    assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
    tt.execute(new TransactionCallback() {
        @Override//from  www .  j  a  va  2  s .c  om
        public Object doInTransaction(TransactionStatus status) {
            final SessionHolder holder = (SessionHolder) TransactionSynchronizationManager.getResource(sf);
            assertTrue("Has thread session", holder != null);
            assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
            assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
            tt.execute(new TransactionCallback() {
                @Override
                public Object doInTransaction(TransactionStatus status) {
                    HibernateTemplate ht = new HibernateTemplate(sf);
                    ht.setFlushMode(HibernateTemplate.FLUSH_EAGER);
                    return ht.executeFind(new HibernateCallback() {
                        @Override
                        public Object doInHibernate(org.hibernate.Session session) {
                            assertTrue("Not enclosing session", session != holder.getSession());
                            assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
                            assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
                            return null;
                        }
                    });
                }
            });
            assertTrue("Same thread session as before",
                    holder.getSession() == SessionFactoryUtils.getSession(sf, false));
            assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
            assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
            return null;
        }
    });
    assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));

    verify(session2).flush();
    verify(session1).close();
    verify(session2).close();
    verify(tx, times(2)).commit();
}

From source file:org.springframework.orm.hibernate3.HibernateTransactionManagerTests.java

License:Apache License

@Test
public void testParticipatingTransactionWithNotSupported() throws Exception {
    final SessionFactory sf = mock(SessionFactory.class);
    Session session = mock(Session.class);
    Connection con = mock(Connection.class);
    Transaction tx = mock(Transaction.class);

    given(sf.openSession()).willReturn(session);
    given(session.getSessionFactory()).willReturn(sf);
    given(session.beginTransaction()).willReturn(tx);
    given(session.isOpen()).willReturn(true);
    given(session.getFlushMode()).willReturn(FlushMode.AUTO);
    given(session.isConnected()).willReturn(true);
    given(session.connection()).willReturn(con);

    HibernateTransactionManager tm = new HibernateTransactionManager(sf);
    final TransactionTemplate tt = new TransactionTemplate(tm);
    tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);

    assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
    tt.execute(new TransactionCallback() {
        @Override//from www . ja  v a 2 s  .co  m
        public Object doInTransaction(TransactionStatus status) {
            SessionHolder holder = (SessionHolder) TransactionSynchronizationManager.getResource(sf);
            assertTrue("Has thread session", holder != null);
            assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
            assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
            tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NOT_SUPPORTED);
            tt.execute(new TransactionCallback() {
                @Override
                public Object doInTransaction(TransactionStatus status) {
                    assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
                    assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
                    assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
                    HibernateTemplate ht = new HibernateTemplate(sf);
                    ht.setFlushMode(HibernateTemplate.FLUSH_EAGER);
                    return ht.executeFind(new HibernateCallback() {
                        @Override
                        public Object doInHibernate(org.hibernate.Session session) {
                            return null;
                        }
                    });
                }
            });
            assertTrue("Same thread session as before",
                    holder.getSession() == SessionFactoryUtils.getSession(sf, false));
            assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
            assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
            return null;
        }
    });
    assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));

    verify(session, times(2)).flush();
    verify(session, times(2)).close();
    verify(tx).commit();
}

From source file:org.springframework.orm.hibernate3.HibernateTransactionManagerTests.java

License:Apache License

@Test
public void testTransactionWithPropagationSupports() throws Exception {
    final SessionFactory sf = mock(SessionFactory.class);
    final Session session = mock(Session.class);

    given(sf.openSession()).willReturn(session);
    given(session.getSessionFactory()).willReturn(sf);
    given(session.getFlushMode()).willReturn(FlushMode.MANUAL);

    LocalSessionFactoryBean lsfb = new LocalSessionFactoryBean() {
        @Override/*from   w w  w .  ja va2 s .  c  o m*/
        protected SessionFactory newSessionFactory(Configuration config) throws HibernateException {
            return sf;
        }
    };
    lsfb.afterPropertiesSet();
    final SessionFactory sfProxy = lsfb.getObject();

    PlatformTransactionManager tm = new HibernateTransactionManager(sfProxy);
    TransactionTemplate tt = new TransactionTemplate(tm);
    tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
    assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sfProxy));

    tt.execute(new TransactionCallback() {
        @Override
        public Object doInTransaction(TransactionStatus status) {
            assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sfProxy));
            assertTrue("Is not new transaction", !status.isNewTransaction());
            assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
            assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
            HibernateTemplate ht = new HibernateTemplate(sfProxy);
            ht.setFlushMode(HibernateTemplate.FLUSH_EAGER);
            ht.execute(new HibernateCallback() {
                @Override
                public Object doInHibernate(org.hibernate.Session session) {
                    return null;
                }
            });
            assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sfProxy));
            return null;
        }
    });

    assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sfProxy));
    InOrder ordered = inOrder(session);
    ordered.verify(session).setFlushMode(FlushMode.AUTO);
    ordered.verify(session).flush();
    ordered.verify(session).setFlushMode(FlushMode.MANUAL);
    ordered.verify(session).close();
}