Example usage for org.springframework.transaction.reactive GenericReactiveTransaction hasTransaction

Introduction

In this page you can find the example usage for org.springframework.transaction.reactive GenericReactiveTransaction hasTransaction.

Prototype

public boolean hasTransaction() 

Source Link

Document

Return whether there is an actual transaction active.

Usage

From source file:org.springframework.transaction.reactive.AbstractReactiveTransactionManager.java

/**
 * Initialize transaction synchronization as appropriate.
 *///from   w  w w  .j  av  a  2s.c  om
private void prepareSynchronization(TransactionSynchronizationManager synchronizationManager,
        GenericReactiveTransaction status, TransactionDefinition definition) {

    if (status.isNewSynchronization()) {
        synchronizationManager.setActualTransactionActive(status.hasTransaction());
        synchronizationManager.setCurrentTransactionIsolationLevel(
                definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT
                        ? definition.getIsolationLevel()
                        : null);
        synchronizationManager.setCurrentTransactionReadOnly(definition.isReadOnly());
        synchronizationManager.setCurrentTransactionName(definition.getName());
        synchronizationManager.initSynchronization();
    }
}

---

From source file:org.springframework.transaction.reactive.AbstractReactiveTransactionManager.java

/**
 * Process an actual rollback.//from ww  w . j av  a2  s  . com
 * The completed flag has already been checked.
 * @param synchronizationManager the synchronization manager bound to the current transaction
 * @param status object representing the transaction
 * @throws TransactionException in case of rollback failure
 */
private Mono<Void> processRollback(TransactionSynchronizationManager synchronizationManager,
        GenericReactiveTransaction status) {

    return triggerBeforeCompletion(synchronizationManager, status).then(Mono.defer(() -> {
        if (status.isNewTransaction()) {
            if (status.isDebug()) {
                logger.debug("Initiating transaction rollback");
            }
            return doRollback(synchronizationManager, status);
        } else {
            Mono<Void> beforeCompletion = Mono.empty();
            // Participating in larger transaction
            if (status.hasTransaction()) {
                if (status.isDebug()) {
                    logger.debug(
                            "Participating transaction failed - marking existing transaction as rollback-only");
                }
                beforeCompletion = doSetRollbackOnly(synchronizationManager, status);
            } else {
                logger.debug("Should roll back transaction but cannot - no transaction available");
            }
            return beforeCompletion;
        }
    })).onErrorResume(ErrorPredicates.RUNTIME_OR_ERROR,
            ex -> triggerAfterCompletion(synchronizationManager, status,
                    TransactionSynchronization.STATUS_UNKNOWN).then(Mono.error(ex)))
            .then(Mono.defer(() -> triggerAfterCompletion(synchronizationManager, status,
                    TransactionSynchronization.STATUS_ROLLED_BACK)))
            .onErrorResume(ex -> cleanupAfterCompletion(synchronizationManager, status).then(Mono.error(ex)))
            .then(cleanupAfterCompletion(synchronizationManager, status));
}

---

From source file:org.springframework.transaction.reactive.AbstractReactiveTransactionManager.java

/**
 * Invoke {@code doRollback}, handling rollback exceptions properly.
 * @param synchronizationManager the synchronization manager bound to the current transaction
 * @param status object representing the transaction
 * @param ex the thrown application exception or error
 * @throws TransactionException in case of rollback failure
 * @see #doRollback/*from  ww  w . j a v  a 2  s  .  com*/
 */
private Mono<Void> doRollbackOnCommitException(TransactionSynchronizationManager synchronizationManager,
        GenericReactiveTransaction status, Throwable ex) throws TransactionException {

    return Mono.defer(() -> {
        if (status.isNewTransaction()) {
            if (status.isDebug()) {
                logger.debug("Initiating transaction rollback after commit exception", ex);
            }
            return doRollback(synchronizationManager, status);
        } else if (status.hasTransaction()) {
            if (status.isDebug()) {
                logger.debug("Marking existing transaction as rollback-only after commit exception", ex);
            }
            return doSetRollbackOnly(synchronizationManager, status);
        }
        return Mono.empty();
    }).onErrorResume(ErrorPredicates.RUNTIME_OR_ERROR, rbex -> {
        logger.error("Commit exception overridden by rollback exception", ex);
        return triggerAfterCompletion(synchronizationManager, status, TransactionSynchronization.STATUS_UNKNOWN)
                .then(Mono.error(rbex));
    }).then(triggerAfterCompletion(synchronizationManager, status,
            TransactionSynchronization.STATUS_ROLLED_BACK));
}

---

From source file:org.springframework.transaction.reactive.AbstractReactiveTransactionManager.java

/**
 * Trigger {@code afterCompletion} callbacks.
 * @param synchronizationManager the synchronization manager bound to the current transaction
 * @param status object representing the transaction
 * @param completionStatus completion status according to TransactionSynchronization constants
 *///w  w w.j  a  v  a 2 s.c  om
private Mono<Void> triggerAfterCompletion(TransactionSynchronizationManager synchronizationManager,
        GenericReactiveTransaction status, int completionStatus) {

    if (status.isNewSynchronization()) {
        List<TransactionSynchronization> synchronizations = synchronizationManager.getSynchronizations();
        synchronizationManager.clearSynchronization();
        if (!status.hasTransaction() || status.isNewTransaction()) {
            if (status.isDebug()) {
                logger.trace("Triggering afterCompletion synchronization");
            }
            // No transaction or new transaction for the current scope ->
            // invoke the afterCompletion callbacks immediately
            return invokeAfterCompletion(synchronizationManager, synchronizations, completionStatus);
        } else if (!synchronizations.isEmpty()) {
            // Existing transaction that we participate in, controlled outside
            // of the scope of this Spring transaction manager -> try to register
            // an afterCompletion callback with the existing (JTA) transaction.
            return registerAfterCompletionWithExistingTransaction(synchronizationManager,
                    status.getTransaction(), synchronizations);
        }
    }

    return Mono.empty();
}

---

From source file:org.springframework.transaction.reactive.AbstractReactiveTransactionManager.java

/**
 * Clean up after completion, clearing synchronization if necessary,
 * and invoking doCleanupAfterCompletion.
 * @param synchronizationManager the synchronization manager bound to the current transaction
 * @param status object representing the transaction
 * @see #doCleanupAfterCompletion//from  w  w w . j  a  v  a 2  s . c o  m
 */
private Mono<Void> cleanupAfterCompletion(TransactionSynchronizationManager synchronizationManager,
        GenericReactiveTransaction status) {

    return Mono.defer(() -> {
        status.setCompleted();
        if (status.isNewSynchronization()) {
            synchronizationManager.clear();
        }
        Mono<Void> cleanup = Mono.empty();
        if (status.isNewTransaction()) {
            cleanup = doCleanupAfterCompletion(synchronizationManager, status.getTransaction());
        }
        if (status.getSuspendedResources() != null) {
            if (status.isDebug()) {
                logger.debug("Resuming suspended transaction after completion of inner transaction");
            }
            Object transaction = (status.hasTransaction() ? status.getTransaction() : null);
            return cleanup.then(resume(synchronizationManager, transaction,
                    (SuspendedResourcesHolder) status.getSuspendedResources()));
        }
        return cleanup;
    });
}

---