Example usage for org.springframework.transaction.support TransactionSynchronizationManager setActualTransactionActive

List of usage examples for org.springframework.transaction.support TransactionSynchronizationManager setActualTransactionActive

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.transaction.support.*
  5. TransactionSynchronizationManager
  6. setActualTransactionActive

Introduction

In this page you can find the example usage for org.springframework.transaction.support TransactionSynchronizationManager setActualTransactionActive.

Prototype

public static void setActualTransactionActive(boolean active)

Source Link

Document

Expose whether there currently is an actual transaction active.

Usage

From source file:com.vladmihalcea.concurrent.aop.OptimisticConcurrencyControlAspectTest.java

@Test(expected = IllegalTransactionStateException.class)
public void testRetryFailsOnTransaction() {
    try {//from  w ww.ja v  a  2  s.  c om
        TransactionSynchronizationManager.setActualTransactionActive(true);
        itemService.saveItem();
    } finally {
        TransactionSynchronizationManager.setActualTransactionActive(false);
    }
}

From source file:com.vladmihalcea.concurrent.aop.OptimisticConcurrencyControlAspectTest.java

@Test
public void testRetryRunsOnTransaction() {
    try {/*  w  w  w .  jav a  2  s  . c  om*/
        TransactionSynchronizationManager.setActualTransactionActive(true);
        assertEquals(0, itemService.getRegisteredCalls());
        try {
            itemService.saveItems();
        } catch (OptimisticLockingException expected) {
        }
        assertEquals(3, itemService.getRegisteredCalls());
    } finally {
        TransactionSynchronizationManager.setActualTransactionActive(false);
    }
}

From source file:org.apache.servicemix.transaction.GeronimoPlatformTransactionManager.java

protected void registerTransactionAssociationListener() {
    addTransactionAssociationListener(new TransactionManagerMonitor() {
        public void threadAssociated(Transaction transaction) {
            try {
                if (transaction.getStatus() == Status.STATUS_ACTIVE) {
                    SuspendedResourcesHolder holder = suspendedResources.remove(transaction);
                    if (holder != null && holder.getSuspendedSynchronizations() != null) {
                        TransactionSynchronizationManager.setActualTransactionActive(true);
                        TransactionSynchronizationManager.setCurrentTransactionReadOnly(holder.isReadOnly());
                        TransactionSynchronizationManager.setCurrentTransactionName(holder.getName());
                        TransactionSynchronizationManager.initSynchronization();
                        for (Iterator<?> it = holder.getSuspendedSynchronizations().iterator(); it.hasNext();) {
                            TransactionSynchronization synchronization = (TransactionSynchronization) it.next();
                            synchronization.resume();
                            TransactionSynchronizationManager.registerSynchronization(synchronization);
                        }//  w ww . j a v a  2s  .  c  om
                    }
                }
            } catch (SystemException e) {
                return;
            }
        }

        public void threadUnassociated(Transaction transaction) {
            try {
                if (transaction.getStatus() == Status.STATUS_ACTIVE) {
                    if (TransactionSynchronizationManager.isSynchronizationActive()) {
                        List<?> suspendedSynchronizations = TransactionSynchronizationManager
                                .getSynchronizations();
                        for (Iterator<?> it = suspendedSynchronizations.iterator(); it.hasNext();) {
                            ((TransactionSynchronization) it.next()).suspend();
                        }
                        TransactionSynchronizationManager.clearSynchronization();
                        String name = TransactionSynchronizationManager.getCurrentTransactionName();
                        TransactionSynchronizationManager.setCurrentTransactionName(null);
                        boolean readOnly = TransactionSynchronizationManager.isCurrentTransactionReadOnly();
                        TransactionSynchronizationManager.setCurrentTransactionReadOnly(false);
                        TransactionSynchronizationManager.setActualTransactionActive(false);
                        SuspendedResourcesHolder holder = new SuspendedResourcesHolder(null,
                                suspendedSynchronizations, name, readOnly);
                        suspendedResources.put(transaction, holder);
                    }
                }
            } catch (SystemException e) {
                return;
            }
        }
    });
}

From source file:nl.strohalm.cyclos.struts.CyclosRequestProcessor.java

private void cleanUpTransaction(final HttpServletRequest request) {
    if (noTransaction(request)) {
        return;/*from  w  w  w .j  a va2  s. c  om*/
    }
    logDebug(request, "Cleaning up transaction");

    // Close any open iterators
    DataIteratorHelper.closeOpenIterators();

    // Close the session
    final SessionHolder holder = (SessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
    if (holder != null) {
        try {
            final Session session = holder.getSession();
            if (session.isOpen()) {
                session.close();
            }
        } catch (final Exception e) {
            LOG.error("Error closing Hibernate session", e);
        }
        TransactionSynchronizationManager.unbindResourceIfPossible(sessionFactory);
    }

    // Close the connection
    final Connection connection = (Connection) TransactionSynchronizationManager
            .getResource(connectionProvider);
    if (connection != null) {
        try {
            connectionProvider.closeConnection(connection);
        } catch (final Exception e) {
            LOG.error("Error closing database connection", e);
        }
        TransactionSynchronizationManager.unbindResourceIfPossible(connectionProvider);
    }

    // Cleanup the Spring transaction data
    TransactionSynchronizationManager.setCurrentTransactionReadOnly(false);
    TransactionSynchronizationManager.setActualTransactionActive(false);

    // Cleanup the current transaction data
    CurrentTransactionData.cleanup();

    request.removeAttribute(EXECUTION_RESULT_KEY);
}

From source file:nl.strohalm.cyclos.struts.CyclosRequestProcessor.java

private void openReadWriteConnection(final HttpServletRequest request) throws IOException, ServletException {
    if (noTransaction(request)) {
        return;//from   w ww  .java 2s  .  c o  m
    }
    logDebug(request, "Opening a new read-write transaction");
    // Open a read-write transaction
    Connection connection = null;
    Session session = null;
    SessionHolder holder = null;
    Transaction transaction = null;
    try {
        connection = connectionProvider.getConnection();
        TransactionSynchronizationManager.bindResource(connectionProvider, connection);
        session = sessionFactory.openSession(connection);
        holder = new SessionHolder(session);
        transaction = session.beginTransaction();
        holder.setTransaction(transaction);
        TransactionSynchronizationManager.bindResource(sessionFactory, holder);
        holder.setSynchronizedWithTransaction(true);
        TransactionSynchronizationManager.setActualTransactionActive(true);
        TransactionSynchronizationManager.setCurrentTransactionReadOnly(false);
    } catch (final Exception e) {
        if (connection != null) {
            try {
                connectionProvider.closeConnection(connection);
            } catch (final SQLException e1) {
                LOG.warn("Error closing connection", e1);
            } finally {
                TransactionSynchronizationManager.unbindResourceIfPossible(connectionProvider);
                TransactionSynchronizationManager.unbindResourceIfPossible(sessionFactory);
            }
        }
        LOG.error("Couldn't open a transaction", e);
        ActionHelper.throwException(e);
    }
}

From source file:org.springframework.integration.endpoint.PseudoTransactionalMessageSourceTests.java

@Test
public void testCommit() {
    SourcePollingChannelAdapter adapter = new SourcePollingChannelAdapter();
    ExpressionEvaluatingTransactionSynchronizationProcessor syncProcessor = new ExpressionEvaluatingTransactionSynchronizationProcessor();
    syncProcessor.setBeanFactory(mock(BeanFactory.class));
    PollableChannel queueChannel = new QueueChannel();
    syncProcessor.setBeforeCommitExpression(new SpelExpressionParser().parseExpression("#bix"));
    syncProcessor.setBeforeCommitChannel(queueChannel);
    syncProcessor.setAfterCommitExpression(new SpelExpressionParser().parseExpression("#baz"));

    DefaultTransactionSynchronizationFactory syncFactory = new DefaultTransactionSynchronizationFactory(
            syncProcessor);/*from  ww  w.ja  v  a  2  s. c o  m*/

    adapter.setTransactionSynchronizationFactory(syncFactory);

    QueueChannel outputChannel = new QueueChannel();
    adapter.setOutputChannel(outputChannel);
    adapter.setSource(new MessageSource<String>() {

        @Override
        public Message<String> receive() {
            GenericMessage<String> message = new GenericMessage<String>("foo");
            IntegrationResourceHolder holder = (IntegrationResourceHolder) TransactionSynchronizationManager
                    .getResource(this);
            holder.addAttribute("baz", "qux");
            holder.addAttribute("bix", "qox");
            return message;
        }
    });

    MessageChannel afterCommitChannel = TestUtils.getPropertyValue(syncProcessor, "afterCommitChannel",
            MessageChannel.class);
    assertThat(afterCommitChannel, Matchers.instanceOf(NullChannel.class));

    Log logger = TestUtils.getPropertyValue(afterCommitChannel, "logger", Log.class);

    logger = Mockito.spy(logger);

    Mockito.when(logger.isDebugEnabled()).thenReturn(true);

    DirectFieldAccessor dfa = new DirectFieldAccessor(afterCommitChannel);
    dfa.setPropertyValue("logger", logger);

    TransactionSynchronizationManager.initSynchronization();
    TransactionSynchronizationManager.setActualTransactionActive(true);
    doPoll(adapter);
    TransactionSynchronizationUtils.triggerBeforeCommit(false);
    TransactionSynchronizationUtils.triggerAfterCommit();
    Message<?> beforeCommitMessage = queueChannel.receive(1000);
    assertNotNull(beforeCommitMessage);
    assertEquals("qox", beforeCommitMessage.getPayload());

    Mockito.verify(logger).debug(Mockito.anyString());

    TransactionSynchronizationUtils.triggerAfterCompletion(TransactionSynchronization.STATUS_COMMITTED);
    TransactionSynchronizationManager.clearSynchronization();
    TransactionSynchronizationManager.setActualTransactionActive(false);
}

From source file:org.springframework.integration.endpoint.PseudoTransactionalMessageSourceTests.java

@Test
public void testTransactionSynchronizationFactoryBean() {
    ConfigurableApplicationContext ctx = new AnnotationConfigApplicationContext(TestTxSyncConfiguration.class);

    TransactionSynchronizationFactory syncFactory = ctx.getBean(TransactionSynchronizationFactory.class);

    PollableChannel queueChannel = ctx.getBean("outputChannel", PollableChannel.class);

    SourcePollingChannelAdapter adapter = new SourcePollingChannelAdapter();

    adapter.setTransactionSynchronizationFactory(syncFactory);

    QueueChannel outputChannel = new QueueChannel();
    adapter.setOutputChannel(outputChannel);
    adapter.setSource(new MessageSource<String>() {

        @Override//w  w  w.  j  a va 2s .  c  om
        public Message<String> receive() {
            GenericMessage<String> message = new GenericMessage<String>("foo");
            IntegrationResourceHolder holder = (IntegrationResourceHolder) TransactionSynchronizationManager
                    .getResource(this);
            holder.addAttribute("baz", "qux");
            holder.addAttribute("bix", "qox");
            return message;
        }
    });

    TransactionSynchronizationManager.initSynchronization();
    TransactionSynchronizationManager.setActualTransactionActive(true);
    doPoll(adapter);
    TransactionSynchronizationUtils.triggerBeforeCommit(false);
    TransactionSynchronizationUtils.triggerAfterCommit();
    Message<?> beforeCommitMessage = queueChannel.receive(1000);
    assertNotNull(beforeCommitMessage);
    assertEquals("qox", beforeCommitMessage.getPayload());
    Message<?> afterCommitMessage = queueChannel.receive(1000);
    assertNotNull(afterCommitMessage);
    assertEquals("qux", afterCommitMessage.getPayload());
    TransactionSynchronizationUtils.triggerAfterCompletion(TransactionSynchronization.STATUS_COMMITTED);
    TransactionSynchronizationManager.clearSynchronization();
    TransactionSynchronizationManager.setActualTransactionActive(false);
    ctx.close();
}

From source file:org.springframework.integration.endpoint.PseudoTransactionalMessageSourceTests.java

@Test
public void testRollback() {
    SourcePollingChannelAdapter adapter = new SourcePollingChannelAdapter();
    ExpressionEvaluatingTransactionSynchronizationProcessor syncProcessor = new ExpressionEvaluatingTransactionSynchronizationProcessor();
    syncProcessor.setBeanFactory(mock(BeanFactory.class));
    PollableChannel queueChannel = new QueueChannel();
    syncProcessor.setAfterRollbackChannel(queueChannel);
    syncProcessor.setAfterRollbackExpression(new SpelExpressionParser().parseExpression("#baz"));

    DefaultTransactionSynchronizationFactory syncFactory = new DefaultTransactionSynchronizationFactory(
            syncProcessor);/* ww w .j a va  2  s .  c om*/

    adapter.setTransactionSynchronizationFactory(syncFactory);

    QueueChannel outputChannel = new QueueChannel();
    adapter.setOutputChannel(outputChannel);
    adapter.setSource(new MessageSource<String>() {

        @Override
        public Message<String> receive() {
            GenericMessage<String> message = new GenericMessage<String>("foo");
            ((IntegrationResourceHolder) TransactionSynchronizationManager.getResource(this))
                    .addAttribute("baz", "qux");
            return message;
        }
    });

    TransactionSynchronizationManager.initSynchronization();
    TransactionSynchronizationManager.setActualTransactionActive(true);
    doPoll(adapter);
    TransactionSynchronizationUtils.triggerAfterCompletion(TransactionSynchronization.STATUS_ROLLED_BACK);
    Message<?> rollbackMessage = queueChannel.receive(1000);
    assertNotNull(rollbackMessage);
    assertEquals("qux", rollbackMessage.getPayload());
    TransactionSynchronizationManager.clearSynchronization();
    TransactionSynchronizationManager.setActualTransactionActive(false);
}

From source file:org.springframework.integration.endpoint.PseudoTransactionalMessageSourceTests.java

@Test
public void testInt2777UnboundResourceAfterTransactionComplete() {
    SourcePollingChannelAdapter adapter = new SourcePollingChannelAdapter();

    adapter.setSource(() -> null);/*from   ww w.  j  a v a 2 s .  com*/

    TransactionSynchronizationManager.setActualTransactionActive(true);
    doPoll(adapter);
    TransactionSynchronizationManager.setActualTransactionActive(false);

    // Before INT-2777 this test was failed here
    TransactionSynchronizationManager.setActualTransactionActive(true);
    doPoll(adapter);
    TransactionSynchronizationManager.setActualTransactionActive(false);
}

From source file:org.springframework.integration.endpoint.PseudoTransactionalMessageSourceTests.java

@Test
public void testInt2777CustomTransactionSynchronizationFactoryWithoutDealWithIntegrationResourceHolder() {
    SourcePollingChannelAdapter adapter = new SourcePollingChannelAdapter();

    final AtomicInteger txSyncCounter = new AtomicInteger();

    TransactionSynchronizationFactory syncFactory = new TransactionSynchronizationFactory() {

        @Override//from   w ww  .  j  av a 2  s  .  co m
        public TransactionSynchronization create(Object key) {
            return new TransactionSynchronizationAdapter() {
                @Override
                public void afterCompletion(int status) {
                    txSyncCounter.incrementAndGet();
                }
            };
        }
    };

    adapter.setTransactionSynchronizationFactory(syncFactory);
    adapter.setSource(() -> null);

    TransactionSynchronizationManager.initSynchronization();
    TransactionSynchronizationManager.setActualTransactionActive(true);
    doPoll(adapter);
    TransactionSynchronizationUtils.triggerAfterCompletion(TransactionSynchronization.STATUS_COMMITTED);
    TransactionSynchronizationManager.clearSynchronization();
    TransactionSynchronizationManager.setActualTransactionActive(false);
    assertEquals(1, txSyncCounter.get());

    TransactionSynchronizationManager.initSynchronization();
    TransactionSynchronizationManager.setActualTransactionActive(true);
    doPoll(adapter);
    TransactionSynchronizationUtils.triggerAfterCompletion(TransactionSynchronization.STATUS_COMMITTED);
    TransactionSynchronizationManager.clearSynchronization();
    TransactionSynchronizationManager.setActualTransactionActive(false);
    assertEquals(2, txSyncCounter.get());
}