Using Spring Transaction Hooks with TransactionSynchronizationManager for Asynchronous Kafka Messaging

In this article, a senior architect introduces the use of Spring transaction hook functions to reliably send Kafka messages after a transaction commits, avoiding interference with the main business logic.

Case background: In a payment system, each account's fund flow must be archived; the requirement is to push flow information to Kafka, where a separate archiving system consumes and stores it with write permissions only.

The solution is to develop a secondary library (starter) that sends messages to Kafka, ensuring it works both with and without an active transaction, and provides a simple API.

Key considerations:

Use Spring Boot and provide a starter.

Implement Kafka producer directly, not using Spring's KafkaTemplate, to avoid conflicts.

Offer an easy-to-use API for integration.

Support transactional sending of messages without affecting the main business.

To achieve this, the TransactionSynchronizationManager is used. The code checks TransactionSynchronizationManager.isSynchronizationActive() to determine if a transaction is present. If not, it asynchronously sends the Kafka message. If a transaction exists, it registers a TransactionSynchronizationAdapter that overrides afterCompletion to send the message after the transaction commits.

Example code (simplified):

private final ExecutorService executor = Executors.newSingleThreadExecutor();

public void sendLog() {
    if (!TransactionSynchronizationManager.isSynchronizationActive()) {
        executor.submit(() -> {
            // send message to Kafka
        });
        return;
    }
    TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
        @Override
        public void afterCompletion(int status) {
            if (status == TransactionSynchronization.STATUS_COMMITTED) {
                executor.submit(() -> {
                    // send message to Kafka
                });
            }
        }
    });
}

The TransactionSynchronizationManager maintains a thread‑local set of synchronizations that is initialized when a transaction begins, allowing the above checks.

Finally, the article warns to avoid thread switching, as the synchronization relies on thread‑local variables.

Note: The article also contains promotional material for ChatGPT services and a community, which is unrelated to the technical content.