/** * Execute given operation within a transaction and return a result. A {@link Transaction} reference is provided to * perform <code>commit</code> and <code>rollback</code> operations. * @param <R> Operation result type * @param operation Operation to execute (not null) * @return The operation result */ default <R> R withTransaction(TransactionalOperation<R> operation) { return withTransaction(operation, TransactionConfiguration.getDefault()); }
/** * Execute given operation within a transaction. A {@link Transaction} reference is provided to perform * <code>commit</code> and <code>rollback</code> operations. * @param operation Operation to execute (not null) */ default void withTransaction(TransactionalInvocation operation) { withTransaction((TransactionalOperation<?>) operation); }
@Override default Void execute(Transaction transaction) { executeInTransaction(transaction); return null; }
public void transactional() { // tag::transactional[] final Datastore datastore = getDatastore(); // build or obtain a JDBC Datastore datastore.requireTransactional().withTransaction(tx -> { // <1> PropertyBox value = buildPropertyBoxValue(); datastore.save(TARGET, value); tx.commit(); // <2> }); OperationResult result = datastore.requireTransactional().withTransaction(tx -> { // <3> PropertyBox value = buildPropertyBoxValue(); return datastore.save(TARGET, value); }, TransactionConfiguration.withAutoCommit()); // <4> // end::transactional[] }
@Override public void start() throws TransactionException { throw new IllegalTransactionStatusException("A delegated transaction should not be started"); }
public void transactional4() throws IOException { // tag::transactional4[] getDatastore().requireTransactional().withTransaction(tx -> { // ... }, TransactionConfiguration.withAutoCommit()); // <1> // end::transactional4[] }
/** * Execute given operation within a transaction and return a result. An {@link ReactiveTransaction} reference is * provided to perform <code>commit</code> and <code>rollback</code> operations. * @param <R> Operation result type * @param operation Operation to execute (not null) * @return A {@link Flux} which can be used to handle the asynchronous operation outcome and the operation results */ default <R> Flux<R> withTransaction(ReactiveTransactionalOperation<R> operation) { return withTransaction(operation, TransactionConfiguration.getDefault()); }
public void transactional3() throws IOException { // tag::transactional3[] getDatastore().requireTransactional().withTransaction(tx -> { tx.setRollbackOnly(); // <1> }); // end::transactional3[] }
public void transactional5() throws IOException { // tag::transactional5[] getDatastore().requireTransactional().withTransaction(tx -> { // ... }, TransactionConfiguration.create(false, false)); // <1> // end::transactional5[] }
@Override public boolean isRollbackOnly() { return getDelegate().isRollbackOnly(); }
@Override public boolean isCompleted() { return getDelegate().isCompleted(); }
@Override public void setRollbackOnly() { getDelegate().setRollbackOnly(); }
@Override public boolean isActive() { return getDelegate().isActive(); }
public void transactional() { // tag::transactional[] final Datastore datastore = getJpaDatastore(); // build or obtain a JPA Datastore datastore.requireTransactional().withTransaction(tx -> { // <1> PropertyBox value = buildPropertyBoxValue(); datastore.save(TARGET, value); tx.commit(); // <2> }); OperationResult result = datastore.requireTransactional().withTransaction(tx -> { // <3> PropertyBox value = buildPropertyBoxValue(); return datastore.save(TARGET, value); }, TransactionConfiguration.withAutoCommit()); // <4> // end::transactional[] }
@Override public CompletionStage<Void> end() throws TransactionException { throw new IllegalTransactionStatusException("A delegated transaction should not be ended"); }
/** * Execute given operation within a transaction and return a result. An {@link AsyncTransaction} reference is * provided to perform <code>commit</code> and <code>rollback</code> operations. * @param <R> Operation result type * @param operation Operation to execute (not null) * @return A {@link CompletionStage} which can be used to handle the asynchronous operation outcome and the * operation result */ default <R> CompletionStage<R> withTransaction(AsyncTransactionalOperation<R> operation) { return withTransaction(operation, TransactionConfiguration.getDefault()); }
/** * Execute given operation within a transaction. A {@link Transaction} reference is provided to perform * <code>commit</code> and <code>rollback</code> operations. * @param operation Operation to execute (not null) * @param transactionConfiguration Transaction configuration */ default void withTransaction(TransactionalInvocation operation, TransactionConfiguration transactionConfiguration) { withTransaction((TransactionalOperation<?>) operation, transactionConfiguration); }
@Override public void start() throws TransactionException { throw new IllegalTransactionStatusException("A delegated transaction should not be started"); }
@Override public void end() throws TransactionException { throw new IllegalTransactionStatusException("A delegated transaction should not be ended"); }
@Override public void setRollbackOnly() { if (isCompleted()) { throw new IllegalTransactionStatusException( "Cannot mark the transaction as rollback-only: the transaction is already completed"); } this.rollbackOnly = true; }