TransactionSynchronizationManager TransactionSynchronizationAdapter

public class TransactionSynchronizer {

    private final static Logger logger = LoggerFactory.getLogger(TransactionSynchronizer.class);



    public static void afterCommit(final Runnable runnable) {

        if (TransactionSynchronizationManager.isActualTransactionActive()) {

            TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {

                @Override

                public void afterCommit() {

                    runnable.run();

                }

            });

        } else {

            //directly call

            runnable.run();

        }

    }



    @SuppressWarnings("unchecked")

    public static <T> Future<T> afterCommit(final Callable<T> callable) {

        final TransactionFuture<T> future = new TransactionFuture<>();

        if (TransactionSynchronizationManager.isActualTransactionActive()) {

            TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {

                @Override

                public void afterCommit() {

                    try {

                        future.put(callable.call());

                    } catch (Exception e) {

                        e.printStackTrace();

                    }

                }

            });

        } else {

            //directly call

            try {

                future.put(callable.call());

            } catch (Exception e) {

                future.cancel(true);

            }

        }

        return future;

    }



    /**

     * after commit or rollback

     */

    public static void afterCompletion(final Runnable runnable) {

        if (TransactionSynchronizationManager.isActualTransactionActive()) {

            TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {

                @Override

                public void afterCompletion(int status) {

                    runnable.run();

                }

            });

        } else {

            //directly call

            runnable.run();

        }

    }



    @SuppressWarnings("unchecked")

    public static <T> Future<T> afterCompletion(final Callable<T> callable) {

        final TransactionFuture<T> future = new TransactionFuture<>();

        if (TransactionSynchronizationManager.isActualTransactionActive()) {

            TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {

                @Override

                public void afterCompletion(int status) {

                    try {

                        future.put(callable.call());

                    } catch (Exception e) {

                        logger.error("error calling callable.", e);

                        future.cancel(true);

                    }

                }

            });

        } else {

            //directly call

            try {

                future.put(callable.call());

            } catch (Exception e) {

                logger.error("error calling callable.", e);

                future.cancel(true);

            }

        }

        return future;

    }

}