org.springframework.transaction.support.DefaultTransactionStatus.hasTransaction java code examples

Common ways to obtain DefaultTransactionStatus

private void myMethod () {
 DefaultTransactionStatus d =Object transaction;TransactionDefinition transactionDefinition;Object suspendedResources;new DefaultTransactionStatus(transaction, newTransaction, newSynchronization, transactionDefinition.isReadOnly(), debug, suspendedResources)
Smart code suggestions by Codota
}

@Override
public boolean isNewTransaction() {
  return (hasTransaction() && this.newTransaction);
}

@Override
public boolean isNewTransaction() {
  return (hasTransaction() && this.newTransaction);
}

/**
 * Invoke {@code doRollback}, handling rollback exceptions properly.
 * @param status object representing the transaction
 * @param ex the thrown application exception or error
 * @throws TransactionException in case of rollback failure
 * @see #doRollback
 */
private void doRollbackOnCommitException(DefaultTransactionStatus status, Throwable ex) throws TransactionException {
  try {
    if (status.isNewTransaction()) {
      if (status.isDebug()) {
        logger.debug("Initiating transaction rollback after commit exception", ex);
      }
      doRollback(status);
    }
    else if (status.hasTransaction() && isGlobalRollbackOnParticipationFailure()) {
      if (status.isDebug()) {
        logger.debug("Marking existing transaction as rollback-only after commit exception", ex);
      }
      doSetRollbackOnly(status);
    }
  }
  catch (RuntimeException | Error rbex) {
    logger.error("Commit exception overridden by rollback exception", ex);
    triggerAfterCompletion(status, TransactionSynchronization.STATUS_UNKNOWN);
    throw rbex;
  }
  triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK);
}

/**
 * Trigger {@code afterCompletion} callbacks.
 * @param status object representing the transaction
 * @param completionStatus completion status according to TransactionSynchronization constants
 */
private void triggerAfterCompletion(DefaultTransactionStatus status, int completionStatus) {
  if (status.isNewSynchronization()) {
    List<TransactionSynchronization> synchronizations = TransactionSynchronizationManager.getSynchronizations();
    TransactionSynchronizationManager.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
      invokeAfterCompletion(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.
      registerAfterCompletionWithExistingTransaction(status.getTransaction(), synchronizations);
    }
  }
}

/**
 * Clean up after completion, clearing synchronization if necessary,
 * and invoking doCleanupAfterCompletion.
 * @param status object representing the transaction
 * @see #doCleanupAfterCompletion
 */
private void cleanupAfterCompletion(DefaultTransactionStatus status) {
  status.setCompleted();
  if (status.isNewSynchronization()) {
    TransactionSynchronizationManager.clear();
  }
  if (status.isNewTransaction()) {
    doCleanupAfterCompletion(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);
    resume(transaction, (SuspendedResourcesHolder) status.getSuspendedResources());
  }
}

/**
 * Invoke {@code doRollback}, handling rollback exceptions properly.
 * @param status object representing the transaction
 * @param ex the thrown application exception or error
 * @throws TransactionException in case of rollback failure
 * @see #doRollback
 */
private void doRollbackOnCommitException(DefaultTransactionStatus status, Throwable ex) throws TransactionException {
  try {
    if (status.isNewTransaction()) {
      if (status.isDebug()) {
        logger.debug("Initiating transaction rollback after commit exception", ex);
      }
      doRollback(status);
    }
    else if (status.hasTransaction() && isGlobalRollbackOnParticipationFailure()) {
      if (status.isDebug()) {
        logger.debug("Marking existing transaction as rollback-only after commit exception", ex);
      }
      doSetRollbackOnly(status);
    }
  }
  catch (RuntimeException | Error rbex) {
    logger.error("Commit exception overridden by rollback exception", ex);
    triggerAfterCompletion(status, TransactionSynchronization.STATUS_UNKNOWN);
    throw rbex;
  }
  triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK);
}

if (status.hasTransaction()) {
  if (status.isLocalRollbackOnly() || isGlobalRollbackOnParticipationFailure()) {
    if (status.isDebug()) {

/**
 * Initialize transaction synchronization as appropriate.
 */
protected void prepareSynchronization(DefaultTransactionStatus status, TransactionDefinition definition) {
  if (status.isNewSynchronization()) {
    TransactionSynchronizationManager.setActualTransactionActive(status.hasTransaction());
    TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(
        definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT ?
            definition.getIsolationLevel() : null);
    TransactionSynchronizationManager.setCurrentTransactionReadOnly(definition.isReadOnly());
    TransactionSynchronizationManager.setCurrentTransactionName(definition.getName());
    TransactionSynchronizationManager.initSynchronization();
  }
}

/**
 * Trigger {@code afterCompletion} callbacks.
 * @param status object representing the transaction
 * @param completionStatus completion status according to TransactionSynchronization constants
 */
private void triggerAfterCompletion(DefaultTransactionStatus status, int completionStatus) {
  if (status.isNewSynchronization()) {
    List<TransactionSynchronization> synchronizations = TransactionSynchronizationManager.getSynchronizations();
    TransactionSynchronizationManager.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
      invokeAfterCompletion(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.
      registerAfterCompletionWithExistingTransaction(status.getTransaction(), synchronizations);
    }
  }
}

/**
 * Clean up after completion, clearing synchronization if necessary,
 * and invoking doCleanupAfterCompletion.
 * @param status object representing the transaction
 * @see #doCleanupAfterCompletion
 */
private void cleanupAfterCompletion(DefaultTransactionStatus status) {
  status.setCompleted();
  if (status.isNewSynchronization()) {
    TransactionSynchronizationManager.clear();
  }
  if (status.isNewTransaction()) {
    doCleanupAfterCompletion(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);
    resume(transaction, (SuspendedResourcesHolder) status.getSuspendedResources());
  }
}

@Test
public void noExistingTransaction() {
  PlatformTransactionManager tm = new TestTransactionManager(false, true);
  DefaultTransactionStatus status1 = (DefaultTransactionStatus)
      tm.getTransaction(new DefaultTransactionDefinition(TransactionDefinition.PROPAGATION_SUPPORTS));
  assertFalse("Must not have transaction", status1.hasTransaction());
  DefaultTransactionStatus status2 = (DefaultTransactionStatus)
      tm.getTransaction(new DefaultTransactionDefinition(TransactionDefinition.PROPAGATION_REQUIRED));
  assertTrue("Must have transaction", status2.hasTransaction());
  assertTrue("Must be new transaction", status2.isNewTransaction());
  try {
    tm.getTransaction(new DefaultTransactionDefinition(TransactionDefinition.PROPAGATION_MANDATORY));
    fail("Should not have thrown NoTransactionException");
  }
  catch (IllegalTransactionStateException ex) {
    // expected
  }
}

if (status.hasTransaction()) {
  if (status.isLocalRollbackOnly() || isGlobalRollbackOnParticipationFailure()) {
    if (status.isDebug()) {

/**
 * Initialize transaction synchronization as appropriate.
 */
protected void prepareSynchronization(DefaultTransactionStatus status, TransactionDefinition definition) {
  if (status.isNewSynchronization()) {
    TransactionSynchronizationManager.setActualTransactionActive(status.hasTransaction());
    TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(
        definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT ?
            definition.getIsolationLevel() : null);
    TransactionSynchronizationManager.setCurrentTransactionReadOnly(definition.isReadOnly());
    TransactionSynchronizationManager.setCurrentTransactionName(definition.getName());
    TransactionSynchronizationManager.initSynchronization();
  }
}

@Override
public boolean isNewTransaction() {
  return (hasTransaction() && this.newTransaction);
}

@Override
public boolean isNewTransaction() {
  return (hasTransaction() && this.newTransaction);
}

public boolean isNewTransaction() {
  return (hasTransaction() && this.newTransaction);
}

@Override
protected void doSetRollbackOnly(DefaultTransactionStatus status) {
  // Is there a transaction?
  if (!status.hasTransaction())
    return;
  // Get transaction
  final JTransaction jtx = ((TxWrapper)status.getTransaction()).getJTransaction();
  if (jtx == null)
    throw new NoTransactionException("no current JTransaction exists");
  // Set rollback only
  if (this.logger.isTraceEnabled())
    this.logger.trace("marking Permazen transaction " + jtx + " for rollback-only");
  jtx.getTransaction().setRollbackOnly();
}

@Override
protected void doSetRollbackOnly(DefaultTransactionStatus status) {
  // Is there a transaction?
  if (!status.hasTransaction())
    return;
  // Get transaction
  final JTransaction jtx = ((TxWrapper)status.getTransaction()).getJTransaction();
  if (jtx == null)
    throw new NoTransactionException("no current JTransaction exists");
  // Set rollback only
  if (this.logger.isTraceEnabled())
    this.logger.trace("marking JSimpleDB transaction " + jtx + " for rollback-only");
  jtx.getTransaction().setRollbackOnly();
}

/**
 * Initialize transaction synchronization as appropriate.
 */
protected void prepareSynchronization(DefaultTransactionStatus status, TransactionDefinition definition) {
  if (status.isNewSynchronization()) {
    TransactionSynchronizationManager.setActualTransactionActive(status.hasTransaction());
    TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(
        definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT ?
            definition.getIsolationLevel() : null);
    TransactionSynchronizationManager.setCurrentTransactionReadOnly(definition.isReadOnly());
    TransactionSynchronizationManager.setCurrentTransactionName(definition.getName());
    TransactionSynchronizationManager.initSynchronization();
  }
}

/**
 * Initialize transaction synchronization as appropriate.
 */
protected void prepareSynchronization(DefaultTransactionStatus status, TransactionDefinition definition) {
  if (status.isNewSynchronization()) {
    TransactionSynchronizationManager.setActualTransactionActive(status.hasTransaction());
    TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(
        definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT ?
            definition.getIsolationLevel() : null);
    TransactionSynchronizationManager.setCurrentTransactionReadOnly(definition.isReadOnly());
    TransactionSynchronizationManager.setCurrentTransactionName(definition.getName());
    TransactionSynchronizationManager.initSynchronization();
  }
}

Javadoc

Return whether there is an actual transaction active.

Popular methods of DefaultTransactionStatus

getTransaction
Return the underlying transaction object.
isDebug
Return whether the progress of this transaction is debugged. This is used by AbstractPlatformTransac
<init>
Create a new DefaultTransactionStatus instance.
isNewTransaction
isReadOnly
Return if this transaction is defined as read-only transaction.
getSuspendedResources
Return the holder for resources that have been suspended for this transaction, if any.
isNewSynchronization
Return if a new transaction synchronization has been opened for this transaction.
isGlobalRollbackOnly
Determine the rollback-only flag via checking the transaction object, provided that the latter imple
setRollbackOnly
createAndHoldSavepoint
hasSavepoint
isLocalRollbackOnly

Popular in Java

Making http post requests using okhttp
getOriginalFilename (MultipartFile)
Return the original filename in the client's filesystem.This may contain path information depending
setContentView (Activity)
scheduleAtFixedRate (ScheduledExecutorService)
Creates and executes a periodic action that becomes enabled first after the given initial delay, and
Font (java.awt)
The Font class represents fonts, which are used to render text in a visible way. A font provides the
IOException (java.io)
Signals that an I/O exception of some sort has occurred. This class is the general class of exceptio
InputStreamReader (java.io)
An InputStreamReader is a bridge from byte streams to character streams: It reads bytes and decodes
Arrays (java.util)
This class contains various methods for manipulating arrays (such as sorting and searching). This cl
ExecutorService (java.util.concurrent)
An Executor that provides methods to manage termination and methods that can produce a Future for tr
JTable (javax.swing)

How to use hasTransactionmethodin org.springframework.transaction.support.DefaultTransactionStatus

Best Java code snippets using org.springframework.transaction.support.DefaultTransactionStatus.hasTransaction (Showing top 20 results out of 315)

How to use
hasTransaction
method
in
org.springframework.transaction.support.DefaultTransactionStatus