如何将一个操作“绑定到数据库事务上”

public class TransactionAwareCacheDecorator implements Cache {

    private final Cache targetCache;

    @Override

    public void put(final Object key, final Object value) {

        // 判断是否开启了事务

        if (TransactionSynchronizationManager.isSynchronizationActive()) {

            // 将操作注册到“afterCommit”阶段

            TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {

                @Override

                public void afterCommit() {

                    targetCache.put(key, value);

                }

            });

        }

        else {

            this.targetCache.put(key, value);

        }

    }

    // 省略其它方法

}

private static final ThreadLocal<Map<Object, Object>> resources =

        new NamedThreadLocal<Map<Object, Object>>("Transactional resources");

// 关注点：事务相关操作的回调模板

private static final ThreadLocal<Set<TransactionSynchronization>> synchronizations =

        new NamedThreadLocal<Set<TransactionSynchronization>>("Transaction synchronizations");

private static final ThreadLocal<String> currentTransactionName =

        new NamedThreadLocal<String>("Current transaction name");

private static final ThreadLocal<Boolean> currentTransactionReadOnly =

        new NamedThreadLocal<Boolean>("Current transaction read-only status");

private static final ThreadLocal<Integer> currentTransactionIsolationLevel =

        new NamedThreadLocal<Integer>("Current transaction isolation level");

private static final ThreadLocal<Boolean> actualTransactionActive =

        new NamedThreadLocal<Boolean>("Actual transaction active");

/**

 * Return if transaction synchronization is active for the current thread.

 * Can be called before register to avoid unnecessary instance creation.

 * @see #registerSynchronization

 */

public static boolean isSynchronizationActive() {

    return (synchronizations.get() != null);

}

/**

 * Register a new transaction synchronization for the current thread.

 * Typically called by resource management code.

 * <p>Note that synchronizations can implement the

 * {@link org.springframework.core.Ordered} interface.

 * They will be executed in an order according to their order value (if any).

 * @param synchronization the synchronization object to register

 * @throws IllegalStateException if transaction synchronization is not active

 * @see org.springframework.core.Ordered

 */

public static void registerSynchronization(TransactionSynchronization synchronization)

        throws IllegalStateException {

    Assert.notNull(synchronization, "TransactionSynchronization must not be null");

    if (!isSynchronizationActive()) {

        throw new IllegalStateException("Transaction synchronization is not active");

    }

    synchronizations.get().add(synchronization);

}

/**

 * Interface for transaction synchronization callbacks.

 * Supported by AbstractPlatformTransactionManager.

 *

 * <p>TransactionSynchronization implementations can implement the Ordered interface

 * to influence their execution order. A synchronization that does not implement the

 * Ordered interface is appended to the end of the synchronization chain.

 *

 * <p>System synchronizations performed by Spring itself use specific order values,

 * allowing for fine-grained interaction with their execution order (if necessary).

 *

 * @author Juergen Hoeller

 * @since 02.06.2003

 * @see TransactionSynchronizationManager

 * @see AbstractPlatformTransactionManager

 * @see org.springframework.jdbc.datasource.DataSourceUtils#CONNECTION_SYNCHRONIZATION_ORDER

 */

public interface TransactionSynchronization extends Flushable {

    /** Completion status in case of proper commit */

    int STATUS_COMMITTED = 0;

    /** Completion status in case of proper rollback */

    int STATUS_ROLLED_BACK = 1;

    /** Completion status in case of heuristic mixed completion or system errors */

    int STATUS_UNKNOWN = 2;

    /**

     * Suspend this synchronization.

     * Supposed to unbind resources from TransactionSynchronizationManager if managing any.

     * @see TransactionSynchronizationManager#unbindResource

     */

    void suspend();

    /**

     * Resume this synchronization.

     * Supposed to rebind resources to TransactionSynchronizationManager if managing any.

     * @see TransactionSynchronizationManager#bindResource

     */

    void resume();

    /**

     * Flush the underlying session to the datastore, if applicable:

     * for example, a Hibernate/JPA session.

     * @see org.springframework.transaction.TransactionStatus#flush()

     */

    @Override

    void flush();

    /**

     * Invoked before transaction commit (before "beforeCompletion").

     * Can e.g. flush transactional O/R Mapping sessions to the database.

     * <p>This callback does <i>not</i> mean that the transaction will actually be committed.

     * A rollback decision can still occur after this method has been called. This callback

     * is rather meant to perform work that‘s only relevant if a commit still has a chance

     * to happen, such as flushing SQL statements to the database.

     * <p>Note that exceptions will get propagated to the commit caller and cause a

     * rollback of the transaction.

     * @param readOnly whether the transaction is defined as read-only transaction

     * @throws RuntimeException in case of errors; will be <b>propagated to the caller</b>

     * (note: do not throw TransactionException subclasses here!)

     * @see #beforeCompletion

     */

    void beforeCommit(boolean readOnly);

    /**

     * Invoked before transaction commit/rollback.

     * Can perform resource cleanup <i>before</i> transaction completion.

     * <p>This method will be invoked after {@code beforeCommit}, even when

     * {@code beforeCommit} threw an exception. This callback allows for

     * closing resources before transaction completion, for any outcome.

     * @throws RuntimeException in case of errors; will be <b>logged but not propagated</b>

     * (note: do not throw TransactionException subclasses here!)

     * @see #beforeCommit

     * @see #afterCompletion

     */

    void beforeCompletion();

    /**

     * Invoked after transaction commit. Can perform further operations right

     * <i>after</i> the main transaction has <i>successfully</i> committed.

     * <p>Can e.g. commit further operations that are supposed to follow on a successful

     * commit of the main transaction, like confirmation messages or emails.

     * <p><b>NOTE:</b> The transaction will have been committed already, but the

     * transactional resources might still be active and accessible. As a consequence,

     * any data access code triggered at this point will still "participate" in the

     * original transaction, allowing to perform some cleanup (with no commit following

     * anymore!), unless it explicitly declares that it needs to run in a separate

     * transaction. Hence: <b>Use {@code PROPAGATION_REQUIRES_NEW} for any

     * transactional operation that is called from here.</b>

     * @throws RuntimeException in case of errors; will be <b>propagated to the caller</b>

     * (note: do not throw TransactionException subclasses here!)

     */

    void afterCommit();

    /**

     * Invoked after transaction commit/rollback.

     * Can perform resource cleanup <i>after</i> transaction completion.

     * <p><b>NOTE:</b> The transaction will have been committed or rolled back already,

     * but the transactional resources might still be active and accessible. As a

     * consequence, any data access code triggered at this point will still "participate"

     * in the original transaction, allowing to perform some cleanup (with no commit

     * following anymore!), unless it explicitly declares that it needs to run in a

     * separate transaction. Hence: <b>Use {@code PROPAGATION_REQUIRES_NEW}

     * for any transactional operation that is called from here.</b>

     * @param status completion status according to the {@code STATUS_*} constants

     * @throws RuntimeException in case of errors; will be <b>logged but not propagated</b>

     * (note: do not throw TransactionException subclasses here!)

     * @see #STATUS_COMMITTED

     * @see #STATUS_ROLLED_BACK

     * @see #STATUS_UNKNOWN

     * @see #beforeCompletion

     */

    void afterCompletion(int status);

}

public abstract class TransactionSynchronizationAdapter implements TransactionSynchronization, Ordered {

    @Override

    public int getOrder() {

        return Ordered.LOWEST_PRECEDENCE;

    }

    @Override

    public void suspend() {

    }

    @Override

    public void resume() {

    }

    @Override

    public void flush() {

    }

    @Override

    public void beforeCommit(boolean readOnly) {

    }

    @Override

    public void beforeCompletion() {

    }

    @Override

    public void afterCommit() {

    }

    @Override

    public void afterCompletion(int status) {

    }

}