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;測試時一定要連外部服務 |