Behavioral on Bill.Lin's Notes

Memento — 不破壞封裝的快照與復原

Tue, 07 Aug 2018 22:39:01 +0800

1. 意圖

在不破壞封裝的前提下，擷取並儲存物件的內部狀態，並能在稍後將物件恢復至該狀態。

2. UML 類圖

classDiagram
    class Originator {
        -state String
        +save() Memento
        +restore(Memento)
    }
    class Memento {
        -state String
        +getState() String
    }
    class Caretaker {
        -history Deque~Memento~
        +backup(Originator)
        +undo(Originator)
    }
    Originator --> Memento : creates
    Caretaker --> Memento : stores
    Caretaker --> Originator

3. 何時用 / 何時別用

用：

需要 undo/redo（文字編輯器、繪圖工具、棋局）
交易 savepoint：資料庫 JTA rollback、遊戲存檔
需要「時光機」式還原，但又不想讓外部直接存取物件欄位

別用：

狀態物件很大（大量圖片、深層 object graph），每次快照記憶體開銷不可接受
外部已有持久化機制（DB、Redis）可直接記錄版本，不需再包一層
狀態欄位非常簡單，直接暴露欄位或用 Builder 更清楚

4. Java 範例

使用 Java record 作為不可變快照（Java 16+）：

Interpreter — 為語言定義文法與解釋器

Tue, 07 Aug 2018 22:38:42 +0800

1. 意圖

為一個語言定義文法表示，並提供解釋器來處理該文法的句子（AST 節點遞迴求值）。

2. UML 類圖

classDiagram
    class Expression {
        <>
        +interpret(Context) int
    }
    class NumberExpression {
        -value int
        +interpret(Context) int
    }
    class AddExpression {
        -left Expression
        -right Expression
        +interpret(Context) int
    }
    class SubtractExpression {
        -left Expression
        -right Expression
        +interpret(Context) int
    }
    Expression <|.. NumberExpression
    Expression <|.. AddExpression
    Expression <|.. SubtractExpression
    AddExpression --> Expression : left
    AddExpression --> Expression : right
    SubtractExpression --> Expression : left
    SubtractExpression --> Expression : right

3. 何時用 / 何時別用

用：

Iterator — 迭代器模式

Tue, 07 Aug 2018 22:38:21 +0800

1. 意圖

提供一種方式，讓外部程式碼可依序存取聚合物件的元素，而不需要知道其底層結構。

2. UML 類圖

classDiagram
    class Iterable~T~ {
        <>
        +iterator() Iterator~T~
    }
    class Iterator~T~ {
        <>
        +hasNext() boolean
        +next() T
        +remove()
    }
    class ConcreteCollection {
        -elements List~T~
        +iterator() Iterator~T~
    }
    class ConcreteIterator {
        -index int
        +hasNext() boolean
        +next() T
    }
    Iterable <|.. ConcreteCollection
    Iterator <|.. ConcreteIterator
    ConcreteCollection --> ConcreteIterator : creates

3. 何時用 / 何時別用

用：

需要為自訂資料結構（樹、圖、分頁資料）提供統一遍歷介面
需要支援多種遍歷方式（正序、逆序、層序）
想讓自訂集合可用 enhanced for-loop（只需實作 Iterable）

別用：

直接使用 JDK 集合時，Stream 通常比自訂 Iterator 更簡潔
資料集合固定且簡單，直接 index 迴圈反而更直覺

4. Java 範例

// 自訂範圍迭代器，避免 int[] 陣列浪費記憶體
public class Range implements Iterable<Integer> {
    private final int start;
    private final int end;   // exclusive

    public Range(int start, int end) {
        this.start = start;
        this.end   = end;
    }

    @Override
    public Iterator<Integer> iterator() {
        return new Iterator<>() {
            private int current = start;

            @Override public boolean hasNext() { return current < end; }
            @Override public Integer next() {
                if (!hasNext()) throw new NoSuchElementException();
                return current++;
            }
        };
    }
}

// 使用 enhanced for-loop
for (int n : new Range(1, 6)) {
    System.out.print(n + " "); // 1 2 3 4 5
}

// 轉成 Stream
StreamSupport.stream(new Range(1, 6).spliterator(), false)
    .filter(n -> n % 2 == 0)
    .forEach(System.out::println); // 2 4

5. JDK / Spring 真實案例

java.util.Iterator<T> + Iterable<T>：所有 JDK 集合實作 Iterable，enhanced for-loop 底層即呼叫 iterator()。這就是 Iterator Pattern 的標準 Java 實作。

Visitor — 將演算法從物件結構抽離

Tue, 07 Aug 2018 22:38:06 +0800

1. 意圖

在不修改物件結構的前提下，將新操作以獨立的 Visitor 類加入，透過雙分派（double dispatch）實現型別安全的呼叫。

2. UML 類圖

classDiagram
    class Visitor {
        <>
        +visitCircle(Circle)
        +visitRectangle(Rectangle)
    }
    class Shape {
        <>
        +accept(Visitor)
    }
    class Circle {
        -radius double
        +accept(Visitor)
    }
    class Rectangle {
        -width double
        -height double
        +accept(Visitor)
    }
    class AreaCalculator {
        +visitCircle(Circle)
        +visitRectangle(Rectangle)
    }
    Visitor <|.. AreaCalculator
    Shape <|.. Circle
    Shape <|.. Rectangle
    Circle --> Visitor : accept
    Rectangle --> Visitor : accept

3. 何時用 / 何時別用

用：

物件結構穩定，但需要頻繁新增對元素的操作（如 AST 有新的 code generation pass）
同一物件結構需要多種不相關的操作（計算面積、序列化、驗證）
不想把所有操作塞進元素類，保持高內聚

別用：

State — 讓物件隨狀態改變行為

Tue, 07 Aug 2018 22:37:58 +0800

1. 意圖

讓物件在其內部狀態改變時自動改變行為，看起來就像換了一個類別。

2. UML 類圖

classDiagram
    class Context {
        -state State
        +setState(State)
        +request()
    }
    class State {
        <>
        +handle(Context)
    }
    class ConcreteStateA {
        +handle(Context)
    }
    class ConcreteStateB {
        +handle(Context)
    }
    Context --> State
    State <|.. ConcreteStateA
    State <|.. ConcreteStateB

3. 何時用 / 何時別用

用：

物件行為取決於狀態，且狀態在執行期變化
存在大量以狀態為條件的 switch / if-else
狀態轉換規則複雜，不同狀態下允許的操作各異（例如訂單狀態機）

別用：

狀態少且不會演進（2–3 個 boolean flag），直接 if 更清晰
狀態轉換純粹線性，沒有分支邏輯
用 Spring Statemachine 等成熟框架更合適的複雜場景（別重造輪子）

4. Java 範例

訂單狀態機（PENDING → PAID → SHIPPED → DELIVERED）：

Command — 命令模式

Tue, 07 Aug 2018 22:37:50 +0800

1. 意圖

將一個請求封裝為獨立物件（Command），使請求可被排隊、記錄、撤銷或重做。

2. UML 類圖

classDiagram
    class Command {
        <>
        +execute()
        +undo()
    }
    class ConcreteCommand {
        -receiver Receiver
        -previousState State
        +execute()
        +undo()
    }
    class Receiver {
        +action()
    }
    class Invoker {
        -history List~Command~
        +executeCommand(Command)
        +undoLast()
    }
    Command <|.. ConcreteCommand
    ConcreteCommand --> Receiver
    Invoker --> Command

3. 何時用 / 何時別用

用：

需要 undo/redo（文字編輯器、繪圖工具）
請求需要排隊、延遲執行或記錄日誌
支援 macro 操作（一次執行多個命令）

別用：

操作簡單且不需要撤銷，引入 Command 只增加類別數量
Receiver 與呼叫者本就在同一層，直接呼叫更清楚

4. Java 範例

// Command 介面
public interface Command {
    void execute();
    void undo();
}

// Receiver
public class TextBuffer {
    private final StringBuilder buf = new StringBuilder();

    public void insert(int pos, String text) { buf.insert(pos, text); }
    public void delete(int pos, int len)    { buf.delete(pos, pos + len); }
    public String content()                 { return buf.toString(); }
}

// ConcreteCommand
public class InsertCommand implements Command {
    private final TextBuffer buf;
    private final int pos;
    private final String text;

    public InsertCommand(TextBuffer buf, int pos, String text) {
        this.buf = buf; this.pos = pos; this.text = text;
    }

    @Override public void execute() { buf.insert(pos, text); }
    @Override public void undo()    { buf.delete(pos, text.length()); }
}

// Invoker（含歷史紀錄）
public class Editor {
    private final Deque<Command> history = new ArrayDeque<>();

    public void execute(Command cmd) {
        cmd.execute();
        history.push(cmd);
    }

    public void undo() {
        if (!history.isEmpty()) history.pop().undo();
    }
}

// 使用
TextBuffer buffer = new TextBuffer();
Editor editor = new Editor();

editor.execute(new InsertCommand(buffer, 0, "Hello"));
editor.execute(new InsertCommand(buffer, 5, " World"));
System.out.println(buffer.content()); // Hello World

editor.undo();
System.out.println(buffer.content()); // Hello

5. JDK / Spring 真實案例

Runnable / Callable：最精簡的 Command 介面。Runnable 是無回傳值的 execute()；Callable<V> 增加了回傳值，兩者都可丟入 ExecutorService 排隊執行。

Strategy — 策略模式

Tue, 07 Aug 2018 22:37:39 +0800

1. 意圖

定義一族演算法，各自封裝，讓它們可以互相替換。演算法的變化不影響使用它的客戶端。

2. UML 類圖

classDiagram
    class Strategy {
        <>
        +execute(data) Result
    }
    class ConcreteStrategyA {
        +execute(data) Result
    }
    class ConcreteStrategyB {
        +execute(data) Result
    }
    class Context {
        -strategy Strategy
        +setStrategy(Strategy)
        +executeStrategy(data) Result
    }
    Strategy <|.. ConcreteStrategyA
    Strategy <|.. ConcreteStrategyB
    Context --> Strategy

3. 何時用 / 何時別用

用：

同一行為有多種實作，且在執行期需動態切換（排序、壓縮、付款方式）
大量 if/else 或 switch 判斷演算法類型，想用多型取代
演算法需要獨立測試

別用：

只有 2-3 種固定演算法且幾乎不會擴充，enum + switch 更簡單
演算法間差異很小，直接 method overloading 即可
客戶端需要了解不同策略的差異才能選擇，說明抽象程度不夠

4. Java 範例

// Strategy 介面（單一方法，可用 @FunctionalInterface）
@FunctionalInterface
public interface SortStrategy<T> {
    List<T> sort(List<T> data, Comparator<T> comparator);
}

// 兩種具體策略
public class QuickSort<T> implements SortStrategy<T> {
    @Override
    public List<T> sort(List<T> data, Comparator<T> comparator) {
        List<T> result = new ArrayList<>(data);
        result.sort(comparator);   // 借用 JDK TimSort 示意
        System.out.println("QuickSort used");
        return result;
    }
}

public class MergeSort<T> implements SortStrategy<T> {
    @Override
    public List<T> sort(List<T> data, Comparator<T> comparator) {
        // 真實場景放入 merge sort 實作
        List<T> result = new ArrayList<>(data);
        result.sort(comparator);
        System.out.println("MergeSort used");
        return result;
    }
}

// Context
public class Sorter<T> {
    private SortStrategy<T> strategy;

    public Sorter(SortStrategy<T> strategy) { this.strategy = strategy; }
    public void setStrategy(SortStrategy<T> strategy) { this.strategy = strategy; }

    public List<T> sort(List<T> data, Comparator<T> cmp) {
        return strategy.sort(data, cmp);
    }
}

// 使用
Sorter<Integer> sorter = new Sorter<>(new QuickSort<>());
sorter.sort(List.of(3, 1, 4, 1, 5), Comparator.naturalOrder());

// 執行期切換
sorter.setStrategy(new MergeSort<>());
sorter.sort(List.of(3, 1, 4, 1, 5), Comparator.reverseOrder());

// 用 lambda 直接注入（不需要具體類別）
sorter.setStrategy((data, cmp) -> data.stream().sorted(cmp).toList());

5. JDK / Spring 真實案例

Comparator：Collections.sort() 與 List.sort() 的第二個參數就是 Strategy。Comparator.comparing() 讓 lambda 成為最常用的 Strategy 形式。

Observer — 一對多狀態變更通知

Tue, 07 Aug 2018 22:37:21 +0800

1. 意圖

定義物件間一對多的依賴關係，當 Subject 狀態改變時，所有依賴它的 Observer 都會自動收到通知並更新。

2. UML 類圖

classDiagram
    class Subject {
        <>
        +subscribe(Observer)
        +unsubscribe(Observer)
        +notifyObservers()
    }
    class Observer {
        <>
        +update(event)
    }
    class ConcreteSubject {
        -observers List~Observer~
        -state
        +setState(state)
    }
    class ConcreteObserver {
        +update(event)
    }
    Subject <|.. ConcreteSubject
    Observer <|.. ConcreteObserver
    ConcreteSubject --> Observer : notifies

3. 何時用 / 何時別用

用：

一個物件狀態改變，多個物件需要連動更新（MVC model → view）
訂閱關係需要在執行期動態增減
跨模組通知，不希望兩者直接相互引用

別用：

觀察者鏈太長，觸發順序難以追蹤（考慮改用 Mediator）
觀察者之間有依賴順序要求（Observer 本身不保證順序，需額外機制）
簡單的一對一回呼，直接傳 lambda 更清楚

4. Java 範例

Push 模型（Subject 主動推送事件物件）：

Chain of Responsibility — 責任鏈模式

Tue, 07 Aug 2018 22:37:08 +0800

1. 意圖

將請求沿著處理者鏈依序傳遞，每個處理者決定自己是否處理，或繼續往下傳。

2. UML 類圖

classDiagram
    class Handler {
        <>
        #next Handler
        +setNext(Handler)
        +handle(request)*
    }
    class ConcreteHandlerA {
        +handle(request)
    }
    class ConcreteHandlerB {
        +handle(request)
    }
    Handler <|-- ConcreteHandlerA
    Handler <|-- ConcreteHandlerB
    Handler --> Handler : next

3. 何時用 / 何時別用

用：

超過一個物件可能處理同一請求，且處理者在執行期才決定（審批流、過濾管道）
需要動態組裝或重排處理者順序
不想讓發送者知道具體由誰處理

別用：

每個請求必須保證被處理——責任鏈可能讓請求靜默消失
處理者固定且少（2-3 個），直接 if/else 更清楚
鏈很長時效能敏感的熱路徑

4. Java 範例

// 審批請求：金額超過閾值就往上傳
public abstract class Approver {
    private Approver next;

    public Approver setNext(Approver next) {
        this.next = next;
        return next;
    }

    public final void approve(long amount) {
        if (canApprove(amount)) {
            doApprove(amount);
        } else if (next != null) {
            next.approve(amount);
        } else {
            throw new IllegalStateException("No approver for amount: " + amount);
        }
    }

    protected abstract boolean canApprove(long amount);
    protected abstract void doApprove(long amount);
}

public class TeamLead extends Approver {
    @Override protected boolean canApprove(long amount) { return amount <= 1_000; }
    @Override protected void doApprove(long amount) {
        System.out.println("TeamLead approved: " + amount);
    }
}

public class Manager extends Approver {
    @Override protected boolean canApprove(long amount) { return amount <= 10_000; }
    @Override protected void doApprove(long amount) {
        System.out.println("Manager approved: " + amount);
    }
}

public class Director extends Approver {
    @Override protected boolean canApprove(long amount) { return true; }
    @Override protected void doApprove(long amount) {
        System.out.println("Director approved: " + amount);
    }
}

// 組裝鏈
Approver chain = new TeamLead();
chain.setNext(new Manager()).setNext(new Director());

chain.approve(500);     // TeamLead approved: 500
chain.approve(5_000);   // Manager approved: 5000
chain.approve(50_000);  // Director approved: 50000

5. JDK / Spring 真實案例

ClassLoader 親委派：ClassLoader.loadClass() 先委派給 parent，parent 找不到才自己載入，這就是責任鏈的「先傳再自處理」變體。

Mediator — 以中介者解耦多方互動

Tue, 07 Aug 2018 22:36:43 +0800

1. 意圖

引入中介者物件封裝一組物件間的互動，使它們不需直接相互引用，從而將網狀耦合（mesh）降為星狀（star）。

2. UML 類圖

classDiagram
    class Mediator {
        <>
        +notify(sender, event)
    }
    class ConcreteMediator {
        -componentA ComponentA
        -componentB ComponentB
        +notify(sender, event)
    }
    class Component {
        <>
        #mediator Mediator
    }
    class ComponentA {
        +doA()
    }
    class ComponentB {
        +doB()
    }
    Mediator <|.. ConcreteMediator
    Component <|-- ComponentA
    Component <|-- ComponentB
    Component --> Mediator
    ConcreteMediator --> ComponentA
    ConcreteMediator --> ComponentB

3. 何時用 / 何時別用

用：

多個物件互相依賴，耦合關係複雜（N×(N-1)/2 條連線）
需要集中管理通訊流程（例如聊天室、航管、表單欄位聯動）
想讓組件可獨立重用，不綁定特定協作對象

別用：

只有 2–3 個物件互動，直接引用更清晰
中介者本身邏輯膨脹成「God Object」時，應拆分或改用事件匯流排
需要點對點高效能通訊，中間層增加 latency 不划算

4. Java 範例

// 事件類型
public sealed interface ChatEvent permits MessageSent, UserJoined {}
public record MessageSent(String from, String text) implements ChatEvent {}
public record UserJoined(String username) implements ChatEvent {}

// Mediator 介面
public interface ChatMediator {
    void register(ChatUser user);
    void relay(ChatEvent event, ChatUser sender);
}

// ConcreteMediator
public class ChatRoom implements ChatMediator {
    private final List<ChatUser> users = new ArrayList<>();

    @Override
    public void register(ChatUser user) {
        users.add(user);
    }

    @Override
    public void relay(ChatEvent event, ChatUser sender) {
        users.stream()
             .filter(u -> u != sender)
             .forEach(u -> u.receive(event));
    }
}

// Component
public class ChatUser {
    private final String name;
    private final ChatMediator mediator;

    public ChatUser(String name, ChatMediator mediator) {
        this.name = name;
        this.mediator = mediator;
        mediator.register(this);
    }

    public void send(String text) {
        mediator.relay(new MessageSent(name, text), this);
    }

    public void receive(ChatEvent event) {
        switch (event) {
            case MessageSent m -> System.out.printf("[%s] %s: %s%n", name, m.from(), m.text());
            case UserJoined j  -> System.out.printf("[%s] %s joined%n", name, j.username());
        }
    }
}

5. JDK / Spring 真實案例

框架	類別 / 機制	說明
Spring	`ApplicationEventPublisher` + `@EventListener`	發布者只呼叫 `publishEvent()`，監聽者以 `@EventListener` 宣告，互相不知道對方
Spring	`ApplicationContext`	Context 本身就是 Mediator，協調所有 Bean 的生命週期
Java Swing	`ActionListener` / `MediatorPanel`	表單元件透過共同 Controller 通訊，而非彼此直接呼叫

Spring 範例：

Template Method — 模板方法模式

Tue, 07 Aug 2018 12:18:20 +0800

1. 意圖

在抽象父類中定義演算法的骨架（final 方法），將某些步驟延遲到子類實作，讓子類在不改變整體結構的前提下覆寫特定步驟。

2. UML 類圖

classDiagram
    class AbstractClass {
        <>
        +templateMethod()
        #step1()*
        #step2()*
        #hook()
    }
    class ConcreteClassA {
        #step1()
        #step2()
    }
    class ConcreteClassB {
        #step1()
        #step2()
        #hook()
    }
    AbstractClass <|-- ConcreteClassA
    AbstractClass <|-- ConcreteClassB

3. 何時用 / 何時別用

用：

多個類別共用相同的演算法骨架，只有部分步驟不同
想控制子類能擴展的範圍（用 final 保護骨架，protected abstract 開放步驟）
框架設計：讓使用者繼承後填入業務邏輯（Hollywood Principle）

別用：

步驟差異大，繼承層次超過 2 層——改用 Strategy（組合優於繼承）
子類只需客製 1 個步驟，傳入 callback / lambda 比繼承更輕量
需要在執行期切換演算法變體，Template Method 是靜態綁定

4. Java 範例

// 資料匯出的通用骨架
public abstract class DataExporter {

    // 模板方法：final 保護流程
    public final void export(String destination) {
        List<String> data = fetchData();
        List<String> processed = transform(data);
        write(processed, destination);
        if (needsNotification()) {
            notify(destination);
        }
    }

    protected abstract List<String> fetchData();
    protected abstract List<String> transform(List<String> data);
    protected abstract void write(List<String> data, String destination);

    // hook：子類可選擇覆寫
    protected boolean needsNotification() { return false; }
    protected void notify(String destination) {
        System.out.println("Exported to: " + destination);
    }
}

// 具體實作 A：CSV 匯出
public class CsvExporter extends DataExporter {
    private final List<String> source;

    public CsvExporter(List<String> source) { this.source = source; }

    @Override
    protected List<String> fetchData() { return List.copyOf(source); }

    @Override
    protected List<String> transform(List<String> data) {
        return data.stream().map(s -> "\"" + s + "\"").toList();
    }

    @Override
    protected void write(List<String> data, String destination) {
        System.out.println("Writing CSV to " + destination + ": " + data);
    }

    @Override
    protected boolean needsNotification() { return true; } // 覆寫 hook
}

// 使用
DataExporter exporter = new CsvExporter(List.of("Alice", "Bob"));
exporter.export("/tmp/output.csv");
// Writing CSV to /tmp/output.csv: ["Alice", "Bob"]
// Exported to: /tmp/output.csv

5. JDK / Spring 真實案例

AbstractList：indexOf()、lastIndexOf()、iterator() 等方法的骨架實作在 AbstractList，只有 get(int index) 和 size() 是 abstract，ArrayList 與 LinkedList 各自提供這兩個方法。