Skip to content

Latest commit

 

History

History
1061 lines (760 loc) · 22.2 KB

STATE.md

File metadata and controls

1061 lines (760 loc) · 22.2 KB

State Pattern trong Java

State trong Java là mẫu thiết kế dùng để cho object thay đổi hành vi khi trạng thái bên trong của nó thay đổi.

Nói rất dễ hiểu:

State = cùng một object, nhưng ở trạng thái khác nhau thì hành xử khác nhau.


Mục lục


Sơ đồ tổng quan

flowchart TD
    A[Object / Context] --> B[Đang giữ state hiện tại]
    B --> C[Nhận request từ client]
    C --> D[Ủy quyền hành vi cho state hiện tại]
    D --> E[ConcreteState xử lý]
    E --> F[Có thể đổi sang state khác]
    F --> A
Loading

1. Ý tưởng cốt lõi

Giả sử bạn có một máy bán hàng.

Máy có thể ở các trạng thái như:

  • chưa có tiền
  • đã có tiền
  • đang giao hàng
  • hết hàng

Khi người dùng bấm nút selectProduct():

  • nếu chưa có tiền → báo lỗi
  • nếu đã có tiền → cho chọn hàng
  • nếu hết hàng → báo hết hàng

Tức là:

  • cùng một method
  • nhưng hành vi khác nhau tùy trạng thái

Đó chính là State.


2. Hình dung đời thường

Ví dụ bạn có một chiếc đèn giao thông.

Nó có các trạng thái:

  • đỏ
  • vàng
  • xanh

Cùng một sự kiện “đến chu kỳ tiếp theo”, nhưng kết quả khác nhau tùy trạng thái hiện tại:

  • đỏ → xanh
  • xanh → vàng
  • vàng → đỏ

Đèn giao thông là một object.
Nhưng hành vi của nó phụ thuộc vào state hiện tại.

Sơ đồ Traffic Light

stateDiagram-v2
    [*] --> Red
    Red --> Green: next()
    Green --> Yellow: next()
    Yellow --> Red: next()
Loading

3. Khi nào cần State

Dùng khi:

  • object có nhiều trạng thái rõ ràng
  • hành vi thay đổi mạnh theo trạng thái
  • code đang đầy if/else hoặc switch dựa trên state
  • state có thể chuyển đổi qua lại theo quy tắc

Ví dụ rất hợp:

  • đơn hàng
  • máy bán hàng
  • media player
  • tài khoản người dùng
  • document workflow
  • game character state
  • TCP connection
  • traffic light

4. Vấn đề nếu không dùng State

Không dùng State, code thường kiểu này:

public class Order {
    private String status;

    public void next() {
        if (status.equals("NEW")) {
            System.out.println("Move to PAID");
            status = "PAID";
        } else if (status.equals("PAID")) {
            System.out.println("Move to SHIPPED");
            status = "SHIPPED";
        } else if (status.equals("SHIPPED")) {
            System.out.println("Move to DELIVERED");
            status = "DELIVERED";
        } else {
            System.out.println("No next state");
        }
    }
}

Vấn đề:

  • nhiều if/else
  • thêm trạng thái mới phải sửa code cũ
  • logic chuyển trạng thái và hành vi bị dồn vào một chỗ
  • class phình to, khó bảo trì

State pattern giúp tách từng trạng thái ra thành class riêng.

So sánh trực quan

flowchart LR
    A[Không dùng State] --> A1[if else / switch lớn]
    A --> A2[logic dồn vào 1 class]
    A --> A3[khó mở rộng]

    B[Dùng State] --> B1[mỗi state là 1 class]
    B --> B2[ủy quyền hành vi]
    B --> B3[dễ mở rộng hơn]
Loading

5. Cấu trúc của State

State pattern thường có 3 phần chính:

a) State

Interface chung cho các trạng thái.

b) ConcreteState

Các trạng thái cụ thể.

c) Context

Object chính, giữ state hiện tại và ủy quyền hành vi cho state đó.

Cấu trúc tổng quát

classDiagram
    class Context {
        -State state
        +setState(State)
        +request()
    }

    class State {
        <<interface>>
        +handle(Context)
    }

    class ConcreteStateA {
        +handle(Context)
    }

    class ConcreteStateB {
        +handle(Context)
    }

    Context --> State : delegates to
    State <|.. ConcreteStateA
    State <|.. ConcreteStateB
Loading

6. Ví dụ cơ bản nhất: Traffic Light

Bước 1: State

public interface TrafficLightState {
    void next(TrafficLight context);
    String getColor();
}

Bước 2: Concrete States

Red

public class RedState implements TrafficLightState {
    @Override
    public void next(TrafficLight context) {
        System.out.println("Red -> Green");
        context.setState(new GreenState());
    }

    @Override
    public String getColor() {
        return "Red";
    }
}

Green

public class GreenState implements TrafficLightState {
    @Override
    public void next(TrafficLight context) {
        System.out.println("Green -> Yellow");
        context.setState(new YellowState());
    }

    @Override
    public String getColor() {
        return "Green";
    }
}

Yellow

public class YellowState implements TrafficLightState {
    @Override
    public void next(TrafficLight context) {
        System.out.println("Yellow -> Red");
        context.setState(new RedState());
    }

    @Override
    public String getColor() {
        return "Yellow";
    }
}

Bước 3: Context

public class TrafficLight {
    private TrafficLightState state;

    public TrafficLight() {
        this.state = new RedState();
    }

    public void setState(TrafficLightState state) {
        this.state = state;
    }

    public void change() {
        state.next(this);
    }

    public void show() {
        System.out.println("Current color: " + state.getColor());
    }
}

Bước 4: Dùng

public class Main {
    public static void main(String[] args) {
        TrafficLight light = new TrafficLight();

        light.show();
        light.change();

        light.show();
        light.change();

        light.show();
        light.change();

        light.show();
    }
}

Luồng chạy ví dụ Traffic Light

sequenceDiagram
    participant Client
    participant TrafficLight
    participant State

    Client->>TrafficLight: change()
    TrafficLight->>State: next(this)
    State-->>TrafficLight: setState(new NextState)
    Client->>TrafficLight: show()
    TrafficLight-->>Client: Current color
Loading

7. Điều gì đang xảy ra

TrafficLight không tự viết if state == RED, if state == GREEN...

Nó chỉ gọi:

state.next(this);

Mỗi state tự biết:

  • nó làm gì
  • state tiếp theo là gì

Đây là tinh thần của State:
đẩy logic hành vi và chuyển trạng thái vào từng state cụ thể.


8. Điểm quan trọng nhất của State

Một object ở trạng thái khác nhau thì:

  • method giống nhau
  • nhưng kết quả khác nhau

Ví dụ cùng là pressPlay() trên media player:

  • nếu đang Stopped → phát nhạc
  • nếu đang Playing → tạm dừng
  • nếu đang Paused → tiếp tục phát

9. Ví dụ thực tế hơn: Order State

Đây là ví dụ rất hay trong backend.

Đơn hàng có thể ở các trạng thái:

  • NEW
  • PAID
  • SHIPPED
  • DELIVERED
  • CANCELLED

Mỗi trạng thái sẽ quyết định:

  • có cho thanh toán không
  • có cho gửi hàng không
  • có cho hủy không

Sơ đồ chuyển trạng thái đơn hàng

stateDiagram-v2
    [*] --> NEW
    NEW --> PAID: pay()
    NEW --> CANCELLED: cancel()
    PAID --> SHIPPED: ship()
    PAID --> CANCELLED: cancel()
    SHIPPED --> SHIPPED: ship() / already shipped
    SHIPPED --> SHIPPED: pay() / cannot pay
    SHIPPED --> SHIPPED: cancel() / cannot cancel
    CANCELLED --> CANCELLED: pay()/ship()/cancel() invalid
Loading

State

public interface OrderState {
    void pay(Order context);
    void ship(Order context);
    void cancel(Order context);
    String getStatus();
}

ConcreteState: NewOrderState

public class NewOrderState implements OrderState {
    @Override
    public void pay(Order context) {
        System.out.println("Payment successful. Order moves to PAID");
        context.setState(new PaidOrderState());
    }

    @Override
    public void ship(Order context) {
        System.out.println("Cannot ship. Order is not paid yet");
    }

    @Override
    public void cancel(Order context) {
        System.out.println("Order cancelled");
        context.setState(new CancelledOrderState());
    }

    @Override
    public String getStatus() {
        return "NEW";
    }
}

ConcreteState: PaidOrderState

public class PaidOrderState implements OrderState {
    @Override
    public void pay(Order context) {
        System.out.println("Order already paid");
    }

    @Override
    public void ship(Order context) {
        System.out.println("Order shipped");
        context.setState(new ShippedOrderState());
    }

    @Override
    public void cancel(Order context) {
        System.out.println("Order cancelled after payment");
        context.setState(new CancelledOrderState());
    }

    @Override
    public String getStatus() {
        return "PAID";
    }
}

ConcreteState: ShippedOrderState

public class ShippedOrderState implements OrderState {
    @Override
    public void pay(Order context) {
        System.out.println("Order already shipped, cannot pay");
    }

    @Override
    public void ship(Order context) {
        System.out.println("Order already shipped");
    }

    @Override
    public void cancel(Order context) {
        System.out.println("Cannot cancel shipped order");
    }

    @Override
    public String getStatus() {
        return "SHIPPED";
    }
}

ConcreteState: CancelledOrderState

public class CancelledOrderState implements OrderState {
    @Override
    public void pay(Order context) {
        System.out.println("Cancelled order cannot be paid");
    }

    @Override
    public void ship(Order context) {
        System.out.println("Cancelled order cannot be shipped");
    }

    @Override
    public void cancel(Order context) {
        System.out.println("Order already cancelled");
    }

    @Override
    public String getStatus() {
        return "CANCELLED";
    }
}

Context

public class Order {
    private OrderState state;

    public Order() {
        this.state = new NewOrderState();
    }

    public void setState(OrderState state) {
        this.state = state;
    }

    public void pay() {
        state.pay(this);
    }

    public void ship() {
        state.ship(this);
    }

    public void cancel() {
        state.cancel(this);
    }

    public void showStatus() {
        System.out.println("Current status: " + state.getStatus());
    }
}

Dùng

public class Main {
    public static void main(String[] args) {
        Order order = new Order();

        order.showStatus();
        order.ship();

        order.pay();
        order.showStatus();

        order.ship();
        order.showStatus();

        order.cancel();
    }
}

10. Điều hay ở ví dụ này

Order không cần viết:

  • if state == NEW
  • if state == PAID
  • if state == SHIPPED

Nó chỉ ủy quyền:

state.pay(this);
state.ship(this);
state.cancel(this);

Từng state chịu trách nhiệm cho hành vi hợp lệ của nó.


11. State khác Strategy thế nào

Đây là cặp dễ nhầm nhất.

Về cấu trúc code, chúng rất giống nhau:

  • đều có interface
  • đều có các class cụ thể
  • đều có context giữ một object hành vi

Nhưng mục đích khác nhau.

Strategy

Mục tiêu:

  • chọn một cách làm

Ví dụ:

  • thanh toán bằng thẻ hay PayPal
  • sắp xếp bằng quicksort hay mergesort

Context thường không tự đổi strategy trừ khi client đổi.

State

Mục tiêu:

  • object thay đổi hành vi theo trạng thái nội bộ

Ví dụ:

  • order từ NEW sang PAID
  • traffic light từ RED sang GREEN

Context hoặc state có thể tự chuyển state.

Cách nhớ rất ngắn

  • Strategy = “chọn cách làm”
  • State = “đang ở trạng thái nào thì cư xử theo kiểu đó”

So sánh Strategy vs State

flowchart TB
    S[Strategy] --> S1[Chọn 1 cách làm]
    S --> S2[Thường do client chọn]
    S --> S3[Ít nhấn mạnh transition]

    T[State] --> T1[Hành vi đổi theo trạng thái]
    T --> T2[Context / state có thể tự đổi]
    T --> T3[Nhấn mạnh transition]
Loading

12. Ví dụ phân biệt nhanh

Strategy

Bạn chọn:

  • đi xe máy
  • đi ô tô
  • đi xe buýt

Đây là lựa chọn cách làm.

State

Bạn là:

  • đang ngủ
  • đang làm việc
  • đang nghỉ

Cùng một người, nhưng hành vi tùy trạng thái.


13. State khác if/else như thế nào

Bạn vẫn có thể làm bằng if/else, nhưng State có lợi khi:

  • số trạng thái nhiều
  • mỗi trạng thái có nhiều hành vi
  • logic chuyển trạng thái phức tạp
  • muốn mở rộng thêm state mới

Lúc đó State giúp:

  • tách logic rõ ràng
  • tránh một class khổng lồ đầy điều kiện

14. Lợi ích của State

a) Loại bỏ if/else hoặc switch phức tạp

Mỗi state là một class riêng.

b) Dễ mở rộng

Thêm state mới ít ảnh hưởng code cũ hơn.

c) Mã rõ ràng hơn

Logic của từng trạng thái nằm đúng chỗ của nó.

d) Hành vi và chuyển trạng thái đi cùng nhau

Rất tự nhiên.


15. Nhược điểm

a) Tăng số lượng class

Mỗi state thường là một class.

b) Có thể hơi nặng với bài toán nhỏ

Nếu chỉ có 2 trạng thái đơn giản, if/else có thể đủ.

c) Luồng chuyển trạng thái có thể khó theo dõi nếu quá nhiều state

Nhất là khi state chuyển qua lại phức tạp.


16. Khi nào nên dùng State

Nên dùng khi:

  • object có nhiều trạng thái rõ ràng
  • hành vi thay đổi theo trạng thái
  • transition giữa các state là phần quan trọng của bài toán
  • code hiện tại đang đầy điều kiện theo state

Ví dụ:

  • workflow đơn hàng
  • trạng thái ticket
  • media player
  • TCP connection
  • workflow document
  • game AI state
  • vending machine

17. Khi nào không nên dùng

Không nên dùng khi:

  • chỉ có 1-2 trạng thái đơn giản
  • logic cực nhỏ
  • việc tạo nhiều class làm code dài hơn giá trị mang lại

18. Ví dụ rất thực tế: Media Player

Trình phát nhạc có thể ở:

  • Stopped
  • Playing
  • Paused

Cùng method pressPlay() nhưng:

  • Stopped → bắt đầu phát
  • Playing → tạm dừng
  • Paused → tiếp tục phát

Đây là bài toán State điển hình.

Sơ đồ Media Player

stateDiagram-v2
    [*] --> STOPPED
    STOPPED --> PLAYING: pressPlay()
    PLAYING --> PAUSED: pressPlay()
    PAUSED --> PLAYING: pressPlay()
Loading

State

public interface PlayerState {
    void pressPlay(MediaPlayer player);
    String getName();
}

PlayingState

public class PlayingState implements PlayerState {
    @Override
    public void pressPlay(MediaPlayer player) {
        System.out.println("Pause music");
        player.setState(new PausedState());
    }

    @Override
    public String getName() {
        return "PLAYING";
    }
}

PausedState

public class PausedState implements PlayerState {
    @Override
    public void pressPlay(MediaPlayer player) {
        System.out.println("Resume music");
        player.setState(new PlayingState());
    }

    @Override
    public String getName() {
        return "PAUSED";
    }
}

StoppedState

public class StoppedState implements PlayerState {
    @Override
    public void pressPlay(MediaPlayer player) {
        System.out.println("Start music");
        player.setState(new PlayingState());
    }

    @Override
    public String getName() {
        return "STOPPED";
    }
}

Context

public class MediaPlayer {
    private PlayerState state = new StoppedState();

    public void setState(PlayerState state) {
        this.state = state;
    }

    public void pressPlay() {
        state.pressPlay(this);
    }

    public void showState() {
        System.out.println("Current state: " + state.getName());
    }
}

19. State có thể tự chuyển trạng thái

Điểm rất đặc trưng của State là:

context.setState(new AnotherState());

Tức là state hiện tại có thể quyết định:

  • sau hành động này thì context nên chuyển sang state nào

Đây là điều Strategy thường không nhấn mạnh.


20. Có nên dùng Singleton cho state không?

Nhiều state là stateless, ví dụ:

  • RedState
  • GreenState
  • PausedState

Nếu state không chứa dữ liệu riêng, bạn có thể tái sử dụng một instance duy nhất cho mỗi state để tiết kiệm object.

Ví dụ ý tưởng:

public class RedState implements TrafficLightState {
    public static final RedState INSTANCE = new RedState();

    private RedState() {}
}

Đây là tối ưu thêm, không bắt buộc cho người mới học.


21. Sai lầm người mới hay gặp

a) Nhầm State với Strategy

Nhớ rằng State gắn với trạng thái nội bộ và transition.

b) Vẫn nhét nhiều if/else vào context

Như vậy mất ý nghĩa của pattern.

c) Để state biết quá ít hoặc quá nhiều

State nên chứa logic thuộc về trạng thái đó, nhưng không nên ôm mọi thứ linh tinh.

d) Chuyển state bừa bãi

Dẫn đến luồng workflow khó hiểu.


22. Mẫu code ngắn gọn dễ nhớ

interface State {
    void handle(Context context);
}

class StateA implements State {
    @Override
    public void handle(Context context) {
        System.out.println("Handling in State A");
        context.setState(new StateB());
    }
}

class StateB implements State {
    @Override
    public void handle(Context context) {
        System.out.println("Handling in State B");
        context.setState(new StateA());
    }
}

class Context {
    private State state;

    public Context(State state) {
        this.state = state;
    }

    public void setState(State state) {
        this.state = state;
    }

    public void request() {
        state.handle(this);
    }
}

public class Main {
    public static void main(String[] args) {
        Context context = new Context(new StateA());

        context.request();
        context.request();
        context.request();
    }
}

Sơ đồ mẫu code ngắn gọn

stateDiagram-v2
    [*] --> StateA
    StateA --> StateB: handle()
    StateB --> StateA: handle()
Loading

23. Công thức nhớ 1 câu

State cho phép một object thay đổi hành vi khi trạng thái bên trong của nó thay đổi.


24. Chốt cực ngắn

  • Strategy: một việc, nhiều cách làm
  • State: một object, nhiều trạng thái hành vi
  • Observer: một thay đổi, nhiều nơi được báo

25. Bảng nhớ nhanh đến hiện tại

Mẫu Ý tưởng chính
Singleton Chỉ có 1 object duy nhất
Factory Method Tạo 1 loại object linh hoạt
Abstract Factory Tạo cả họ object liên quan
Builder Tạo object từng bước
Prototype Sao chép object từ mẫu có sẵn
Adapter Chuyển interface không tương thích
Bridge Tách abstraction và implementation
Decorator Bọc thêm chức năng cho object
Facade Đơn giản hóa hệ thống phức tạp
Proxy Đại diện và kiểm soát truy cập
Composite Biểu diễn cấu trúc cây
Flyweight Chia sẻ trạng thái chung để tiết kiệm bộ nhớ
Observer Một thay đổi, nhiều nơi được thông báo
Strategy Một việc, nhiều cách làm
State Một object, nhiều trạng thái hành vi

26. Kết luận

State trong Java rất hữu ích khi object của bạn có nhiều trạng thái và hành vi thay đổi theo từng trạng thái đó. Nó giúp:

  • code sạch hơn
  • tách logic theo state rõ ràng
  • dễ mở rộng
  • tránh if/else rối rắm

Điểm cốt lõi phải nhớ là:

trạng thái không chỉ là dữ liệu; trạng thái còn quyết định cách object hành xử.

Bước tiếp theo hợp lý nhất là Template Method hoặc Command. Nếu học liền mạch thì Template Method rất dễ so với Strategy và State.