Leveraging Spring Transaction Hooks with TransactionSynchronizationManager for Asynchronous Kafka Messaging

The author, a senior architect, introduces a practical case where a payment system must archive each account's fund flow by publishing a Kafka message after the database transaction commits, ensuring data consistency and avoiding interference with the main business logic.

To meet the requirement, a lightweight second‑party library is designed as a Spring Boot starter that directly uses the Kafka producer API instead of Spring's KafkaTemplate, minimizing integration friction and providing a simple API for developers.

The core challenge is to determine whether a transaction is currently active and to trigger custom logic only after the transaction successfully commits. This is achieved by querying TransactionSynchronizationManager.isSynchronizationActive() and registering a TransactionSynchronizationAdapter via TransactionSynchronizationManager.registerSynchronization().

The following pseudocode demonstrates the solution:

private final ExecutorService executor = Executors.newSingleThreadExecutor();

public void sendLog() {
    // Check if a transaction is active
    if (!TransactionSynchronizationManager.isSynchronizationActive()) {
        // No transaction – send message asynchronously
        executor.submit(() -> {
            try {
                // send message to Kafka
            } catch (Exception e) {
                // log exception, notify developers
            }
        });
        return;
    }
    // Transaction is active – register a synchronization callback
    TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
        @Override
        public void afterCompletion(int status) {
            if (status == TransactionSynchronization.STATUS_COMMITTED) {
                // After commit, send message asynchronously
                executor.submit(() -> {
                    try {
                        // send message to Kafka
                    } catch (Exception e) {
                        // log exception, notify developers
                    }
                });
            }
        }
    });
}

The code relies on the static, thread‑local synchronizations field inside TransactionSynchronizationManager, which is populated when Spring's transaction manager calls initSynchronization() at transaction start. When the transaction ends, Spring iterates over the registered synchronizations and invokes their callbacks.

By using this approach, the library ensures that Kafka messages are only sent after the surrounding transaction has been committed, preserving data integrity while keeping the main business flow unaffected.

At the end of the article, the author adds promotional material for a ChatGPT‑focused community, private accounts, and various paid services, which are unrelated to the technical content but serve as marketing outreach.