Example usage for org.springframework.transaction TransactionDefinition PROPAGATION_REQUIRES_NEW

List of usage examples for org.springframework.transaction TransactionDefinition PROPAGATION_REQUIRES_NEW

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.transaction.*
  5. TransactionDefinition
  6. PROPAGATION_REQUIRES_NEW

Introduction

In this page you can find the example usage for org.springframework.transaction TransactionDefinition PROPAGATION_REQUIRES_NEW.

Prototype

int PROPAGATION_REQUIRES_NEW

To view the source code for org.springframework.transaction TransactionDefinition PROPAGATION_REQUIRES_NEW.

Click Source Link

Document

Create a new transaction, suspending the current transaction if one exists.

Usage

From source file:org.dbflute.utflute.spring.SpringTestCase.java

protected SpringTransactionResource xregisterTransaction(SpringTransactionResource resource,
        final String managerKey) {
    final PlatformTransactionManager manager = getComponent(managerKey);
    final DefaultTransactionDefinition def = new DefaultTransactionDefinition();
    def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
    final TransactionStatus status = manager.getTransaction(def);
    resource.registerTransaction(manager, status);
    return resource;
}

From source file:org.ohdsi.webapi.feasibility.PerformFeasibilityTasklet.java

@Override
public RepeatStatus execute(final StepContribution contribution, final ChunkContext chunkContext)
        throws Exception {
    Date startTime = Calendar.getInstance().getTime();
    Map<String, Object> jobParams = chunkContext.getStepContext().getJobParameters();
    Integer studyId = Integer.valueOf(jobParams.get("study_id").toString());
    Integer sourceId = Integer.valueOf(jobParams.get("source_id").toString());
    boolean isValid = false;

    DefaultTransactionDefinition requresNewTx = new DefaultTransactionDefinition();
    requresNewTx.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);

    TransactionStatus initStatus = this.transactionTemplate.getTransactionManager()
            .getTransaction(requresNewTx);
    FeasibilityStudy study = this.feasibilityStudyRepository.findOne(studyId);

    CohortDefinition resultDef = study.getResultRule();
    if (resultDef != null) {
        CohortGenerationInfo resultInfo = findCohortGenerationInfoBySourceId(resultDef.getGenerationInfoList(),
                sourceId);//from www.  jav  a 2s. c o m
        resultInfo.setIsValid(false).setStatus(GenerationStatus.RUNNING).setStartTime(startTime)
                .setExecutionDuration(null);
    }
    StudyGenerationInfo studyInfo = findStudyGenerationInfoBySourceId(study.getStudyGenerationInfoList(),
            sourceId);
    studyInfo.setIsValid(false);
    studyInfo.setStartTime(startTime);
    studyInfo.setStatus(GenerationStatus.RUNNING);

    this.feasibilityStudyRepository.save(study);
    this.transactionTemplate.getTransactionManager().commit(initStatus);

    try {
        final int[] ret = this.transactionTemplate.execute(new TransactionCallback<int[]>() {

            @Override
            public int[] doInTransaction(final TransactionStatus status) {
                return doTask(chunkContext);
            }
        });
        log.debug("Update count: " + ret.length);
        isValid = true;
    } catch (final TransactionException e) {
        isValid = false;
        log.error(e.getMessage(), e);
        throw e;//FAIL job status
    } finally {
        TransactionStatus completeStatus = this.transactionTemplate.getTransactionManager()
                .getTransaction(requresNewTx);
        Date endTime = Calendar.getInstance().getTime();
        study = this.feasibilityStudyRepository.findOne(studyId);
        resultDef = study.getResultRule();
        if (resultDef != null) {
            CohortGenerationInfo resultInfo = findCohortGenerationInfoBySourceId(
                    resultDef.getGenerationInfoList(), sourceId);
            resultInfo = findCohortGenerationInfoBySourceId(resultDef.getGenerationInfoList(), sourceId);
            resultInfo.setIsValid(isValid);
            resultInfo.setExecutionDuration(new Integer((int) (endTime.getTime() - startTime.getTime())));
            resultInfo.setStatus(GenerationStatus.COMPLETE);
        }

        studyInfo = findStudyGenerationInfoBySourceId(study.getStudyGenerationInfoList(), sourceId);
        studyInfo.setIsValid(isValid);
        studyInfo.setExecutionDuration(new Integer((int) (endTime.getTime() - startTime.getTime())));
        studyInfo.setStatus(GenerationStatus.COMPLETE);

        this.feasibilityStudyRepository.save(study);
        this.transactionTemplate.getTransactionManager().commit(completeStatus);
    }

    return RepeatStatus.FINISHED;
}

From source file:com.googlecode.starflow.engine.support.TriggerProcessEventUtil.java

/**
 * ?//from   ww  w  . ja va  2s  .c o  m
 * 
 * @param processInstId
 * @param action
 * @return
 */
private static void executeLogicInNewTransaction(ProcessDefine processDefine, ProcessInstance processInstance,
        IAction action) {
    PlatformTransactionManager txManager = ApplicationContextHolder.getBean(PlatformTransactionManager.class);
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    definition.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
    TransactionStatus status = txManager.getTransaction(definition);
    try {
        action.execute(processDefine, processInstance);
        txManager.commit(status);
    } catch (Exception e) {
        txManager.rollback(status);
        throw new ProcessEngineException("?", e);
    }
}

From source file:com.googlecode.starflow.engine.handle.BaseHandlerAdapter.java

/**
 * ?// w w  w .j  a  v  a 2  s. c o  m
 * 
 * @param event
 * @param activityInst
 * @param action
 * @return
 */
protected Object executeLogicInNewTransaction(final AbstractFlowEvent event, final ActivityInst activityInst,
        final IAction action) {
    TransactionTemplate template = event.getProcessEngine().getTransactionTemplate();

    return template.execute(TransactionDefinition.PROPAGATION_REQUIRES_NEW, new TransactionCallback<Object>() {

        @Override
        public Object doInTransaction(TransactionStatus status) {
            return action.execute(event, activityInst);
        }
    });
}

From source file:com.googlecode.starflow.engine.support.TriggerActivityEventUtil.java

/**
 * ?/*w w w . j a va 2s. c o  m*/
 * 
 * @param activityXml
 * @param activityInst
 * @param action
 * @return
 */
private static void executeLogicInNewTransaction(ActivityElement activityXml, ActivityInst activityInst,
        IAction action) {
    PlatformTransactionManager txManager = ApplicationContextHolder.getBean(PlatformTransactionManager.class);
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    definition.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
    TransactionStatus status = txManager.getTransaction(definition);
    try {
        action.execute(activityXml, activityInst);
        txManager.commit(status);
    } catch (Exception e) {
        txManager.rollback(status);
        throw new ProcessEngineException("?", e);
    }
}

From source file:es.tid.fiware.rss.expenditureLimit.processing.test.ProcessingLimitServiceTest.java

/**
 * Check that the acummulated is set to 0 and added a negative value (refund)
 *///  ww w  .j a  va2 s  .co  m
@Test
public void updateResetControls() {
    try {
        DbeTransaction tx = ProcessingLimitServiceTest.generateTransaction();
        // Set user for testing
        tx.setTxEndUserId("userIdUpdate");
        tx.setTcTransactionType(Constants.REFUND_TYPE);
        tx.setFtChargedTotalAmount(new BigDecimal(2));
        List<DbeExpendControl> controls = controlService.getExpendDataForUserAppProvCurrencyObCountry(
                tx.getTxEndUserId(), tx.getBmService(), tx.getTxAppProvider(), tx.getBmCurrency(),
                tx.getBmObMop().getBmObCountry());
        DbeExpendControl control = controls.get(0);
        // Reset period
        Date date = new Date();
        date.setTime((new Date()).getTime() - 100000000);
        control.setDtNextPeriodStart(date);
        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
        def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
        TransactionStatus status = transactionManager.getTransaction(def);
        controlService.createOrUpdate(control);
        transactionManager.commit(status);
        limitService.updateLimit(tx);
        List<DbeExpendControl> controls2 = controlService.getExpendDataForUserAppProvCurrencyObCountry(
                tx.getTxEndUserId(), tx.getBmService(), tx.getTxAppProvider(), tx.getBmCurrency(),
                tx.getBmObMop().getBmObCountry());
        for (DbeExpendControl controlAux : controls2) {
            if (control.getId().getTxElType().equalsIgnoreCase(controlAux.getId().getTxElType())) {
                Assert.assertTrue(controlAux.getFtExpensedAmount().compareTo(new BigDecimal(-2)) == 0);
            }
        }

    } catch (RSSException e) {
        Assert.fail("Exception not expected" + e.getMessage());
    }
}

From source file:es.upm.fiware.rss.expenditureLimit.processing.test.ProcessingLimitServiceTest.java

/**
 * Check that the acummulated is set to 0 and added a negative value (refund)
 *//*from  ww w. ja v  a2 s  .  c o m*/
@Transactional
public void updateResetControls() {
    try {
        DbeTransaction tx = ProcessingLimitServiceTest.generateTransaction();
        // Set user for testing
        tx.setTxEndUserId("userIdUpdate");
        tx.setTcTransactionType(Constants.REFUND_TYPE);
        tx.setFtChargedAmount(new BigDecimal(2));

        List<DbeExpendControl> controls = this.getExpenditureControls(tx);

        DbeExpendControl control = controls.get(0);
        // Reset period
        Date date = new Date();
        date.setTime((new Date()).getTime() - 100000000);
        control.setDtNextPeriodStart(date);

        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
        def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
        TransactionStatus status = transactionManager.getTransaction(def);

        controlService.createOrUpdate(control);

        transactionManager.commit(status);

        limitService.updateLimit(tx);
        List<DbeExpendControl> controls2 = this.getExpenditureControls(tx);

        for (DbeExpendControl controlAux : controls2) {
            if (control.getId().getTxElType().equalsIgnoreCase(controlAux.getId().getTxElType())) {
                Assert.assertTrue("Expensed amount: " + controlAux.getFtExpensedAmount(),
                        controlAux.getFtExpensedAmount().compareTo(new BigDecimal(-2)) == 0);
            }
        }

    } catch (RSSException e) {
        Assert.fail("Exception not expected" + e.getMessage());
    }
}

From source file:org.jspresso.hrsample.backend.JspressoUnitOfWorkTest.java

/**
 * Tests the use of nested transactions.
 *///from   w ww.j  a  va 2s  .  c  o m
@Test
public void testNestedTransactions() {
    final HibernateBackendController hbc = (HibernateBackendController) getBackendController();
    final TransactionTemplate tt = hbc.getTransactionTemplate();

    Serializable empId = tt.execute(new TransactionCallback<Serializable>() {

        @Override
        public Serializable doInTransaction(TransactionStatus status) {
            TransactionTemplate nestedTT = new ControllerAwareTransactionTemplate(tt.getTransactionManager());
            nestedTT.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
            Serializable id = nestedTT.execute(new TransactionCallback<Serializable>() {

                @Override
                public Serializable doInTransaction(TransactionStatus nestedStatus) {
                    DetachedCriteria empCrit = DetachedCriteria.forClass(Employee.class);
                    Employee emp = hbc.findFirstByCriteria(empCrit, null, Employee.class);
                    emp.setFirstName("Committed");
                    return emp.getId();
                }
            });
            // asserts that UOW is still active after the end of the nested transaction.
            assertTrue("UOW should still be active since outer TX is ongoing.", hbc.isUnitOfWorkActive());
            // forces rollback of outer TX.
            status.setRollbackOnly();
            return id;
        }
    });
    DetachedCriteria empById = DetachedCriteria.forClass(Employee.class);
    empById.add(Restrictions.eq(IEntity.ID, empId));
    Employee emp = hbc.findFirstByCriteria(empById, EMergeMode.MERGE_CLEAN_EAGER, Employee.class);
    assertTrue("Inner transaction should have been committed", "Committed".equals(emp.getFirstName()));

    Serializable emp2Id = tt.execute(new TransactionCallback<Serializable>() {

        @Override
        public Serializable doInTransaction(TransactionStatus status) {
            TransactionTemplate nestedTT = new ControllerAwareTransactionTemplate(tt.getTransactionManager());
            nestedTT.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
            Serializable id = nestedTT.execute(new TransactionCallback<Serializable>() {

                @Override
                public Serializable doInTransaction(TransactionStatus nestedStatus) {
                    DetachedCriteria empCrit = DetachedCriteria.forClass(Employee.class);
                    Employee emp2 = hbc.findFirstByCriteria(empCrit, null, Employee.class);
                    emp2.setFirstName("Rollbacked");
                    return emp2.getId();
                }
            });
            // forces rollback of outer TX.
            status.setRollbackOnly();
            return id;
        }
    });
    DetachedCriteria emp2ById = DetachedCriteria.forClass(Employee.class);
    emp2ById.add(Restrictions.eq(IEntity.ID, emp2Id));
    Employee emp2 = hbc.findFirstByCriteria(empById, EMergeMode.MERGE_CLEAN_EAGER, Employee.class);
    assertFalse("Inner transaction should have been rollbacked", "Rollbacked".equals(emp2.getFirstName()));

    tt.execute(new TransactionCallbackWithoutResult() {

        @Override
        protected void doInTransactionWithoutResult(TransactionStatus status) {
            City newCity = hbc.getEntityFactory().createEntityInstance(City.class);
            newCity.setName("Test City");

            TransactionTemplate nestedTT = new ControllerAwareTransactionTemplate(tt.getTransactionManager());
            nestedTT.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
            String testZip = nestedTT.execute(new TransactionCallback<String>() {

                @Override
                public String doInTransaction(TransactionStatus nestedStatus) {
                    return "12345";
                }
            });
            newCity.setZip(testZip);
            hbc.registerForUpdate(newCity);
        }
    });

    tt.execute(new TransactionCallbackWithoutResult() {

        @Override
        protected void doInTransactionWithoutResult(TransactionStatus status) {
            final City randomCity = hbc.findFirstByCriteria(DetachedCriteria.forClass(City.class),
                    EMergeMode.MERGE_KEEP, City.class);
            TransactionTemplate nestedTT = new ControllerAwareTransactionTemplate(tt.getTransactionManager());
            nestedTT.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
            nestedTT.execute(new TransactionCallbackWithoutResult() {

                @Override
                public void doInTransactionWithoutResult(TransactionStatus nestedStatus) {
                    DetachedCriteria cityById = DetachedCriteria.forClass(City.class);
                    cityById.add(Restrictions.eq(IEntity.ID, randomCity.getId()));
                    City innerRandomCity = (City) cityById.getExecutableCriteria(hbc.getHibernateSession())
                            .uniqueResult();
                    // If we reach this point without exception, there is no mix between the inner TX and the outer UOW.
                    // See bug #1118
                }
            });
        }
    });
}

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

private void doTestJtaTransactionWithPropagationRequiresNew(final boolean rollback,
        final boolean openOuterConnection, final boolean accessAfterResume,
        final boolean useTransactionAwareContentSource) throws Exception {

    given(transactionManager.suspend()).willReturn(transaction);
    if (rollback) {
        given(userTransaction.getStatus()).willReturn(Status.STATUS_NO_TRANSACTION, Status.STATUS_ACTIVE);
    } else {//from   w  ww.j  a va  2 s  .  c  o  m
        given(userTransaction.getStatus()).willReturn(Status.STATUS_NO_TRANSACTION, Status.STATUS_ACTIVE,
                Status.STATUS_ACTIVE);
    }

    given(session.getTransactionMode()).willReturn(Session.TransactionMode.QUERY);

    final ContentSource dsToUse = useTransactionAwareContentSource
            ? new TransactionAwareContentSourceProxy(contentSource)
            : contentSource;

    JtaTransactionManager ptm = new JtaTransactionManager(userTransaction, transactionManager);
    final TransactionTemplate tt = new TransactionTemplate(ptm);
    tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
    assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(dsToUse));
    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(dsToUse));
            assertTrue("JTA synchronizations active",
                    TransactionSynchronizationManager.isSynchronizationActive());
            assertTrue("Is new transaction", status.isNewTransaction());

            Session s = ContentSourceUtils.getSession(dsToUse);
            assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(dsToUse));
            s.getTransactionMode();
            ContentSourceUtils.releaseSession(s, dsToUse);

            s = ContentSourceUtils.getSession(dsToUse);
            assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(dsToUse));
            if (!openOuterConnection) {
                ContentSourceUtils.releaseSession(s, dsToUse);
            }

            for (int i = 0; i < 5; i++) {

                tt.execute(new TransactionCallbackWithoutResult() {
                    @Override
                    protected void doInTransactionWithoutResult(TransactionStatus status)
                            throws RuntimeException {
                        assertTrue("Hasn't thread session",
                                !TransactionSynchronizationManager.hasResource(dsToUse));
                        assertTrue("JTA synchronizations active",
                                TransactionSynchronizationManager.isSynchronizationActive());
                        assertTrue("Is new transaction", status.isNewTransaction());

                        Session s = ContentSourceUtils.getSession(dsToUse);
                        s.getTransactionMode();
                        assertTrue("Has thread session",
                                TransactionSynchronizationManager.hasResource(dsToUse));
                        ContentSourceUtils.releaseSession(s, dsToUse);

                        s = ContentSourceUtils.getSession(dsToUse);
                        assertTrue("Has thread session",
                                TransactionSynchronizationManager.hasResource(dsToUse));
                        ContentSourceUtils.releaseSession(s, dsToUse);
                    }
                });

            }

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

            if (accessAfterResume) {
                if (!openOuterConnection) {
                    s = ContentSourceUtils.getSession(dsToUse);
                }
                assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(dsToUse));
                s.getTransactionMode();
                ContentSourceUtils.releaseSession(s, dsToUse);

                s = ContentSourceUtils.getSession(dsToUse);
                assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(dsToUse));
                ContentSourceUtils.releaseSession(s, dsToUse);
            } else {
                if (openOuterConnection) {
                    ContentSourceUtils.releaseSession(s, dsToUse);
                }
            }
        }
    });

    assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(dsToUse));
    assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
    verify(userTransaction, times(6)).begin();
    verify(transactionManager, times(5)).resume(transaction);
    if (rollback) {
        verify(userTransaction, times(5)).commit();
        verify(userTransaction).rollback();
    } else {
        verify(userTransaction, times(6)).commit();
    }
    if (accessAfterResume && !openOuterConnection) {
        verify(session, times(7)).close();
    } else {
        verify(session, times(6)).close();
    }
}

From source file:alfio.manager.TicketReservationManager.java

public TicketReservationManager(EventRepository eventRepository, OrganizationRepository organizationRepository,
        TicketRepository ticketRepository, TicketReservationRepository ticketReservationRepository,
        TicketCategoryRepository ticketCategoryRepository,
        TicketCategoryDescriptionRepository ticketCategoryDescriptionRepository,
        ConfigurationManager configurationManager, PaymentManager paymentManager,
        PromoCodeDiscountRepository promoCodeDiscountRepository, SpecialPriceRepository specialPriceRepository,
        TransactionRepository transactionRepository, NotificationManager notificationManager,
        MessageSource messageSource, TemplateManager templateManager,
        PlatformTransactionManager transactionManager, WaitingQueueManager waitingQueueManager,
        PluginManager pluginManager, TicketFieldRepository ticketFieldRepository,
        AdditionalServiceRepository additionalServiceRepository,
        AdditionalServiceItemRepository additionalServiceItemRepository,
        AdditionalServiceTextRepository additionalServiceTextRepository,
        InvoiceSequencesRepository invoiceSequencesRepository, AuditingRepository auditingRepository,
        UserRepository userRepository, ExtensionManager extensionManager) {
    this.eventRepository = eventRepository;
    this.organizationRepository = organizationRepository;
    this.ticketRepository = ticketRepository;
    this.ticketReservationRepository = ticketReservationRepository;
    this.ticketCategoryRepository = ticketCategoryRepository;
    this.ticketCategoryDescriptionRepository = ticketCategoryDescriptionRepository;
    this.configurationManager = configurationManager;
    this.paymentManager = paymentManager;
    this.promoCodeDiscountRepository = promoCodeDiscountRepository;
    this.specialPriceRepository = specialPriceRepository;
    this.transactionRepository = transactionRepository;
    this.notificationManager = notificationManager;
    this.messageSource = messageSource;
    this.templateManager = templateManager;
    this.waitingQueueManager = waitingQueueManager;
    this.pluginManager = pluginManager;
    this.requiresNewTransactionTemplate = new TransactionTemplate(transactionManager,
            new DefaultTransactionDefinition(TransactionDefinition.PROPAGATION_REQUIRES_NEW));
    this.ticketFieldRepository = ticketFieldRepository;
    this.additionalServiceRepository = additionalServiceRepository;
    this.additionalServiceItemRepository = additionalServiceItemRepository;
    this.additionalServiceTextRepository = additionalServiceTextRepository;
    this.invoiceSequencesRepository = invoiceSequencesRepository;
    this.auditingRepository = auditingRepository;
    this.userRepository = userRepository;
    this.extensionManager = extensionManager;
}