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

Introduction

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

Prototype

public void setCurrentTransactionIsolationLevel(@Nullable Integer isolationLevel) 

Source Link

Document

Expose an isolation level for the current transaction.

Usage

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

/**
 * Initialize transaction synchronization as appropriate.
 *//*from  w  w 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//from  w  w  w. ja va2 s .co 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)//from  w w  w .j  av  a 2  s. 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;
}

---