Example usage for org.springframework.transaction.support TransactionTemplate execute

List of usage examples for org.springframework.transaction.support TransactionTemplate execute

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.transaction.support.*
  5. TransactionTemplate
  6. execute

Introduction

In this page you can find the example usage for org.springframework.transaction.support TransactionTemplate execute.

Prototype

@Override
    @Nullable
    public <T> T execute(TransactionCallback<T> action) throws TransactionException

Source Link

Usage

From source file:com._4dconcept.springframework.data.marklogic.datasource.DatabaseConnectorJtaTransactionTest.java

private void doTestJtaTransactionCommitWithNewTransactionWithinEmptyTransaction(final boolean requiresNew,
        boolean notSupported) throws Exception {

    if (notSupported) {
        given(userTransaction.getStatus()).willReturn(Status.STATUS_ACTIVE, Status.STATUS_NO_TRANSACTION,
                Status.STATUS_ACTIVE, Status.STATUS_ACTIVE);
        given(transactionManager.suspend()).willReturn(transaction);
    } else {/*from w  ww  . jav  a 2s . c om*/
        given(userTransaction.getStatus()).willReturn(Status.STATUS_NO_TRANSACTION,
                Status.STATUS_NO_TRANSACTION, Status.STATUS_ACTIVE, Status.STATUS_ACTIVE);
    }

    final ContentSource contentSource = mock(ContentSource.class);
    final Session session1 = mock(Session.class);
    final Session session2 = mock(Session.class);
    given(contentSource.newSession()).willReturn(session1, session2);

    final JtaTransactionManager ptm = new JtaTransactionManager(userTransaction, transactionManager);
    TransactionTemplate tt = new TransactionTemplate(ptm);
    tt.setPropagationBehavior(notSupported ? TransactionDefinition.PROPAGATION_NOT_SUPPORTED
            : TransactionDefinition.PROPAGATION_SUPPORTS);

    assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
    tt.execute(new TransactionCallbackWithoutResult() {
        @Override
        protected void doInTransactionWithoutResult(TransactionStatus status) {
            assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
            assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
            assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
            assertSame(session1, ContentSourceUtils.getSession(contentSource));
            assertSame(session1, ContentSourceUtils.getSession(contentSource));

            TransactionTemplate tt2 = new TransactionTemplate(ptm);
            tt2.setPropagationBehavior(requiresNew ? TransactionDefinition.PROPAGATION_REQUIRES_NEW
                    : TransactionDefinition.PROPAGATION_REQUIRED);
            tt2.execute(new TransactionCallbackWithoutResult() {
                @Override
                protected void doInTransactionWithoutResult(TransactionStatus status) {
                    assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
                    assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
                    assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
                    assertSame(session2, ContentSourceUtils.getSession(contentSource));
                    assertSame(session2, ContentSourceUtils.getSession(contentSource));
                }
            });

            assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
            assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
            assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
            assertSame(session1, ContentSourceUtils.getSession(contentSource));
        }
    });
    assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
    verify(userTransaction).begin();
    verify(userTransaction).commit();
    if (notSupported) {
        verify(transactionManager).resume(transaction);
    }
    verify(session2).close();
    verify(session1).close();
}

From source file:com.exxonmobile.ace.hybris.test.orders.B2BAcceleratorTestOrderData.java

protected String placeOrderAndApproveByB2BApprover(final String userID, final String purchaseOrderNumber) {
    LOG.debug(String.format(/*from ww w.j av  a  2 s  . co  m*/
            "******************Starting Attempt to setup and create order for PONumber: %s for " + "%s ",
            purchaseOrderNumber, userID));

    final TransactionTemplate template = new TransactionTemplate(getTransactionManager());
    template.setPropagationBehavior(TransactionTemplate.PROPAGATION_REQUIRED);
    return template.execute(new TransactionCallback<String>() {
        @Override
        public String doInTransaction(final TransactionStatus status) {
            String orderCode = null;
            final Map<String, Long> products = new HashMap<String, Long>();
            products.put(PRODUCT_C, Long.valueOf(5));
            final OrderData orderData = placeOrder(userID, products, createUsAddressData(), purchaseOrderNumber,
                    ExxonmobilTestConstants.STANDARD_COSTCENTER, null);

            orderCode = orderData == null ? null : orderData.getCode();

            if (orderCode != null) {
                b2bApproverApproveThisOrder(orderCode);
            }
            return orderCode;
        }
    });
}

From source file:de.hybris.platform.yb2bacceleratortest.orders.B2BAcceleratorTestOrderData.java

protected String placeOrderAndApproveByB2BApprover(final String userID, final String purchaseOrderNumber) {
    LOG.debug(String.format(//from   w  w w. j av a 2  s  .  co  m
            "******************Starting Attempt to setup and create order for PONumber: %s for " + "%s ",
            purchaseOrderNumber, userID));

    final TransactionTemplate template = new TransactionTemplate(getTransactionManager());
    template.setPropagationBehavior(TransactionTemplate.PROPAGATION_REQUIRED);
    return template.execute(new TransactionCallback<String>() {
        @Override
        public String doInTransaction(final TransactionStatus status) {
            String orderCode = null;
            final Map<String, Long> products = new HashMap<String, Long>();
            products.put(PRODUCT_C, Long.valueOf(5));
            final OrderData orderData = placeOrder(userID, products, createUsAddressData(), purchaseOrderNumber,
                    YB2BAcceleratorTestConstants.STANDARD_COSTCENTER, null);

            orderCode = orderData == null ? null : orderData.getCode();

            if (orderCode != null) {
                b2bApproverApproveThisOrder(orderCode);
            }
            return orderCode;
        }
    });
}

From source file:com.jnj.b2b.test.orders.B2BAcceleratorTestOrderData.java

protected String placeOrderAndApproveByB2BApprover(final String userID, final String purchaseOrderNumber) {
    LOG.debug(String.format(/*from   ww  w. j a v  a2s .  co m*/
            "******************Starting Attempt to setup and create order for PONumber: %s for " + "%s ",
            purchaseOrderNumber, userID));

    final TransactionTemplate template = new TransactionTemplate(getTransactionManager());
    template.setPropagationBehavior(TransactionTemplate.PROPAGATION_REQUIRED);
    return template.execute(new TransactionCallback<String>() {
        @Override
        public String doInTransaction(final TransactionStatus status) {
            String orderCode = null;
            final Map<String, Long> products = new HashMap<String, Long>();
            products.put(PRODUCT_C, Long.valueOf(5));
            final OrderData orderData = placeOrder(userID, products, createUsAddressData(), purchaseOrderNumber,
                    Jnjb2bTestConstants.STANDARD_COSTCENTER, null);

            orderCode = orderData == null ? null : orderData.getCode();

            if (orderCode != null) {
                b2bApproverApproveThisOrder(orderCode);
            }
            return orderCode;
        }
    });
}

From source file:com.mitre.test.orders.B2BAcceleratorTestOrderData.java

protected String placeOrderAndApproveByB2BApprover(final String userID, final String purchaseOrderNumber) {
    LOG.debug(String.format(/*from   www.  j  a va 2s.c o  m*/
            "******************Starting Attempt to setup and create order for PONumber: %s for " + "%s ",
            purchaseOrderNumber, userID));

    final TransactionTemplate template = new TransactionTemplate(getTransactionManager());
    template.setPropagationBehavior(TransactionTemplate.PROPAGATION_REQUIRED);
    return template.execute(new TransactionCallback<String>() {
        @Override
        public String doInTransaction(final TransactionStatus status) {
            String orderCode = null;
            final Map<String, Long> products = new HashMap<String, Long>();
            products.put(PRODUCT_C, Long.valueOf(5));
            final OrderData orderData = placeOrder(userID, products, createUsAddressData(), purchaseOrderNumber,
                    MitreTestConstants.STANDARD_COSTCENTER, null);

            orderCode = orderData == null ? null : orderData.getCode();

            if (orderCode != null) {
                b2bApproverApproveThisOrder(orderCode);
            }
            return orderCode;
        }
    });
}

From source file:com.octanner.test.orders.B2BAcceleratorTestOrderData.java

protected String placeOrderAndApproveByB2BApprover(final String userID, final String purchaseOrderNumber) {
    LOG.debug(String.format(// w  w w .ja va  2s . c  o m
            "******************Starting Attempt to setup and create order for PONumber: %s for " + "%s ",
            purchaseOrderNumber, userID));

    final TransactionTemplate template = new TransactionTemplate(getTransactionManager());
    template.setPropagationBehavior(TransactionTemplate.PROPAGATION_REQUIRED);
    return template.execute(new TransactionCallback<String>() {
        @Override
        public String doInTransaction(final TransactionStatus status) {
            String orderCode = null;
            final Map<String, Long> products = new HashMap<String, Long>();
            products.put(PRODUCT_C, Long.valueOf(5));
            final OrderData orderData = placeOrder(userID, products, createUsAddressData(), purchaseOrderNumber,
                    OctannerTestConstants.STANDARD_COSTCENTER, null);

            orderCode = orderData == null ? null : orderData.getCode();

            if (orderCode != null) {
                b2bApproverApproveThisOrder(orderCode);
            }
            return orderCode;
        }
    });
}

From source file:com._4dconcept.springframework.data.marklogic.datasource.DatabaseConnectorJtaTransactionTest.java

private void doTestJtaTransactionWithPropagationRequiresNew(final boolean rollback,
        final boolean openOuterConnection, final boolean accessAfterResume,
        final boolean useTransactionAwareContentSource) throws Exception {

    given(transactionManager.suspend()).willReturn(transaction);
    if (rollback) {
        given(userTransaction.getStatus()).willReturn(Status.STATUS_NO_TRANSACTION, Status.STATUS_ACTIVE);
    } else {/*from   ww w .j  a  va 2 s  .co  m*/
        given(userTransaction.getStatus()).willReturn(Status.STATUS_NO_TRANSACTION, Status.STATUS_ACTIVE,
                Status.STATUS_ACTIVE);
    }

    given(session.getTransactionMode()).willReturn(Session.TransactionMode.QUERY);

    final ContentSource dsToUse = useTransactionAwareContentSource
            ? new TransactionAwareContentSourceProxy(contentSource)
            : contentSource;

    JtaTransactionManager ptm = new JtaTransactionManager(userTransaction, transactionManager);
    final TransactionTemplate tt = new TransactionTemplate(ptm);
    tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
    assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(dsToUse));
    assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());

    tt.execute(new TransactionCallbackWithoutResult() {
        @Override
        protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
            assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(dsToUse));
            assertTrue("JTA synchronizations active",
                    TransactionSynchronizationManager.isSynchronizationActive());
            assertTrue("Is new transaction", status.isNewTransaction());

            Session s = ContentSourceUtils.getSession(dsToUse);
            assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(dsToUse));
            s.getTransactionMode();
            ContentSourceUtils.releaseSession(s, dsToUse);

            s = ContentSourceUtils.getSession(dsToUse);
            assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(dsToUse));
            if (!openOuterConnection) {
                ContentSourceUtils.releaseSession(s, dsToUse);
            }

            for (int i = 0; i < 5; i++) {

                tt.execute(new TransactionCallbackWithoutResult() {
                    @Override
                    protected void doInTransactionWithoutResult(TransactionStatus status)
                            throws RuntimeException {
                        assertTrue("Hasn't thread session",
                                !TransactionSynchronizationManager.hasResource(dsToUse));
                        assertTrue("JTA synchronizations active",
                                TransactionSynchronizationManager.isSynchronizationActive());
                        assertTrue("Is new transaction", status.isNewTransaction());

                        Session s = ContentSourceUtils.getSession(dsToUse);
                        s.getTransactionMode();
                        assertTrue("Has thread session",
                                TransactionSynchronizationManager.hasResource(dsToUse));
                        ContentSourceUtils.releaseSession(s, dsToUse);

                        s = ContentSourceUtils.getSession(dsToUse);
                        assertTrue("Has thread session",
                                TransactionSynchronizationManager.hasResource(dsToUse));
                        ContentSourceUtils.releaseSession(s, dsToUse);
                    }
                });

            }

            if (rollback) {
                status.setRollbackOnly();
            }

            if (accessAfterResume) {
                if (!openOuterConnection) {
                    s = ContentSourceUtils.getSession(dsToUse);
                }
                assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(dsToUse));
                s.getTransactionMode();
                ContentSourceUtils.releaseSession(s, dsToUse);

                s = ContentSourceUtils.getSession(dsToUse);
                assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(dsToUse));
                ContentSourceUtils.releaseSession(s, dsToUse);
            } else {
                if (openOuterConnection) {
                    ContentSourceUtils.releaseSession(s, dsToUse);
                }
            }
        }
    });

    assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(dsToUse));
    assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
    verify(userTransaction, times(6)).begin();
    verify(transactionManager, times(5)).resume(transaction);
    if (rollback) {
        verify(userTransaction, times(5)).commit();
        verify(userTransaction).rollback();
    } else {
        verify(userTransaction, times(6)).commit();
    }
    if (accessAfterResume && !openOuterConnection) {
        verify(session, times(7)).close();
    } else {
        verify(session, times(6)).close();
    }
}

From source file:com._4dconcept.springframework.data.marklogic.datasource.DatabaseConnectorJtaTransactionTest.java

private void doTestJtaTransactionWithPropagationRequiresNewAndBeginException(boolean suspendException,
        final boolean openOuterConnection, final boolean useTransactionAwareContentSource) throws Exception {

    given(userTransaction.getStatus()).willReturn(Status.STATUS_NO_TRANSACTION, Status.STATUS_ACTIVE,
            Status.STATUS_ACTIVE);
    if (suspendException) {
        given(transactionManager.suspend()).willThrow(new SystemException());
    } else {/*  w ww. j  a v  a 2s.  c  om*/
        given(transactionManager.suspend()).willReturn(transaction);
        willThrow(new SystemException()).given(userTransaction).begin();
    }

    given(session.getTransactionMode()).willReturn(Session.TransactionMode.QUERY);

    final ContentSource dsToUse = useTransactionAwareContentSource
            ? new TransactionAwareContentSourceProxy(contentSource)
            : contentSource;
    if (dsToUse instanceof TransactionAwareContentSourceProxy) {
        ((TransactionAwareContentSourceProxy) dsToUse).setReobtainTransactionalSessions(true);
    }

    JtaTransactionManager ptm = new JtaTransactionManager(userTransaction, transactionManager);
    final TransactionTemplate tt = new TransactionTemplate(ptm);
    tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
    assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(dsToUse));
    assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());

    try {
        tt.execute(new TransactionCallbackWithoutResult() {
            @Override
            protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
                assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(dsToUse));
                assertTrue("JTA synchronizations active",
                        TransactionSynchronizationManager.isSynchronizationActive());
                assertTrue("Is new transaction", status.isNewTransaction());

                Session c = ContentSourceUtils.getSession(dsToUse);
                assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(dsToUse));
                c.getTransactionMode();
                ContentSourceUtils.releaseSession(c, dsToUse);

                c = ContentSourceUtils.getSession(dsToUse);
                assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(dsToUse));
                if (!openOuterConnection) {
                    ContentSourceUtils.releaseSession(c, dsToUse);
                }

                try {
                    tt.execute(new TransactionCallbackWithoutResult() {
                        @Override
                        protected void doInTransactionWithoutResult(TransactionStatus status)
                                throws RuntimeException {
                            assertTrue("Hasn't thread session",
                                    !TransactionSynchronizationManager.hasResource(dsToUse));
                            assertTrue("JTA synchronizations active",
                                    TransactionSynchronizationManager.isSynchronizationActive());
                            assertTrue("Is new transaction", status.isNewTransaction());

                            Session c = ContentSourceUtils.getSession(dsToUse);
                            assertTrue("Has thread session",
                                    TransactionSynchronizationManager.hasResource(dsToUse));
                            ContentSourceUtils.releaseSession(c, dsToUse);

                            c = ContentSourceUtils.getSession(dsToUse);
                            assertTrue("Has thread session",
                                    TransactionSynchronizationManager.hasResource(dsToUse));
                            ContentSourceUtils.releaseSession(c, dsToUse);
                        }
                    });
                } finally {
                    if (openOuterConnection) {
                        c.getTransactionMode();
                        ContentSourceUtils.releaseSession(c, dsToUse);

                    }
                }
            }
        });

        fail("Should have thrown TransactionException");
    } catch (TransactionException ex) {
        // expected
    }

    assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(dsToUse));
    assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());

    verify(userTransaction).begin();
    if (suspendException) {
        verify(userTransaction).rollback();
    }

    if (suspendException) {
        verify(session, atLeastOnce()).close();
    } else {
        verify(session, never()).close();
    }
}

From source file:com.wavemaker.runtime.data.spring.SpringDataServiceManager.java

private Object runInTx(Task task, Object... input) {
    HibernateCallback action = new RunInHibernate(task, input);
    TransactionTemplate txTemplate = new TransactionTemplate(this.txMgr);
    boolean rollbackOnly = task instanceof DefaultRollback && !isTxRunning();
    RunInTx tx = new RunInTx(action, rollbackOnly);
    if (txLogger.isInfoEnabled()) {
        if (isTxRunning()) {
            txLogger.info("tx is running executing \"" + task.getName() + "\" in current tx");
        } else {/*from   w  w w. ja v a 2  s  . com*/
            txLogger.info("no tx running, wrapping execution of \"" + task.getName() + "\" in tx");
            if (rollbackOnly) {
                txLogger.info("rollback enabled for \"" + task.getName() + "\"");
            }
        }
    }
    Object rtn = null;
    try {
        rtn = txTemplate.execute(tx);
    } catch (Throwable ex) {
        //The following logic intends to display a sensible message for the user when a column contains a value whose length
        //exceeds the maximum length allowed in the database.  The logic has been tested on MySQL, Postgres, Oracle and
        //SQLServer so far.
        if (ex.getCause() instanceof java.sql.BatchUpdateException) { //Oracle
            String msg = ((java.sql.BatchUpdateException) ex.getCause()).getNextException().getMessage();
            if (msg != null) {
                ex.printStackTrace();
                throw new WMRuntimeException(msg);
            }
        } else if (ex.getCause().getCause() instanceof java.sql.BatchUpdateException) { //Postgres
            java.sql.BatchUpdateException e = (java.sql.BatchUpdateException) ex.getCause().getCause();
            if (e != null && e.getMessage() != null) {
                ex.printStackTrace();
                throw new WMRuntimeException(e.getNextException().getMessage());
            }
        } else if (ex.getCause().getCause() != null) { //MySQL, SQLServer
            String msg = ex.getCause().getCause().getMessage();
            if (msg != null) {
                ex.printStackTrace();
                throw new WMRuntimeException(msg);
            }
        } else {
            throw new WMRuntimeException(ex);
        }
    }
    if (txLogger.isInfoEnabled()) {
        if (isTxRunning()) {
            txLogger.info("tx is running after execution of \"" + task.getName() + "\"");
        } else {
            txLogger.info("tx is not running after execution of \"" + task.getName() + "\"");
        }

    }
    return rtn;
}

From source file:com._4dconcept.springframework.data.marklogic.datasource.DatabaseConnectorJtaTransactionTest.java

@Test
public void testJtaTransactionWithConnectionHolderStillBound() throws Exception {
    @SuppressWarnings("serial")
    JtaTransactionManager ptm = new JtaTransactionManager(userTransaction) {

        @Override// ww w.j av  a 2 s  . com
        protected void doRegisterAfterCompletionWithJtaTransaction(JtaTransactionObject txObject,
                final List<TransactionSynchronization> synchronizations)
                throws RollbackException, SystemException {
            Thread async = new Thread() {
                @Override
                public void run() {
                    invokeAfterCompletion(synchronizations, TransactionSynchronization.STATUS_COMMITTED);
                }
            };
            async.start();
            try {
                async.join();
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    };
    TransactionTemplate tt = new TransactionTemplate(ptm);
    assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(contentSource));
    assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());

    given(userTransaction.getStatus()).willReturn(Status.STATUS_ACTIVE);
    for (int i = 0; i < 3; i++) {
        final boolean releaseCon = (i != 1);

        tt.execute(new TransactionCallbackWithoutResult() {
            @Override
            protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
                assertTrue("JTA synchronizations active",
                        TransactionSynchronizationManager.isSynchronizationActive());
                assertTrue("Is existing transaction", !status.isNewTransaction());

                Session c = ContentSourceUtils.getSession(contentSource);
                assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(contentSource));
                ContentSourceUtils.releaseSession(c, contentSource);

                c = ContentSourceUtils.getSession(contentSource);
                assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(contentSource));
                if (releaseCon) {
                    ContentSourceUtils.releaseSession(c, contentSource);
                }
            }
        });

        if (!releaseCon) {
            assertTrue("Still has session holder",
                    TransactionSynchronizationManager.hasResource(contentSource));
        } else {
            assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(contentSource));
        }
        assertTrue("JTA synchronizations not active",
                !TransactionSynchronizationManager.isSynchronizationActive());
    }
    verify(session, times(3)).close();
}