Example usage for org.springframework.transaction.jta JtaTransactionManager JtaTransactionManager

List of usage examples for org.springframework.transaction.jta JtaTransactionManager JtaTransactionManager

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.transaction.jta.*
  5. JtaTransactionManager
  6. JtaTransactionManager

Introduction

In this page you can find the example usage for org.springframework.transaction.jta JtaTransactionManager JtaTransactionManager.

Prototype

public JtaTransactionManager(TransactionManager transactionManager)

Source Link

Document

Create a new JtaTransactionManager instance.

Usage

From source file:com.example.switchyard.idempotent.jpa.IdempotentJpaConsumer.java

private static TransactionTemplate transactionTemplate() {
    TransactionTemplate transactionTemplate = new TransactionTemplate();
    transactionTemplate.setTransactionManager(new JtaTransactionManager(getTransactionManager()));

    transactionTemplate.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);

    return transactionTemplate;
}

From source file:org.wildfly.swarm.examples.camel.jpa.JpaRouteBuilder.java

@Override
public void configure() throws Exception {

    // Configure our JaxbDataFormat to point at our 'model' package
    JaxbDataFormat jaxbDataFormat = new JaxbDataFormat();
    jaxbDataFormat.setContextPath(Customer.class.getPackage().getName());

    EntityManagerFactory entityManagerFactory = em.getEntityManagerFactory();

    // Configure a JtaTransactionManager by looking up the JBoss transaction manager from JNDI
    JtaTransactionManager transactionManager = new JtaTransactionManager(userTransaction);
    transactionManager.afterPropertiesSet();

    // Configure the JPA endpoint to use the correct EntityManagerFactory and JtaTransactionManager
    JpaEndpoint jpaEndpoint = new JpaEndpoint();
    jpaEndpoint.setCamelContext(getContext());
    jpaEndpoint.setEntityType(Customer.class);
    jpaEndpoint.setEntityManagerFactory(entityManagerFactory);
    jpaEndpoint.setTransactionManager(transactionManager);

    /*/*  ww  w  .  j  ava2  s. c om*/
     *  Simple route to consume customer record files from directory input/customers,
     *  unmarshall XML file content to a Customer entity and then use the JPA endpoint
     *  to persist the it to the 'ExampleDS' datasource (see standalone.camel.xml for datasource config).
     */
    from("file://{{jboss.server.data.dir}}/customers").unmarshal(jaxbDataFormat).to(jpaEndpoint)
            .to("log:input?showAll=true");
}

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

private void doTestJtaTransaction(final boolean rollback) throws Exception {
    if (rollback) {
        given(userTransaction.getStatus()).willReturn(Status.STATUS_NO_TRANSACTION, Status.STATUS_ACTIVE);
    } else {// ww  w  .  ja  v a2s  . com
        given(userTransaction.getStatus()).willReturn(Status.STATUS_NO_TRANSACTION, Status.STATUS_ACTIVE,
                Status.STATUS_ACTIVE);
    }

    JtaTransactionManager ptm = new JtaTransactionManager(userTransaction);
    TransactionTemplate tt = new TransactionTemplate(ptm);
    assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(contentSource));
    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(contentSource));
            assertTrue("JTA synchronizations active",
                    TransactionSynchronizationManager.isSynchronizationActive());
            assertTrue("Is new 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));
            ContentSourceUtils.releaseSession(c, contentSource);

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

    assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(contentSource));
    assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
    verify(userTransaction).begin();
    if (rollback) {
        verify(userTransaction).rollback();
    }
    verify(session).close();
}

From source file:org.mybatis.spring.MyBatisSpringTest.java

@Test
public void testWithJtaTxManager() {
    JtaTransactionManager jtaManager = new JtaTransactionManager(new MockUserTransaction());

    DefaultTransactionDefinition txDef = new DefaultTransactionDefinition();
    txDef.setPropagationBehaviorName("PROPAGATION_REQUIRED");

    TransactionStatus status = jtaManager.getTransaction(txDef);

    session = SqlSessionUtils.getSqlSession(sqlSessionFactory);
    session.getMapper(TestMapper.class).findTest();
    SqlSessionUtils.closeSqlSession(session, sqlSessionFactory);

    jtaManager.commit(status);/*from www.  java  2  s .c  om*/

    // assume a real JTA tx would enlist and commit the JDBC connection
    assertNoCommitJdbc();
    assertCommitSession();
    assertSingleConnection();
}

From source file:org.mybatis.spring.MyBatisSpringTest.java

@Test
public void testWithJtaTxManagerAndNonSpringTxManager() throws java.sql.SQLException {
    Environment original = sqlSessionFactory.getConfiguration().getEnvironment();

    MockDataSource mockDataSource = new MockDataSource();
    mockDataSource.setupConnection(createMockConnection());

    Environment nonSpring = new Environment("non-spring", new ManagedTransactionFactory(), mockDataSource);
    sqlSessionFactory.getConfiguration().setEnvironment(nonSpring);

    JtaTransactionManager jtaManager = new JtaTransactionManager(new MockUserTransaction());

    DefaultTransactionDefinition txDef = new DefaultTransactionDefinition();
    txDef.setPropagationBehaviorName("PROPAGATION_REQUIRED");

    TransactionStatus status = jtaManager.getTransaction(txDef);

    try {//w  ww  . j a  v  a 2  s.  c  om
        session = SqlSessionUtils.getSqlSession(sqlSessionFactory);
        session.getMapper(TestMapper.class).findTest();
        // Spring is not managing SqlSession, so commit is needed
        session.commit(true);
        SqlSessionUtils.closeSqlSession(session, sqlSessionFactory);

        jtaManager.commit(status);

        // assume a real JTA tx would enlist and commit the JDBC connection
        assertNoCommitJdbc();
        assertCommitSession();

        MockConnection mockConnection = (MockConnection) mockDataSource.getConnection();
        assertEquals("should call commit on Connection", 0, mockConnection.getNumberCommits());
        assertEquals("should not call rollback on Connection", 0, mockConnection.getNumberRollbacks());

        assertEquals("should not call DataSource.getConnection()", 0, dataSource.getConnectionCount());

    } finally {
        SqlSessionUtils.closeSqlSession(session, sqlSessionFactory);

        sqlSessionFactory.getConfiguration().setEnvironment(original);

        // null the connection since it was not used
        // this avoids failing in validateConnectionClosed()
        connection = null;
    }
}

From source file:org.apache.servicemix.jms.endpoints.JmsConsumerEndpoint.java

private AbstractMessageListenerContainer createDefaultMessageListenerContainer() {
    final DefaultMessageListenerContainer cont;
    if (isJms102()) {
        cont = new DefaultMessageListenerContainer102();
    } else {/*from w  w  w .ja va 2s . c  o  m*/
        cont = new DefaultMessageListenerContainer();
    }
    cont.setCacheLevel(cacheLevel);
    cont.setConcurrentConsumers(concurrentConsumers);
    cont.setMaxMessagesPerTask(maxMessagesPerTask);
    cont.setPubSubNoLocal(pubSubNoLocal);
    cont.setReceiveTimeout(receiveTimeout);
    cont.setRecoveryInterval(recoveryInterval);
    if (TRANSACTED_XA.equals(transacted)) {
        cont.setSessionTransacted(true);
        TransactionManager tm = (TransactionManager) getContext().getTransactionManager();
        if (tm == null) {
            throw new IllegalStateException("No TransactionManager available");
        } else if (tm instanceof PlatformTransactionManager) {
            cont.setTransactionManager((PlatformTransactionManager) tm);
        } else {
            cont.setTransactionManager(new JtaTransactionManager(tm));
        }
    } else if (TRANSACTED_JMS.equals(transacted)) {
        cont.setSessionTransacted(true);
        if (isJms102()) {
            cont.setTransactionManager(new JmsTransactionManager102(getConnectionFactory(), isPubSubDomain()));
        } else {
            cont.setTransactionManager(new JmsTransactionManager(getConnectionFactory()));
        }
    }
    return cont;
}

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/*from w  w  w .j a v a2 s  . c  o m*/
        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();
}

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

@Test
public void testJtaTransactionWithIsolationLevelContentSourceAdapter() throws Exception {
    given(userTransaction.getStatus()).willReturn(Status.STATUS_NO_TRANSACTION, Status.STATUS_ACTIVE,
            Status.STATUS_ACTIVE, Status.STATUS_NO_TRANSACTION, Status.STATUS_ACTIVE, Status.STATUS_ACTIVE);

    final IsolationLevelContentSourceAdapter dsToUse = new IsolationLevelContentSourceAdapter();
    dsToUse.setTargetContentSource(contentSource);
    dsToUse.afterPropertiesSet();/*from w w  w  .  java  2s.c o  m*/

    JtaTransactionManager ptm = new JtaTransactionManager(userTransaction);
    ptm.setAllowCustomIsolationLevels(true);

    TransactionTemplate tt = new TransactionTemplate(ptm);
    tt.execute(new TransactionCallbackWithoutResult() {
        @Override
        protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
            Session c = ContentSourceUtils.getSession(dsToUse);
            assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(dsToUse));
            assertSame(session, c);
            ContentSourceUtils.releaseSession(c, dsToUse);
        }
    });

    tt.setIsolationLevel(TransactionDefinition.ISOLATION_REPEATABLE_READ);
    tt.setReadOnly(true);
    tt.execute(new TransactionCallbackWithoutResult() {
        @Override
        protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
            Session c = ContentSourceUtils.getSession(dsToUse);
            assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(dsToUse));
            assertSame(session, c);
            ContentSourceUtils.releaseSession(c, dsToUse);
        }
    });

    verify(userTransaction, times(2)).begin();
    verify(userTransaction, times(2)).commit();
    verify(session).setTransactionMode(Session.TransactionMode.QUERY);
    verify(session, times(2)).close();
}

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

private void doTestJtaTransactionWithIsolationLevelContentSourceRouter() throws Exception {
    given(userTransaction.getStatus()).willReturn(Status.STATUS_NO_TRANSACTION, Status.STATUS_ACTIVE,
            Status.STATUS_ACTIVE, Status.STATUS_NO_TRANSACTION, Status.STATUS_ACTIVE, Status.STATUS_ACTIVE);

    final ContentSource contentSource1 = mock(ContentSource.class);
    final Session session1 = mock(Session.class);
    given(contentSource1.newSession()).willReturn(session1);

    final ContentSource contentSource2 = mock(ContentSource.class);
    final Session session2 = mock(Session.class);
    given(contentSource2.newSession()).willReturn(session2);

    final IsolationLevelContentSourceRouter dsToUse = new IsolationLevelContentSourceRouter();
    Map<Object, Object> targetContentSources = new HashMap<Object, Object>();

    targetContentSources.put("ISOLATION_REPEATABLE_READ", contentSource2);
    dsToUse.setDefaultTargetContentSource(contentSource1);

    dsToUse.setTargetContentSources(targetContentSources);
    dsToUse.afterPropertiesSet();// w  ww .  jav  a2  s  .  c o  m

    JtaTransactionManager ptm = new JtaTransactionManager(userTransaction);
    ptm.setAllowCustomIsolationLevels(true);

    TransactionTemplate tt = new TransactionTemplate(ptm);
    tt.execute(new TransactionCallbackWithoutResult() {
        @Override
        protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
            Session c = ContentSourceUtils.getSession(dsToUse);
            assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(dsToUse));
            assertSame(session1, c);
            ContentSourceUtils.releaseSession(c, dsToUse);
        }
    });

    tt.setIsolationLevel(TransactionDefinition.ISOLATION_REPEATABLE_READ);
    tt.execute(new TransactionCallbackWithoutResult() {
        @Override
        protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
            Session c = ContentSourceUtils.getSession(dsToUse);
            assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(dsToUse));
            assertSame(session2, c);
            ContentSourceUtils.releaseSession(c, dsToUse);
        }
    });

    verify(userTransaction, times(2)).begin();
    verify(userTransaction, times(2)).commit();
    verify(session1).close();
    verify(session2).close();
}