以下是 PHP 中常用的设计模式及其典型应用场景的整理，按模式类型分类说明：

一、创建型模式（怎么“造”对象）

1. 单例模式 (Singleton)

一句话：一个类只能创建一个对象，全局共用这一个实例。
为什么用：避免重复创建对象浪费资源（数据库连接、日志、配置）。
例子：数据库连接类，全局只用一个连接，不重复连。
目的：确保一个类只有一个实例，并提供全局访问点。
场景：数据库连接、日志记录器、配置管理器。 

  1. class Db
  2. {
  3.     private static $instance; // 保存唯一实例
  5.     // 私有化构造，禁止外部 new
  6.     private function __construct() {}
  8.     // 获取实例
  9.     public static function getInstance()
  10.     {
  11.         if (!self::$instance) {
  12.             self::$instance = new self();
  13.         }
  14.         return self::$instance;
  15.     }
  16. }
  18. $db1 = Db::getInstance();
  19. $db2 = Db::getInstance();
  20. var_dump($db1 === $db2); // true 同一个对象

2. 工厂方法模式 (Factory Method)

一句话：专门造对象的工厂，你不用自己 new，告诉工厂要什么，它给你对象。 为什么用：解耦“创建对象”和“使用对象”。 例子：支付工厂 → 你说要支付宝/微信，工厂直接返回对应支付类。 目的：定义创建对象的接口，由子类决定实例化哪个类。
场景：框架中对象创建（如 HTTP 请求对象）。 

  1. // 产品接口
  2. interface Pay
  3. {
  4.     public function pay();
  5. }
  7. // 具体产品
  8. class AliPay implements Pay
  9. {
  10.     public function pay() { echo "支付宝支付"; }
  11. }
  12. class WechatPay implements Pay
  13. {
  14.     public function pay() { echo "微信支付"; }
  15. }
  17. // 工厂
  18. class PayFactory
  19. {
  20.     public static function make($type)
  21.     {
  22.         return match ($type) {
  23.             'ali' => new AliPay(),
  24.             'wechat' => new WechatPay()
  25.         };
  26.     }
  27. }
  29. $pay = PayFactory::make('ali');
  30. $pay->pay(); // 支付宝支付

3. 抽象工厂（Abstract Factory）

一句话：工厂的工厂，能生产一整套相关对象。
例子：电脑工厂 → 生产一套：CPU + 主板 + 内存，而不是单个零件。
和之前的工厂模式区别：工厂模式造单个对象，抽象工厂造一整套相关对象。 

  1. // 抽象工厂：生产一套产品（CPU+主板）
  2. interface AbstractFactory {
  3.     public function createCpu();
  4.     public function createMainboard();
  5. }
  7. // 具体工厂：Intel套装
  8. class IntelFactory implements AbstractFactory {
  9.     public function createCpu() { return new IntelCpu(); }
  10.     public function createMainboard() { return new IntelBoard(); }
  11. }
  13. // 产品接口
  14. interface Cpu { public function run(); }
  15. interface Mainboard { public function run(); }
  17. // 具体产品
  18. class IntelCpu implements Cpu { public function run(){echo "IntelCPU运行\n";}}
  19. class IntelBoard implements Mainboard { public function run(){echo "Intel主板运行\n";}}
  21. // 使用
  22. $factory = new IntelFactory();
  23. $factory->createCpu()->run();
  24. $factory->createMainboard()->run();

4. 建造者模式 (Builder)

一句话：把复杂对象一步步拼装出来。
例子：造电脑 → 先装CPU，再装显卡，再装硬盘，最后组装成一台电脑。
目的：分步构造复杂对象，分离对象的构造与表示。
场景：生成 HTML 表单、构建 SQL 查询。 

  1. class HtmlFormBuilder {
  2.     private $form = [];
  3.     public function addInput($name, $type) { /* ... */ }
  4.     public function build() { return new Form($this->form); }
  5. }

5. 原型模式 (Prototype)

一句话：对象克隆自己，而不是重新创建。
例子：一个复杂配置好的订单对象，直接克隆一份，改个别字段就能用。
目的：通过克隆现有对象创建新对象，减少重复初始化。
场景：缓存对象、复制复杂数据结构。 

  1. class User implements Cloneable {
  2.     public function __clone() {
  3.         // 深拷贝逻辑
  4.     }
  5. }
  6. $user = new User();
  7. $cloneUser = clone $user;

二、结构型模式

6. 适配器模式 (Adapter)

一句话：把不兼容的接口转成兼容，像电源转接头。
例子：老接口返回 XML，新系统要用 JSON → 适配器转一下。
目的：使不兼容的接口能够协同工作。
场景：集成第三方库（如支付网关适配）。 

  1. // 老类
  2. class OldSystem
  3. {
  4.     public function oldRequest()
  5.     {
  6.         return "XML 数据";
  7.     }
  8. }
  10. // 新接口
  11. interface NewInterface
  12. {
  13.     public function request();
  14. }
  16. // 适配器
  17. class Adapter implements NewInterface
  18. {
  19.     public function __construct(public OldSystem $old) {}
  21.     public function request()
  22.     {
  23.         // 转换
  24.         return str_replace("XML", "JSON", $this->old->oldRequest());
  25.     }
  26. }
  28. // 使用
  29. $old = new OldSystem();
  30. $adapter = new Adapter($old);
  31. echo $adapter->request(); // JSON 数据
  33. # 以下另一示例：
  34. class PayPalAdapter implements PaymentGateway {
  35.     private $paypal;
  36.     public function __construct(PayPal $paypal) {
  37.         $this->paypal = $paypal;
  38.     }
  39.     public function pay($amount) {
  40.         $this->paypal->executePayment($amount);
  41.     }
  42. }

7. 装饰器模式 (Decorator)

一句话：不修改原类，给对象动态加功能。
例子：一杯咖啡 → 加牛奶、加糖、加冰，都是装饰，咖啡本身不变。
目的：动态地为对象添加职责。
场景：文件流处理（如压缩、加密）。 

  1. interface Coffee
  2. {
  3.     public function cost();
  4. }
  6. // 基础咖啡
  7. class SimpleCoffee implements Coffee
  8. {
  9.     public function cost() { return 10; }
  10. }
  12. // 装饰器基类
  13. abstract class Decorator implements Coffee
  14. {
  15.     public function __construct(protected Coffee $coffee) {}
  16. }
  18. // 加牛奶
  19. class Milk extends Decorator
  20. {
  21.     public function cost()
  22.     {
  23.         return $this->coffee->cost() + 2;
  24.     }
  25. }
  27. // 使用
  28. $coffee = new SimpleCoffee();
  29. $coffee = new Milk($coffee); // 装饰
  30. echo $coffee->cost(); // 12
  33. # 以下另一示例：
  34. interface Logger {
  35.     public function log($message);
  36. }
  38. class FileLogger implements Logger { /* ... */ }
  40. class EncryptedLogger implements Logger {
  41.     private $logger;
  42.     public function __construct(Logger $logger) {
  43.         $this->logger = $logger;
  44.     }
  45.     public function log($message) {
  46.         $encrypted = encrypt($message);
  47.         $this->logger->log($encrypted);
  48.     }
  49. }

8. 代理模式 (Proxy)

一句话：找个中间人帮你做事，控制原对象访问。
例子：

  • 日志代理：记录方法调用
  • 延迟加载：真正用到时才初始化
  • 权限控制：没权限不让调用
    目的：为其他对象提供代理以控制访问。
    场景：延迟加载大对象、权限验证。
    ```php interface User { public function getInfo(); }

// 真实类 class RealUser implements User { public function getInfo() { echo “获取用户信息”; } }

// 代理 class ProxyUser implements User { public function __construct(public RealUser $user) {}

  1. public function getInfo()
  2. {
  3.     echo "权限验证\n"; // 附加功能
  4.     $this->user->getInfo();
  5. }

}

// 使用 $user = new ProxyUser(new RealUser()); $user->getInfo();

以下另一示例：

class ImageProxy { private $image = null; public function display() { if ($this->image === null) { $this->image = new RealImage(“large.jpg”); } $this->image->display(); } }

  1. #### 9. 外观模式（Facade）
  2. **一句话**：给复杂系统**包一层简单入口**。  
  3. **例子**：电脑开机 → 你只按一个键，内部CPU、内存、硬盘自动启动。  
  4. ```html
  5. // 子系统
  6. class CPU
  7. {
  8.     public function start() { echo "CPU启动\n"; }
  9. }
  10. class Memory
  11. {
  12.     public function run() { echo "内存运行\n"; }
  13. }
  15. // 外观
  16. class Computer
  17. {
  18.     public function open()
  19.     {
  20.         (new CPU)->start();
  21.         (new Memory)->run();
  22.     }
  23. }
  25. // 使用
  26. $computer = new Computer();
  27. $computer->open(); // 一键启动

10. 桥接模式（Bridge）

一句话：把两个变化维度分开，互不影响。 例子：
形状（圆、方） + 颜色（红、蓝）
分开设计，自由组合：红圆、蓝方… 

  1. // 维度1：颜色
  2. interface Color { public function show(); }
  3. class Red implements Color { public function show(){echo "红色";} }
  4. class Blue implements Color { public function show(){echo "蓝色";} }
  6. // 维度2：形状（桥接颜色）
  7. abstract class Shape {
  8.     public function __construct(protected Color $color) {}
  9.     public abstract function draw();
  10. }
  12. // 圆形
  13. class Circle extends Shape {
  14.     public function draw() {
  15.         $this->color->show(); echo "圆形\n";
  16.     }
  17. }
  19. // 使用：任意组合
  20. $shape = new Circle(new Red());
  21. $shape->draw(); // 红色圆形

11. 组合模式 (Composite)

一句话：单个对象和组合对象用起来一样。
例子：文件和文件夹 → 都能“打开/删除/移动”。
目的：将对象组合成树形结构以表示“部分-整体”层次。
场景：文件系统目录结构、菜单系统。 

  1. interface FileSystemComponent {
  2.     public function render();
  3. }
  5. class File implements FileSystemComponent {
  6.     public function render() { /* 显示文件 */ }
  7. }
  9. class Directory implements FileSystemComponent {
  10.     private $children = [];
  11.     public function addComponent(FileSystemComponent $c) { /* ... */ }
  12.     public function render() { /* 递归渲染子项 */ }
  13. }

12. 享元模式（Flyweight）

一句话：共享相同对象，节省内存。
例子：围棋棋子，黑棋白棋各一个对象，无数次复用。 

  1. // 享元工厂：复用棋子
  2. class PieceFactory {
  3.     private static $pool = []; // 对象池
  5.     public static function get($color) {
  6.         if(!isset(self::$pool[$color])){
  7.             self::$pool[$color] = new Piece($color);
  8.         }
  9.         return self::$pool[$color];
  10.     }
  11. }
  13. // 享元类
  14. class Piece {
  15.     public function __construct(private $color) {}
  16.     public function show($x,$y){
  17.         echo "{$this->color}棋在($x,$y)\n";
  18.     }
  19. }
  21. // 使用：黑棋永远只有一个对象
  22. $p1 = PieceFactory::get("黑");
  23. $p2 = PieceFactory::get("黑");
  24. $p1->show(1,2);
  25. var_dump($p1===$p2); // true 同一个对象

三、行为型模式

（对象之间“怎么通信、怎么运作”）

13. 观察者模式 (Observer)

你刚才问的 TP6 事件系统就是这个！
一句话：一个对象变化，自动通知所有依赖它的对象。
例子：订阅公众号 → 发文章自动推送给所有粉丝。
目的：定义对象间的一对多依赖，当一个对象状态改变时自动通知依赖者。
场景：事件监听（如用户注册后发送邮件）、日志记录。 

  1. // 被观察者
  2. class Event
  3. {
  4.     private $listeners = [];
  6.     // 绑定监听
  7.     public function attach($listener)
  8.     {
  9.         $this->listeners[] = $listener;
  10.     }
  12.     // 触发
  13.     public function trigger()
  14.     {
  15.         foreach ($this->listeners as $l) $l->update();
  16.     }
  17. }
  19. // 观察者
  20. class Listener1
  21. {
  22.     public function update() { echo "记录日志\n"; }
  23. }
  24. class Listener2
  25. {
  26.     public function update() { echo "发送消息\n"; }
  27. }
  29. // 使用
  30. $event = new Event();
  31. $event->attach(new Listener1());
  32. $event->attach(new Listener2());
  33. $event->trigger(); // 同时执行两个监听

14. 策略模式 (Strategy)

一句话：把不同算法封装起来，可以随时切换。
例子：支付方式 → 支付宝、微信、银行卡，随时切换，逻辑互不干扰。
目的：定义一系列算法并使其可互换。
场景：支付方式切换（支付宝/微信）、排序算法选择。 

  1. interface Strategy
  2. {
  3.     public function calc($a, $b);
  4. }
  6. // 策略A
  7. class Add implements Strategy
  8. {
  9.     public function calc($a, $b) { return $a + $b; }
  10. }
  11. // 策略B
  12. class Sub implements Strategy
  13. {
  14.     public function calc($a, $b) { return $a - $b; }
  15. }
  17. // 环境类
  18. class Context
  19. {
  20.     public function __construct(public Strategy $strategy) {}
  21.     public function exec($a, $b)
  22.     {
  23.         return $this->strategy->calc($a, $b);
  24.     }
  25. }
  27. // 切换策略
  28. $ctx = new Context(new Add());
  29. echo $ctx->exec(5, 3); // 8
  31. $ctx = new Context(new Sub());
  32. echo $ctx->exec(5, 3); // 2
  34. # 以下另一示例：
  35. interface SortStrategy {
  36.     public function sort(array $data);
  37. }
  39. class QuickSort implements SortStrategy { /* ... */ }
  41. class Sorter {
  42.     private $strategy;
  43.     public function setStrategy(SortStrategy $s) { $this->strategy = $s; }
  44.     public function execute(array $data) { return $this->strategy->sort($data); }
  45. }

15. 命令模式 (Command)

一句话：把请求封装成命令对象，可记录、可撤销、可排队。
例子：遥控器按钮 → 每个按钮是一个命令，可撤销操作。
目的：将请求封装为对象，以便参数化、队列化或记录请求。
场景：任务队列、事务回滚、宏命令。 

  1. interface Command {
  2.     public function execute();
  3. }
  5. class CreateUserCommand implements Command {
  6.     private $userService;
  7.     public function execute() { $this->userService->create(); }
  8. }
  10. class CommandQueue {
  11.     private $commands = [];
  12.     public function add(Command $c) { $this->commands[] = $c; }
  13.     public function process() { foreach ($this->commands as $c) $c->execute(); }
  14. }

16. 迭代器模式（Iterator）

一句话：不暴露集合内部结构，按顺序遍历元素。安全遍历集合，不暴露内部结构。PHP 内置支持，最常用。
例子：PHP 的 foreach 就是迭代器。 

  1. // 自定义集合
  2. class ListCollection implements IteratorAggregate {
  3.     private $items = ['A','B','C'];
  5.     // 返回迭代器
  6.     public function getIterator() {
  7.         return new ArrayIterator($this->items);
  8.     }
  9. }
  11. // 使用：foreach 就是迭代器
  12. $list = new ListCollection();
  13. foreach($list as $v) echo $v."\n";

17. 责任链模式 (Chain of Responsibility)

一句话：请求顺着一条链传递，直到有人处理它。
例子：请假审批 → 组长 → 经理 → 总监，一层层传递。
目的：使多个对象都有机会处理请求，避免请求发送者与接收者耦合。
场景：中间件管道（如 Laravel 中间件）、审批流程。 

  1. abstract class Handler
  2. {
  3.     protected $next;
  4.     public function setNext($next)
  5.     {
  6.         $this->next = $next;
  7.     }
  9.     abstract public function handle($day);
  10. }
  12. // 组长
  13. class Leader extends Handler
  14. {
  15.     public function handle($day)
  16.     {
  17.         if ($day <= 1) echo "组长批准\n";
  18.         else $this->next->handle($day);
  19.     }
  20. }
  21. // 经理
  22. class Manager extends Handler
  23. {
  24.     public function handle($day)
  25.     {
  26.         if ($day <= 3) echo "经理批准\n";
  27.         else echo "总监批准\n";
  28.     }
  29. }
  31. // 使用
  32. $leader = new Leader();
  33. $manager = new Manager();
  34. $leader->setNext($manager);
  35. $leader->handle(2); // 经理批准
  37. # 以下另一示例：
  38. abstract class Middleware {
  39.     protected $next;
  40.     public function setNext(Middleware $m) { $this->next = $m; }
  41.     public function handle($request) {
  42.         if ($this->next) return $this->next->handle($request);
  43.     }
  44. }
  46. class AuthMiddleware extends Middleware {
  47.     public function handle($request) {
  48.         if (!auth()->check()) throw new UnauthorizedException();
  49.         parent::handle($request);
  50.     }
  51. }

18. 模板方法模式（Template）

一句话：定义固定流程骨架，具体步骤子类实现。
例子：做咖啡流程：烧水 → 冲泡 → 加调料 → 完成，流程固定，调料不同。 

  1. abstract class MakeDrink
  2. {
  3.     // 模板：固定流程
  4.     public final function make()
  5.     {
  6.         $this->boil();
  7.         $this->brew();
  8.         $this->add();
  9.     }
  11.     public function boil() { echo "烧水\n"; }
  12.     abstract public function brew();
  13.     abstract public function add();
  14. }
  16. // 咖啡
  17. class Coffee extends MakeDrink
  18. {
  19.     public function brew() { echo "冲泡咖啡\n"; }
  20.     public function add() { echo "加糖\n"; }
  21. }
  23. // 使用
  24. $drink = new Coffee();
  25. $drink->make();

19. 状态模式（State）

一句话：对象内部状态改变，行为就改变。，不用大量 if/else。
例子：订单状态：待付款 → 已付款 → 已发货 → 完成，状态不同行为不同。 

  1. // 状态接口
  2. interface State { public function handle(Order $order); }
  4. // 订单
  5. class Order {
  6.     private $state;
  7.     public function setState(State $state){$this->state=$state;}
  8.     public function do(){ $this->state->handle($this); }
  9. }
  11. // 具体状态
  12. class PayState implements State {
  13.     public function handle(Order $order){echo "已付款\n";}
  14. }
  15. class ShipState implements State {
  16.     public function handle(Order $order){echo "已发货\n";}
  17. }
  19. // 使用：切换状态自动变行为
  20. $order = new Order();
  21. $order->setState(new PayState());
  22. $order->do(); // 已付款

20. 中介者模式（Mediator）

一句话：对象之间不直接通信，通过中介交互。
例子：聊天室 → 大家不私聊，都发给服务器，服务器转发。 

  1. // 中介者：聊天室
  2. class ChatRoom {
  3.     public static function send(User $user, $msg) {
  4.         echo $user->name."：".$msg."\n";
  5.     }
  6. }
  8. // 用户
  9. class User {
  10.     public function __construct(public $name) {}
  11.     public function send($msg) {
  12.         ChatRoom::send($this, $msg);
  13.     }
  14. }
  16. // 使用：不直接私聊
  17. $u1 = new User("张三");
  18. $u2 = new User("李四");
  19. $u1->send("你好"); // 张三：你好

21. 访问者模式（Visitor）

一句话：不改变数据结构，给结构增加新操作。或不修改类，给类增加新功能。
例子：一个商品列表，增加“计算总价”“导出报表”等功能。 

  1. // 访问者
  2. interface Visitor { public function visit(Product $p); }
  3. class PriceVisitor implements Visitor {
  4.     public function visit(Product $p) {echo "价格：".$p->price."\n";}
  5. }
  7. // 元素
  8. class Product {
  9.     public function __construct(public $price) {}
  10.     public function accept(Visitor $v) {$v->visit($this);}
  11. }
  13. // 使用
  14. $p = new Product(99);
  15. $p->accept(new PriceVisitor()); // 打印价格

22. 备忘录模式（Memento）

一句话：保存对象某个时刻状态，需要时恢复。或保存状态，可撤销 / 回滚。
例子：游戏存档、编辑器撤销（Ctrl+Z）。 

  1. // 备忘录：保存状态
  2. class Memento {
  3.     public function __construct(public $state) {}
  4. }
  6. // 原发器
  7. class Editor {
  8.     private $content;
  9.     public function set($c) {$this->content=$c;}
  10.     public function save() {return new Memento($this->content);}
  11.     public function restore($m) {$this->content=$m->state;}
  12. }
  14. // 使用
  15. $e = new Editor();
  16. $e->set("版本1");
  17. $backup = $e->save(); // 存档
  18. $e->set("版本2");
  19. $e->restore($backup); // 回滚到版本1

23. 解释器模式（Interpreter）

一句话：自定义语法规则，自己解析执行。
例子：简单计算器、规则引擎、表达式判断。 

  1. // 解释器
  2. class Context {
  3.     public function __construct(public $input) {}
  4. }
  6. // 规则：判断是否包含
  7. class ContainsExp {
  8.     public function __construct(private $key) {}
  9.     public function interpret(Context $ctx) {
  10.         return str_contains($ctx->input, $this->key);
  11.     }
  12. }
  14. // 使用
  15. $ctx = new Context("HelloWorld");
  16. $exp = new ContainsExp("Hello");
  17. var_dump($exp->interpret($ctx)); // true

四、超简记忆口诀（你记这个就够）

  • 创建型：怎么new对象（单例、工厂、建造者）
  • 结构型：怎么组合代码（适配器、装饰器、代理、外观）
  • 行为型：对象怎么通信（观察者、策略、责任链、命令）

五、如何选择设计模式？

  1. 解耦需求：当系统需要降低模块间耦合时（如观察者模式）。
  2. 复用与扩展：需灵活扩展功能时（如装饰器模式）。
  3. 复杂流程控制：如状态模式管理订单生命周期。
  4. 代码可维护性：如策略模式替代条件分支（switch-case）。

通过合理使用设计模式，可以提升代码的可维护性、扩展性和复用性，但需避免过度设计。