SOLID 設計原則

本文寫於 2013 年,當時的範例是 Laravel 4。2026 年重新整理:範例改成 PHP 8.1 以上與現行 Laravel 的寫法,也修正了原文幾個不正確的說明。

SOLID 是五個物件導向設計原則的縮寫。這些原則由 Robert C. Martin(Uncle Bob)在 2000 年前後整理成一組,SOLID 這個縮寫則是 Michael Feathers 取的:

原則 一句話
S 單一職責(Single Responsibility) 一個類別只有一個改變的理由
O 開放封閉(Open/Closed) 加新功能時寫新的程式碼,不改舊的
L 里氏替換(Liskov Substitution) 子型別要能放在父型別的位置,而且行為符合預期
I 介面隔離(Interface Segregation) 不要逼使用者依賴它用不到的方法
D 依賴反轉(Dependency Inversion) 依賴抽象,不依賴具體的實作

五個原則的目的都一樣:讓需求改變時,要改的地方少、而且集中。


S:單一職責原則

A class should have one, and only one, reason to change.

「單一職責」常被誤解成「一個類別只做一件事」。Uncle Bob 後來把它講得更精確:一個模組只對一個角色(actor)負責,也就是只有一種人會要求它改變。

下面這個註冊流程,同時處理了三件事:

class RegisterController
{
    public function store(Request $request)
    {
        // 1. 驗證:產品規格改了就要改
        $data = $request->validate([
            'email' => ['required', 'email', 'unique:users'],
            'password' => ['required', 'min:8'],
        ]);

        // 2. 建立帳號:資料結構改了就要改
        $user = User::create([
            'email' => $data['email'],
            'password' => Hash::make($data['password']),
        ]);

        // 3. 寄歡迎信:行銷想換內容或改寄簡訊就要改
        Mail::to($user)->send(new WelcomeMail($user));

        return redirect('/home');
    }
}

三個不同的人、三種不同的理由,都會改到同一個方法。拆開之後,每個類別只有一個改變的理由:

// 驗證規則
class RegisterUserRequest extends FormRequest
{
    public function rules(): array
    {
        return [
            'email' => ['required', 'email', 'unique:users'],
            'password' => ['required', 'min:8'],
        ];
    }
}

// 建立帳號,並發出「已註冊」事件
final class RegisterUser
{
    public function handle(string $email, string $password): User
    {
        $user = User::create([
            'email' => $email,
            'password' => Hash::make($password),
        ]);

        event(new Registered($user));

        return $user;
    }
}

// 收到「已註冊」事件時寄歡迎信;改成寄簡訊只要改這裡
final class SendWelcomeMail
{
    public function handle(Registered $event): void
    {
        Mail::to($event->user)->send(new WelcomeMail($event->user));
    }
}

// Controller 只負責把 HTTP 請求轉給對的人
class RegisterController
{
    public function store(RegisterUserRequest $request, RegisterUser $register)
    {
        $register->handle($request->validated('email'), $request->validated('password'));

        return redirect('/home');
    }
}
flowchart LR
    subgraph before ["拆開前:三種理由改同一個類別"]
        direction TB
        P1(["產品"]) -->|"驗證規則"| RC["RegisterController"]
        P2(["工程"]) -->|"資料結構"| RC
        P3(["行銷"]) -->|"歡迎信"| RC
    end
    subgraph after ["拆開後:一個角色對應一個類別"]
        direction TB
        Q1(["產品"]) --> R1["RegisterUserRequest"]
        Q2(["工程"]) --> R2["RegisterUser"]
        Q3(["行銷"]) --> R3["SendWelcomeMail"]
    end
    before ~~~ after

圖:拆開前,三種角色的需求都會改到 RegisterController;拆開後,每個類別只對一個角色負責。

判斷方式:描述這個類別在做什麼時,如果需要用到「而且」,就該想想是不是要拆開。


O:開放封閉原則

Software entities should be open for extension, but closed for modification.

這個原則最早由 Bertrand Meyer 在 1988 年提出。意思是:需求增加時,用新增程式碼的方式擴充,而不是去修改已經能正常運作的程式碼。

違反的典型徵兆,是一個會不斷長大的 if 或 switch:

class FormValidator
{
    public function rules(string $form): array
    {
        // 每多一個表單,就要回來改這個方法
        return match ($form) {
            'login' => ['email' => ['required', 'email'], 'password' => ['required']],
            'register' => ['email' => ['required', 'email', 'unique:users'], 'password' => ['required', 'min:8']],
        };
    }
}

改成:共用的流程寫在父類別裡固定下來(對修改封閉),每個表單的規則由子類別提供(對擴充開放):

abstract class FormValidation
{
    /** 每個表單自己定義規則 */
    abstract protected function rules(): array;

    /** 自訂錯誤訊息,不需要的表單可以不寫 */
    protected function messages(): array
    {
        return [];
    }

    /** 驗證失敗時丟出 ValidationException;成功時回傳通過驗證的資料 */
    final public function validate(array $input): array
    {
        return Validator::make($input, $this->rules(), $this->messages())->validate();
    }
}

final class LoginValidation extends FormValidation
{
    protected function rules(): array
    {
        return [
            'email' => ['required', 'email'],
            'password' => ['required', 'min:8'],
        ];
    }

    protected function messages(): array
    {
        return [
            'email.required' => '請輸入 Email。',
            'password.min' => '密碼至少要 8 個字元。',
        ];
    }
}

// 新增註冊表單:加一個類別,不必改 FormValidation 或 LoginValidation
final class RegisterValidation extends FormValidation
{
    protected function rules(): array
    {
        return [
            'email' => ['required', 'email', 'unique:users'],
            'password' => ['required', 'min:8', 'confirmed'],
        ];
    }
}
classDiagram
    class FormValidation {
        <<abstract>>
        #rules()* array
        #messages() array
        +validate(input) array
    }
    class LoginValidation {
        #rules() array
        #messages() array
    }
    class RegisterValidation {
        #rules() array
    }
    FormValidation <|-- LoginValidation
    FormValidation <|-- RegisterValidation
    note for FormValidation "validate() 是 final:共用流程固定,對修改封閉"
    note for RegisterValidation "新增的表單:只加這個類別,對擴充開放"

圖:父類別固定驗證的流程,子類別只提供規則。新增表單時加一個子類別,既有的類別都不用改。

validate() 加上 final,子類別不能改寫共用的流程,只能提供規則。Laravel 的 FormRequest 就是這個設計。

要注意,「封閉」不是指把屬性都設成 private 就好。封裝是手段,真正的目標是:新需求進來時,舊的、測試過的程式碼不需要被打開。


L:里氏替換原則

If S is a subtype of T, then objects of type T may be replaced with objects of type S without altering any of the desirable properties of the program.

由 Barbara Liskov 在 1987 年提出。重點不只是「子類別能放進父類別的位置」,PHP 的型別檢查就能保證這件事。重點是:子類別的行為必須符合父類別(或介面)承諾的契約,使用者不需要知道拿到的是哪一個子類別。

子型別不可以:

  • 加強前置條件:父型別接受的輸入,子型別不能拒絕。
  • 削弱後置條件:父型別保證的結果,子型別也要做到。
  • 丟出契約沒有說明的例外。

例如這個「磁碟」介面,承諾 save() 之後檔案就存在:

final class File
{
    public function __construct(
        public readonly string $name,
        public readonly int $size,  // bytes
    ) {}
}

interface Disk
{
    /** 存檔;完成後 exists($file->name) 為 true */
    public function save(File $file): void;

    public function exists(string $name): bool;
}

function backup(Disk $disk, File $file): void
{
    $disk->save($file);
    // 依照契約,這裡可以放心假設檔案已經存在
}

現在加一個 FAT32 格式的隨身碟,它的單一檔案不能超過 4GB:

final class Fat32Disk implements Disk
{
    private array $files = [];

    public function save(File $file): void
    {
        if ($file->size >= 4 * 1024 ** 3) {
            throw new LogicException('FAT32 單一檔案不能超過 4GB');
        }
        $this->files[$file->name] = $file;
    }

    public function exists(string $name): bool
    {
        return isset($this->files[$name]);
    }
}

型別完全正確,backup() 也能接受它,但只要遇到大檔案就會失敗。Fat32Disk 加強了前置條件,所以違反了 LSP。呼叫的人只好寫 if ($disk instanceof Fat32Disk),抽象就失去了意義。

解法是把限制寫進契約,讓每一種磁碟都用同樣的方式表達:

final class FileTooLarge extends RuntimeException {}

interface Disk
{
    /** 單一檔案的大小上限(bytes),null 表示沒有限制 */
    public function maxFileSize(): ?int;

    /**
     * 存檔;完成後 exists($file->name) 為 true。
     * 超過 maxFileSize() 時丟出 FileTooLarge。
     */
    public function save(File $file): void;

    public function exists(string $name): bool;
}

現在「檔案可能太大」是契約的一部分,backup() 可以事先檢查 maxFileSize(),或捕捉 FileTooLarge。不論拿到哪一種磁碟,處理方式都一樣。

最經典的反例是「正方形繼承長方形」:數學上正方形是長方形,但長方形的契約是「寬和高可以分別設定」,正方形做不到。繼承要看行為是否相容,不是看名詞之間的分類關係。


I:介面隔離原則

Clients should not be forced to depend upon interfaces that they do not use.

在 PHP 裡,實作一個介面就必須實作它的所有方法。介面太大時,類別會被迫實作用不到的方法,最後只能留空或丟出例外,這通常也同時違反了 LSP:

interface Animal
{
    public function walk(): void;
    public function fly(): void;
    public function swim(): void;
}

final class Penguin implements Animal
{
    public function walk(): void {}
    public function swim(): void {}

    public function fly(): void
    {
        throw new LogicException('企鵝不會飛');  // 被迫實作的方法
    }
}

把介面依能力拆小,每個類別只實作自己做得到的事:

interface Walkable
{
    public function walk(): void;
}

interface Flyable
{
    public function fly(): void;
}

interface Swimmable
{
    public function swim(): void;
}

final class Starck implements Walkable
{
    public function walk(): void {}
}

final class Pigeon implements Walkable, Flyable
{
    public function walk(): void {}
    public function fly(): void {}
}

final class Penguin implements Walkable, Swimmable
{
    public function walk(): void {}
    public function swim(): void {}
}

使用的一方也只依賴它需要的能力。例如 function race(Swimmable ...$swimmers) 只在乎會不會游泳,企鵝可以參加,鴿子在型別檢查時就會被擋下來。

就設計的角度來看,介面隔離是在思考哪些行為總是一起被使用,而不是「這個東西有哪些功能」。


D:依賴反轉原則

High-level modules should not depend on low-level modules. Both should depend on abstractions.

高階模組是商業邏輯(例如「列出使用者」),低階模組是實作細節(例如 MySQL)。依賴反轉的目的,是讓資料來源、金流、寄信這些細節更換時,商業邏輯不受影響。

用一句話來比喻。第一版程式像是「我要去 MySQL 資料庫查詢使用者名單」:

final class MySqlDatabase
{
    public function all(string $table): array
    {
        // SELECT * FROM ...
        return [];
    }
}

final class UserList
{
    public function users(): array
    {
        $db = new MySqlDatabase();  // 自己決定用 MySQL
        return $db->all('users');
    }
}

UserList 直接 new 了 MySQL,想改用別的資料來源,或想在測試裡不連資料庫,都得修改它。

第二版把來源從外面傳進來,像是「我要去『MySQL 資料庫』查詢使用者名單」,但句子裡還是寫死了 MySQL:

final class UserList
{
    public function __construct(private MySqlDatabase $db) {}

    public function users(): array
    {
        return $this->db->all('users');
    }
}

第三版改用統稱:「我要去使用者資料來源查詢使用者名單」。至於來源是什麼,由外部決定:

interface UserRepository
{
    /** @return list<User> */
    public function all(): array;
}

final class EloquentUserRepository implements UserRepository
{
    public function all(): array
    {
        return User::all()->all();
    }
}

final class InMemoryUserRepository implements UserRepository
{
    /** @param list<User> $users */
    public function __construct(private array $users = []) {}

    public function all(): array
    {
        return $this->users;
    }
}

final class UserList
{
    public function __construct(private UserRepository $users) {}

    public function users(): array
    {
        return $this->users->all();
    }
}
flowchart LR
    subgraph before ["改寫前:商業邏輯依賴細節"]
        direction TB
        A["UserList"] --> B["MySqlDatabase"]
    end
    subgraph after ["改寫後:細節依賴商業邏輯定義的介面"]
        direction TB
        subgraph high ["高階模組"]
            C["UserList"] --> D[["UserRepository(介面)"]]
        end
        E["EloquentUserRepository"] -.->|"實作"| D
        F["InMemoryUserRepository"] -.->|"實作"| D
    end
    before ~~~ after

圖:注意箭頭的方向。改寫前,UserList 指向 MySQL;改寫後,資料庫的實作反過來指向 UserList 這一側定義的介面。

「反轉」指的是介面由高階模組來定義:UserRepository 描述的是 UserList 需要什麼,而不是 MySQL 能提供什麼。原本是商業邏輯依賴資料庫,現在變成資料庫的實作要配合商業邏輯定義的介面,依賴的方向反過來了。

就像電器只依賴插座的規格。電是來自台電還是自家屋頂的太陽能板,電器不需要知道,也不用為此改裝。

在 Laravel 裡切換實作

Laravel 的服務容器會依照建構子的型別自動注入。在 AppServiceProvider 綁定介面要用哪一個實作:

final class AppServiceProvider extends ServiceProvider
{
    public function register(): void
    {
        $this->app->bind(UserRepository::class, EloquentUserRepository::class);
    }
}

測試時換成記憶體版本,不需要資料庫:

$this->app->instance(UserRepository::class, new InMemoryUserRepository([
    new User(['name' => 'Starck']),
]));

依使用者的設定選擇金流

實作也可以在執行時才決定。例如依照使用者選擇的付款方式:

interface PaymentGateway
{
    /** 扣款;回傳交易編號 */
    public function charge(int $amount): string;
}

final class PaypalGateway implements PaymentGateway
{
    public function charge(int $amount): string
    {
        // 呼叫 PayPal API
        return 'paypal-transaction-id';
    }
}

final class StripeGateway implements PaymentGateway
{
    public function charge(int $amount): string
    {
        // 呼叫 Stripe API
        return 'stripe-transaction-id';
    }
}

final class CheckoutController
{
    public function __construct(private PaymentGateway $gateway) {}

    public function store(Order $order)
    {
        $transactionId = $this->gateway->charge($order->total);
        // ...
    }
}

// AppServiceProvider::register()
$this->app->bind(PaymentGateway::class, fn ($app) => match (Auth::user()?->payment_method) {
    'paypal' => $app->make(PaypalGateway::class),
    default => $app->make(StripeGateway::class),
});

CheckoutController 只知道「有一個可以扣款的東西」。日後加上 LINE Pay,只要新增一個實作並修改綁定,結帳流程不用動。這也同時符合開放封閉原則。


什麼時候不需要

SOLID 是用來控制變化的工具,不是每段程式都要套用。如果某個實作只有一種、而且看不到更換的可能,直接使用具體類別通常比較簡單。等到第二種實作真的出現,或是需要為了測試而替換時,再抽出介面也不遲。

原則 違反時的徵兆
單一職責 不相關的需求都會改到同一個類別;描述它時需要用「而且」
開放封閉 每加一種類型,就要回去改同一個 if/switch
里氏替換 呼叫的人要用 instanceof 判斷實際的類別;子類別丟出 LogicException('不支援')
介面隔離 實作裡出現空方法,或丟出「不支援」的例外
依賴反轉 商業邏輯裡直接 new 資料庫、API client;測試時一定要連外部服務