Example usage for org.springframework.transaction.reactive TransactionSynchronizationManager setActualTransactionActive

Introduction

In this page you can find the example usage for org.springframework.transaction.reactive TransactionSynchronizationManager setActualTransactionActive.

Prototype

public void setActualTransactionActive(boolean active) 

Source Link

Document

Expose whether there currently is an actual transaction active.

Usage

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

/**
 * Initialize transaction synchronization as appropriate.
 *///ww  w  . j  a  va  2  s. c o m
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

/**
 * Suspend the given transaction. Suspends transaction synchronization first,
 * then delegates to the {@code doSuspend} template method.
 * @param synchronizationManager the synchronization manager bound to the current transaction
 * @param transaction the current transaction object
 * (or {@code null} to just suspend active synchronizations, if any)
 * @return an object that holds suspended resources
 * (or {@code null} if neither transaction nor synchronization active)
 * @see #doSuspend/* ww w  . j a v  a 2s  . c o  m*/
 * @see #resume
 */
private Mono<SuspendedResourcesHolder> suspend(TransactionSynchronizationManager synchronizationManager,
        @Nullable Object transaction) throws TransactionException {

    if (synchronizationManager.isSynchronizationActive()) {
        Mono<List<TransactionSynchronization>> suspendedSynchronizations = doSuspendSynchronization(
                synchronizationManager);
        return suspendedSynchronizations.flatMap(synchronizations -> {
            Mono<Optional<Object>> suspendedResources = (transaction != null
                    ? doSuspend(synchronizationManager, transaction).map(Optional::of)
                            .defaultIfEmpty(Optional.empty())
                    : Mono.just(Optional.empty()));
            return suspendedResources.map(it -> {
                String name = synchronizationManager.getCurrentTransactionName();
                synchronizationManager.setCurrentTransactionName(null);
                boolean readOnly = synchronizationManager.isCurrentTransactionReadOnly();
                synchronizationManager.setCurrentTransactionReadOnly(false);
                Integer isolationLevel = synchronizationManager.getCurrentTransactionIsolationLevel();
                synchronizationManager.setCurrentTransactionIsolationLevel(null);
                boolean wasActive = synchronizationManager.isActualTransactionActive();
                synchronizationManager.setActualTransactionActive(false);
                return new SuspendedResourcesHolder(it.orElse(null), synchronizations, name, readOnly,
                        isolationLevel, wasActive);
            }).onErrorResume(ErrorPredicates.RUNTIME_OR_ERROR,
                    ex -> doResumeSynchronization(synchronizationManager, synchronizations)
                            .cast(SuspendedResourcesHolder.class));
        });
    } else if (transaction != null) {
        // Transaction active but no synchronization active.
        Mono<Optional<Object>> suspendedResources = doSuspend(synchronizationManager, transaction)
                .map(Optional::of).defaultIfEmpty(Optional.empty());
        return suspendedResources.map(it -> new SuspendedResourcesHolder(it.orElse(null)));
    } else {
        // Neither transaction nor synchronization active.
        return Mono.empty();
    }
}

---

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

/**
 * Resume the given transaction. Delegates to the {@code doResume}
 * template method first, then resuming transaction synchronization.
 * @param synchronizationManager the synchronization manager bound to the current transaction
 * @param transaction the current transaction object
 * @param resourcesHolder the object that holds suspended resources,
 * as returned by {@code suspend} (or {@code null} to just
 * resume synchronizations, if any)// w ww.  j av  a  2s  .c o m
 * @see #doResume
 * @see #suspend
 */
private Mono<Void> resume(TransactionSynchronizationManager synchronizationManager,
        @Nullable Object transaction, @Nullable SuspendedResourcesHolder resourcesHolder)
        throws TransactionException {

    Mono<Void> resume = Mono.empty();

    if (resourcesHolder != null) {
        Object suspendedResources = resourcesHolder.suspendedResources;
        if (suspendedResources != null) {
            resume = doResume(synchronizationManager, transaction, suspendedResources);
        }
        List<TransactionSynchronization> suspendedSynchronizations = resourcesHolder.suspendedSynchronizations;
        if (suspendedSynchronizations != null) {
            synchronizationManager.setActualTransactionActive(resourcesHolder.wasActive);
            synchronizationManager.setCurrentTransactionIsolationLevel(resourcesHolder.isolationLevel);
            synchronizationManager.setCurrentTransactionReadOnly(resourcesHolder.readOnly);
            synchronizationManager.setCurrentTransactionName(resourcesHolder.name);
            return resume.then(doResumeSynchronization(synchronizationManager, suspendedSynchronizations));
        }
    }

    return resume;
}

---