thinkphp6.0常用设计模式实例

单例模式 (Singleton)

场景：确保一个类只有一个实例，并提供一个全局访问点。
实际业务：数据库连接、日志记录器、配置管理等。

ThinkPHP 6.0 实现：

namespace app\common;class DatabaseConnection
{private static $instance = null;private function __construct() {}public static function getInstance(){if (self::$instance === null) {self::$instance = new self();}return self::$instance;}public function connect(){// 连接数据库return "Database connected!";}
}// 使用
$db = DatabaseConnection::getInstance();
echo $db->connect();

namespace app\lib;class Database
{private static $instance = null;private function __construct(){// 私有化构造函数，防止外部实例化}public static function getInstance(){if (self::$instance === null) {self::$instance = new self();}return self::$instance;}public function query($sql){// 执行数据库查询return "Executing: $sql";}
}// 使用
$db = Database::getInstance();
echo $db->query("SELECT * FROM users");

工厂模式 (Factory)

场景：根据不同的条件创建不同的对象。
实际业务：支付方式选择、日志记录器创建等。

namespace app\lib;class PaymentFactory
{public static function create($type){switch ($type) {case 'wechat':return new WechatPayment();case 'alipay':return new AlipayPayment();default:throw new \Exception("Unsupported payment type");}}
}class WechatPayment
{public function pay(){return "Paying with WeChat";}
}class AlipayPayment
{public function pay(){return "Paying with Alipay";}
}// 使用
$payment = PaymentFactory::create('wechat');
echo $payment->pay();

观察者模式 (Observer)

场景：当一个对象的状态发生变化时，通知依赖它的所有对象。
实际业务：订单状态变更通知、用户注册后发送邮件等。

示例代码：

namespace app\lib;class Order
{private $observers = [];public function attach($observer){$this->observers[] = $observer;}public function notify(){foreach ($this->observers as $observer) {$observer->update($this);}}public function complete(){echo "Order completed!\n";$this->notify();}
}class EmailNotifier
{public function update($order){echo "Sending email notification...\n";}
}// 使用
$order = new Order();
$order->attach(new EmailNotifier());
$order->complete();

策略模式 (Strategy)

场景：定义一系列算法，使它们可以互相替换。
实际业务：支付方式选择、折扣计算等。

示例代码：

namespace app\lib;interface DiscountStrategy
{public function calculate($price);
}class NoDiscount implements DiscountStrategy
{public function calculate($price){return $price;}
}class HalfDiscount implements DiscountStrategy
{public function calculate($price){return $price * 0.5;}
}class Order
{private $discountStrategy;public function setDiscountStrategy(DiscountStrategy $strategy){$this->discountStrategy = $strategy;}public function calculatePrice($price){return $this->discountStrategy->calculate($price);}
}// 使用
$order = new Order();
$order->setDiscountStrategy(new HalfDiscount());
echo $order->calculatePrice(100); // 输出: 50

命令模式 (Command)

场景：将请求封装为对象，使请求的发送者和接收者解耦。
实际业务：任务队列、撤销操作等。

示例代码：

namespace app\lib;interface Command
{public function execute();
}class LightOnCommand implements Command
{private $light;public function __construct($light){$this->light = $light;}public function execute(){$this->light->on();}
}class Light
{public function on(){echo "Light is on\n";}
}// 使用
$light = new Light();
$command = new LightOnCommand($light);
$command->execute();

适配器模式 (Adapter)

场景：将一个类的接口转换成客户端期望的另一个接口。
实际业务：兼容不同第三方库、接口转换等。

示例代码：

namespace app\lib;class OldLibrary
{public function specificRequest(){return "Old library response";}
}interface NewLibraryInterface
{public function request();
}class Adapter implements NewLibraryInterface
{private $oldLibrary;public function __construct(OldLibrary $oldLibrary){$this->oldLibrary = $oldLibrary;}public function request(){return $this->oldLibrary->specificRequest();}
}// 使用
$oldLibrary = new OldLibrary();
$adapter = new Adapter($oldLibrary);
echo $adapter->request();

装饰者模式 (Decorator)

场景：动态地为对象添加功能。
实际业务：日志记录、权限校验等。

示例代码：

namespace app\lib;interface Component
{public function operation();
}class ConcreteComponent implements Component
{public function operation(){return "ConcreteComponent";}
}class Decorator implements Component
{protected $component;public function __construct(Component $component){$this->component = $component;}public function operation(){return $this->component->operation();}
}class LogDecorator extends Decorator
{public function operation(){echo "Logging before operation\n";$result = parent::operation();echo "Logging after operation\n";return $result;}
}// 使用
$component = new ConcreteComponent();
$decorator = new LogDecorator($component);
echo $decorator->operation();

责任链模式 (Chain of Responsibility)

场景：将请求的发送者和接收者解耦，使多个对象都有机会处理请求。
实际业务：权限校验、日志记录等。

示例代码：

namespace app\lib;abstract class Handler
{protected $nextHandler;public function setNext(Handler $handler){$this->nextHandler = $handler;}public function handle($request){if ($this->nextHandler !== null) {return $this->nextHandler->handle($request);}return null;}
}class AuthHandler extends Handler
{public function handle($request){if ($request === 'auth') {return "AuthHandler: Handling request\n";}return parent::handle($request);}
}class LogHandler extends Handler
{public function handle($request){if ($request === 'log') {return "LogHandler: Handling request\n";}return parent::handle($request);}
}// 使用
$authHandler = new AuthHandler();
$logHandler = new LogHandler();
$authHandler->setNext($logHandler);echo $authHandler->handle('log');

访问者模式 (Visitor)

场景：将算法与对象结构分离。
实际业务：报表生成、数据导出等。

示例代码：

namespace app\lib;interface Visitor
{public function visitElementA(ElementA $element);public function visitElementB(ElementB $element);
}class ConcreteVisitor implements Visitor
{public function visitElementA(ElementA $element){echo "Visiting ElementA\n";}public function visitElementB(ElementB $element){echo "Visiting ElementB\n";}
}interface Element
{public function accept(Visitor $visitor);
}class ElementA implements Element
{public function accept(Visitor $visitor){$visitor->visitElementA($this);}
}class ElementB implements Element
{public function accept(Visitor $visitor){$visitor->visitElementB($this);}
}// 使用
$visitor = new ConcreteVisitor();
$elementA = new ElementA();
$elementB = new ElementB();$elementA->accept($visitor);
$elementB->accept($visitor);

中介者模式 (Mediator)

场景：减少对象之间的直接依赖，通过中介者进行通信。
实际业务：聊天室、事件调度等。

示例代码：

namespace app\lib;class ChatRoom
{public static function showMessage($user, $message){echo "[" . $user . "] : " . $message . "\n";}
}class User
{private $name;public function __construct($name){$this->name = $name;}public function sendMessage($message){ChatRoom::showMessage($this->name, $message);}
}// 使用
$john = new User("John");
$jane = new User("Jane");$john->sendMessage("Hi Jane!");
$jane->sendMessage("Hello John!");

备忘录模式 (Memento)

场景：捕获并外部化对象的内部状态，以便以后可以恢复。
实际业务：撤销操作、游戏存档等。

示例代码：

namespace app\lib;class Editor
{private $content;public function setContent($content){$this->content = $content;}public function getContent(){return $this->content;}public function save(){return new EditorMemento($this->content);}public function restore(EditorMemento $memento){$this->content = $memento->getContent();}
}class EditorMemento
{private $content;public function __construct($content){$this->content = $content;}public function getContent(){return $this->content;}
}// 使用
$editor = new Editor();
$editor->setContent("First content");
$saved = $editor->save();$editor->setContent("Second content");
echo $editor->getContent(); // 输出: Second content$editor->restore($saved);
echo $editor->getContent(); // 输出: First content

迭代器模式 (Iterator)

场景：提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部表示。
实际业务：遍历集合、分页查询等。

示例代码：

namespace app\lib;class Book
{private $title;public function __construct($title){$this->title = $title;}public function getTitle(){return $this->title;}
}class BookList implements \Iterator
{private $books = [];private $position = 0;public function addBook(Book $book){$this->books[] = $book;}public function current(){return $this->books[$this->position];}public function next(){$this->position++;}public function key(){return $this->position;}public function valid(){return isset($this->books[$this->position]);}public function rewind(){$this->position = 0;}
}// 使用
$bookList = new BookList();
$bookList->addBook(new Book("Design Patterns"));
$bookList->addBook(new Book("Clean Code"));foreach ($bookList as $book) {echo $book->getTitle() . "\n";
}

门面模式

ThinkPHP 6.0 的门面模式依赖于容器（Container）和门面类（Facade）。门面类通过 __callStatic 方法将静态调用转发到容器中的实例。

示例代码：
以下是一个自定义门面类的实现：

namespace app\facade;use think\Facade;class MyService extends Facade
{protected static function getFacadeClass(){// 返回容器中绑定的类标识return 'my_service';}
}

绑定服务到容器：
在服务提供者中，将具体的实现类绑定到容器：

namespace app\provider;use think\Service;class MyServiceProvider extends Service
{public function register(){// 绑定服务到容器$this->app->bind('my_service', \app\service\MyService::class);}
}

具体实现类：

namespace app\service;class MyService
{public function doSomething(){return "Doing something...";}
}

使用门面类：

use app\facade\MyService;echo MyService::doSomething(); // 输出: Doing something...

ThinkPHP 6.0 内置门面类

ThinkPHP 6.0 提供了许多内置的门面类，例如：

Db：数据库操作

Cache：缓存操作

Log：日志记录

Request：请求对象

Config：配置管理

示例：使用内置门面类

use think\facade\Db;
use think\facade\Cache;
use think\facade\Log;// 数据库查询
$users = Db::table('users')->select();// 缓存操作
Cache::set('name', 'ThinkPHP');
echo Cache::get('name');// 日志记录
Log::info('This is a log message.');

门面模式的优势

简化调用：通过静态方法调用，代码更加简洁。

解耦：调用者无需关心具体的实现类，降低了耦合度。

易于扩展：可以通过绑定不同的实现类来扩展功能。

统一接口：为复杂的子系统提供一个统一的接口。

门面模式的使用场景

数据库操作：通过 Db 门面类，统一调用数据库操作方法。

缓存操作：通过 Cache 门面类，统一调用缓存操作方法。

日志记录：通过 Log 门面类，统一调用日志记录方法。

配置管理：通过 Config 门面类，统一调用配置管理方法。

自定义服务：为自定义的服务提供统一的静态调用接口。

门面模式的实现原理

ThinkPHP 6.0 的门面模式依赖于容器和 Facade 基类。以下是其核心实现原理：

Facade 基类：

namespace think;abstract class Facade
{protected static $app;public static function setFacadeApplication($app){self::$app = $app;}public static function __callStatic($method, $params){$instance = self::$app->make(static::getFacadeClass());return $instance->$method(...$params);}protected static function getFacadeClass(){throw new \RuntimeException('Facade does not implement getFacadeClass method.');}
}

关键点：
__callStatic 方法：将静态调用转发到容器中的实例。

getFacadeClass 方法：返回容器中绑定的类标识。