Tabnine Logo
DefaultTransactionStatus
Code IndexAdd Tabnine to your IDE (free)

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

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

Refine searchRefine arrow

  • TransactionSystemException
origin: spring-projects/spring-framework

@Override
protected void doCommit(DefaultTransactionStatus status) {
  DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
  Connection con = txObject.getConnectionHolder().getConnection();
  if (status.isDebug()) {
    logger.debug("Committing JDBC transaction on Connection [" + con + "]");
  }
  try {
    con.commit();
  }
  catch (SQLException ex) {
    throw new TransactionSystemException("Could not commit JDBC transaction", ex);
  }
}
origin: spring-projects/spring-framework

/**
 * Create a TransactionStatus instance for the given arguments.
 */
protected DefaultTransactionStatus newTransactionStatus(
    TransactionDefinition definition, @Nullable Object transaction, boolean newTransaction,
    boolean newSynchronization, boolean debug, @Nullable Object suspendedResources) {
  boolean actualNewSynchronization = newSynchronization &&
      !TransactionSynchronizationManager.isSynchronizationActive();
  return new DefaultTransactionStatus(
      transaction, newTransaction, actualNewSynchronization,
      definition.isReadOnly(), debug, suspendedResources);
}
origin: spring-projects/spring-framework

/**
 * 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());
  }
}
origin: spring-projects/spring-framework

/**
 * Trigger {@code beforeCommit} callbacks.
 * @param status object representing the transaction
 */
protected final void triggerBeforeCommit(DefaultTransactionStatus status) {
  if (status.isNewSynchronization()) {
    if (status.isDebug()) {
      logger.trace("Triggering beforeCommit synchronization");
    }
    TransactionSynchronizationUtils.triggerBeforeCommit(status.isReadOnly());
  }
}
origin: spring-projects/spring-framework

/**
 * Trigger {@code beforeCompletion} callbacks.
 * @param status object representing the transaction
 */
protected final void triggerBeforeCompletion(DefaultTransactionStatus status) {
  if (status.isNewSynchronization()) {
    if (status.isDebug()) {
      logger.trace("Triggering beforeCompletion synchronization");
    }
    TransactionSynchronizationUtils.triggerBeforeCompletion();
  }
}
origin: org.springframework.ldap/spring-ldap-core

protected void doRollback(DefaultTransactionStatus status) {
  ContextSourceAndDataSourceTransactionObject actualTransactionObject = (ContextSourceAndDataSourceTransactionObject) status
      .getTransaction();
  super.doRollback(new DefaultTransactionStatus(actualTransactionObject
      .getDataSourceTransactionObject(), status.isNewTransaction(),
      status.isNewSynchronization(), status.isReadOnly(), status
          .isDebug(), status.getSuspendedResources()));
  ldapManagerDelegate.doRollback(new DefaultTransactionStatus(
      actualTransactionObject.getLdapTransactionObject(), status
          .isNewTransaction(), status.isNewSynchronization(),
      status.isReadOnly(), status.isDebug(), status
          .getSuspendedResources()));
}
origin: spring-projects/spring-framework

@Override
protected void doRollback(DefaultTransactionStatus status) {
  JtaTransactionObject txObject = (JtaTransactionObject) status.getTransaction();
  try {
    int jtaStatus = txObject.getUserTransaction().getStatus();
    if (jtaStatus != Status.STATUS_NO_TRANSACTION) {
      try {
        txObject.getUserTransaction().rollback();
      }
      catch (IllegalStateException ex) {
        if (jtaStatus == Status.STATUS_ROLLEDBACK) {
          // Only really happens on JBoss 4.2 in case of an early timeout...
          if (logger.isDebugEnabled()) {
            logger.debug("Rollback failure with transaction already marked as rolled back: " + ex);
          }
        }
        else {
          throw new TransactionSystemException("Unexpected internal transaction state", ex);
        }
      }
    }
  }
  catch (SystemException ex) {
    throw new TransactionSystemException("JTA failure on rollback", ex);
  }
}
origin: spring-projects/spring-framework

@Override
protected void doSetRollbackOnly(DefaultTransactionStatus status) {
  HibernateTransactionObject txObject = (HibernateTransactionObject) status.getTransaction();
  if (status.isDebug()) {
    logger.debug("Setting Hibernate transaction on Session [" +
        txObject.getSessionHolder().getSession() + "] rollback-only");
  }
  txObject.setRollbackOnly();
}
origin: spring-projects/spring-framework

/**
 * 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);
    }
  }
}
origin: redisson/redisson

@Override
protected void doSetRollbackOnly(DefaultTransactionStatus status) throws TransactionException {
  RedissonTransactionObject to = (RedissonTransactionObject) status.getTransaction();
  to.setRollbackOnly(true);
}

origin: spring-projects/spring-framework

@Test
public void existingTransaction() {
  PlatformTransactionManager tm = new TestTransactionManager(true, true);
  DefaultTransactionStatus status1 = (DefaultTransactionStatus)
      tm.getTransaction(new DefaultTransactionDefinition(TransactionDefinition.PROPAGATION_SUPPORTS));
  assertTrue("Must have transaction", status1.getTransaction() != null);
  assertTrue("Must not be new transaction", !status1.isNewTransaction());
  DefaultTransactionStatus status2 = (DefaultTransactionStatus)
      tm.getTransaction(new DefaultTransactionDefinition(TransactionDefinition.PROPAGATION_REQUIRED));
  assertTrue("Must have transaction", status2.getTransaction() != null);
  assertTrue("Must not be new transaction", !status2.isNewTransaction());
  try {
    DefaultTransactionStatus status3 = (DefaultTransactionStatus)
        tm.getTransaction(new DefaultTransactionDefinition(TransactionDefinition.PROPAGATION_MANDATORY));
    assertTrue("Must have transaction", status3.getTransaction() != null);
    assertTrue("Must not be new transaction", !status3.isNewTransaction());
  }
  catch (NoTransactionException ex) {
    fail("Should not have thrown NoTransactionException");
  }
}
origin: springframework/spring-orm

protected void doCommit(DefaultTransactionStatus status) {
  TopLinkTransactionObject txObject = (TopLinkTransactionObject) status.getTransaction();
  if (status.isDebug()) {
    logger.debug("Committing TopLink transaction on session [" +
        txObject.getSessionHolder().getSession() + "]");
  }
  try {
    if (!status.isReadOnly()) {
      txObject.getSessionHolder().getSession().getActiveUnitOfWork().commit();
    }
    txObject.getSessionHolder().clear();
  }
  catch (DatabaseException ex) {
    throw convertJdbcAccessException((SQLException) ex.getInternalException());
  }
  catch (TopLinkException ex) {
    throw convertTopLinkAccessException(ex);
  }
}
origin: spring-projects/spring-framework

triggerBeforeCompletion(status);
if (status.hasSavepoint()) {
  if (status.isDebug()) {
    logger.debug("Rolling back transaction to savepoint");
  status.rollbackToHeldSavepoint();
else if (status.isNewTransaction()) {
  if (status.isDebug()) {
    logger.debug("Initiating transaction rollback");
  if (status.hasTransaction()) {
    if (status.isLocalRollbackOnly() || isGlobalRollbackOnParticipationFailure()) {
      if (status.isDebug()) {
        logger.debug("Participating transaction failed - marking existing transaction as rollback-only");
      if (status.isDebug()) {
        logger.debug("Participating transaction failed - letting transaction originator decide on rollback");
origin: spring-projects/spring-framework

beforeCompletionInvoked = true;
if (status.hasSavepoint()) {
  if (status.isDebug()) {
    logger.debug("Releasing transaction savepoint");
  unexpectedRollback = status.isGlobalRollbackOnly();
  status.releaseHeldSavepoint();
else if (status.isNewTransaction()) {
  if (status.isDebug()) {
    logger.debug("Initiating transaction commit");
  unexpectedRollback = status.isGlobalRollbackOnly();
  doCommit(status);
  unexpectedRollback = status.isGlobalRollbackOnly();
origin: spring-projects/spring-framework

/**
 * 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);
}
origin: spring-projects/spring-batch

  @Override
  protected void doCommit(DefaultTransactionStatus status) throws TransactionException {
    if (writer.getWritten().isEmpty() || failed || !isExistingTransaction(status.getTransaction())) {
      super.doCommit(status);
      return;
    }
    failed = true;
    status.setRollbackOnly();
    super.doRollback(status);
    throw new UnexpectedRollbackException("Planned");
  }
};
origin: spring-projects/spring-framework

if (status.isDebug()) {
  logger.debug("Rolling back on application exception from transaction callback", ex);
if (status.isLocalRollbackOnly()) {
  if (status.isDebug()) {
    logger.debug("Transaction callback has explicitly requested rollback");
if (status.isNewSynchronization()) {
  List<TransactionSynchronization> synchronizations = TransactionSynchronizationManager.getSynchronizations();
  TransactionSynchronizationManager.clear();
origin: spring-projects/spring-framework

if (defStatus.isLocalRollbackOnly()) {
  if (defStatus.isDebug()) {
    logger.debug("Transactional code has requested rollback");
if (!shouldCommitOnGlobalRollbackOnly() && defStatus.isGlobalRollbackOnly()) {
  if (defStatus.isDebug()) {
    logger.debug("Global transaction is marked as rollback-only but transactional code requested commit");
origin: spring-projects/spring-framework

@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
  }
}
origin: br.com.anteros/Anteros-Spring

@Override
protected void prepareForCommit(DefaultTransactionStatus status) {
  if (this.earlyFlushBeforeCommit && status.isNewTransaction()) {
  }
}
org.springframework.transaction.supportDefaultTransactionStatus

Javadoc

Default implementation of the org.springframework.transaction.TransactionStatusinterface, used by AbstractPlatformTransactionManager. Based on the concept of an underlying "transaction object".

Holds all status information that AbstractPlatformTransactionManagerneeds internally, including a generic transaction object determined by the concrete transaction manager implementation.

Supports delegating savepoint-related methods to a transaction object that implements the SavepointManager interface.

NOTE: This is not intended for use with other PlatformTransactionManager implementations, in particular not for mock transaction managers in testing environments. Use the alternative SimpleTransactionStatus class or a mock for the plain org.springframework.transaction.TransactionStatus interface instead.

Most used methods

  • 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.
  • hasTransaction
    Return whether there is an actual transaction active.
  • isGlobalRollbackOnly
    Determine the rollback-only flag via checking the transaction object, provided that the latter imple
  • setRollbackOnly
  • createAndHoldSavepoint
  • hasSavepoint
  • createAndHoldSavepoint,
  • hasSavepoint,
  • isLocalRollbackOnly,
  • releaseHeldSavepoint,
  • rollbackToHeldSavepoint,
  • setCompleted,
  • isCompleted,
  • isTransactionSavepointManager

Popular in Java

  • Making http post requests using okhttp
  • requestLocationUpdates (LocationManager)
  • getResourceAsStream (ClassLoader)
  • compareTo (BigDecimal)
  • Font (java.awt)
    The Font class represents fonts, which are used to render text in a visible way. A font provides the
  • Point (java.awt)
    A point representing a location in (x,y) coordinate space, specified in integer precision.
  • PrintWriter (java.io)
    Wraps either an existing OutputStream or an existing Writerand provides convenience methods for prin
  • Cipher (javax.crypto)
    This class provides access to implementations of cryptographic ciphers for encryption and decryption
  • Servlet (javax.servlet)
    Defines methods that all servlets must implement. A servlet is a small Java program that runs within
  • BoxLayout (javax.swing)
  • Top 12 Jupyter Notebook extensions
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now