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

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

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

origin: spring-projects/spring-framework

@Override
@Nullable
public final Object doInTransaction(TransactionStatus status) {
  doInTransactionWithoutResult(status);
  return null;
}
origin: spring-projects/spring-framework

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

  @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());
  }
});
origin: org.springframework/spring-tx

@Override
@Nullable
public final Object doInTransaction(TransactionStatus status) {
  doInTransactionWithoutResult(status);
  return null;
}
origin: spring-projects/spring-framework

  @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");
  }
});
origin: springframework/spring-dao

public final Object doInTransaction(TransactionStatus status) {
  doInTransactionWithoutResult(status);
  return null;
}
origin: spring-projects/spring-framework

  @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());
  }
});
origin: org.apache.servicemix.bundles/org.apache.servicemix.bundles.spring-tx

@Override
@Nullable
public final Object doInTransaction(TransactionStatus status) {
  doInTransactionWithoutResult(status);
  return null;
}
origin: spring-projects/spring-framework

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 {
origin: apache/servicemix-bundles

@Override
@Nullable
public final Object doInTransaction(TransactionStatus status) {
  doInTransactionWithoutResult(status);
  return null;
}
origin: spring-projects/spring-framework

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 {
origin: spring-projects/spring-framework

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

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

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

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

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

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

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

tt.execute(new TransactionCallbackWithoutResult() {
  @Override
  protected void doInTransactionWithoutResult(TransactionStatus status) {
origin: spring-projects/spring-framework

tt.execute(new TransactionCallbackWithoutResult() {
  @Override
  protected void doInTransactionWithoutResult(TransactionStatus status) {
org.springframework.transaction.supportTransactionCallbackWithoutResult

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