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

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

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

Introduction

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

Prototype

public static boolean hasResource(Object key)

Source Link

Document

Check if there is a resource for the given key bound to the current thread.

Usage

From source file:org.springextensions.neodatis.NeoDatisTransactionManager.java

@Override
protected void doResume(Object transaction, Object suspendedResources) throws TransactionException {
    SuspendedResourcesHolder suspendedResourcesHolder = (SuspendedResourcesHolder) suspendedResources;
    if (TransactionSynchronizationManager.hasResource(getOdb())) {
        TransactionSynchronizationManager.unbindResource(getOdb());
    }/*from   ww w .  j  a  va  2s .c o  m*/
    TransactionSynchronizationManager.bindResource(getOdb(), suspendedResourcesHolder.getOdbHolder());
}

From source file:org.grails.datastore.mapping.core.AbstractDatastore.java

public boolean hasCurrentSession() {
    return TransactionSynchronizationManager.hasResource(this);
}

From source file:org.springextensions.neodatis.NeoDatisTransactionManagerTest.java

@Test
public void testTransactionRollbackOnly() {
    final ODB odb = Mockito.mock(ODB.class);
    Mockito.when(odb.store(Mockito.isNull())).thenThrow(new RuntimeException());
    PlatformTransactionManager tm = new NeoDatisTransactionManager(odb);
    TransactionTemplate tmpl = new TransactionTemplate(tm);

    Assert.assertFalse("Should not have a resource", TransactionSynchronizationManager.hasResource(odb));
    Assert.assertFalse("There should no active synchronizations",
            TransactionSynchronizationManager.isSynchronizationActive());

    try {/*ww  w  .  j a v a2s  .  co m*/
        tmpl.execute(new TransactionCallbackWithoutResult() {
            @Override
            protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {
                Assert.assertTrue(TransactionSynchronizationManager.hasResource(odb));
                NeoDatisTemplate neoDatisTemplate = new NeoDatisTemplate(odb);
                neoDatisTemplate.store(null);
                transactionStatus.setRollbackOnly();
            }
        });
    } catch (RuntimeException e) {
        // is ok
    }

    Assert.assertFalse("Should not have a resource", TransactionSynchronizationManager.hasResource(odb));
    Assert.assertFalse("There should no active synchronizations",
            TransactionSynchronizationManager.isSynchronizationActive());

    Mockito.verify(odb, Mockito.times(1)).rollback();
}

From source file:org.drools.container.spring.beans.persistence.DroolsSpringJpaManager.java

public void endCommandScopedEntityManager() {
    if (TransactionSynchronizationManager.hasResource("cmdEM")) {
        TransactionSynchronizationManager.unbindResource("cmdEM");
        if (this.env.get(EnvironmentName.CMD_SCOPED_ENTITY_MANAGER) != null) {
            getCommandScopedPersistenceContext().close();
        }// ww w  . ja v a 2 s . c  o m

    }
}

From source file:org.springextensions.db4o.Db4oTransactionManagerTest.java

@Test
public void testTransactionRollbackOnly() throws Exception {
    final ExtObjectContainer container = mock(ExtObjectContainer.class);
    when(container.identity()).thenReturn(null);
    when(container.ext()).thenReturn(container);

    PlatformTransactionManager tm = new Db4oTransactionManager(container);
    TransactionTemplate tt = new TransactionTemplate(tm);

    Assert.assertTrue(!TransactionSynchronizationManager.hasResource(container), "Has no container");
    Assert.assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());

    try {/*from  ww  w.ja v  a2 s  . com*/
        tt.execute(new TransactionCallbackWithoutResult() {
            protected void doInTransactionWithoutResult(TransactionStatus status) {
                Assert.assertTrue(TransactionSynchronizationManager.hasResource(container),
                        "Has thread session");
                Db4oTemplate template = new Db4oTemplate(container);
                template.execute(new Db4oCallback() {
                    public Object doInDb4o(ObjectContainer cont) {
                        cont.ext().identity();
                        return null;
                    }

                });
                status.setRollbackOnly();
            }
        });
    } catch (RuntimeException e) {
        // it's okay
    }

    Assert.assertTrue(!TransactionSynchronizationManager.hasResource(container), "Has no container");
    Assert.assertTrue(!TransactionSynchronizationManager.isSynchronizationActive(),
            "JTA synchronizations not active");

    verify(container).rollback();
}

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 {//from w  w  w .  j a  v  a2 s  . c  o  m
        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:eu.supersede.fe.multitenant.MultiJpaProvider.java

public <T extends JpaRepository<?, ?>> T getRepository(Class<T> jpaRepositoryClass, String tenant) {
    T repo = null;// w ww.  j  a v a 2s .co  m

    if (repositoriesFactory.containsKey(tenant)) {
        ContainerUtil factory = repositoriesFactory.get(tenant);
        repo = factory.jpaRepositoryFactory.getRepository(jpaRepositoryClass);

        if (!TransactionSynchronizationManager.hasResource(factory.entityManagerFactory)) {
            EntityManagerHolder emh = new EntityManagerHolder(factory.entityManager);
            TransactionSynchronizationManager.bindResource(factory.entityManagerFactory, emh);
        }
    }

    return repo;
}

From source file:de.codecentric.batch.metrics.BatchMetricsImpl.java

@Override
public void afterCompletion(int status) {
    if (LOG.isDebugEnabled()) {
        LOG.debug("Entered afterCompletion with status " + status + ".");
    }//w  w  w .j a v  a2s  .c  om
    if (status == STATUS_COMMITTED) {
        MetricContainer currentMetricContainer = metricContainer.get();
        for (Pair<String, ? extends Number> metric : currentMetricContainer.metrics) {
            if (metric.getRight() instanceof Long) {
                if (LOG.isDebugEnabled()) {
                    LOG.debug("Increment " + metric + ".");
                }
                incrementNonTransactional(metric.getLeft(), (Long) metric.getRight());
            } else if (metric.getRight() instanceof Double) {
                if (LOG.isDebugEnabled()) {
                    LOG.debug("Gauge " + metric + ".");
                }
                set(metric.getLeft(), (Double) metric.getRight());
            } else if (metric.getRight() == null) {
                if (LOG.isDebugEnabled()) {
                    LOG.debug("Reset " + metric + ".");
                }
                remove(metric.getLeft());
            }
        }
    }
    metricContainer.remove();
    if (TransactionSynchronizationManager.hasResource(serviceKey)) {
        TransactionSynchronizationManager.unbindResource(serviceKey);
    }
}

From source file:org.jtalks.poulpe.web.osod.OpenSessions.java

/** Checks in current thread binded hibernate session */
@VisibleForTesting
boolean noSessionBoundToThread() {
    return !TransactionSynchronizationManager.hasResource(sessionFactory);
}

From source file:org.springextensions.neodatis.NeoDatisTransactionManagerTest.java

@Test
public void testWrongIsolationLevel() {
    final ODB odb = Mockito.mock(ODB.class);
    Mockito.when(odb.store(Mockito.isNull())).thenThrow(new RuntimeException());
    PlatformTransactionManager tm = new NeoDatisTransactionManager(odb);
    TransactionTemplate tmpl = new TransactionTemplate(tm);

    Assert.assertFalse("Should not have a resource", TransactionSynchronizationManager.hasResource(odb));
    Assert.assertFalse("There should no active synchronizations",
            TransactionSynchronizationManager.isSynchronizationActive());

    tmpl.setIsolationLevel(TransactionDefinition.ISOLATION_SERIALIZABLE);
    try {/*  w ww .  ja  va2s .  c o m*/
        tmpl.execute(new TransactionCallbackWithoutResult() {
            @Override
            protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {
                Assert.assertTrue(TransactionSynchronizationManager.hasResource(odb));
                NeoDatisTemplate neoDatisTemplate = new NeoDatisTemplate(odb);
                neoDatisTemplate.store(null);
                transactionStatus.setRollbackOnly();
            }
        });
        Assert.fail("Should throw an exception.");
    } catch (InvalidIsolationLevelException e) {
        // is ok
    }

    Assert.assertFalse("Should not have a resource", TransactionSynchronizationManager.hasResource(odb));
    Assert.assertFalse("There should no active synchronizations",
            TransactionSynchronizationManager.isSynchronizationActive());

}