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:org.cfr.capsicum.server.ServerRuntimeFactoryBean.java

/**
 * {@inheritDoc}/*from   w w  w .  jav a 2  s .c  om*/
 */
@Override
public <T> T performInTransaction(final TransactionalOperation<T> op) {
    TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);
    return transactionTemplate.execute(new TransactionCallback<T>() {

        @Override
        public T doInTransaction(TransactionStatus status) {
            return op.perform();
        }
    });
}

From source file:ca.uhn.fhir.jpa.dao.BaseHapiFhirSystemDao.java

private void markResourceAsIndexingFailed(final long theId) {
    TransactionTemplate txTemplate = new TransactionTemplate(myTxManager);
    txTemplate.setPropagationBehavior(TransactionTemplate.PROPAGATION_REQUIRES_NEW);
    txTemplate.execute(new TransactionCallback<Void>() {
        @Override/*from w  ww .j a v  a2  s  .  c o m*/
        public Void doInTransaction(TransactionStatus theStatus) {
            ourLog.info("Marking resource with PID {} as indexing_failed", new Object[] { theId });
            Query q = myEntityManager
                    .createQuery("UPDATE ResourceTable t SET t.myIndexStatus = :status WHERE t.myId = :id");
            q.setParameter("status", INDEX_STATUS_INDEXING_FAILED);
            q.setParameter("id", theId);
            q.executeUpdate();

            q = myEntityManager.createQuery("DELETE FROM ResourceTag t WHERE t.myResourceId = :id");
            q.setParameter("id", theId);
            q.executeUpdate();

            q = myEntityManager
                    .createQuery("DELETE FROM ResourceIndexedSearchParamCoords t WHERE t.myResourcePid = :id");
            q.setParameter("id", theId);
            q.executeUpdate();

            q = myEntityManager
                    .createQuery("DELETE FROM ResourceIndexedSearchParamDate t WHERE t.myResourcePid = :id");
            q.setParameter("id", theId);
            q.executeUpdate();

            q = myEntityManager
                    .createQuery("DELETE FROM ResourceIndexedSearchParamNumber t WHERE t.myResourcePid = :id");
            q.setParameter("id", theId);
            q.executeUpdate();

            q = myEntityManager.createQuery(
                    "DELETE FROM ResourceIndexedSearchParamQuantity t WHERE t.myResourcePid = :id");
            q.setParameter("id", theId);
            q.executeUpdate();

            q = myEntityManager
                    .createQuery("DELETE FROM ResourceIndexedSearchParamString t WHERE t.myResourcePid = :id");
            q.setParameter("id", theId);
            q.executeUpdate();

            q = myEntityManager
                    .createQuery("DELETE FROM ResourceIndexedSearchParamToken t WHERE t.myResourcePid = :id");
            q.setParameter("id", theId);
            q.executeUpdate();

            q = myEntityManager
                    .createQuery("DELETE FROM ResourceIndexedSearchParamUri t WHERE t.myResourcePid = :id");
            q.setParameter("id", theId);
            q.executeUpdate();

            q = myEntityManager.createQuery("DELETE FROM ResourceLink t WHERE t.mySourceResourcePid = :id");
            q.setParameter("id", theId);
            q.executeUpdate();

            q = myEntityManager.createQuery("DELETE FROM ResourceLink t WHERE t.myTargetResourcePid = :id");
            q.setParameter("id", theId);
            q.executeUpdate();

            return null;
        }
    });
}

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

@Test
public void testTransactionRollback() 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(),
            "JTA synchronizations not active");

    try {/*from w w  w . j  av a2 s .  c  o m*/
        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();
                        throw new RuntimeException();
                    }

                });
            }
        });
    } 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:org.springextensions.neodatis.NeoDatisTransactionManagerTest.java

@Test
public void testTransactionRollback() {
    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 {/* w  ww.  j  a v  a  2  s.  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);
            }
        });
    } 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.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 {//from ww  w.  j  a  v  a  2  s  .  com
        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:ca.uhn.fhir.jpa.dao.dstu3.FhirResourceDaoSubscriptionDstu3.java

@Scheduled(fixedDelay = DateUtils.MILLIS_PER_MINUTE)
@Transactional(propagation = Propagation.NOT_SUPPORTED)
@Override// w  ww .  ja  va2 s  .  c om
public void purgeInactiveSubscriptions() {
    if (getConfig().isSchedulingDisabled()) {
        return;
    }

    Long purgeInactiveAfterMillis = getConfig().getSubscriptionPurgeInactiveAfterMillis();
    if (getConfig().isSubscriptionEnabled() == false || purgeInactiveAfterMillis == null) {
        return;
    }

    Date cutoff = new Date(System.currentTimeMillis() - purgeInactiveAfterMillis);
    Collection<SubscriptionTable> toPurge = mySubscriptionTableDao.findInactiveBeforeCutoff(cutoff);
    for (SubscriptionTable subscriptionTable : toPurge) {

        final IdDt subscriptionId = subscriptionTable.getSubscriptionResource().getIdDt();
        ourLog.info("Deleting inactive subscription {} - Created {}, last client poll {}",
                new Object[] { subscriptionId.toUnqualified(), subscriptionTable.getCreated(),
                        subscriptionTable.getLastClientPoll() });
        TransactionTemplate txTemplate = new TransactionTemplate(myTxManager);
        txTemplate.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
        txTemplate.execute(new TransactionCallback<Void>() {
            @Override
            public Void doInTransaction(TransactionStatus theStatus) {
                delete(subscriptionId, null);
                return null;
            }
        });
    }
}

From source file:com.hypersocket.netty.Main.java

protected void createApplicationContext() {

    if (log.isInfoEnabled()) {
        log.info("Creating spring application context");
    }//from  www  .  ja v a2  s .  c om

    applicationContext = new ClassPathXmlApplicationContext("classpath*:/applicationContext.xml");

    if (log.isInfoEnabled()) {
        log.info("Obtaining platform transaction manager");
    }

    PlatformTransactionManager transactionManager = (PlatformTransactionManager) applicationContext
            .getBean("transactionManager");

    if (log.isInfoEnabled()) {
        log.info("Creating transaction template");
    }

    TransactionTemplate txnTemplate = new TransactionTemplate(transactionManager);

    if (log.isInfoEnabled()) {
        log.info("Calling TransactionTemplate.afterPropertiesSet");
    }

    txnTemplate.afterPropertiesSet();

    if (log.isInfoEnabled()) {
        log.info("Creating transaction for upgrade");
    }

    txnTemplate.execute(new TransactionCallback<Object>() {
        public Object doInTransaction(TransactionStatus status) {
            UpgradeService upgradeService = (UpgradeService) applicationContext.getBean("upgradeService");
            try {
                if (log.isInfoEnabled()) {
                    log.info("Starting upgrade");
                }
                upgradeService.upgrade();

                if (log.isInfoEnabled()) {
                    log.info("Completed upgrade");
                }
            } catch (Throwable e) {
                log.error("Failed to upgrade", e);
                throw new IllegalStateException("Errors upgrading database");
            }
            return null;
        }
    });

}

From source file:com.hybris.datahub.outbound.adapter.TmallAdapter.java

private List<ErrorData> processItems(final TargetSystemPublication targetSystemPublication,
        final TargetItemMetadata targetItemMetadata) {
    final List<ErrorData> errors = Lists.newArrayList();
    final TransactionTemplate template = new TransactionTemplate(transactionManager);
    Pair<Integer, Long> elementsAndLastId = new ImmutablePair<>(0, 0L);
    do {//  ww w.  ja  va2s . co m
        final Long lastProcessedId = elementsAndLastId.getRight();
        elementsAndLastId = template.execute(status -> {
            final List<? extends TargetItem> items = getItems(targetItemMetadata, targetSystemPublication,
                    makePageable(lastProcessedId));
            final Pair<Integer, Long> pageElementsAndLastId;
            if (!CollectionUtils.isEmpty(items)) {
                for (final TargetItem targetItem : items) {
                    errors.addAll(doPublish(targetItem, targetSystemPublication));
                }
                pageElementsAndLastId = new ImmutablePair<>(items.size(),
                        getLastProcessedId(lastProcessedId, items));
            } else {
                pageElementsAndLastId = new ImmutablePair<>(0, 0L);
            }
            return pageElementsAndLastId;
        });
    } while (elementsAndLastId.getRight() > 0);
    return errors;
}

From source file:fi.hsl.parkandride.core.service.PredictionService.java

private void doUpdatePredictions() {
    log.info("Updating predictions");
    TransactionTemplate txTemplate = new TransactionTemplate(transactionManager);
    txTemplate.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED); // TODO: set in Core/JdbcConfiguration
    txTemplate.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);

    for (Long predictorId : findPredictorsNeedingUpdate()) {
        try {/*from   www  . j  a  va  2 s  .  c o  m*/
            txTemplate.execute(tx -> {
                updatePredictor(predictorId);
                log.debug("Updating predictor {} done", predictorId);
                return null;
            });
        } catch (Exception e) {
            log.error("Failed to update predictor {}", predictorId, e);
        }
    }
}

From source file:ro.nextreports.server.web.NextServerApplication.java

private SchedulerJob[] getSchedulerJobs() {
    PlatformTransactionManager transactionManager = (PlatformTransactionManager) getSpringBean(
            "transactionManager");
    TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);
    SchedulerJob[] schedulerJobs = transactionTemplate.execute(new TransactionCallback<SchedulerJob[]>() {

        public SchedulerJob[] doInTransaction(TransactionStatus transactionStatus) {
            StorageDao storageDao = (StorageDao) getSpringBean("storageDao");
            try {
                Entity[] entities = storageDao.getEntitiesByClassName(StorageConstants.SCHEDULER_ROOT,
                        SchedulerJob.class.getName());
                SchedulerJob[] schedulerJobs = new SchedulerJob[entities.length];
                System.arraycopy(entities, 0, schedulerJobs, 0, entities.length);

                return schedulerJobs;
            } catch (Exception e) {
                // TODO
                e.printStackTrace();/*w  w  w .j  a v a  2s .c  o  m*/
                transactionStatus.setRollbackOnly();
                return null;
            }
        }

    });

    return schedulerJobs;
}