org.springframework.transaction.support.TransactionCallbackWithoutResult java code examples

@Override
@Nullable
public final Object doInTransaction(TransactionStatus status) {
  doInTransactionWithoutResult(status);
  return null;
}

  @Override
  protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
    assertTrue("Synchronization active", TransactionSynchronizationManager.isSynchronizationActive());
    TransactionTemplate tt2 = new TransactionTemplate(tm);
    tt2.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
    tt2.execute(new TransactionCallbackWithoutResult() {
      @Override
      protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
        assertTrue("Has thread connection", TransactionSynchronizationManager.hasResource(ds));
        assertTrue("Synchronization active", TransactionSynchronizationManager.isSynchronizationActive());
        assertTrue("Is new transaction", status.isNewTransaction());
        assertSame(con, DataSourceUtils.getConnection(ds));
        assertSame(con, DataSourceUtils.getConnection(ds));
      }
    });
  }
});

  @Override
  protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
    assertFalse("Is not rollback-only", status.isRollbackOnly());
    tt2.execute(new TransactionCallbackWithoutResult() {
      @Override
      protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
        status.setRollbackOnly();
      }
    });
    assertTrue("Is rollback-only", status.isRollbackOnly());
  }
});

@Override
@Nullable
public final Object doInTransaction(TransactionStatus status) {
  doInTransactionWithoutResult(status);
  return null;
}

  @Override
  protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
    assertTrue("Is new transaction", status.isNewTransaction());
    tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NEVER);
    tt.execute(new TransactionCallbackWithoutResult() {
      @Override
      protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
        fail("Should have thrown IllegalTransactionStateException");
      }
    });
    fail("Should have thrown IllegalTransactionStateException");
  }
});

public final Object doInTransaction(TransactionStatus status) {
  doInTransactionWithoutResult(status);
  return null;
}

  @Override
  protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
    assertFalse("Is not rollback-only", status.isRollbackOnly());
    tt2.execute(new TransactionCallbackWithoutResult() {
      @Override
      protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
        status.setRollbackOnly();
      }
    });
    assertTrue("Is rollback-only", status.isRollbackOnly());
  }
});

@Override
@Nullable
public final Object doInTransaction(TransactionStatus status) {
  doInTransactionWithoutResult(status);
  return null;
}

assertTrue("Isn't nested transaction", !status.hasSavepoint());
try {
  tt.execute(new TransactionCallbackWithoutResult() {
    @Override
    protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
      assertTrue("Is nested transaction", status.hasSavepoint());
      TransactionTemplate ntt = new TransactionTemplate(tm);
      ntt.execute(new TransactionCallbackWithoutResult() {
        @Override
        protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {

@Override
@Nullable
public final Object doInTransaction(TransactionStatus status) {
  doInTransactionWithoutResult(status);
  return null;
}

assertTrue("Isn't nested transaction", !status.hasSavepoint());
try {
  tt.execute(new TransactionCallbackWithoutResult() {
    @Override
    protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
      assertTrue("Is nested transaction", status.hasSavepoint());
      TransactionTemplate ntt = new TransactionTemplate(tm);
      ntt.execute(new TransactionCallbackWithoutResult() {
        @Override
        protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {

  @Override
  protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
    assertTrue("Is new transaction", status.isNewTransaction());
    assertTrue("Synchronization active", TransactionSynchronizationManager.isSynchronizationActive());
    assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
    assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
    tt2.execute(new TransactionCallbackWithoutResult() {
      @Override
      protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
        status.setRollbackOnly();
      }
    });
  }
});

  @Override
  protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
    assertTrue("Synchronization active", TransactionSynchronizationManager.isSynchronizationActive());
    assertSame(con1, DataSourceUtils.getConnection(ds));
    assertSame(con1, DataSourceUtils.getConnection(ds));
    TransactionTemplate tt2 = new TransactionTemplate(tm);
    tt2.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
    tt2.execute(new TransactionCallbackWithoutResult() {
      @Override
      protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
        assertTrue("Has thread connection", TransactionSynchronizationManager.hasResource(ds));
        assertTrue("Synchronization active", TransactionSynchronizationManager.isSynchronizationActive());
        assertTrue("Is new transaction", status.isNewTransaction());
        assertSame(con2, DataSourceUtils.getConnection(ds));
        assertSame(con2, DataSourceUtils.getConnection(ds));
      }
    });
    assertSame(con1, DataSourceUtils.getConnection(ds));
  }
});

  @Override
  protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
    assertTrue("Is existing transaction", !status.isNewTransaction());
    assertFalse("Is not rollback-only", status.isRollbackOnly());
    tt.execute(new TransactionCallbackWithoutResult() {
      @Override
      protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
        assertTrue("Has thread connection", TransactionSynchronizationManager.hasResource(ds));
        assertTrue("Synchronization active", TransactionSynchronizationManager.isSynchronizationActive());
        assertTrue("Is existing transaction", !status.isNewTransaction());
        status.setRollbackOnly();
      }
    });
    assertTrue("Is existing transaction", !status.isNewTransaction());
    assertTrue("Is rollback-only", status.isRollbackOnly());
  }
});

  @Override
  protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
    assertTrue("Is new transaction", status.isNewTransaction());
    assertTrue("Isn't nested transaction", !status.hasSavepoint());
    tt.execute(new TransactionCallbackWithoutResult() {
      @Override
      protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
        assertTrue("Has thread connection", TransactionSynchronizationManager.hasResource(ds));
        assertTrue("Synchronization active", TransactionSynchronizationManager.isSynchronizationActive());
        assertTrue("Isn't new transaction", !status.isNewTransaction());
        assertTrue("Is nested transaction", status.hasSavepoint());
        status.setRollbackOnly();
      }
    });
    assertTrue("Is new transaction", status.isNewTransaction());
    assertTrue("Isn't nested transaction", !status.hasSavepoint());
  }
});

  @Override
  protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
    assertTrue("Is new transaction", status.isNewTransaction());
    assertTrue("Isn't nested transaction", !status.hasSavepoint());
    for (int i = 0; i < count; i++) {
      tt.execute(new TransactionCallbackWithoutResult() {
        @Override
        protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
          assertTrue("Has thread connection", TransactionSynchronizationManager.hasResource(ds));
          assertTrue("Synchronization active", TransactionSynchronizationManager.isSynchronizationActive());
          assertTrue("Isn't new transaction", !status.isNewTransaction());
          assertTrue("Is nested transaction", status.hasSavepoint());
        }
      });
    }
    assertTrue("Is new transaction", status.isNewTransaction());
    assertTrue("Isn't nested transaction", !status.hasSavepoint());
  }
});

  @Override
  protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
    assertTrue("Is existing transaction", !status.isNewTransaction());
    assertFalse("Is not rollback-only", status.isRollbackOnly());
    tt.execute(new TransactionCallbackWithoutResult() {
      @Override
      protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
        assertTrue("Has thread connection", TransactionSynchronizationManager.hasResource(ds));
        assertTrue("Synchronization active", TransactionSynchronizationManager.isSynchronizationActive());
        assertTrue("Is existing transaction", !status.isNewTransaction());
        status.setRollbackOnly();
      }
    });
    assertTrue("Is existing transaction", !status.isNewTransaction());
    assertTrue("Is rollback-only", status.isRollbackOnly());
    TransactionSynchronizationManager.registerSynchronization(synch);
  }
});

  @Override
  protected void doInTransactionWithoutResult(TransactionStatus status) {
    assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
    assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
    assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
    TransactionTemplate tt2 = new TransactionTemplate(ptm);
    tt2.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
    tt2.execute(new TransactionCallbackWithoutResult() {
      @Override
      protected void doInTransactionWithoutResult(TransactionStatus status) {
        assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
        assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
        assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
      }
    });
    assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
    assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
    assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
  }
});

tt.execute(new TransactionCallbackWithoutResult() {
  @Override
  protected void doInTransactionWithoutResult(TransactionStatus status) {

tt.execute(new TransactionCallbackWithoutResult() {
  @Override
  protected void doInTransactionWithoutResult(TransactionStatus status) {

Javadoc

Simple convenience class for TransactionCallback implementation. Allows for implementing a doInTransaction version without result, i.e. without the need for a return statement.

Most used methods

doInTransactionWithoutResult
Gets called by TransactionTemplate.execute within a transactional context. Does not need to care abo
<init>

Popular in Java

Start an intent from android
getContentResolver (Context)
orElseThrow (Optional)
Return the contained value, if present, otherwise throw an exception to be created by the provided s
scheduleAtFixedRate (ScheduledExecutorService)
ServerSocket (java.net)
This class represents a server-side socket that waits for incoming client connections. A ServerSocke
UnknownHostException (java.net)
Thrown when a hostname can not be resolved.
Executor (java.util.concurrent)
An object that executes submitted Runnable tasks. This interface provides a way of decoupling task s
Modifier (javassist)
The Modifier class provides static methods and constants to decode class and member access modifiers
ImageIO (javax.imageio)
BasicDataSource (org.apache.commons.dbcp)
Basic implementation of javax.sql.DataSource that is configured via JavaBeans properties. This is no
CodeWhisperer alternatives

How to useTransactionCallbackWithoutResult in org.springframework.transaction.support

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

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