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

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 Connection c =String url;DriverManager.getConnection(url)
String url;Properties info;DriverManager.getConnection(url, info)
Driver driver;String url;Properties info;driver.connect(url, info)
Smart code suggestions by Tabnine
}

@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

Reading from database using SQL prepared statement
onRequestPermissionsResult (Fragment)
getSystemService (Context)
notifyDataSetChanged (ArrayAdapter)
Container (java.awt)
A generic Abstract Window Toolkit(AWT) container object is a component that can contain other AWT co
GridBagLayout (java.awt)
The GridBagLayout class is a flexible layout manager that aligns components vertically and horizonta
InputStreamReader (java.io)
A class for turning a byte stream into a character stream. Data read from the source input stream is
PriorityQueue (java.util)
A PriorityQueue holds elements on a priority heap, which orders the elements according to their natu
HttpServletRequest (javax.servlet.http)
Extends the javax.servlet.ServletRequest interface to provide request information for HTTP servlets.
JComboBox (javax.swing)
Top 12 Jupyter Notebook Extensions

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