Doanh nghiệpEnterprise

Unit of Workaka Persistence Context (JPA)

Ghi lại mọi thay đổi trong một nghiệp vụ rồi commit tất cả cùng lúc — hoặc không gì cả.Track every change in a business operation, then commit them all at once — or nothing at all.

Độ khóDifficulty: VừaMedium
Mức phổ biếnUsage: Mức phổ biếnUsage 4/5
Thời gian đọcReading time: ~9 phút đọc~9 min read

Thảo luậnDiscussion

Ví dụ đời thườngReal-life analogy

Đi siêu thị, bạn bỏ đồ vào giỏ, bỏ ra, đổi món khác thoải mái — kho của siêu thị chưa hề bị trừ. Chỉ khi ra quầy thanh toán, mọi thứ trong giỏ được tính tiền MỘT lần. Thẻ bị từ chối? Cả giỏ trả lại kệ, không có chuyện thanh toán được nửa giỏ. Cái giỏ chính là Unit of Work.At the supermarket you put items into your basket, take some out, swap others — the store's stock hasn't changed yet. Only at the checkout is everything in the basket paid for in ONE go. Card declined? The whole basket goes back to the shelves; you never pay for half of it. The basket is the Unit of Work.

Vấn đề và giải phápProblem and solution

Không có patternWithout the pattern

Chuyển 500k từ ví A sang ví B gồm: trừ A, cộng B, ghi sổ cái. Nếu mỗi bước tự gọi save() và commit riêng, server sập giữa chừng là tiền 'bốc hơi' — A đã bị trừ nhưng B chưa được cộng. Code còn phải tự nhớ object nào đã sửa để UPDATE, object nào mới để INSERT, và dễ ghi một dòng hai lần.Transferring 500k from wallet A to wallet B means: debit A, credit B, write a ledger entry. If each step calls save() and commits on its own, a crash midway makes money 'vanish' — A is debited but B never credited. The code also has to remember which objects changed (UPDATE) and which are new (INSERT), and can easily write a row twice.

Với Unit of WorkWith Unit of Work

Unit of Work theo dõi các object được đọc, sửa, tạo mới hoặc xoá trong một nghiệp vụ, rồi khi commit sẽ ghi tất cả xuống DB trong MỘT transaction theo đúng thứ tự. Trong JPA, persistence context (EntityManager) chính là Unit of Work: @Transactional mở nó, dirty checking tự phát hiện field bị sửa và flush lúc commit. Go không có ORM làm sẵn, nên ta viết hàm WithTx(ctx, fn) bọc *sql.Tx và đưa các repository dùng chung transaction đó.A Unit of Work tracks objects that are read, modified, created or deleted during a business operation, and on commit writes them all to the DB in ONE transaction, in the right order. In JPA the persistence context (EntityManager) IS the Unit of Work: @Transactional opens it, dirty checking detects modified fields and flushes at commit. Go has no ORM doing this for you, so we write a WithTx(ctx, fn) helper that wraps *sql.Tx and hands out repositories sharing that transaction.

Thành phần tham giaParticipants

Unit of Work: Theo dõi thay đổi, quyết định commit hay rollback (EntityManager, hàm WithTx).Tracks changes and decides commit or rollback (EntityManager, a WithTx function).
Repositories: Đọc/ghi aggregate, tất cả dùng chung một transaction của Unit of Work.Load/save aggregates, all sharing the Unit of Work's transaction.
Entities: Object được theo dõi trạng thái: new, clean, dirty, removed.Objects whose state is tracked: new, clean, dirty, removed.
Client (Service): Định nghĩa ranh giới: bắt đầu và kết thúc một đơn vị công việc.Defines the boundary: where one unit of work starts and ends.

Sơ đồ và luồng thực thiDiagram and execution flow

Dùng Tự chạy hoặc phím mũi tên để đi qua từng bước gọi giữa các object. Console hiển thị output tương ứng của chương trình.Use Autoplay or the arrow keys to step through each call between objects. The console shows the matching program output.

1Gọi transfer(): proxy @Transactional mở transaction và một persistence context trống.transfer() is called: the @Transactional proxy opens a transaction and an empty persistence context.

← →

console

1BEGIN

implementsimplementsextendsextendsgọi / dùngcalls / usestạo racreatesgửi qua channelsends via channel1thứ tự chạy (bấm để nhảy bước)execution order (click to jump)

Code: Java Spring Boot ⇄ GoCode: Java Spring Boot ⇄ Go

Cùng một bài toán, hai ngôn ngữ. Rê chuột hoặc focus vào chú thích (số màu cam) để làm nổi bật dòng code tương ứng.Same problem, two languages. Hover or focus an annotation (orange number) to highlight its line.

JavaSpring Boot 3 · Java 21Spring Boot 3 · Java 21

package com.pay.wallet;

import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Version;

@Entity
public class Wallet {
    @Id
    private String id;

    private long balance; // VND

    @Version1
    private long version; // optimistic locking

    protected Wallet() {}

    public void debit(long amount) {
        if (amount <= 0) throw new IllegalArgumentException("amount must be > 0");
        if (balance < amount) throw new InsufficientFundsException(id, balance, amount);
        balance -= amount;2
    }

    public void credit(long amount) {
        if (amount <= 0) throw new IllegalArgumentException("amount must be > 0");
        balance += amount;
    }

    public long getBalance() { return balance; }
}

GoGo 1.23 · thư viện chuẩnGo 1.23 · standard library

package store

import (
	"context"
	"database/sql"
	"fmt"
)

// Tx is the unit of work: every repository inside shares ONE *sql.Tx.
type Tx struct {1
	Wallets *WalletRepo
	Ledger  *LedgerRepo
}

type Store struct{ db *sql.DB }

func New(db *sql.DB) *Store { return &Store{db: db} }

// WithTx commits if fn returns nil; otherwise (error or panic) it rolls back.
func (s *Store) WithTx(ctx context.Context, fn func(tx Tx) error) (err error) {2
	sqlTx, err := s.db.BeginTx(ctx, nil)
	if err != nil {
		return fmt.Errorf("begin: %w", err)
	}
	defer func() {
		if p := recover(); p != nil {3
			_ = sqlTx.Rollback()
			panic(p) // re-panic after cleaning up
		}
		if err != nil {
			_ = sqlTx.Rollback()
		}
	}()

	tx := Tx{Wallets: &WalletRepo{q: sqlTx}, Ledger: &LedgerRepo{q: sqlTx}}
	if err = fn(tx); err != nil {
		return err
	}
	return sqlTx.Commit()4
}

Khác biệt chính giữa Java và GoKey differences between Java and Go

01JPA có Unit of Work 'xịn': identity map, snapshot, dirty checking, tự sắp thứ tự SQL khi flush. Go với database/sql chỉ có transaction — bạn tự gọi UPDATE/INSERT tường minh.JPA has a 'full' Unit of Work: identity map, snapshots, dirty checking, SQL ordering at flush. Go with database/sql only has a transaction — you issue UPDATE/INSERT explicitly.
02Ranh giới: Spring dùng @Transactional (proxy) và gắn transaction vào thread. Go truyền closure vào WithTx(ctx, fn) và đưa repository gắn với tx qua tham số.Boundary: Spring uses @Transactional (a proxy) and binds the transaction to the thread. Go passes a closure to WithTx(ctx, fn) and hands transaction-bound repositories in as parameters.
03Rollback: Spring rollback khi có RuntimeException (checked exception mặc định KHÔNG rollback trừ khi khai báo rollbackFor). Go rollback khi fn trả error hoặc panic — quy tắc đơn giản hơn.Rollback: Spring rolls back on RuntimeException (checked exceptions do NOT roll back by default unless you set rollbackFor). Go rolls back when fn returns an error or panics — a simpler rule.
04Xung đột ghi: JPA có @Version (optimistic locking) gần như miễn phí. Trong Go bạn tự chọn: SELECT ... FOR UPDATE, hoặc cột version với UPDATE ... WHERE version = $n và kiểm RowsAffected.Write conflicts: JPA gives you @Version (optimistic locking) almost for free. In Go you choose yourself: SELECT ... FOR UPDATE, or a version column with UPDATE ... WHERE version = $n and checking RowsAffected.

Ứng dụng thực tếReal-world usage

Hibernate Session / JPA EntityManagerHibernate Session / JPA EntityManager
Persistence context là cài đặt Unit of Work kinh điển, đúng như Martin Fowler mô tả trong PoEAA.The persistence context is the textbook Unit of Work implementation, exactly as Martin Fowler describes in PoEAA.
TransactionTemplate của SpringSpring TransactionTemplate
transactionTemplate.execute(status -> {...}) — phiên bản lập trình của @Transactional, rất giống WithTx của Go.transactionTemplate.execute(status -> {...}) — the programmatic version of @Transactional, very close to Go's WithTx.
pgx.BeginFunc, sqlc Queries.WithTx, GORM db.Transactionpgx.BeginFunc, sqlc Queries.WithTx, GORM db.Transaction
Hệ sinh thái Go đều chọn cùng một hình dạng: truyền một closure, trả nil thì commit, trả error thì rollback.The Go ecosystem converges on one shape: pass a closure; nil commits, an error rolls back.
Ví điện tử, chuyển khoản ngân hàngE-wallets and bank transfers
Trừ ví, cộng ví, ghi sổ cái, ghi outbox — mọi thứ phải nằm trong một đơn vị công việc nguyên tử.Debit, credit, ledger entry, outbox row — everything must be in one atomic unit of work.

Khi nào dùng và khi nào khôngWhen to use it, and when not

Nên dùng khiUse it when

Một nghiệp vụ ghi nhiều bảng/aggregate và phải nguyên tử (tiền, tồn kho, đơn hàng).One operation writes several tables/aggregates and must be atomic (money, stock, orders).
Muốn repository không tự commit, để tầng service quyết định ranh giới.You want repositories that never commit on their own, so the service decides the boundary.
Cần gom nhiều thay đổi rồi ghi một lần để giảm round-trip tới DB.You want to batch many changes and write once to cut DB round-trips.

Không nên dùng khiAvoid it when

Thao tác trải qua nhiều service/database khác nhau — một transaction DB không bao được, hãy dùng Saga hoặc Transactional Outbox.Operations spanning several services/databases — one DB transaction can't cover them; use a Saga or Transactional Outbox.
Transaction dài chờ người dùng hoặc gọi HTTP bên ngoài — giữ khoá quá lâu, giết hiệu năng.Long transactions waiting on users or external HTTP calls — they hold locks too long and kill throughput.

Ưu điểmPros

Tất cả hoặc không gì cả: không còn dữ liệu nửa vời.All or nothing: no more half-written data.
Repository đơn giản, không lo commit; service nắm ranh giới rõ ràng.Simple repositories that never commit; the service owns a clear boundary.
JPA: tự phát hiện thay đổi, ít code save() thừa, có identity map tránh load trùng.JPA: automatic change detection, fewer redundant save() calls, an identity map that avoids duplicate loads.

Nhược điểmCons

Dirty checking 'vô hình' khiến người mới bất ngờ: sửa một entity managed là bị UPDATE dù không gọi save().'Invisible' dirty checking surprises beginners: modifying a managed entity triggers an UPDATE without any save().
Persistence context lớn (load hàng nghìn entity) tốn RAM và flush chậm.A large persistence context (thousands of entities) eats memory and flushes slowly.
Go phải tự viết và tự kỷ luật: quên truyền tx là câu SQL chạy ngoài transaction.In Go you write it yourself and need discipline: forget to pass tx and the SQL runs outside the transaction.

Anti-pattern: lỗi thường gặpAnti-pattern: common mistake

Mỗi bước tự commitCommitting every step on its own

Mỗi lệnh dùng thẳng *sql.DB nên tự commit riêng. Lỗi ở bước 2 thì bước 1 đã ghi xong — tiền bị trừ mà không được cộng. Hãy bọc cả nghiệp vụ trong một WithTx (hoặc @Transactional).Each statement uses *sql.DB directly, so each auto-commits. If step 2 fails, step 1 is already written — money debited but never credited. Wrap the whole operation in one WithTx (or @Transactional).

func Transfer(ctx context.Context, db *sql.DB, from, to string, amt int64) error {
	// ❌ each Exec auto-commits independently
	if _, err := db.ExecContext(ctx, "UPDATE wallet SET balance = balance - $1 WHERE id = $2", amt, from); err != nil {
		return err
	}
	// ❌ crash or error here → money has vanished
	if _, err := db.ExecContext(ctx, "UPDATE wallet SET balance = balance + $1 WHERE id = $2", amt, to); err != nil {
		return err
	}
	_, err := db.ExecContext(ctx, "INSERT INTO ledger (from_id, to_id, amount) VALUES ($1, $2, $3)", from, to, amt)
	return err
}

Dễ nhầm vớiEasily confused with

Unit of Work vs Repository

Repository lo đọc/ghi MỘT loại aggregate. Unit of Work điều phối thay đổi trên NHIỀU repository và commit chúng cùng nhau.A Repository reads/writes ONE aggregate type. A Unit of Work coordinates changes across SEVERAL repositories and commits them together.

Unit of Work vs Saga

Unit of Work: một transaction ACID trong một database. Saga: chuỗi transaction cục bộ qua nhiều service, lỗi thì chạy hành động bù trừ.Unit of Work: one ACID transaction in one database. Saga: a chain of local transactions across services, compensating on failure.

Bài tập áp dụngExercise

Thêm phí chuyển khoản 1.000đ: trừ thêm ở ví nguồn và cộng vào ví 'FEE' của hệ thống, ghi thêm một dòng sổ cái cho phí — tất cả trong cùng Unit of Work.Add a 1,000 VND transfer fee: debit it from the source wallet, credit the system 'FEE' wallet, and write an extra ledger line for it — all in the same Unit of Work.

Kiểm tra kiến thứcKnowledge check

Câu 1 / 5Question 1 of 5

Trong method @Transactional, bạn load một Wallet rồi gọi wallet.debit(100) mà KHÔNG gọi save(). Điều gì xảy ra khi commit?In a @Transactional method you load a Wallet and call wallet.debit(100) WITHOUT save(). What happens at commit?

Phím 1–4 để chọn đáp án, Enter để kiểm tra.Press 1–4 to choose an answer, Enter to check.

Thẻ ghi nhớFlashcards

Ôn tập ngắt quãng (spaced repetition): thẻ được lặp lại sau 1 → 3 → 7 → 14 → 30 ngày để củng cố trí nhớ dài hạn.Spaced repetition: cards are repeated after 1 → 3 → 7 → 14 → 30 days to build long-term memory.

Dùng trong bài toánUsed in problems

5 bài toán Backend dùng pattern này5 backend problems use this pattern

Pattern liên quanRelated patterns

Repository Service Layer Transactional Outbox Saga

Bài trướcPrevious

Specification

Bài tiếpNext

Retry with Exponential Backoff

Thảo luậnDiscussion

Unit of Workaka Persistence Context (JPA)

VừaMedium

Mức phổ biếnUsage 4/5

~9 phút đọc~9 min read

package com.pay.wallet; import jakarta.persistence.Entity; import jakarta.persistence.Id; import jakarta.persistence.Version; @Entity public class Wallet { @Id private String id; private long balance; // VND @Version1 private long version; // optimistic locking protected Wallet() {} public void debit(long amount) { if (amount <= 0) throw new IllegalArgumentException("amount must be > 0"); if (balance < amount) throw new InsufficientFundsException(id, balance, amount); balance -= amount;2 } public void credit(long amount) { if (amount <= 0) throw new IllegalArgumentException("amount must be > 0"); balance += amount; } public long getBalance() { return balance; } }

package store import ( "context" "database/sql" "fmt" ) // Tx is the unit of work: every repository inside shares ONE *sql.Tx. type Tx struct {1 Wallets *WalletRepo Ledger *LedgerRepo } type Store struct{ db *sql.DB } func New(db *sql.DB) *Store { return &Store{db: db} } // WithTx commits if fn returns nil; otherwise (error or panic) it rolls back. func (s *Store) WithTx(ctx context.Context, fn func(tx Tx) error) (err error) {2 sqlTx, err := s.db.BeginTx(ctx, nil) if err != nil { return fmt.Errorf("begin: %w", err) } defer func() { if p := recover(); p != nil {3 _ = sqlTx.Rollback() panic(p) // re-panic after cleaning up } if err != nil { _ = sqlTx.Rollback() } }() tx := Tx{Wallets: &WalletRepo{q: sqlTx}, Ledger: &LedgerRepo{q: sqlTx}} if err = fn(tx); err != nil { return err } return sqlTx.Commit()4 }

func Transfer(ctx context.Context, db *sql.DB, from, to string, amt int64) error { // ❌ each Exec auto-commits independently if _, err := db.ExecContext(ctx, "UPDATE wallet SET balance = balance - $1 WHERE id = $2", amt, from); err != nil { return err } // ❌ crash or error here → money has vanished if _, err := db.ExecContext(ctx, "UPDATE wallet SET balance = balance + $1 WHERE id = $2", amt, to); err != nil { return err } _, err := db.ExecContext(ctx, "INSERT INTO ledger (from_id, to_id, amount) VALUES ($1, $2, $3)", from, to, amt) return err }