Hành viBehavioral

Stateaka Objects for States, State Machine

Object đổi hành vi khi trạng thái bên trong đổi — mỗi trạng thái là một object riêng.An object changes behaviour when its internal state changes — each state is its own object.

Độ 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

Cái đèn giao thông chỉ có một nút 'next', nhưng bấm lúc đang đỏ thì sang xanh, đang xanh thì sang vàng. Cùng một hành động, kết quả tuỳ đèn đang ở màu nào. Mỗi màu tự biết 'sau mình là ai' — không cần một ông cảnh sát đứng tra bảng if/else.A traffic light has one 'next' button, yet pressing it on red gives green, on green gives yellow. Same action, different outcome depending on the current colour. Each colour knows 'who comes after me' — no officer needed to look up an if/else table.

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

Không có patternWithout the pattern

Đơn hàng đi qua PENDING → PAID → SHIPPED → DELIVERED, có thể CANCELLED. Code của bạn đầy if (status == PAID && action == SHIP) ... else if (status == PENDING && action == CANCEL) ... rải khắp service. Thêm trạng thái RETURNED là phải lục từng hàm, và rất dễ quên chặn một chuyển trạng thái sai như ship đơn chưa trả tiền.An order moves PENDING → PAID → SHIPPED → DELIVERED, and may be CANCELLED. Your code is full of if (status == PAID && action == SHIP) ... else if (status == PENDING && action == CANCEL) ... scattered across services. Adding RETURNED means hunting through every method, and it's easy to forget blocking an illegal move like shipping an unpaid order.

Với StateWith State

Mỗi trạng thái thành một object implement cùng interface (pay, ship, cancel...). Trạng thái tự quyết định hành động nào hợp lệ và trả về trạng thái kế tiếp; hành động không hợp lệ thì báo lỗi. Order (Context) chỉ giữ trạng thái hiện tại và uỷ quyền — không còn switch theo status.Each state becomes an object implementing one interface (pay, ship, cancel...). The state decides which actions are legal and returns the next state; illegal actions raise an error. The Order (Context) only holds the current state and delegates — no more switch on status.

Thành phần tham giaParticipants

Context: Object có vòng đời (Order). Giữ state hiện tại và uỷ quyền cho nó.The object with a lifecycle (Order). Holds the current state and delegates to it.
State: Interface khai báo mọi hành động có thể xảy ra.Interface declaring every action that can happen.
ConcreteState: Một trạng thái cụ thể: biết hành động nào hợp lệ và trạng thái kế tiếp.A concrete state: knows which actions are legal and the next state.
Client: Gọi hành động lên Context, không cần biết trạng thái hiện tại.Calls actions on the Context without knowing the current state.

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.

1Đơn #A1 vừa tạo, state hiện tại là Pending.Order #A1 is created; its current state is Pending.

← →

console

1order A1 created: PENDING

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.shop.order;

// Each constant is its own State object with its own behaviour
public enum OrderStatus {
    PENDING {1
        @Override OrderStatus pay(Order o) { return PAID; }
        @Override OrderStatus cancel(Order o) { return CANCELLED; }
    },
    PAID {
        @Override OrderStatus ship(Order o) { return SHIPPED; }
        @Override OrderStatus cancel(Order o) {
            o.refund(); // only a PAID order needs a refund2
            return CANCELLED;
        }
    },
    SHIPPED {
        @Override OrderStatus deliver(Order o) { return DELIVERED; }
    },
    DELIVERED,3
    CANCELLED;

    // Default: the action is not allowed in this state
    OrderStatus pay(Order o)     { throw illegal("pay"); }4
    OrderStatus ship(Order o)    { throw illegal("ship"); }
    OrderStatus deliver(Order o) { throw illegal("deliver"); }
    OrderStatus cancel(Order o)  { throw illegal("cancel"); }

    private IllegalStateException illegal(String action) {
        return new IllegalStateException("Cannot " + action + " a " + this + " order");
    }
}

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

package order

import "fmt"

// State decides which actions are legal and returns the next state.
type State interface {
	Name() string
	Pay(o *Order) (State, error)
	Ship(o *Order) (State, error)
	Deliver(o *Order) (State, error)
	Cancel(o *Order) (State, error)
}

// base rejects everything; concrete states embed it and override.
type base struct{ name string }1

func (b base) Name() string                  { return b.name }
func (b base) Pay(*Order) (State, error)     { return nil, b.deny("pay") }
func (b base) Ship(*Order) (State, error)    { return nil, b.deny("ship") }
func (b base) Deliver(*Order) (State, error) { return nil, b.deny("deliver") }
func (b base) Cancel(*Order) (State, error)  { return nil, b.deny("cancel") }
func (b base) deny(action string) error {
	return fmt.Errorf("cannot %s a %s order", action, b.name)
}

type pending struct{ base }2
type paid struct{ base }
type shipped struct{ base }

var (
	Pending   State = pending{base{"PENDING"}}3
	Paid      State = paid{base{"PAID"}}
	Shipped   State = shipped{base{"SHIPPED"}}
	Delivered State = base{"DELIVERED"}
	Cancelled State = base{"CANCELLED"}
)

func (pending) Pay(*Order) (State, error)     { return Paid, nil }4
func (pending) Cancel(*Order) (State, error)  { return Cancelled, nil }
func (paid) Ship(*Order) (State, error)       { return Shipped, nil }
func (shipped) Deliver(*Order) (State, error) { return Delivered, nil }
func (paid) Cancel(o *Order) (State, error) {
	o.refund()
	return Cancelled, nil
}

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

01Java có enum với thân riêng cho từng hằng — State pattern gọn và lưu DB dễ (@Enumerated(STRING)). Go không có enum như vậy; dùng interface + giá trị dùng chung, lưu DB bằng tên rồi tra map ngược lại.Java enums can give each constant its own body — a compact State pattern that persists easily (@Enumerated(STRING)). Go has no such enums; use an interface + shared values, persist the name and look it up via a map.
02Hành vi mặc định 'từ chối': Java đặt ở method của enum (các hằng override). Go dùng struct embedding (base) rồi shadow method.Default 'reject' behaviour: Java puts it in the enum's methods (constants override). Go uses struct embedding (base) and shadows methods.
03Hành động sai: Java ném IllegalStateException (và rollback nếu trong @Transactional). Go trả về error, Order giữ nguyên state.Illegal action: Java throws IllegalStateException (rolling back inside @Transactional). Go returns an error and Order keeps its state.
04Trong Go, nhiều team dùng bảng chuyển trạng thái map[Status]map[Event]Status thay cho interface khi các state không có hành vi riêng — đơn giản hơn mà vẫn chặn được chuyển sai.In Go many teams use a transition table map[Status]map[Event]Status instead of an interface when states have no special behaviour — simpler and still blocks illegal moves.

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

Spring StatemachineSpring Statemachine
Khai báo state, event, transition, guard, action bằng config — phù hợp quy trình phức tạp (duyệt khoản vay nhiều bước).Declare states, events, transitions, guards and actions via config — fits complex workflows (multi-step loan approval).
Vòng đời đơn hàng / chuyến xeOrder / ride lifecycle
Đơn Shopee, chuyến Grab (TÌM TÀI XẾ → ĐANG ĐÓN → ĐANG CHỞ → HOÀN THÀNH): mỗi trạng thái cho phép một nhóm hành động khác nhau.A marketplace order or a ride (FINDING DRIVER → PICKING UP → IN TRIP → DONE): each state allows a different set of actions.
Thread.State và TCPThread.State and TCP
Thread.State (NEW, RUNNABLE, BLOCKED...) và kết nối TCP (LISTEN, ESTABLISHED, CLOSE_WAIT) là những state machine kinh điển.Thread.State (NEW, RUNNABLE, BLOCKED...) and TCP connections (LISTEN, ESTABLISHED, CLOSE_WAIT) are classic state machines.
Lexer trong GoLexers in Go
text/template dùng type stateFn func(*lexer) stateFn — mỗi state là một hàm trả về state kế tiếp (bài nói nổi tiếng của Rob Pike).text/template uses type stateFn func(*lexer) stateFn — each state is a function returning the next one (from Rob Pike's well-known talk).

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

Nên dùng khiUse it when

Object có vòng đời rõ ràng và hành vi khác nhau theo từng trạng thái.An object has a clear lifecycle and behaves differently per state.
Bạn thấy switch/if theo status lặp lại ở nhiều method.You see switch/if on status repeated across many methods.
Cần chặn chặt chẽ các chuyển trạng thái không hợp lệ (tiền, đơn hàng, hợp đồng).You must strictly block illegal transitions (money, orders, contracts).

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

Chỉ có 2–3 trạng thái và gần như không có hành vi riêng — một enum + vài if là đủ.Only 2–3 states with almost no specific behaviour — an enum + a few ifs is enough.
Quy trình dài, nhiều bước chờ người duyệt, cần lưu lịch sử — cân nhắc workflow engine (Camunda, Temporal) hoặc Spring Statemachine.Long processes with human approvals and history — consider a workflow engine (Camunda, Temporal) or Spring Statemachine.

Ưu điểmPros

Luật của mỗi trạng thái nằm một chỗ, dễ đọc và test.Each state's rules live in one place, easy to read and test.
Thêm trạng thái mới không phải sửa Context.Adding a state doesn't require changing the Context.
Chuyển trạng thái sai bị chặn ngay ở thiết kế, không phụ thuộc dev nhớ kiểm tra.Illegal transitions are blocked by design, not by developers remembering to check.

Nhược điểmCons

Nhiều class/struct hơn; bức tranh tổng thể (sơ đồ chuyển trạng thái) bị chia nhỏ.More classes/structs; the big picture (the transition diagram) gets split up.
Thêm một hành động mới phải sửa interface và có thể nhiều state.Adding a new action means changing the interface and maybe many states.

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

Setter status công khaiA public status setter

Cho phép order.setStatus(...) từ bất kỳ đâu khiến mọi luật chuyển trạng thái bị bỏ qua: có thể nhảy thẳng từ PENDING sang DELIVERED. Hãy chỉ cho đổi trạng thái qua hành động có tên (pay, ship).Allowing order.setStatus(...) from anywhere bypasses every transition rule: you can jump from PENDING straight to DELIVERED. Only allow state changes through named actions (pay, ship).

@Transactional
public void markDelivered(long id) {
    Order order = orders.findById(id).orElseThrow();
    // ❌ no rules checked: unpaid or cancelled orders become DELIVERED
    order.setStatus(OrderStatus.DELIVERED);
}

Dễ nhầm vớiEasily confused with

State vs Strategy

Strategy: client chọn thuật toán, các strategy độc lập. State: object tự chuyển trạng thái, các state biết trạng thái kế tiếp.Strategy: the client picks an algorithm, strategies are independent. State: the object transitions itself, states know the next state.

Bài tập áp dụngExercise

Thêm trạng thái RETURNED: chỉ đơn DELIVERED mới được trả hàng (hành động returnItems), và trả hàng phải gọi refund().Add a RETURNED state: only DELIVERED orders can be returned (action returnItems), and a return must call refund().

Kiểm tra kiến thứcKnowledge check

Câu 1 / 6Question 1 of 6

Trong State pattern, ai quyết định trạng thái kế tiếp?In the State pattern, who decides the next state?

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

3 bài toán Backend dùng pattern này3 backend problems use this pattern

Pattern liên quanRelated patterns

Strategy Memento Command Saga

Bài trướcPrevious

Command

Bài tiếpNext

Chain of Responsibility

Thảo luậnDiscussion

Stateaka Objects for States, State Machine

VừaMedium

Mức phổ biếnUsage 4/5

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

package com.shop.order; // Each constant is its own State object with its own behaviour public enum OrderStatus { PENDING {1 @Override OrderStatus pay(Order o) { return PAID; } @Override OrderStatus cancel(Order o) { return CANCELLED; } }, PAID { @Override OrderStatus ship(Order o) { return SHIPPED; } @Override OrderStatus cancel(Order o) { o.refund(); // only a PAID order needs a refund2 return CANCELLED; } }, SHIPPED { @Override OrderStatus deliver(Order o) { return DELIVERED; } }, DELIVERED,3 CANCELLED; // Default: the action is not allowed in this state OrderStatus pay(Order o) { throw illegal("pay"); }4 OrderStatus ship(Order o) { throw illegal("ship"); } OrderStatus deliver(Order o) { throw illegal("deliver"); } OrderStatus cancel(Order o) { throw illegal("cancel"); } private IllegalStateException illegal(String action) { return new IllegalStateException("Cannot " + action + " a " + this + " order"); } }

package order import "fmt" // State decides which actions are legal and returns the next state. type State interface { Name() string Pay(o *Order) (State, error) Ship(o *Order) (State, error) Deliver(o *Order) (State, error) Cancel(o *Order) (State, error) } // base rejects everything; concrete states embed it and override. type base struct{ name string }1 func (b base) Name() string { return b.name } func (b base) Pay(*Order) (State, error) { return nil, b.deny("pay") } func (b base) Ship(*Order) (State, error) { return nil, b.deny("ship") } func (b base) Deliver(*Order) (State, error) { return nil, b.deny("deliver") } func (b base) Cancel(*Order) (State, error) { return nil, b.deny("cancel") } func (b base) deny(action string) error { return fmt.Errorf("cannot %s a %s order", action, b.name) } type pending struct{ base }2 type paid struct{ base } type shipped struct{ base } var ( Pending State = pending{base{"PENDING"}}3 Paid State = paid{base{"PAID"}} Shipped State = shipped{base{"SHIPPED"}} Delivered State = base{"DELIVERED"} Cancelled State = base{"CANCELLED"} ) func (pending) Pay(*Order) (State, error) { return Paid, nil }4 func (pending) Cancel(*Order) (State, error) { return Cancelled, nil } func (paid) Ship(*Order) (State, error) { return Shipped, nil } func (shipped) Deliver(*Order) (State, error) { return Delivered, nil } func (paid) Cancel(o *Order) (State, error) { o.refund() return Cancelled, nil }

@Transactional public void markDelivered(long id) { Order order = orders.findById(id).orElseThrow(); // ❌ no rules checked: unpaid or cancelled orders become DELIVERED order.setStatus(OrderStatus.DELIVERED); }