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

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

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

Introduction

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

Prototype

public static void initSynchronization() throws IllegalStateException

Source Link

Document

Activate transaction synchronization for the current thread.

Usage

From source file:bigbank.transaction.DefaultSynchronizationManager.java

@Override
public void initSynchronization() {
    TransactionSynchronizationManager.initSynchronization();
}

From source file:com.becool.base.spring.tx.SpringTransactionSynchronizationManager.java

public void initSynchronization() {
    TransactionSynchronizationManager.initSynchronization();
}

From source file:org.parancoe.web.ParancoeOpenSessionInViewInterceptor.java

@Override
public boolean preHandle(HttpServletRequest req, HttpServletResponse res, Object handler) throws Exception {
    logger.debug("Opening session and beginning transaction");
    Session session = sessionFactory.openSession();
    session.beginTransaction();//www .jav a 2s.  c om
    if (!TransactionSynchronizationManager.hasResource(sessionFactory)) {
        TransactionSynchronizationManager.bindResource(sessionFactory, new SessionHolder(session));
        TransactionSynchronizationManager.initSynchronization();
    }
    return true;
}

From source file:org.parancoe.web.PopulateInitialDataContextListener.java

@Override
public void contextInitialized(ServletContextEvent evt) {
    ctx = (ApplicationContext) evt.getServletContext()
            .getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);
    Set<Class> fixtureClasses = new LinkedHashSet<Class>(getFixtureClasses());
    if (fixtureClasses.isEmpty()) {
        log.info("Skipping initial data population (no models)");
        return;// w ww  .j av a 2  s.c om
    }

    Map<Class, List> fixtures = YamlFixtureHelper.loadFixturesFromResource("initialData/", fixtureClasses);
    log.info("Populating initial data for models...");

    SessionFactory sessionFactory = (SessionFactory) ctx.getBean("sessionFactory");
    Session session = sessionFactory.openSession();
    session.beginTransaction();
    //Attach transaction to thread
    TransactionSynchronizationManager.bindResource(sessionFactory, new SessionHolder(session));
    TransactionSynchronizationManager.initSynchronization();

    try {
        for (Class clazz : fixtures.keySet()) {
            List modelFixtures = fixtures.get(clazz);
            if (modelFixtures.isEmpty()) {
                log.warn("No data for {}, did you created the fixture file?",
                        YamlFixtureHelper.getModelName(clazz));
                continue;
            }
            populateTableForModel(clazz, modelFixtures);
        }
        fixtures.clear();
        log.info("Populating initial data for models done!");
        session.getTransaction().commit();
        if (session.isOpen()) {
            session.close();
        }
    } catch (Exception e) {
        log.error("Error while populating initial data for models {}", e.getMessage(), e);
        log.debug("Rolling back the populating database transaction");
        session.getTransaction().rollback();
    } finally {
        try {
            if (session.isOpen()) {
                session.close();
            }
        } catch (Exception e) {
            /*do nothing*/
        }
        TransactionSynchronizationManager.unbindResource(sessionFactory);
        TransactionSynchronizationManager.clearSynchronization();
    }
}

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);
                        }/*from   w w  w .  ja  va2 s. c o m*/
                    }
                }
            } 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:com.wavemaker.runtime.data.spring.SpringDataServiceManager.java

@Override
public void commit() {

    if (txLogger.isInfoEnabled()) {
        txLogger.info("commit");
    }/*www . j ava 2  s .com*/

    ThreadContext.Context ctx = ThreadContext.getContext(this.metaData.getName());

    if (ctx == null) {
        if (txLogger.isWarnEnabled()) {
            txLogger.warn("ignoring commit - no tx in progress");
            if (txLogger.isDebugEnabled()) {
                logStackTrace();
            }
        }
        return;
    }

    TransactionStatus txStatus = ctx.getTransactionStatus();

    try {
        if (txStatus == null) {
            if (txLogger.isWarnEnabled()) {
                txLogger.warn("ignoring commit - no tx status");
                if (txLogger.isDebugEnabled()) {
                    logStackTrace();
                }
            }
        } else {
            this.txMgr.commit(txStatus);
        }
    } finally {
        ctx.setTransactionStatus(null);
        ThreadContext.unsetContext(this.metaData.getName());
        HashMap<String, ThreadContext.Context> contextHash = ThreadContext.getThreadLocalHash();

        if (contextHash != null && contextHash.size() > 0) {
            if (!TransactionSynchronizationManager.isSynchronizationActive()) {
                TransactionSynchronizationManager.initSynchronization();
            }
        } else {
            if (TransactionSynchronizationManager.isSynchronizationActive()) {
                TransactionSynchronizationManager.clear();
                Map map = TransactionSynchronizationManager.getResourceMap();
                for (Object entry : map.keySet()) {
                    TransactionSynchronizationManager.unbindResource(entry);
                }
            }
        }
    }
}

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);//w  w w  .j a  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//from  w w  w .  ja  v  a 2s  . co  m
        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 v a2 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) 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);
}