Làm chủ giao dịch trong Spring: Cam kết, Hoàn tác, Lặp lại

Bạn đặt @Transactional lên một method, gọi nó từ method khác trong cùng class, và transaction biến mất — không lỗi, không cảnh báo. Đây không phải bug hiếm: đó là hệ quả của việc Spring dùng proxy. Cùng cơ chế làm @Async im lặng chạy đồng bộ. Hiểu proxy, propagation và ranh giới transaction giúp bạn tránh những lỗi dữ liệu chỉ xuất hiện khi tải cao.

Cập nhật 2026

  • Spring Framework 7.0.10 / Boot 4.1.2 / Hibernate 7.4.15.Final; chỉ còn jakarta.persistence/jakarta.transaction, javax.persistence/javax.transaction đã bị bỏ.
  • @Transactional vẫn proxy-based; self-invocation vẫn là lỗi im lặng phổ biến nhất, cùng gốc rễ với @Async.
  • readOnly = true đặt Hibernate FlushMode.MANUAL; write không được flush lúc commit và mất im lặng.
  • Testcontainers 2.0.5 đổi module sang testcontainers-*; PostgreSQLContainer ở org.testcontainers.postgresql.

@Transactional là proxy, không phải phép thuật

Khi context khởi động, Spring bọc bean có @Transactional bằng proxy CGLIB và gắn TransactionInterceptor. Proxy mở transaction trước khi gọi method thật, commit hoặc rollback sau khi method trả về; code của bạn không gọi begin() hay commit().

Hệ quả: chỉ lời gọi đi qua proxy mới được bọc. Khi method A gọi this.methodB(), lời gọi không rời khỏi object, nên @Transactional trên B bị bỏ qua hoàn toàn. Đây đúng là lý do @Async cũng "không chạy" khi self-invocation: cả hai đều dựa trên AOP proxy.

Cách sửa: tách method sang bean khác (sạch nhất, và thường lộ ra ranh giới nghiệp vụ đang đặt sai), dùng TransactionTemplate, hoặc inject chính bean qua @Lazy/ObjectProvider rồi gọi qua reference đó.

private và final cũng không dùng được: CGLIB không override được final, còn Spring chỉ xét method public khi dùng proxy. @Transactional trên private gần như chưa từng có tác dụng.

Ranh giới transaction thuộc về service, không phải controller

Đặt ở controller là sai: transaction bao cả bind dữ liệu, validation, gọi service và render response. Nó sống lâu hơn nghiệp vụ, giữ connection khi serialize JSON, và che giấu lazy loading xảy ra ngoài service.

Ranh giới đúng là một use case — method public của service, nơi nghiệp vụ bắt đầu và kết thúc. Repository chỉ là hạ tầng; đừng đặt transaction ở đó cho nghiệp vụ nhiều bước.

Vòng lặp repository cũng không phải ranh giới. for (Order o : orders) repo.save(o) ngoài transaction tạo một transaction và một connection cho mỗi phần tử; phần tử thứ ba lỗi thì hai phần tử trước đã commit. Đưa cả vòng lặp vào một method service transactional, bật batch Hibernate, flush/clear theo lô.

Propagation: bảy mức, chọn theo ranh giới

Mức Hành vi Dùng khi
REQUIRED Tham gia transaction hiện có; tạo mới nếu chưa có Mặc định cho use case nghiệp vụ
REQUIRES_NEW Luôn tạo transaction mới, suspend transaction ngoài Audit phải sống sót sau rollback; coi chừng connection pool
NESTED Savepoint trong transaction hiện có; không có thì như REQUIRED Rollback một phần, chỉ khi hiểu giới hạn của JPA
SUPPORTS Dùng transaction nếu có, không thì chạy không transaction Method đọc dùng chung hai ngữ cảnh
NOT_SUPPORTED Suspend transaction hiện có, chạy không transaction Việc không được phép nằm trong transaction
MANDATORY Bắt buộc có transaction, nếu không ném exception Chỉ gọi từ use case transactional
NEVER Bắt buộc không có transaction, nếu có ném exception Chốt chặn để không gọi nhầm

REQUIRED đúng cho hầu hết use case. REQUIRES_NEW tạo transaction vật lý mới, suspend transaction ngoài và lấy thêm connection; hữu ích cho audit phải sống sót sau rollback, nhưng mỗi request đang giữ một connection lại xin cái thứ hai.

NESTED dùng savepoint trên cùng connection. Với JPA/Hibernate, savepoint chỉ áp dụng cho JDBC connection, không rollback persistence context: entity managed vẫn dirty sau rollback, và nestedTransactionAllowed mặc định là false. Cần rollback một phần thì tách bean với REQUIRES_NEW.

Isolation: mức nào chặn được gì

Mức Chặn Vẫn có thể xảy ra
READ_UNCOMMITTED Không chặn gì Dirty, non-repeatable, phantom
READ_COMMITTED Dirty read Non-repeatable, phantom
REPEATABLE_READ Dirty, non-repeatable Phantom theo chuẩn SQL; InnoDB chặn phantom cho consistent read
SERIALIZABLE Cả ba hiện tượng Chậm, deadlock hoặc serialization failure; cần retry

Dirty read là thấy dữ liệu chưa commit; non-repeatable read là đọc cùng row hai lần ra hai giá trị; phantom read là cùng query ra tập row khác. Mặc định phụ thuộc database: PostgreSQL, Oracle và SQL Server dùng READ_COMMITTED; MySQL InnoDB dùng REPEATABLE_READ.

Spring gửi isolation xuống driver như gợi ý, và nhiều driver bỏ qua. Không đổi được isolation giữa transaction, nên đặt ở lớp ngoài cùng. SERIALIZABLE cần retry lỗi serialization (PostgreSQL mã 40001); isolation không giải quyết lost update — dùng @Version hoặc pessimistic lock.

Rollback: runtime mặc định, checked thì không

Spring rollback khi exception là RuntimeException hoặc Error. Checked exception không rollback: transaction vẫn commit những gì đã ghi trước khi exception được ném.

// Checked exception: transaction VAN COMMIT neu khong khai bao rollbackFor
@Transactional
public Invoice issue(Order order) throws PaymentDeclinedException {
    Invoice invoice = invoiceRepository.save(buildInvoice(order));
    paymentRepository.save(buildPayment(order));
    if (!order.isPayable()) {
        throw new PaymentDeclinedException(order.id());
    }
    return invoice;
}

// Sua: khai bao ro rang
@Transactional(rollbackFor = PaymentDeclinedException.class)
public Invoice issueSafely(Order order) throws PaymentDeclinedException {
    Invoice invoice = invoiceRepository.save(buildInvoice(order));
    paymentRepository.save(buildPayment(order));
    if (!order.isPayable()) {
        throw new PaymentDeclinedException(order.id());
    }
    return invoice;
}

rollbackFor thêm exception checked vào danh sách rollback; noRollbackFor loại trừ. Đừng dùng checked exception cho lỗi nghiệp vụ nếu không có lý do; nếu buộc phải dùng, khai báo rollbackFor ở đúng method ngoài cùng.

UnexpectedRollbackException. Khi method trong REQUIRED ném exception, transaction ngoài bị đánh dấu rollback-only. Bắt exception rồi tiếp tục, lúc commit Spring vẫn ném UnexpectedRollbackException. Đừng giả vờ mọi thứ ổn.

readOnly, timeout và transaction manager

readOnly = true

Với JPA/Hibernate, readOnly = true đặt FlushMode.MANUAL và Session.setDefaultReadOnly(true). Hibernate không giữ snapshot dirty và không flush trước commit, tiết kiệm bộ nhớ và CPU khi đọc nhiều. Với JDBC thuần, DataSourceTransactionManager đặt connection read-only, thuận lợi cho routing sang replica qua LazyConnectionDataSourceProxy.

Nhưng read-only không phải hàng rào an toàn: gọi save() trong method read-only thì insert/update có thể không được flush và mất im lặng. Đừng đặt @Transactional(readOnly = true) ở cấp class rồi quên override method ghi.

timeout

@Transactional(timeout = 5) tính bằng giây và chỉ áp dụng khi Spring tạo transaction mới; method REQUIRED tham gia transaction ngoài dùng timeout của transaction ngoài. Hibernate biến nó thành statement timeout của JDBC, không phải đồng hồ trên toàn method: 10 query, mỗi query dưới 5 giây, vẫn có thể chạy 50 giây. Timeout không hủy HTTP call đang chờ — dùng Resilience4j TimeLimiter.

Chọn transaction manager

Manager Dùng cho Lưu ý
JpaTransactionManager JPA/Hibernate, entity và repository Mặc định với JPA; expose EntityManager cho JDBC trong cùng transaction
DataSourceTransactionManager JDBC thuần, JdbcClient, Spring Data JDBC Không có persistence context; mỗi thao tác là SQL
JtaTransactionManager Nhiều resource/XA: hai database, database và JMS Chậm, cần driver XA; ưu tiên outbox hoặc saga trước khi dùng

Boot tự cấu hình khi chỉ có một DataSource hoặc một EntityManagerFactory. Nhiều manager thì dùng qualifier @Transactional("ordersTx") hoặc @Primary; hai DataSource không nằm chung transaction nếu không có XA.

Service chạy được: audit log bằng REQUIRES_NEW

Bài toán: audit cho giao dịch chuyển tiền thất bại phải còn trong database dù transaction chính rollback. Tách audit sang bean riêng với REQUIRES_NEW, vì self-invocation sẽ bỏ qua proxy.

// File: src/main/java/com/evotek/bank/Account.java
// imports: jakarta.persistence.*, java.math.BigDecimal
@Entity
public class Account {

    @Id
    private Long id;

    @Column(precision = 19, scale = 2)
    private BigDecimal balance;

    protected Account() { }

    public Account(Long id, BigDecimal balance) {
        this.id = id;
        this.balance = balance;
    }

    public void debit(BigDecimal amount) {
        if (balance.compareTo(amount) < 0) {
            throw new InsufficientBalanceException(id);
        }
        this.balance = this.balance.subtract(amount);
    }

    public void credit(BigDecimal amount) {
        this.balance = this.balance.add(amount);
    }

    public BigDecimal getBalance() { return balance; }
}

class InsufficientBalanceException extends RuntimeException {
    InsufficientBalanceException(Long accountId) {
        super("Insufficient balance: " + accountId);
    }
}

// File: src/main/java/com/evotek/bank/AuditLog.java
@Entity
public class AuditLog {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private Long fromAccountId;
    private Long toAccountId;
    private BigDecimal amount;
    private String outcome;

    protected AuditLog() { }

    public AuditLog(Long fromAccountId, Long toAccountId,
                    BigDecimal amount, String outcome) {
        this.fromAccountId = fromAccountId;
        this.toAccountId = toAccountId;
        this.amount = amount;
        this.outcome = outcome;
    }

    public String getOutcome() { return outcome; }
}

// File: src/main/java/com/evotek/bank/AccountRepository.java
// imports: org.springframework.data.jpa.repository.*, org.springframework.data.repository.query.Param,
//          java.util.Optional
public interface AccountRepository extends JpaRepository<Account, Long> {

    @Lock(LockModeType.PESSIMISTIC_WRITE)
    @Query("select a from Account a where a.id = :id")
    Optional<Account> findForUpdate(@Param("id") Long id);
}

// File: src/main/java/com/evotek/bank/AuditLogRepository.java
public interface AuditLogRepository extends JpaRepository<AuditLog, Long> { }
// File: src/main/java/com/evotek/bank/AuditLogService.java
// imports: org.springframework.stereotype.Service,
//          org.springframework.transaction.annotation.{Transactional, Propagation}, java.math.BigDecimal
@Service
public class AuditLogService {

    private final AuditLogRepository auditLogs;

    public AuditLogService(AuditLogRepository auditLogs) {
        this.auditLogs = auditLogs;
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void recordFailure(Long fromId, Long toId, BigDecimal amount) {
        auditLogs.save(new AuditLog(fromId, toId, amount, "FAILED"));
    }
}

// File: src/main/java/com/evotek/bank/TransferService.java
// imports: org.springframework.stereotype.Service,
//          org.springframework.transaction.annotation.Transactional, java.math.BigDecimal
@Service
public class TransferService {

    private final AccountRepository accounts;
    private final AuditLogService audit;

    public TransferService(AccountRepository accounts, AuditLogService audit) {
        this.accounts = accounts;
        this.audit = audit;
    }

    @Transactional
    public void transfer(Long fromId, Long toId, BigDecimal amount) {
        Account from = accounts.findForUpdate(fromId)
                .orElseThrow(() -> new IllegalArgumentException("Unknown account " + fromId));
        Account to = accounts.findForUpdate(toId)
                .orElseThrow(() -> new IllegalArgumentException("Unknown account " + toId));

        try {
            from.debit(amount);
            to.credit(amount);
        } catch (RuntimeException ex) {
            // REQUIRES_NEW: audit commit doc lap, song sot sau rollback
            audit.recordFailure(fromId, toId, amount);
            throw ex; // de proxy rollback transaction chinh
        }
        // Khong can save(): dirty checking flush khi commit
    }
}

Hai chi tiết production: khóa hai account theo thứ tự id tăng dần để tránh deadlock, và không ghi audit thành công bằng REQUIRES_NEW trong transaction chính — nó commit trước, nên nếu commit sau thất bại, audit nói "OK" trong khi tiền đã rollback. Dùng @TransactionalEventListener(phase = AFTER_COMMIT) hoặc outbox. Method audit phải cực ngắn, không gọi mạng: nó giữ connection ngoài rồi xin thêm connection thứ hai.

Kiểm chứng rollback bằng @SpringBootTest + Testcontainers

Test dùng PostgreSQL thật, không dùng H2, và không đánh dấu @Transactional trên test class — nếu có, transaction rollback sau test và bạn không chứng minh được rollback thật. Dependency: org.testcontainers:testcontainers-postgresql và :testcontainers-junit-jupiter bản 2.0.5, cộng spring-boot-testcontainers.

// File: src/test/java/com/evotek/bank/TransferServiceIT.java
// imports: org.junit.jupiter.api.Test, org.springframework.boot.test.context.SpringBootTest,
//          org.springframework.boot.testcontainers.service.connection.ServiceConnection,
//          org.testcontainers.junit.jupiter.*, org.testcontainers.postgresql.PostgreSQLContainer,
//          org.assertj.core.api.Assertions.*, java.math.BigDecimal, java.util.List
@SpringBootTest
@Testcontainers
class TransferServiceIT {

    @Container
    @ServiceConnection
    static PostgreSQLContainer<?> postgres =
            new PostgreSQLContainer<>("postgres:17-alpine");

    @Autowired TransferService transferService;
    @Autowired AccountRepository accounts;
    @Autowired AuditLogRepository auditLogs;

    @Test
    void rollbackKeepsBalancesAndFailureAudit() {
        accounts.saveAll(List.of(
                new Account(1L, new BigDecimal("100.00")),
                new Account(2L, new BigDecimal("0.00"))));

        assertThatThrownBy(() ->
                transferService.transfer(1L, 2L, new BigDecimal("150.00")))
                .isInstanceOf(InsufficientBalanceException.class);

        assertThat(accounts.findById(1L).orElseThrow().getBalance())
                .isEqualByComparingTo("100.00");
        assertThat(accounts.findById(2L).orElseThrow().getBalance())
                .isEqualByComparingTo("0.00");
        assertThat(auditLogs.findAll())
                .extracting(AuditLog::getOutcome)
                .containsExactly("FAILED");
    }
}

Ba assertion kiểm ba điều: transaction chính rollback (số dư không đổi), audit REQUIRES_NEW đã commit, và không có bản ghi audit thứ hai. Nếu dùng @DataJpaTest, hãy nhớ nó transactional mặc định; muốn test propagation thì phải tắt transaction của test hoặc chuyển sang @SpringBootTest.

Pitfalls thường gặp

Pitfall Triệu chứng Cách sửa
Bắt exception trong transaction rồi tiếp tục Commit phần đã ghi, hoặc UnexpectedRollbackException Để exception nổi ra proxy; nếu phải bắt, đánh dấu rollback-only
Checked exception không có rollbackFor Commit dù nghiệp vụ thất bại Khai báo rollbackFor ở method ngoài cùng, hoặc đổi sang unchecked
@Transactional trên private/final hoặc self-invocation Không có transaction, không log, không cảnh báo Tách bean; chỉ đặt trên public method
Gọi HTTP hoặc Kafka trong transaction Connection bị giữ khi chờ mạng, timeout dây chuyền Chạy sau commit qua @TransactionalEventListener(AFTER_COMMIT) hoặc outbox
Transaction dài: batch lớn, report Giữ connection, khóa row, pool cạn Chia lô, flush/clear, đặt timeout, đẩy việc nặng ra ngoài
Lazy loading sau khi transaction kết thúc LazyInitializationException, hoặc OSIV giữ connection đến lúc render Fetch join hoặc DTO trong transaction; tắt spring.jpa.open-in-view
REQUIRES_NEW lồng nhau Mỗi request giữ hai connection; pool starvation, self-deadlock Chỉ dùng cho write nhỏ ở bảng khác; cân nhắc async hoặc outbox
readOnly = true nhưng có ghi Dữ liệu mất im lặng Tách method ghi; không đặt readOnly ở cấp class
Test có @Transactional Rollback không xảy ra, lỗi flush bị che Dùng @SpringBootTest không transactional; assert bằng transaction mới

2026: virtual threads không làm transaction rẻ đi

spring.threads.virtual.enabled=true giúp thread HTTP rẻ hơn, nhưng JDBC vẫn blocking và mỗi transaction vẫn cần một connection vật lý. Nếu pool Hikari là 10, bạn có 10 transaction đồng thời, không phải 10.000 — virtual thread chỉ làm nhiều request cùng xếp hàng ở pool hơn. Hãy đo hikaricp.connections.active, đặt maximum-pool-size theo database, và dùng bulkhead hoặc semaphore cho endpoint nặng.

Cũng trong 2026: không còn javax.persistence hay javax.transaction. Code cũ phải đổi sang jakarta.persistence; annotation transaction nên dùng org.springframework.transaction.annotation.Transactional để có đủ propagation, isolation, rollbackFor và timeout.

Checklist trước khi merge

  • Mỗi use case có đúng một method public transactional ở service; controller và repository không có annotation.
  • Không có this.methodTransactional(); mọi method @Transactional đều public và không final.
  • Checked exception nghiệp vụ có rollbackFor, hoặc đã đổi thành unchecked.
  • Có integration test chứng minh rollback và một test chứng minh audit REQUIRES_NEW sống sót.

Nhìn sang 2027

Spring Boot 4.2.0-RC2 và Framework 7.1.0-RC2 đang preview, chưa GA; transaction core không đổi lớn. Điều đáng theo dõi là tích hợp virtual thread sâu hơn và retry/observability của Framework 7. Java 27 là feature release; LTS tiếp theo là Java 29 (2027).

Bài tiếp theo