How to use

DefaultTransactionStatus

in

org.springframework.transaction.support

@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);
  }
}

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

/**
 * 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());
  }
}

/**
 * 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());
  }
}

/**
 * Trigger {@code afterCommit} callbacks.
 * @param status object representing the transaction
 */
private void triggerAfterCommit(DefaultTransactionStatus status) {
  if (status.isNewSynchronization()) {
    if (status.isDebug()) {
      logger.trace("Triggering afterCommit synchronization");
    }
    TransactionSynchronizationUtils.triggerAfterCommit();
  }
}

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()));
}

@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);
  }
}

@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();
}

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

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

@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");
  }
}

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);
  }
}

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");

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();

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

  @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");
  }
};

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();

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");

@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
  }
}

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