PHP设计模式-模板方法模式 模板方法（Template Method）模式，英文是 Template Method Design Pattern。在 GoF 的《设计模式》一书中，它是这么定义的：Define the skeleton of an algorithm in an operation, deferring some steps to subclasses. Template Method lets subclasses redefine certain steps of an algorithm without changing the algorithm’s structure.翻译成中文就是：模板方法模式在一个方法中定义一个算法骨架，并将某些步骤推迟到子类中实现。模板方法模式可以让子类在不改变算法整体结构的情况下，重新定义算法中的某些步骤。这里的“算法”，我们可以理解为广义上的“业务逻辑”，并不特指数据结构和算法中的“算法”。这里的算法骨架就是“模板”，包含算法骨架的方法就是“模板方法”，这也是模板方法模式名字的由来。模板方法模式的结构与实现结构抽象类（Abstract Class）：定义了一到多个的抽象方法，以供具体的子类来实现它们；而且还要实现一个模板方法，来定义一个算法的骨架。该模板方法不仅调用前面的抽象方法，也可以调用其他的操作，只要能完成自身的使命。如果你不想模板方法被子类重写，可用 final修饰模板方法以防止子类对其进行重写。具体类（Concrete Class）：实现父类中的抽象方法以完成算法中与特定子类相关的步骤。代码实现AbstractClass.php<?php namespace DesignPatterns\TemplateMethod\example1; /** * AbstractClass是抽象类，其实也就是一抽象模板， 定义并实现了一个模板方法。这个模板方法一般 * 是一个具体方法，它给出了一个顶级逻辑的骨架，而逻辑的组成步骤在相应的抽象操作中，推迟到子类 * 实现。顶级逻辑也有可能调用一些具体方法。 * Class AbstractClass * @package DesignPatterns\TemplateMethod\example1 */ abstract class AbstractClass { //定义抽象行为，在子类中实现 abstract public function PrimitiveOperation1(); abstract public function PrimitiveOperation2(); //模板方法给出逻辑的骨架，而逻辑的组成是一些相应的抽象操作 //它们都推迟到子类中实现 public function TemplateMethod() { $this->PrimitiveOperation1(); $this->PrimitiveOperation2(); } }ConcreteClassA.php<?php namespace DesignPatterns\TemplateMethod\example1; /** * ConcreteClass,实现父类所定义的一一个或多个抽象方法。每一一个AbstractClass都可以有任意多个 * ConcreteClass与之对应，而每一一个 ConcreteClass都可以 * 给出这些抽象方法(也就是顶级逻辑的组成步骤)的不同实现，从而使得顶级逻辑的实现各不相同。 * Class ConcreteClassA * @package DesignPatterns\TemplateMethod\example1 */ class ConcreteClassA extends AbstractClass { public function PrimitiveOperation1() { echo '具体类A实现方法1',PHP_EOL; } public function PrimitiveOperation2() { echo '具体类A实现方法2',PHP_EOL; } }ConcreteClassB.php<?php namespace DesignPatterns\TemplateMethod\example1; /** * Class ConcreteClassB * @package DesignPatterns\TemplateMethod\example1 */ class ConcreteClassB extends AbstractClass { public function PrimitiveOperation1() { echo '具体类B实现方法1',PHP_EOL; } public function PrimitiveOperation2() { echo '具体类B实现方法2',PHP_EOL; } }运行Client.php<?php namespace DesignPatterns\TemplateMethod\example1; require dirname(__DIR__).'/../vendor/autoload.php'; /** * Class Client * @package DesignPatterns\TemplateMethod\example1 */ class Client { public function run(){ $c = new ConcreteClassA(); $c->TemplateMethod(); echo "<br>"; $c = new ConcreteClassB(); $c->TemplateMethod(); } } $worker = new Client(); $worker->run();运行结果：在客户端的调用中，实例化子类，但调用的是子类所继承的父类的模板方法。它决定了执行的顺序等行为只能由父级抽象类决定；而子类只需要完成具体的操作内容；示例在本例中， 模板方法模式定义了在社交网络上发布消息的算法框架。 每个子类都代表一个不同的社交网络， 它们虽以不同方式实现所有步骤， 但却会复用基本的算法。SocialNetwork.php<?php namespace DesignPatterns\TemplateMethod\example2; /** * Class SocialNetwork * @package DesignPatterns\TemplateMethod\example2 */ abstract class SocialNetwork { protected $username; protected $password; public function __construct(string $username, string $password) { $this->username = $username; $this->password = $password; } /** * 实际的模板方法按特定的顺序调用抽象步骤。 * 子类可以实现所有的步骤，允许这个方法在社交网络上发布内容。 * @param string $message * @return bool */ public function post(string $message): bool { if ($this->logIn($this->username, $this->password)) { $result = $this->sendData($message); $this->logOut(); return $result; } return false; } //登陆 abstract public function logIn(string $userName, string $password): bool; //发布信息 abstract public function sendData(string $message): bool; //退出 abstract public function logOut(): void; //一个小助手方法，让等待时间感觉真实。 protected function simulateNetworkLatency() { $i = 0; while ($i < 5) { echo "."; sleep(1); $i++; } } } Facebook.php<?php namespace DesignPatterns\TemplateMethod\example2; /** * Class Facebook * @package DesignPatterns\TemplateMethod\example2 */ class Facebook extends SocialNetwork { public function logIn(string $userName, string $password): bool { echo "\n正在检查用户的凭据...\n"; echo "名称: " . $this->username . "\n"; echo "密码: " . str_repeat("*", strlen($this->password)) . "\n"; $this->simulateNetworkLatency(); echo "\n\nFacebook: '" . $this->username . "' 登录成功\n"; return true; } public function sendData(string $message): bool { echo "Facebook: '" . $this->username . "'发布了'".$message."'\n"; return true; } public function logOut(): void { echo "Facebook: '" . $this->username . "' 退出登录.\n"; } }ZhiHu.php<?php namespace DesignPatterns\TemplateMethod\example2; /** * Class Facebook * @package DesignPatterns\TemplateMethod\example2 */ class ZhiHu extends SocialNetwork { public function logIn(string $userName, string $password): bool { echo "\n正在检查用户的凭据...\n"; echo "名称: " . $this->username . "\n"; echo "密码: " . str_repeat("*", strlen($this->password)) . "\n"; $this->simulateNetworkLatency(); echo "\n\nzhihu: '" . $this->username . "' 登录成功\n"; return true; } public function sendData(string $message): bool { echo "zhihu: '" . $this->username . "'发布了'".$message."'\n"; return true; } public function logOut(): void { echo "zhihu: '" . $this->username . "' 退出登录.\n"; } }Client.php<?php namespace DesignPatterns\TemplateMethod\example2; require dirname(__DIR__).'/../vendor/autoload.php'; /** * Class Client * @package DesignPatterns\TemplateMethod\example2 */ class Client { public function run() { echo "Username: \n"; $username = readline(); echo "Password: \n"; $password = readline(); echo "Message: \n"; $message = readline(); echo "\nChoose the social network to post the message:\n" . "1 - Facebook\n" . "2 - zhihu\n"; $choice = readline(); // Now, let's create a proper social network object and send the message. if ($choice == 1) { $network = new Facebook($username, $password); } elseif ($choice == 2) { $network = new ZhiHu($username, $password); } else { die("Sorry, I'm not sure what you mean by that.\n"); } $network->post($message); } } $worker = new Client(); $worker->run();运行 Client.php总结模板方法模式在一个方法中定义一个算法骨架，并将某些步骤推迟到子类中实现。模板方法模式可以让子类在不改变算法整体结构的情况下，重新定义算法中的某些步骤。这里的“算法”，我们可以理解为广义上的“业务逻辑”，并不特指数据结构和算法中的“算法”。这里的算法骨架就是“模板”，包含算法骨架的方法就是“模板方法”，这也是模板方法模式名字的由来。在模板模式经典的实现中，模板方法定义为 final，可以避免被子类重写。需要子类重写的方法定义为 abstract，可以强迫子类去实现。不过，在实际项目开发中，模板模式的实现比较灵活，以上两点都不是必须的。参考资料：《大话设计模式》，《深入设计模式-模板方法模式》github示例：https://github.com/yangpanyao/design-patterns/tree/master/TemplateMethod

PHP设计模式-观察者模式 我们常把 23 种经典的设计模式分为三类：创建型、结构型、行为型。前面的文章我们已经讲了了创建型和结构型，我们知道，创建型设计模式主要解决“对象的创建”问题，结构型设计模式主要解决“类或对象的组合或组装”问题，从这篇文章开始，我们开始学习行为型设计模式。行为型设计模式主要解决的就是“类或对象之间的交互”问题。行为型设计模式比较多，有 11 个，几乎占了 23 种经典设计模式的一半。它们分别是：观察者模式、模板模式、策略模式、职责链模式、状态模式、迭代器模式、访问者模式、备忘录模式、命令模式、解释器模式、中介模式。这篇文章我们开始学习第一个行为型设计模式，也是在实际的开发中用得比较多的一种模式：观察者模式。观察者模式（Observer Design Pattern）也被称为发布订阅模式（Publish-Subscribe Design Pattern）。在 GoF 的《设计模式》一书中，它的定义是这样的：Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.翻译成中文就是：在对象之间定义一个一对多的依赖，当一个对象状态改变的时候，所有依赖的对象都会自动收到通知。一般情况下，被依赖的对象叫作被观察者（Observable），依赖的对象叫作观察者（Observer）。不过，在实际的项目开发中，这两种对象的称呼是比较灵活的，有各种不同的叫法，比如：Subject-Observer、Publisher-Subscriber、Producer-Consumer、EventEmitter-EventListener、Dispatcher-Listener。不管怎么称呼，只要应用场景符合刚刚给出的定义，都可以看作观察者模式。观察者模式的结构与实现结构抽象主题角色（Subject）：Subject类他把所有对观察者对象的引用保存在一个聚集里，每一个主题都可以有任意数量的观察者，抽象主题提供一个接口，可以增加和删除观察者对象 抽象观察者角色（Observer）：为所有的具体观察者定义一个接口在得到主题的通知时更新自己 具体主题角色（Concrete Subject）：将有关状态存入具体观察者对象，在具体主题的内部状态改变时，给所有登记过的观察者发出通知。 具体观察者角色（Concrete Observer）：实现抽象观察者角色所需要的更新接口，以便使本身的状态与主题的状态相协调。代码示例Subject.php<?php namespace DesignPatterns\Observer\example1; /** * Subject类，可翻译为主题或抽象通知者，- -般用-一个抽象类或者- -一个接口实现。它把所有对观察者 * 对象的引用保存在一一个聚集里，每个主题都可以有任何数量的观察者。抽象主题提供一一个接口， 可以增 * 加和删除观察者对象。 * Class Subject * @package DesignPatterns\Observer\example1 */ abstract class Subject { private $observers = []; //增加观察者 public function attach(Observer $observer) { array_push($this->observers,$observer); } //移除观察者 public function detach(Observer $observer) { foreach ($this->observers as $key =>$value){ if ($observer == $value){ unset($this->observers[$key]); } } } //通知 public function notify() { foreach ($this->observers as $observer){ $observer->update(); } } }Observer.php<?php namespace DesignPatterns\Observer\example1; /** * Observer类，抽象观察者，为所有的具体观察者定义一一个接口，在得到主题的通知时更新自己。 * 这个接口叫做更新接口。抽象观察者一-般用一 一个抽象类或者一 一个 接口实现。 * 更新接口通常包含一个Update()方法，这个方法叫做更新方法。 * Class Observer * @package DesignPatterns\Observer\example1 */ abstract class Observer { abstract public function update(); }ConcreteSubject.php<?php namespace DesignPatterns\Observer\example1; /** * ConcreteSubject类，叫做具体主题或具体通知者，将有关状态存入具体现察者对象;在具体主题的 * 内部状态改变时，给所有登记过的观察者发出通知。具体主题角色通常用一个具体子类实现。 * Class ConcreteSubject * @package DesignPatterns\Observer\example1 */ class ConcreteSubject extends Subject { private $subjectState; /** * @return mixed */ public function getSubjectState() { return $this->subjectState; } /** * @param mixed $subjectState */ public function setSubjectState($subjectState): void { $this->subjectState = $subjectState; } }ConcreteObserver.php<?php namespace DesignPatterns\Observer\example1; /** * ConcreteObserver类，具体观察者，实现抽象观察者角色所要求的更新接口，以便使本身的状态与 * 主题的状态相协调。具体观察者角色可以保存一个指向具体主题对象的引用。具体观察者角色通常用一个具体子类实现。 * Class ConcreteObserver * @package DesignPatterns\Observer\example1 */ class ConcreteObserver extends Observer { private $name; private $observerState; private $subject; public function __construct(ConcreteSubject $subject,$name) { $this->subject = $subject; $this->name = $name; } public function update() { echo "观察者".$this->name."的新状态是".$this->subject->getSubjectState()."<br>"; } }运行client.php<?php namespace DesignPatterns\Observer\example1; require dirname(__DIR__).'/../vendor/autoload.php'; class Client { public function run() { $concreteSubject = new ConcreteSubject(); $concreteSubject->attach(new ConcreteObserver($concreteSubject,"X")); $concreteSubject->attach(new ConcreteObserver($concreteSubject,'Y')); $z = new ConcreteObserver($concreteSubject,'Z'); $concreteSubject->attach($z); $concreteSubject->detach($z); $concreteSubject->setSubjectState("ABC"); $concreteSubject->notify(); } } $worker = new Client(); $worker->run();运行结果：上面的代码算是观察者模式PHP版的模版代码。而在PHP中5.1版本后PHP就内置了很多优秀的特性，其中之一就是提供了一组可以用于观察者设计模式的接口。包括SplObserver接口以及SplSubject和SplObjectStorage接口，利用这些接口，构建PHP观察者模式简直易如反掌。“SPL” 是标准PHP库(Standard PHP Library)的简写，这个库中包括一组解决标准问题的接口和类。下面是 基于PHP内置观察者模式接口的代码示例：ConcreteSubject.php<?php namespace DesignPatterns\Observer\example2; /** *具体主题 * Class ConcreteSubject * @package DesignPatterns\Observer\example2 */ class ConcreteSubject implements \SplSubject { protected $subjectState; protected $observer; public function __construct() { $this->observer = new \SplObjectStorage(); } //增加观察者 public function attach(\SplObserver $observer) { $this->observer->attach($observer); } //删除观察者 public function detach(\SplObserver $observer) { $this->observer->detach($observer); } //通知 public function notify() { foreach ($this->observer as $observer){ $observer->update($this); } } /** * @param mixed $subjectState */ public function setSubjectState($subjectState): void { $this->subjectState = $subjectState; } /** * @return mixed */ public function getSubjectState() { return $this->subjectState; } }ConcreteObserver.php<?php namespace DesignPatterns\Observer\example2; /** * 具体观察者 * Class ConcreteObserver * @package DesignPatterns\Observer\example2 */ class ConcreteObserver implements \SplObserver { private $name; private $subject; public function __construct(\SplSubject $subject,$name) { $this->subject = $subject; $this->name = $name; } public function update(\SplSubject $subject) { echo "观察者".$this->name."的新状态是".$subject->getSubjectState()."<br>"; } }运行Client.php<?php namespace DesignPatterns\Observer\example2; require dirname(__DIR__).'/../vendor/autoload.php'; class Client { public function run() { $concreteSubject = new ConcreteSubject(); $concreteSubject->attach(new ConcreteObserver($concreteSubject,'X')); $concreteSubject->attach(new ConcreteObserver($concreteSubject,'Y')); $z = new ConcreteObserver($concreteSubject,'Z'); $concreteSubject->attach($z); $concreteSubject->detach($z); $concreteSubject->setSubjectState("abc"); $concreteSubject->notify(); } } $worker = new Client(); $worker->run();运行结果：观察者模式的原理和代码实现都非常简单，也比较好理解，不需要过多的解释。我们还是通过一个具体的例子来重点讲一下，什么情况下需要用到这种设计模式？或者说，这种设计模式能解决什么问题呢？示例假设我们在开发一个 P2P 投资理财系统，用户注册成功之后，我们会给用户发放投资体验金。代码实现大致是下面这个样子的。class User { public function register($phone) { //省略输入参数的校验代码 echo "用户注册成功，用户账号".$phone;//简化注册 echo "发放投资体验金500";//简化发放投资体验金 } }虽然注册接口做了两件事情，注册和发放体验金，违反单一职责原则，但是，如果没有扩展和修改的需求，现在的代码实现是可以接受的。如果非得用观察者模式，就需要引入更多的类和更加复杂的代码结构，反倒是一种过度设计。相反，如果需求频繁变动，比如，用户注册成功之后，不再发放体验金，而是改为发放优惠券，并且还要给用户发送一封“欢迎注册成功”的站内信。这种情况下，我们就需要频繁地修改 register() 函数中的代码，违反开闭原则。而且，如果注册成功之后需要执行的后续操作越来越多，那 register() 函数的逻辑会变得越来越复杂，也就影响到代码的可读性和可维护性。这个时候，观察者模式就能派上用场了。利用观察者模式，我对上面的代码进行了重构。重构之后的代码如下所示：interface RegObserver { public function handleRegSuccess($phone); } class RegPromotionObserver implements RegObserver { public function handleRegSuccess($phone) { echo "用户 ".$phone.",你的投资体验金500元已到账<br>"; } } class RegNotificationObserver implements RegObserver { public function handleRegSuccess($phone) { echo "用户 ".$phone.",welcome <br>"; } } class User { private $regObservers=[]; /** * @param mixed $regObservers */ public function setRegObservers(RegObserver$regObservers) { $this->regObservers[] = $regObservers; } public function register($phone) { //省略输入参数的校验代码 //省略注册 foreach ($this->regObservers as $regObserver){ $regObserver->handleRegSuccess($phone); } } } //clientCode $user = new User(); $user->setRegObservers(new RegPromotionObserver()); $user->setRegObservers(new RegNotificationObserver()); $user->register('12345678901'); 运行结果：当我们需要添加新的观察者的时候，比如，用户注册成功之后，推送用户注册信息给大数据征信系统，基于观察者模式的代码实现，UserController 类的 register() 函数完全不需要修改，只需要再添加一个实现了RegObserver 接口的类，并且通过 setRegObservers() 函数将它注册到 UserController 类中即可。不过，你可能会说，当我们把发送体验金替换为发送优惠券的时候，需要修改 RegPromotionObserver 类中 handleRegSuccess() 函数的代码，这还是违反开闭原则呀？你说得没错，不过，相对于 register() 函数来说，handleRegSuccess() 函数的逻辑要简单很多，修改更不容易出错，引入 bug 的风险更低。前面我们已经学习了很多设计模式，不知道你有没有发现，实际上，设计模式要干的事情就是解耦。创建型模式是将创建和使用代码解耦，结构型模式是将不同功能代码解耦，行为型模式是将不同的行为代码解耦，具体到观察者模式，它是将观察者和被观察者代码解耦。借助设计模式，我们利用更好的代码结构，将一大坨代码拆分成职责更单一的小类，让其满足开闭原则、高内聚松耦合等特性，以此来控制和应对代码的复杂性，提高代码的可扩展性。总结观察者模式，定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。观察者模式所做的工作其实就是在接触耦合。让耦合的双方都依赖于抽象，而不是依赖于具体。从而使得各自的变化都不会影响另一边的变化。参考文章：设计模式之美-观察者模式（上）：详解各种应用场景下观察者模式的不同实现方式github示例：https://github.com/yangpanyao/design-patterns/tree/master/Observer

PHP设计模式-亨元模式 前面我们已经讲了结构型设计模式中的，代理模式、桥接模式、装饰器模式、适配器模式、门面模式以及组合模式。今天我们来讲结构型设计模式的最后一个模式-亨元（Flyweight）模式。享元模式的定义为：采用一个共享类来避免大量拥有相同内容的“小类”的开销。这种开销中最常见、直观的影响就是增加了内存的损耗。享元模式以共享的方式高效的支持大量的细粒度对象，减少其带来的开销。享元模式的意图是复用对象，节省内存，前提是享元对象是不可变对象。亨元模式的结构与实现结构代码实现Flyweight.php<?php namespace DesignPatterns\Flyweight\example1; /** * Flyweight类，它是所有具体亨元类的超类或者接口，通过这个接口Flyweight可以接受并作用于外部状态 * Class Flyweight * @package DesignPatterns\Flyweight\example1 */ abstract class Flyweight { abstract public function Operation(int $extrinsicstate); }ConcreteFlyweight.php<?php namespace DesignPatterns\Flyweight\example1; /** * ConcreteFlyweight继承Flyweight超类或实现Flyweight接口，并为内部状态增加储存空间 * Class ConcreteFlyweight * @package DesignPatterns\Flyweight\example1 */ class ConcreteFlyweight extends Flyweight { public function Operation(int $extrinsicstate) { echo "具体Flyweight: ".$extrinsicstate."<br>"; } }UnsharedConcreteFlyweight.php<?php namespace DesignPatterns\Flyweight\example1; /** * UnsharedConcreteFlyweight 是指那些不需要共享的Flyweight子类，因为Flyweight接口并不强制共享 * Class UnsharedConcreteFlyweight * @package DesignPatterns\Flyweight\example1 */ class UnsharedConcreteFlyweight extends Flyweight { public function Operation(int $extrinsicstate) { echo "不共享的具体Flyweight: ".$extrinsicstate."<br>"; } }FlyweightFactory.php<?php namespace DesignPatterns\Flyweight\example1; /** * FlyweightFactory 是一个亨元工厂用来创建并管理Flyweight对象它主要用来确保 * 合理的共享Flyweight，当用户请求Flyweight时，FlyweightFactory对象提供一个已经创建的实例或者创建一个 * Class FlyweightFactory * @package DesignPatterns\Flyweight\example1 */ class FlyweightFactory { private $flyweights = []; public function __construct() { //初始化是先生成三个实例 $this->flyweights['X'] = new ConcreteFlyweight(); $this->flyweights['Y'] = new ConcreteFlyweight(); $this->flyweights['Z'] = new ConcreteFlyweight(); } //根据客户端的请求获取已请求的实例 public function GetFlyweight($key) { return $this->flyweights[$key]; } }运行 Client.php<?php namespace DesignPatterns\Flyweight\example1; require dirname(__DIR__).'/../vendor/autoload.php'; /** * Class Client * @package DesignPatterns\Flyweight\example1 */ class Client { public function run() { $extrinsicstate = 22; $FlyweightFactory = new FlyweightFactory(); $fx = $FlyweightFactory->GetFlyweight('X'); $fx->Operation(--$extrinsicstate); $fy = $FlyweightFactory->GetFlyweight('Y'); $fy->Operation(--$extrinsicstate); $fz = $FlyweightFactory->GetFlyweight('Z'); $fz->Operation(--$extrinsicstate); $UnsharedConcreteFlyweight = new UnsharedConcreteFlyweight(); $UnsharedConcreteFlyweight->Operation(--$extrinsicstate); } } $worker = new Client(); $worker->run();运行结果：在本例中FlyweightFactory（亨元工厂）在初始化中直接生成好了客户需要的对象。实例开发中我们不一定需要，完全可以初始化时不操作，到需要时再去判断对象是否为null再决定是否实例化。关于UnsharedConcreteFlyweight，我们大部分的时间都需要都需要共享对象来降低内存的损耗，但个别时候也有可能不需要共享，那么此时的UnsharedConcreteFlyweight就有了存在的必要。他可以解决那些不需要共享对象的问题。示例假如你接手了一个项目，客户要求做一个产品展示的网站。这个不难实现，你花了一份时间就写好了并成功上线。后来又有大量的客户来找你，也希望能做这样的网站，但要求不太一样。有的客户希望是新闻发布形式的，有的希望是博客形式的。也有的希望是产品加图片说明形式的。你开始发愁了，随着这种需求的增多，每写一个网站你都要新建一份数据库，复制代码，建立空间等。如果有新的需求改动或bug，那么维护量就太大了。我们先来看看我们现在的代码，如果每个网站是一个实例的话，代码应该是这样的<?php namespace DesignPatterns\Flyweight\example2\v1; class WebSite { private $name; public function __construct($name) { $this->name = $name; } public function use() { echo "网站分类: ".$this->name."<br>"; } } //ClientCode $WebSite1 = new WebSite('产品展示'); $WebSite1->use(); $WebSite2 = new WebSite('产品展示'); $WebSite2->use(); $WebSite3 = new WebSite('产品展示'); $WebSite3->use(); $WebSite4 = new WebSite('博客'); $WebSite4->use(); $WebSite5 = new WebSite('博客'); $WebSite5->use(); $WebSite6 = new WebSite('博客'); $WebSite6->use(); 运行结果：如果我们想要做三个产品展示，三个博客的网站，就需要6个网站类的实例。而其实它们的本质代码都差不多。如果网站增多，实例也就随着增多，对服务器的资源浪费也比较严重。如果有什么办法可以让网站的代码能够共用一套就好了。我们发现虽然这些网站的模版和具体数据可能不同，但代码核心和数据库却是共享的。首先这些企业客户，他们需要的网站结构相似度很高，而且都不是那种高访问量的网站，如果分成多个虚拟空间来处理，相当于-一个相同网站的实例对象很多，这是造成服务器的大量资源浪费，当然更实际的其实就是钞票的浪费，如果整合到一个网站中，共享其相关的代码和数据，那么对于硬盘、内存、CPU、数据库空间等服务器资源都可以达成共享，减少服务器资源，而对于代码，由于是一-份实例，维护和扩展都更加容易。那么如何做到共享一份实例呢？这就用到了我们今天讲的亨元模式。下面是亨元模式的实现：WebSite.php<?php namespace DesignPatterns\Flyweight\example2\v2; /** * 网站抽象类 * Class WebSite * @package DesignPatterns\Flyweight\example2\v2 */ abstract class WebSite { abstract public function use(); }ConcreteWebSite.php<?php namespace DesignPatterns\Flyweight\example2\v2; /** * 具体网站类 * Class ConcreteWebSite * @package DesignPatterns\Flyweight\example2\v2 */ class ConcreteWebSite extends WebSite { private $name; public function __construct($name) { $this->name = $name; } public function use() { echo "网站分类: ".$this->name."<br>"; } }WebSiteFactory.php<?php namespace DesignPatterns\Flyweight\example2\v2; /** * 网站工厂类 * Class WebSiteFactory * @package DesignPatterns\Flyweight\example2\v2 */ class WebSiteFactory { private $flyweights = []; //获得网站分类 public function getWebSiteCategory(string $key) { //判断是否存在这个对象，如果存在则直接返回。如果不存在，则实例化后在返回 if (empty($this->flyweights[$key])) { $this->flyweights[$key] = new ConcreteWebSite($key); } return $this->flyweights[$key]; } //获得网站分类总数 public function getWebSiteCount() { return count($this->flyweights); } }运行 Client.php<?php namespace DesignPatterns\Flyweight\example2\v2; require dirname(dirname(__DIR__)).'/../vendor/autoload.php'; /** * Class Client * @package DesignPatterns\Adapter\example2\v2 */ class Client { public function run() { $websiteFactory = new WebSiteFactory(); //实例化产品展示的对象 $website1 = $websiteFactory->getWebSiteCategory('产品展示'); $website1->use(); //共享上方生成的对象不在实例化 $website2 = $websiteFactory->getWebSiteCategory('产品展示'); $website2->use(); $website3 = $websiteFactory->getWebSiteCategory('产品展示'); $website3->use(); $website4 = $websiteFactory->getWebSiteCategory('博客'); $website4->use(); $website5 = $websiteFactory->getWebSiteCategory('博客'); $website5->use(); $website6 = $websiteFactory->getWebSiteCategory('博客'); $website6->use(); //统计实例化个数 结果为2 echo "网站分类总数为: ".$websiteFactory->getWebSiteCount(); } } $worker = new Client(); $worker->run();运行结果：这样写完算是基本实现了享元模式的共享对象的目的，也就是说，不管建几个网站，只要是‘产品展示’，都是一样的，只要是‘博客’，也是完全相同的。但这样是有问题的，如果我们给企业建的网站不是一家企业的，它们的数据不会相同，所以至少它们都应该有不同的账号，这样应该如何处理？这个时候我们就需要考虑亨元模式的内部状态与外部状态了。内部状态与外部状态在享元对象内部并且不会随环境改变而改变的共享部分，可以称为是享元对象的内部状态，而随环境改变而改变的、不可以共享的状态就是外部状态了。事实上，享元模式可以避免大量非常相似类的开销。在程序设计中，有时需要生成大量细粒度的类实例来表示数据。如果能发现这些实例除了几个参数外基本上都是相同的，有时就能够受大幅度地减少需要实例化的类的数量。如果能把那些参数移到类实例的外面，在方法调用时将它们传递进来，就可以通过共享大幅度地减少单个实例的数目。也就是说，享元模式Flyweight 执行时所需的状态是有内部的也可能有外部的，内部状态存储于ConcreteFlyweight对象之中，而外部对象则应该考虑由客户端对象存储或计算，当调用Flyweight 对象的操作时，将该状态传递给它。也就是说客户的账号就是外部状态应该由专门的对象来处理。代码示例User.php<?php namespace DesignPatterns\Flyweight\example2\v3; /** * 用户类，用于网站的客户账号，是“网站”类的外部状态 * Class User * @package DesignPatterns\Flyweight\example2\v3 */ class User { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } }WebSite.php<?php namespace DesignPatterns\Flyweight\example2\v3; /** * 网站抽象类 * Class WebSite * @package DesignPatterns\Flyweight\example2\v3 */ abstract class WebSite { abstract public function use(User $user); }ConcreteWebSite.php<?php namespace DesignPatterns\Flyweight\example2\v3; /** * 具体网站类 * Class ConcreteWebSite * @package DesignPatterns\Flyweight\example2\v3 */ class ConcreteWebSite extends WebSite { private $name; public function __construct($name) { $this->name = $name; } public function use(User $user) { echo "网站分类: ".$this->name." 用户： ".$user->getName()."<br>"; } }WebSiteFactory.php<?php namespace DesignPatterns\Flyweight\example2\v3; /** * 网站工厂类 * Class WebSiteFactory * @package DesignPatterns\Flyweight\example2\v3 */ class WebSiteFactory { private $flyweights = []; //获得网站分类 public function getWebSiteCategory(string $key) { //判断是否存在这个对象，如果存在则直接返回。如果不存在，则实例化后在返回 if (empty($this->flyweights[$key])) { $this->flyweights[$key] = new ConcreteWebSite($key); } return $this->flyweights[$key]; } //获得网站分类总数 public function getWebSiteCount() { return count($this->flyweights); } }运行 Client.php<?php namespace DesignPatterns\Flyweight\example2\v3; require dirname(dirname(__DIR__)).'/../vendor/autoload.php'; /** * Class Client * @package DesignPatterns\Adapter\example2\v3 */ class Client { public function run() { $websiteFactory = new WebSiteFactory(); //实例化产品展示的对象 $website1 = $websiteFactory->getWebSiteCategory('产品展示'); $website1->use(new User('张三')); //共享上方生成的对象不在实例化 $website2 = $websiteFactory->getWebSiteCategory('产品展示'); $website2->use(new User('小明')); $website3 = $websiteFactory->getWebSiteCategory('产品展示'); $website3->use(new User('小花')); $website4 = $websiteFactory->getWebSiteCategory('博客'); $website4->use(new User('王武')); $website5 = $websiteFactory->getWebSiteCategory('博客'); $website5->use(new User('李白')); $website6 = $websiteFactory->getWebSiteCategory('博客'); $website6->use(new User('杜甫')); //统计实例化个数 结果为2 echo "网站分类总数为: ".$websiteFactory->getWebSiteCount(); } } $worker = new Client(); $worker->run();运行结果：这样就可以协调内部与外部状态了。由于用了享元模式，哪怕你接手了1000 个网站的需求，只要要求相同或类似，你的实际开发代码也就是分类的那几种，对于服务器来说，占用的硬盘空间、内存、CPU资源都是非常少的。总结享元模式 运用共享技术有效地支持大量细粒度的对象享元模式可以避免大量非常类似类的开销。在程序设计中，有时需要生成大量细粒度的类实例来表示数据。如果能发现这些实例除了几个参数外基本上都是相同的，有时就能够受大幅度地减少需要实例化的类的数量。如果能把参数移到类实例的外面，在方法调用时将它们传递进来，就可以通过共享大幅度地减少单个实例的数目。如果一个应用程序使用了大量的对象，而大量的这些对象造成了很大的存储开销时就应该考虑使用；还有就是对象的大多数状态可以外部状态，如果删除对象的外部状态，那么可以用相对较少的共享对象取代很多组对象，此时可以考虑使用享元模式。参考书籍：《 大话设计模式》github示例：https://github.com/yangpanyao/design-patterns/tree/master/Flyweight

PHP设计模式-组合模式 组合（Composite）模式跟我们之前讲的面向对象设计中的“组合关系（通过组合来组装两个类）”，完全是两码事。这里讲的“组合模式”，主要是用来处理树形结构数据。这里的“数据”，你可以简单理解为一组对象集合。正因为其应用场景的特殊性，数据必须能表示成树形结构，这也导致了这种模式在实际的项目开发中并不那么常用。但是，一旦数据满足树形结构，应用这种模式就能发挥很大的作用，能让代码变得非常简洁。组合模式在 GoF 的《设计模式》一书中，是这样定义的：Compose objects into tree structure to represent part-whole hierarchies.Composite lets client treat individual objects and compositions of objects uniformly.翻译成中文就是：将一组对象组织（Compose）成树形结构，以表示一种“部分 - 整体”的层次结构。组合让客户端（在很多设计模式书籍中，“客户端”代指代码的使用者。）可以统一单个对象和组合对象的处理逻辑。组合模式的结构与实现结构 组件 （Component） 接口描述了树中简单项目和复杂项目所共有的操作。 叶节点 （Leaf） 是树的基本结构， 它不包含子项目。一般情况下， 叶节点最终会完成大部分的实际工作， 因为它们无法将工作指派给其他部分。容器 （Container）——又名 “组合 （Composite”——是包含叶节点或其他容器等子项目的单位。 容器不知道其子项目所属的具体类， 它只通过通用的组件接口与其子项目交互。容器接收到请求后会将工作分配给自己的子项目， 处理中间结果， 然后将最终结果返回给客户端。客户端 （Client） 通过组件接口与所有项目交互。 因此， 客户端能以相同方式与树状结构中的简单或复杂项目交互。代码实现Component.php<?php namespace DesignPatterns\Composite\example; /** * Component为组合中对象声明的接口，在适当的情况下，实现所有类共有接口的默认行为。声明一个接口 * 用于访问和管理component的子部件。 * Class Component * @package DesignPatterns\Composite\example */ abstract class Component { protected $name; public function __construct($name) { $this->name = $name; } //通常用add和remove方法来提供增加或移除树枝货树叶的功能 abstract public function Add(Component $component); abstract public function Remove(Component $component); abstract public function Display(int $depth); }Leaf.php<?php namespace DesignPatterns\Composite\example; /** * leaf在组合中表示叶节点对象，叶节点对象没有子节点。 * Class Leaf * @package DesignPatterns\Composite\example */ class Leaf extends Component { // 由于叶子没有再增加分枝和树叶，所以add和remove方法实现它没有意义， // 但这样做可以消除叶节点和枝节点对象在抽象层次的区别，它们具有完全一致的接口 public function Add(Component $component) { echo "can not add to a leaf<br>"; } public function Remove(Component $component) { echo "can not remove to a leaf<br>"; } public function Display(int $depth) { echo str_repeat('-', $depth) . $this->name . "<br>"; } }Composite.php<?php namespace DesignPatterns\Composite\example; /** * composite定义有枝节点行为，用来存储子部件， * 在Component接口中实现与子部件有关的操作，比如增加add和删除remove. * Class Composite * @package DesignPatterns\Composite\example */ class Composite extends Component { private $childern = [];//一个子对象集合用来存储其下属的枝节点和叶节点。 public function Add(Component $component) { array_push($this->childern, $component); } public function Remove(Component $component) { foreach ($this->childern as $key => $value) { if ($component === $value) { unset($this->childern[$key]); } } } // 显示其枝节点名称，并对其下级进行遍历 public function Display(int $depth) { echo str_repeat('-', $depth).$this->name."<br>"; foreach ($this->childern as $component) { $component->display($depth + 2); } } }client.php<?php namespace DesignPatterns\Composite\example; require dirname(__DIR__).'/../vendor/autoload.php'; /** * 客户端代码可以通过Component接口操作组合部件（Composite）对象 * Class Client * @package DesignPatterns\Composite\example */ class Client { public function run() { //生成树根root //根上长出两页 Leaf A 和 Leaf B $root = new Composite('root'); $root->add(new Leaf("Leaf A")); $root->add(new Leaf("Leaf B")); //根上长出分支Composite X //分枝上也有两叶 Leaf XA 和 LeafX B $comp = new Composite("Composite X"); $comp->add(new Leaf("Leaf XA")); $comp->add(new Leaf("Leaf XB")); $root->add($comp); //在Composite 在长出 CompositeXY分枝 分枝上也有两叶 Leaf XYA 和 LeafXYB $comp2 = new Composite("Composite XY"); $comp2->add(new Leaf("Leaf XYA")); $comp2->add(new Leaf("Leaf XYB")); $comp->add($comp2); $root->add(new Leaf("Leaf C"));//根部分枝Leaf C $leaf = new Leaf("Leaf D"); $root->add($leaf);//根部分枝Leaf D $root->remove($leaf);//移除根部分枝LeafD $root->display(1);//显示 } } $worker = new Client(); $worker->run();运行结果：透明方式与安全方式透明方式就是说在Component中声明的用来管理子对象的方法，其中包括Add、Remove等。继承或实现Component的子类都具备Add和Remove方法，这样做的好处就是叶节点和枝节点对于外界没有区别。它们具备完全一致的行为接口。但问题也很明显，因为Leaf类并不具备Add，Remove方法的功能所以实现它们并没有意义。安全方式就是在Component接口中不在声明Add和Remove方法，那么子类也不需要去实现它，而在Composite中声明所有用来管理子对象的方法。这样就不会出现透明方式的问题了，不过由于不够透明，所有树枝和树叶将不具有相同的接口。客户端调用就需要做相应的判断，带来了不便。组合模式示例假如现在你要为一个家在全国许多城市都有分销机构的大公司开发一款办公管理系统。总部有人力资源，财务和运营等部门。这是很常见的OA系统，很快一段时间后产品就正式运行了，过了一段时间后，客户希望在他们全部分公司推广使用。他们在北京有总部，在全国其他城市设有分公司，比如上海设有华东区分部，然后在一些省会还会设有办事处，比如南京办事处，杭州办事处。现在有一个问题是，客户希望总公司的人力资源部，财务部等办公管理功能可以在所有的分公司或者办事处都可以使用。如下所示：总部，分部和办事处呈树状结构，也就是有组织结构，所以我们就不能进行简单的平行管理，因为实际开发中，我们就需要一个一个去判断他是总公司的财务还是分公司的财务，然后去执行不同的方法。我们其实可以发现类似这种部分与整体的情况很多，例如，买电脑的商家。可以卖单独的配件，也可以卖整装的主机。又如复制文件，你可以一个一个复制，还可以整个文件夹进行复制。再比如文本编辑，你可以给单个字加粗、变色、改字体等，当然也可以给整段文字做相同的操作。其本质都是相同的问题。其实我们的分公司或办事处与总公司的关系就是部分与整体的关系。我们希望公司的组织架构，比如人力资源部，财务部的管理功能可以复用于分公司。这其实就是部分与整体可以被一致对待的问题。回到这个项目，如果我们把北京总公司比做数的根部，而它下属的分公司就是树的分枝，至于办事处就是更小的分枝，而它们相关的职能部门由于没有分枝了，所以可以理解为树叶。尽管天下没有两片相同的树叶，但同一颗树长出的树叶也不会差到哪去，也就是说，我们希望总部的财务功能复制用到子公司，最好的方法就是我们在处理总公司的财务管理功能和子公司的财务功能的方法是一样的。而本章所讲的组合模式恰好就能够处理这种需求。下面是代码实现Company.php<?php namespace DesignPatterns\Composite\OA; /** * 公司类 抽象类或者接口 * Class Company * @package DesignPatterns\Composite\OA */ abstract class Company { protected $name; public function __construct($name) { $this->name = $name; } abstract public function Add(Company $company);//增加 abstract public function Remove(Company $company);//移除 abstract public function Display(int $depth);//显示 abstract public function LineOfDuty();//增加履行责任的方法，不同的部门需要履行不同的责任 }ConcreteCompany.php<?php namespace DesignPatterns\Composite\OA; /** * 具体公司类 实现接口 树枝节点 * Class ConcreteCompany * @package DesignPatterns\Composite\OA */ class ConcreteCompany extends Company { private $childern = [];//一个子对象集合用来存储其下属的枝节点和叶节点。 public function Add(Company $company) { array_push($this->childern, $company); } public function Remove(Company $company) { foreach ($this->childern as $key => $value) { if ($company === $value) { unset($this->childern[$key]); } } } // 显示其枝节点名称，并对其下级进行遍历 public function Display(int $depth) { echo str_repeat('-', $depth).$this->name."<br>"; foreach ($this->childern as $company) { $company->display($depth + 2); } } public function LineOfDuty() { foreach ($this->childern as $company) { $company->LineOfDuty(); } } }HRDepartment.php<?php namespace DesignPatterns\Composite\OA; /** * 人力资源部 树叶节点 * Class HRDepartment * @package DesignPatterns\Composite\OA */ class HRDepartment extends Company { public function Add(Company $company){} public function Remove(Company $company){} public function Display(int $depth) { echo str_repeat('-', $depth) . $this->name . "<br>"; } public function LineOfDuty() { echo $this->name." 员工招聘培训管理<br>"; } }FinanceDepartment.php<?php namespace DesignPatterns\Composite\OA; /** * 财务部 树叶节点 * Class HRDepartment * @package DesignPatterns\Composite\OA */ class FinanceDepartment extends Company { public function Add(Company $company){} public function Remove(Company $company){} public function Display(int $depth) { echo str_repeat('-', $depth) . $this->name . "<br>"; } public function LineOfDuty() { echo $this->name . " 公司财务收支管理<br>"; } }运行Client.php<?php namespace DesignPatterns\Composite\OA; require dirname(__DIR__) . '/../vendor/autoload.php'; /** * 客户端 * Class Client * @package DesignPatterns\Composite\OA */ class Client { public function run() { $root = new ConcreteCompany("北京总公司"); $root->Add(new HRDepartment("总公司人力资源部")); $root->Add(new FinanceDepartment("总公司财务部")); $comp = new ConcreteCompany("上海华东分公司"); $comp->Add(new HRDepartment("上海华东分公司人力资源部")); $comp->Add(new FinanceDepartment("上海华东分公司财务部")); $root->add($comp); $comp1 = new ConcreteCompany("南京办事处"); $comp1->Add(new HRDepartment("南京办事处人力资源部")); $comp1->Add(new FinanceDepartment("南京办事处财务部")); $root->add($comp1); $comp2 = new ConcreteCompany("杭州办事处"); $comp2->Add(new HRDepartment("杭州办事处人力资源部")); $comp2->Add(new FinanceDepartment("杭州办事处财务部")); $root->add($comp2); echo "结构图<br>"; echo $root->Display(1); echo "职责<br>"; echo $root->LineOfDuty(); } } $worker = new Client(); $worker->run();运行结果：示例中，组合模式定义了，包含人力资源部和财务部这些基本对象和分公司、办事处等组合对象的类层次结构，基本对象可以被组合成更复杂的组合对象，而这个组合对象，又可以被组合，这样不断递归下去，客户代码中，任何用到基本对象的对象都可以使用组合对象。用户不在关心到底是处理一个叶节点还是一个组合组件，也就不用为定义组合而写一些判断语句。简单的说就是组合模式让客户可以一致的使用组合结构和单个对象。总结组合模式的设计思路，与其说是一种设计模式，倒不如说是对业务场景的一种数据结构和算法的抽象。其中，数据可以表示成树这种数据结构，业务需求可以通过在树上的递归遍历算法来实现。组合模式，将一组对象组织成树形结构，将单个对象和组合对象都看做树中的节点，以统一处理逻辑，并且它利用树形结构的特点，递归地处理每个子树，依次简化代码实现。使用组合模式的前提在于，你的业务场景必须能够表示成树形结构。所以，组合模式的应用场景也比较局限，它并不是一种很常用的设计模式github示例：https://github.com/yangpanyao/design-patterns/tree/master/Composite参考资料：组合模式：如何设计实现支持递归遍历的文件系统目录树结构？参考书籍：大话设计模式

PHP设计模式-门面模式 门面模式门面(Facade）模式，也叫外观模式，英文全称是 Facade Design Pattern。在 GoF 的《设计模式》一书中，门面模式是这样定义的：Provide a unified interface to a set of interfaces in a subsystem. Facade Pattern defines a higher-level interface that makes the subsystem easier to use.翻译成中文就是：门面模式为子系统提供一组统一的接口，定义一组高层接口让子系统更易用。门面模式的结构代码实现子系统1 SubSystemOne.php<?php namespace DesignPatterns\Facade; /** * 子系统1 * Class SubSystemOne * @package DesignPatterns\Facade */ class SubSystemOne { public function MethodOne() { echo "子系统1的方法\n"; } }子系统2 SubSystemTwo.php<?php namespace DesignPatterns\Facade; /** * 子系统2 * Class SubSystemTwo * @package DesignPatterns\Facade */ class SubSystemTwo { public function MethodTwo() { echo"子系统2的方法\n"; } }子系统3 SubSystemThree.php<?php namespace DesignPatterns\Facade; /** * 子系统3 * Class SubSystemThree * @package DesignPatterns\Facade */ class SubSystemThree { public function MethodThree() { echo "子系统3的方法\n"; } }子系统4 SubSystemFour.php<?php namespace DesignPatterns\Facade; /** * 子系统4 * Class SubSystemFour * @package DesignPatterns\Facade */ class SubSystemFour { public function MethodFour() { echo "子系统4的方法\n"; } }门面类 Facade.php<?php namespace DesignPatterns\Facade; /** * 门面类 * Class Facade * @package DesignPatterns\Facade */ class Facade { private $systemOne; private $systemTwo; private $systemThree; private $systemFour; public function __construct() { $this->systemOne = new SubSystemOne(); $this->systemTwo = new SubSystemTwo(); $this->systemThree = new SubSystemThree(); $this->systemFour = new SubSystemFour(); } public function methodA() { echo "方法组A() ---\n"; $this->systemOne->methodOne(); $this->systemThree->methodThree(); } public function methodB() { echo "方法组B() ---\n"; $this->systemTwo->methodTwo(); $this->systemFour->methodFour(); } }运行Client.php<?php namespace DesignPatterns\Facade; require __DIR__.'/../vendor/autoload.php'; class Client { public function run() { $facade = new Facade(); $facade->methodA(); echo '<br>'; $facade->methodB(); } } $worker = new Client(); $worker->run();运行结果：从代码上看，如果没有门面类，客户端只能直接与子系统进行交互，子系统如果变化，很可能将会影响到客户端的调用。而子系统在不断优化重构中，可能会产生更多更小的类。这对于客户端来说似乎要记住太多的接口。使用门面模式增加门面类后，减少了客户端与子系统之间的耦合，也提高了可维护性。门面模式的应用场景首先，在设计初期阶段，应该要有意识的将不同的两个层分离，层与层之间建立外观Facade；其次，在开发阶段，子系统往往因为不断的重构演化而变得越来越复杂，增加外观Facade可以提供一个简单的接口，减少它们之间的依赖；另外在维护一个遗留的大型系统时，可能这个系统已经非常难以维护和扩展了，为新系统开发一个外观Facade类，来提供设计粗糙或高度复杂的遗留代码的比较清晰简单的接口，让系统与Facade对象交互，Facade与遗留代码交互所有复杂的工作github示例：https://github.com/yangpanyao/design-patterns/tree/master/Facade

PHP设计模式-适配器模式 适配器（Adapter）模式的英文翻译是 Adapter Design Pattern。顾名思义，这个模式就是用来做适配的，它将不兼容的接口转换为可兼容的接口，让原本由于接口不兼容而不能一起工作的类可以一起工作。对于这个模式，有一个经常被拿来解释它的例子，就是 USB 转接头充当适配器，把两种不兼容的接口，通过转接变得可以一起工作。适配器模式有两种实现方式：类适配器和对象适配器。其中，类适配器使用继承关系来实现，对象适配器使用组合关系来实现。适配器模式的结构类适配器类适配器不需要封装任何对象， 因为它同时继承了客户端和服务的行为。 适配功能在重写的方法中完成。 最后生成的适配器可替代已有的客户端类进行使用。由于php只支持单继承，所以我们可以使用继承+实现的方式达到同样的效果。对象适配器客户端 （Client） 是包含当前程序业务逻辑的类。客户端接口 （Client Interface） 描述了其他类与客户端代码合作时必须遵循的协议。服务 （Service） 中有一些功能类 （通常来自第三方或遗留系统）。 客户端与其接口不兼容， 因此无法直接调用其功能适配器 （Adapter） 是一个可以同时与客户端和服务交互的类： 它在实现客户端接口的同时封装了服务对象。 适配器接受客户端通过适配器接口发起的调用， 并将其转换为适用于被封装服务对象的调用。客户端代码只需通过接口与适配器交互即可， 无需与具体的适配器类耦合。 因此， 你可以向程序中添加新类型的适配器而无需修改已有代码。 这在服务类的接口被更改或替换时很有用： 你无需修改客户端代码就可以创建新的适配器类。示例假设现在有一个企业网站在同时销售软件服务和软件产品，目前只支持人民币来完成计算，现在由于新增了海外客户，现在开发者希望能有一个转换器能处理人民币与美元的兑换。而不要改变原来的人民币计算交易金额的类。通过增加一个适配器可以让我们的程序可以用人民币计算也可以用美元计算。类适配器实现代码示例：MoneyCalc.php<?php namespace DesignPatterns\Adapter\example1; class MoneyCalc { private $money;//金额 默认人民币 private $product;//软件产品 private $service;//软件服务 public $rate = 1;//兑换率 public function requestCalc($productNow,$serviceNow) { $this->product = $productNow; $this->service = $serviceNow; $this->money = $this->product + $this->service; return $this->requestTotal(); } public function requestTotal() { $this->money *= $this->rate; return $this->money; } }创建美元适配器，使系统可以支持美元。首先我们要创建一个接口,接口名为ITarget，接口内有一个抽象方法requester().ITarget.php<?php namespace DesignPatterns\Adapter\example1; interface ITarget { public function requester(); } 适配器（Adapter）需要实现ITarget接口与MoneyCalc具体类,创建DollarCalcAdapter不需要太多的工作,我们大部分的工作已经在MoneyCalc类中实现，所以我们只需实现 requester方法让它能把人民币转化为美元。DollarCalcAdapter.php<?php namespace DesignPatterns\Adapter\example1; class DollarCalcAdapter extends MoneyCalc implements ITarget { public function __construct() { $this->requester(); } public function requester() { $this->rate = 0.141; return $this->rate; } }运行 Client.php<?php namespace DesignPatterns\Adapter\example1; require dirname(__DIR__).'/../vendor/autoload.php'; class Client { public function run() { //默认人民币 $moneyCalc = new MoneyCalc(); echo 'rmb ¥'.$moneyCalc->requestCalc(40,50); echo '<br>'; //美元金额 $dollarCalc = new DollarCalcAdapter(); echo "dollar ：$".$dollarCalc->requestCalc(40,50);; } } $worker = new Client(); $worker->run();运行结果：对象适配器实现代码示例：MoneyCalc.php<?php namespace DesignPatterns\Adapter\example1; class MoneyCalc { private $money;//金额 默认人民币 private $product;//软件产品 private $service;//软件服务 public $rate = 1;//兑换率 public function requestCalc($productNow,$serviceNow) { $this->product = $productNow; $this->service = $serviceNow; $this->money = $this->product + $this->service; return $this->requestTotal(); } public function requestTotal() { $this->money *= $this->rate; return $this->money; } }ITarget.php<?php namespace DesignPatterns\Adapter\example2; interface ITarget { public function requestCalc($productNow,$serviceNow); } 适配器 DollarCalcAdapter.php<?php namespace DesignPatterns\Adapter\example2; class DollarCalcAdapter implements ITarget { private $moneyCalc; public function __construct(MoneyCalc $moneyCalc) { $this->moneyCalc = $moneyCalc; $this->moneyCalc->rate = 0.141; } public function requestCalc($productNow,$serviceNow) { return $this->moneyCalc->requestCalc($productNow,$serviceNow); } } 运行 Client.php<?php namespace DesignPatterns\Adapter\example2; require dirname(__DIR__).'/../vendor/autoload.php'; class Client { public function run() { //默认人民币 $moneyCalc = new MoneyCalc(); echo 'rmb ¥'.$moneyCalc->requestCalc(40,50); echo '<br>'; //美元金额 $dollarCalc = new DollarCalcAdapter($moneyCalc); echo "dollar ：$".$dollarCalc->requestCalc(40,50);; } } $worker = new Client(); $worker->run();运行结果：类适配器和对象适配器如何选择针对类适配器和对象适配器两种实现方式，在实际的开发中，我们应该选择使用哪一种呢？判断的标准主要有两个，一个是 Adaptee（被适配类 如例子中的MoneyCalc类） 接口的个数，另一个是 Adaptee 和 ITarget 的契合程度。如果 Adaptee 接口并不多，那两种实现方式都可以。如果 Adaptee 接口很多，而且 Adaptee 和 ITarget 接口定义大部分都相同，那我们推荐使用类适配器，因为 Adaptor 复用父类 Adaptee 的接口，比起对象适配器的实现方式，Adaptor 的代码量要少一些。如果 Adaptee 接口很多，而且 Adaptee 和 ITarget 接口定义大部分都不相同，那我们推荐使用对象适配器，因为组合结构相对于继承更加灵活。代理、桥接、装饰器、适配器 4 种设计模式的区别代理、桥接、装饰器、适配器，这 4 种模式是比较常用的结构型设计模式。它们的代码结构非常相似。笼统来说，它们都可以称为 Wrapper 模式，也就是通过 Wrapper 类二次封装原始类。尽管代码结构相似，但这 4 种设计模式的用意完全不同，也就是说要解决的问题、应用场景不同，这也是它们的主要区别。代理模式：代理模式在不改变原始类接口的条件下，为原始类定义一个代理类，主要目的是控制访问，而非加强功能，这是它跟装饰器模式最大的不同。桥接模式：桥接模式的目的是将接口部分和实现部分分离，从而让它们可以较为容易、也相对独立地加以改变。装饰器模式：装饰者模式在不改变原始类接口的情况下，对原始类功能进行增强，并且支持多个装饰器的嵌套使用。适配器模式：适配器模式是一种事后的补救策略。适配器提供跟原始类不同的接口，而代理模式、装饰器模式提供的都是跟原始类相同的接口。github示例：https://github.com/yangpanyao/design-patterns/tree/master/Adapter

PHP设计模式-装饰器模式 装饰器（Decorator）模式装饰器模式是结构型设计模式的一种，也叫包装器（Wrappe）模式。装饰器模式的定义为动态的给对象添加一些额外的职责。简单的说，如果你想在不改变现有功能的情况下，增加新的功能，这个时候我们就可以使用装饰器模式。装饰器模式的结构抽象构件角色（Component）：定义一个抽象接口，以规范准备接收附加责任的对象。具体构件角色(Concrete Component)：这是被装饰者，定义一个将要被装饰增加功能的类。装饰角色(Decorator)：持有一个构件对象的实例，并定义了抽象构件定义的接口。具体装饰角色(Concrete Decorator)：负责给构件添加增加的功能。示例假设你正在开发一个提供通知功能的库， 其他程序可使用它向用户发送关于重要事件的通知。库的最初版本基于 通知器Notifier类， 其中只有很少的几个成员变量， 一个构造函数和一个 send发送方法。 该方法可以接收来自客户端的消息参数， 并将该消息发送给一系列的邮箱， 邮箱列表则是通过构造函数传递给通知器的。 作为客户端的第三方程序仅会创建和配置通知器对象一次， 然后在有重要事件发生时对其进行调用。如下图：过了一段时间后，随着用户的增多，你收到用户的反馈，用户希望除邮件通知外，增加新的通知，例如在重要的通知上发送短信通知，有的用户希望发送微信通知，或者qq通知。这个也不难实现，我们需要扩展 通知器类， 然后在新的子类中加入额外的通知方法。 现在客户端要对所需通知形式的对应类进行初始化， 然后使用该类发送后续所有的通知消息。如下图：很快就有人反馈了，为什么我们不能使用多种通知形式呢？如果事态紧急，用户应该会想在所有渠道中都收到相同的消息吧。我们可以尝试创建一个特殊子类来将多种通知方法组合在一起以解决该问题。 但这种方式会使得代码量迅速膨胀， 不仅仅是程序库代码， 客户端代码也会如此。如图：下面我们使用装饰器模式进行修改，代码如下：具体构建角色 Notifiter.php<?php namespace DesignPatterns\Decorator; /** * 具体构件角色concrete component * 这里我们不需要使用抽象component（抽象构件），所以只需要使用具体构件（concrete component） * 让装饰角色直接继承具体构件（concrete component），如果只需要一个具体装饰角色（concrete decorator）， * 那么我们也可以将装饰角色（decorator）和具体装饰角色（concrete decorator）的责任合成一个类 * Class Notifier * @package DesignPatterns\Decorator */ class Notifier { public function send(){ echo '发送邮件通知'; } }装饰角色 BaseDecorator.php<?php namespace DesignPatterns\Decorator; class BaseDecorator extends Notifier { private $notifier; public function __construct(Notifier $notifier) { $this->notifier = $notifier; } public function send() { $this->notifier->send(); } }具体装饰角色 SMSDecorator.php<?php namespace DesignPatterns\Decorator; class SMSDecorator extends BaseDecorator { public function send() { parent::send(); echo ' 发送短信通知'; } }具体装饰角色 QQDecorator.php<?php namespace DesignPatterns\Decorator; class QQDecorator extends BaseDecorator { public function send() { parent::send(); // TODO: Change the autogenerated stub echo ' 发送QQ通知'; } }具体装饰角色 WeChatDecorator.php<?php namespace DesignPatterns\Decorator; class WeChatDecorator extends BaseDecorator { public function send() { parent::send(); // TODO: Change the autogenerated stub echo ' 发送微信通知'; } } 运行Client.php<?php namespace DesignPatterns\Decorator; require __DIR__.'/../vendor/autoload.php'; class Client{ public function run() { $notifier = new Notifier(); $notifier->send(); echo '<br>'; $smsdecorator = new SMSDecorator($notifier); $smsdecorator->send(); echo '<br>'; $qqdecorator = new QQDecorator($notifier); $qqdecorator->send(); echo '<br>'; $wechatdecorator = new WeChatDecorator($notifier); $wechatdecorator->send(); } } $client = new Client(); $client->run();运行结果总结装饰模式，动态地给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更为灵活。装饰模式是为已有功能动态的添加更多功能的一种方式。当系统需要新功能的时候，是向旧的类中添加新的代码。这些新的代码通常装饰了原有类的核心职责或主要行为。在主类中加入新的字段，新的方法和新的逻辑，从而增加了主类的复杂度，而这些新加入的东西仅仅是为满足一些只在某种特定情况下才会执行的特殊行为的需要。装饰模式却提供了一个非常好的解决方案，它把每个要装饰的功能放在单独的类中，并让这个类包装它要装饰的对象，对此，当需要执行特殊行为时，客户代码就可以在运行时根据需要选择地，按顺序地使用装饰功能包装对象了。装饰模式的优点就是把类中的装饰功能从类中搬移去除，这样可以简化原有的类。有效地把类的核心职责和装饰功能区分开了，而且可以去除相关类中的重复的装饰逻辑。github示例：https://github.com/yangpanyao/design-patterns/tree/master/Decorator参考资料 装饰模式

PHP设计模式-桥接模式 桥接（Bridge）模式，也叫作桥梁模式，英文是 Bridge Design Pattern。也是结构型设计模式之一。在 GoF 的《设计模式》一书中，桥接模式是这么定义的：“Decouple an abstraction from its implementation so that the two can vary independently。”翻译成中文就是：“将抽象和实现解耦，让它们可以独立变化。”关于桥接模式，另外一种理解是：“如果一个类存在两个（或多个）独立变化的维度，我们通过组合的方式，让这两个（或多个）维度可以独立进行扩展。”通过组合关系来替代继承关系，避免继承层次的指数级爆炸。这种理解方式非常类似于，我们之前讲过的“组合优于继承”设计原则。我们来看一个例子：假如我们现在有一款手机游戏，手机品牌M和手机品牌N都可以玩，这个时候代码该如何设计，我们很快可以想到，让手机游戏充当父类，品牌M和品牌N的手机游戏都去继承它，类图如下：然后问题又来了，我们的手机都有通讯录，如果手机品牌M和品牌N都要增加通讯录功能又该如何设计，这个也不是很难，我们可以让手机品牌充当父类，手机品牌下有手机品牌M和手机品牌N，每个子类下各有通讯录和游戏子类，类图如下：现在的结构还可以接受，那么问题来了，如果我们现在给每个品牌手机都加上音乐的功能，那么我们需要在手机品牌M和品牌M下分别加一个子类，那么问题又来了现在我们有了新的品牌手机S，他也需要增加音乐，通讯录游戏等功能，那么我们就需要增加 手机品牌S，手机品牌S通讯录，手机品牌S音乐，手机品牌S游戏等4个类，我们现在可以发现，随着功能的增加，我们如果使用继承的形式，那么我们继承的子类，就会越来越多，这个时候程序就太复杂了。这个时候就用到我们今天的主角桥接模式了。桥接模式的定义：是将抽象和实现解偶，让它们可以独立变化。我们先来看一下桥接模式的结构图：桥接模式结构抽象角色 （Abstraction） 提供高层控制逻辑， 依赖于完成底层实际工作的实现对象。实现角色 （Implementation） 为所有具体实现声明通用接口。 抽象部分仅能通过在这里声明的方法与实现对象交互。抽象部分可以列出和实现部分一样的方法， 但是抽象部分通常声明一些复杂行为， 这些行为依赖于多种由实现部分声明的原语操作。具体实现角色 （Concrete Implementations） 中包括特定于平台的代码。精确抽象角色 （Refined Abstraction） 提供控制逻辑的变体。 与其父类一样， 它们通过通用实现接口与不同的实现进行交互。通常情况下， 客户端 （Client） 仅关心如何与抽象部分合作。 但是， 客户端需要将抽象对象与一个实现对象连接起来。回到我们这个例子 ，我们的手机游戏，通讯录音乐等其实都是手机里的软件，我们可以将手机品牌和手机软件作为两个抽象类让不同的品牌和功能都分别继承它们，这样如果我们要增加新的品牌或功能就不会影响到其他类了。我们根据桥接模式画出这个例子中的类图，如下：示例代码：实现角色 手机品牌 HandsetSoft.php<?php namespace DesignPatterns\Bridge; /** * 实现角色 * 手机软件 * Class HandsetSoft * @package DesignPatterns\Bridge */ abstract class HandsetSoft { abstract public function run(); }具体实现角色 手机游戏 HandsetGame.php<?php namespace DesignPatterns\Bridge; /** * 具体实现角色 * 手机游戏 * Class HandsetGame * @package DesignPatterns\Bridge */ class HandsetGame extends HandsetSoft { public function run() { return '运行手机游戏'; } }具体实现角色 手机通讯录 HandsetAddressList.php<?php namespace DesignPatterns\Bridge; /** * 具体实现角色 * 手机通讯录 * Class HandsetAddressList * @package DesignPatterns\Bridge */ class HandsetAddressList extends HandsetSoft { public function run() { return '运行手机通讯录'; } }具体实现角色 手机音乐 HansetMusic.php<?php namespace DesignPatterns\Bridge; /** * 具体实现角色 * 手机音乐 * Class HandsetMusic * @package DesignPatterns\Bridge */ class HandsetMusic extends HandsetSoft { public function run() { return '运行手机音乐'; } } 抽象角色 手机品牌 HandsetBrand.php<?php namespace DesignPatterns\Bridge; /** * 抽象角色 * 手机品牌 * Class HandsetBrand * @package DesignPatterns\Bridge */ abstract class HandsetBrand { protected $soft; /** * 手机品牌需要关注手机软件 * @param HandsetSoft $soft */ public function __construct(HandsetSoft $soft) { $this->soft = $soft; } abstract public function run(); }精确抽象角色 手机品牌M HandsetBrandM.php<?php namespace DesignPatterns\Bridge; /** * 精确抽象角色 * 手机品牌m * Class HandsetBrandM * @package DesignPatterns\Bridge */ class HandsetBrandM extends HandsetBrand { public function run() { echo '手机品牌M'.$this->soft->run()."<br>"; } }精确抽象角色 手机品牌N HandsetBrandN.php<?php namespace DesignPatterns\Bridge; /** * 精确抽象角色 * 手机品牌N * Class HandsetBrandN * @package DesignPatterns\Bridge */ class HandsetBrandN extends HandsetBrand { public function run() { echo '手机品牌N'.$this->soft->run()."<br>"; } }运行Client.php<?php namespace DesignPatterns\Bridge; require __DIR__.'/../vendor/autoload.php'; class Client { public function run() { //手机游戏 $HandsetGame = new HandsetGame(); //手机通讯录 $HandsetAddressList = new HandsetAddressList(); //手机音乐 $HandsetMusic = new HandsetMusic(); //运行手机品牌M游戏 $HandsetBrandM = new HandsetBrandM($HandsetGame); $HandsetBrandM->run(); //运行手机品牌M通讯录 $HandsetBrandM = new HandsetBrandM($HandsetAddressList); $HandsetBrandM->run(); //运行手机品牌M音乐 $HandsetBrandM = new HandsetBrandM($HandsetMusic); $HandsetBrandM->run(); echo '<br>'; //运行手机品牌N游戏 $HandsetBrandN = new HandsetBrandN($HandsetGame); $HandsetBrandN->run(); //运行手机品牌N通讯录 $HandsetBrandN = new HandsetBrandN($HandsetAddressList); $HandsetBrandN->run(); //运行手机品牌N音乐 $HandsetBrandN = new HandsetBrandN($HandsetMusic); $HandsetBrandN->run(); } } $client = new Client(); $client->run();运行结果：总结桥梁模式实现是比较简单的，但原理理解起来却是不太容易。弄懂定义中“抽象”和“实现”两个概念，是理解它的关键。定义中的“抽象”，指的并非“抽象类”或“接口”，而是被抽象出来的一套“类库”，如本例中的手机品牌。它只包含骨架代码，真正的业务逻辑需要委派给定义中的“实现”来完成。而定义中的“实现”，也并非“接口的实现类”，而是一套独立的“类库”，如本例中的手机软件。“抽象”和“实现”独立开发，通过对象之间的组合关系，组装在一起。手机品牌的所有操作最终都交给手机软啊斤来实现。github示例：https://github.com/yangpanyao/design-patterns/tree/master/Bridge参考书籍： 大话设计模式

PHP设计模式-代理模式 前面几篇文章中，我们介绍了了设计模式中的创建型模式。创建型模式主要解决对象的创建问题，封装复杂的创建过程，解耦对象的创建代码和使用代码。其中，单例模式 用来创建全局唯一的对象。工厂模式 用来创建不同但是相关类型的对象（继承同一父类或者接口的一组子类），由给定的参数来决定创建哪种类型的对象。建造者模式 是用来创建复杂对象，可以通过设置不同的可选参数，“定制化”地创建不同的对象。原型模式 针对创建成本比较大的对象，利用对已有对象进行复制的方式进行创建，以达到节省创建时间的目的。从这篇文章，我们来学习设计模式的结构性设计模式。结构型模式主要总结了一些类或对象组合在一起的经典结构，这些经典的结构可以解决特定应用场景的问题。结构型模式包括：代理模式、桥接模式、装饰器模式、适配器模式、门面模式、组合模式、享元模式。这篇文章中我将为大家来介绍代理模式代理模式代理（Proxy）模式的定义为：为其他对象提供一种代理以控制对这个对象的访问。简单的说就是，在一些情况下客户不想或者不能直接引用一个对象，而代理对象可以在客户和目标对象之间起到中介作用，去掉客户不能看到的内容和服务或者增添客户需要的额外服务。代理模式的结构抽象主题角色 服务接口 （Service Interface） 声明了服务接口。 代理必须遵循该接口才能伪装成服务对象。真实主题角色 服务 （Service） 类提供了一些实用的业务逻辑。代理主题角色 代理 （Proxy） 类包含一个指向服务对象的引用成员变量。 代理完成其任务 （例如延迟初始化、 记录日志、 访问控制和缓存等） 后会将请求传递给服务对象。 通常情况下， 代理会对其服务对象的整个生命周期进行管理。客户端 （Client） 能通过同一接口与服务或代理进行交互， 所以你可在一切需要服务对象的代码中使用代理。示例下面是一个使用代理模式通过对结果进行缓存来提高下载器对象的性能的例子抽象主题角色 服务接口 Downloader.php<?php namespace DesignPatterns\Proxy; /** * Interface Downloader * @package DesignPatterns\Proxy */ interface Downloader { public function download(string $url): string; }真实主题角色 服务 RealDownloader.php<?php namespace DesignPatterns\Proxy; /** * Class ProxyDownloader * @package DesignPatterns\Proxy */ class RealDownloader implements Downloader { /** * @param string $url * @return string */ public function download(string $url): string { echo "下载文件<br>"; $result = file_get_contents($url); echo "文件大小 " . strlen($result) . "bytes<br>"; return $result; } }代理主题角色 Proxydownloader.php<?php namespace DesignPatterns\Proxy; class ProxyDownloader implements Downloader { private $downloader; private $cache = []; public function __construct(RealDownloader $downloader) { $this->downloader = $downloader; } public function download(string $url): string { if (!isset($this->cache[$url])) { echo "缓存代理未命中<br>"; $result = $this->downloader->download($url); $this->cache[$url] = $result; }else{ echo "缓存命中,从缓存中检索结果<br>"; } return $this->cache[$url]; } }运行 client.php<?php namespace DesignPatterns\Proxy; require dirname(__DIR__).'/vendor/autoload.php'; class Client { public function run(Downloader $subject) { $result = $subject->download("https://www.baidu.com"); $result = $subject->download("https://www.baidu.com"); } } //使用真实主题执行客户端代码 echo "使用真实主题执行客户端代码:<br>"; $client = new Client(); $realSubject = new RealDownloader(); $client->run($realSubject); echo "<br>"; //使用代理执行相同的客户端代码 echo "使用代理执行相同的客户端代码:<br>"; $client->run(new ProxyDownloader($realSubject));运行结果：代理模式在不改变原有类的情况下通过引入代理类来给原始类附加功能，将目标写入缓存，提升下载器性能，也符合我们的开闭原则。github示例：https://github.com/yangpanyao/design-patterns/tree/master/Proxy

PHP设计模式-原型模式 在前面几篇文章中我们讲了创建型设计模式的单例模式，工厂方法，抽象工厂，以及建造者模式，在这篇文章我将为大家来介绍创建型模式的最后一个模式： 原型（Prototype） 模式。场景现在我们有一个需求 要求有一个简历类，必须要有姓名，可以设置性别年龄，可以设置工作经历。我们可能需要用到多份简历。很快我们就写出了第一个版本，代码如下：简历类 Resume.php<?php namespace DesignPatterns\Prototype\V1; class Resume { private $name; private $sex; private $age; private $timeArea; private $company; /** * Resume constructor. * @param $name */ public function __construct(string $name) { $this->name = $name; } //设置个人信息 public function SetPersonalInfo(string $sex,string $age) { $this->sex = $sex; $this->age = $age; } //设置工作经历 public function SetWorkExperience(string $timArea,string $company) { $this->timeArea = $timArea; $this->company = $company; } //显示 public function Display(){ return $this->name." ".$this->sex." ".$this->age."<br>工作经历：".$this->timeArea." ".$this->company."<br>"; } } 运行 client.php：<?php namespace DesignPatterns\Prototype\V1; require dirname(__DIR__).'/../vendor/autoload.php'; class Client { public function run(){ $resumea = new Resume("张三"); $resumea->SetPersonalInfo('男','18'); $resumea->SetWorkExperience('2000-2004','xx公司'); $resumeb = new Resume("张三"); $resumeb->SetPersonalInfo('男','18'); $resumeb->SetWorkExperience('2000-2004','xx公司'); $resumec = new Resume("张三"); $resumec->SetPersonalInfo('男','18'); $resumec->SetWorkExperience('2000-2004','xx公司'); echo $resumea->Display(); echo $resumeb->Display(); echo $resumec->Display(); } } $client = new Client(); $client->run();运行结果：代码没有什么问题，但是试想一下代码中三份简历就需要实例化三次，如果是二十份简历那么我们是不是要实例化二十次，如果我们当中有些输入错了 例如年龄 那么我们就需要改二十次。这对客户端来说是十分糟糕的。这就需要用的我们开头讲的原型模式了。原型（Prototype）模式用已有对象（原型）进行复制（或者叫拷贝）的方式来创建新对象，以达到节省创建时间的目的。这种基于原型来创建对象的方式就叫作原型设计模式（Prototype Design Pattern），简称原型模式。原型模式的结构原型 （Prototype） 接口将对克隆方法进行声明。 在绝大多数情况下， 其中只会有一个名为 clone克隆的方法。具体原型 （Concrete Prototype） 类将实现克隆方法。 除了将原始对象的数据复制到克隆体中之外， 该方法有时还需处理克隆过程中的极端情况， 例如克隆关联对象和梳理递归依赖等等。客户端 （Client） 可以复制实现了原型接口的任何对象。使用原型模式实现简历接下来我们用原型模式去实现简历 PHP的原型模式比较简单， 你只需要去克隆他就好了。代码如下：原型类 Resume.php<?php namespace DesignPatterns\Prototype\V2; class Resume { private $name; private $sex; private $age; private $timeArea; private $company; /** * Resume constructor. * @param $name */ public function __construct(string $name) { $this->name = $name; } //设置个人信息 public function SetPersonalInfo(string $sex,string $age) { $this->sex = $sex; $this->age = $age; } //设置工作经历 public function SetWorkExperience(string $timArea,string $company) { $this->timeArea = $timArea; $this->company = $company; } //显示 public function Display(){ return $this->name." ".$this->sex." ".$this->age."<br>工作经历：".$this->timeArea." ".$this->company."<br>"; } }运行 Client.php<?php namespace DesignPatterns\Prototype\V2; require dirname(__DIR__).'/../vendor/autoload.php'; class Client { public function run(){ $resumea = new Resume("张三"); $resumea->SetPersonalInfo('男','18'); $resumea->SetWorkExperience('2000-2004','xx公司'); $resumeb = clone $resumea; $resumeb->SetPersonalInfo('男','20'); $resumeb->SetWorkExperience('2000-2004','yy公司'); $resumec = clone $resumea; $resumec->SetPersonalInfo('男','24'); $resumec->SetWorkExperience('2004-2008','zz公司'); echo $resumea->Display(); echo $resumeb->Display(); echo $resumec->Display(); } } $client = new Client(); $client->run();运行结果：我们发现使用clone后 我们如果想修改某一份简历，只需要对这一份简历进行修改就可以了，不会影响到其他简历，使用原型模式对对性能也有很大的提高，如果我们使用第一版代码每new一次,都需要执行一次构造函数，如果构造函数运行时间过长，那么我们多次的执行初始化操作效率就太低了，使用clone后，我们隐藏了对象创建的细节，又极大的提高了性能。浅复制与深复制在上面的代码中就是一个原型模式浅复制的例子，clone关键字可以帮我们一个对象的浅副本，克隆出来的产品与原对象有相同的属性。如果对象中有属性是对象，那么它们是不会复制到新产品的对象中的。意思就是如果我们的简历类中如果有对象引用。那么引用的对象数据是不会克隆过来的。举个例子，我们的简历类中有一个设置工作经验的方法，一般会再有一个工作经历类，当中有时间区间，和公司名称等属性。然后我们对代码进行改造如下：工作经历 WorkExperience.php<?php namespace DesignPatterns\Prototype\V3; /** * 工作经历 * Class WorkExperience * @package DesignPatterns\Prototype\V3 */ class WorkExperience { private $workDate; private $company; /** * @return mixed */ public function getCompany() { return $this->company; } /** * @return mixed */ public function getWorkDate() { return $this->workDate; } /** * @param $workDate * @return mixed */ public function SetWorkDate($workDate) { $this->workDate = $workDate; } /** * @param $company * @return mixed */ public function SetCompany($company) { $this->company = $company; } }简历类 Resume.php<?php namespace DesignPatterns\Prototype\V3; /** * 简历类 * Class Resume * @package DesignPatterns\Prototype\V3 */ class Resume { private $name; private $sex; private $age; private $work; public function __construct($name) { $this->name = $name; $this->work = new WorkExperience(); } //设置个人信息 public function SetPersonalInfo(string $sex,string $age) { $this->sex = $sex; $this->age = $age; } //设置工作经历 public function SetWorkExperience(string $timArea,string $company) { $this->work->SetWorkDate($timArea); $this->work->SetCompany($company); } //显示 public function Display() { return $this->name." ".$this->sex." ".$this->age. "<br>工作经历：".$this->work->getWorkDate()." ".$this->work->getCompany()."<br>"; } }运行Client.php<?php namespace DesignPatterns\Prototype\V3; require dirname(__DIR__).'/../vendor/autoload.php'; class Client { public function run(){ $resumea = new Resume("张三"); $resumea->SetPersonalInfo('男','18'); $resumea->SetWorkExperience('2000-2004','xx公司'); $resumeb = clone $resumea; $resumeb->SetPersonalInfo('男','20'); $resumeb->SetWorkExperience('2000-2004','yy公司'); $resumec = clone $resumea; $resumec->SetPersonalInfo('男','24'); $resumec->SetWorkExperience('2004-2008','zz公司'); echo $resumea->Display(); echo $resumeb->Display(); echo $resumec->Display(); } } $client = new Client(); $client->run();我们可以看到 使用浅复制对于值的引用没什么问题，但对于引用对象还是指向了原来的对象，虽然我们给三份简历都引用设置了工作经历，但可以看到三个引用都是最后一次设置，因为三个引用都指向了同一个对象。简历的深复制我们只需要在简历类中创建一个克隆方法__clone()，在克隆方法中让工作经验克隆完成，然后在对简历的相关字段赋值，最终返回一个深复制的简历对象。代码如下：Resume.php public function __clone() { $this->work = clone $this->work; }然后我们再次运行 client.php,结果如下总结什么是原型模式？如果对象的创建成本比较大，而同一个类的不同对象之间差别不大（大部分字段都相同），在这种情况下，我们可以利用对已有对象（原型）进行复制（或者叫拷贝）的方式，来创建新对象，以达到节省创建时间的目的。这种基于原型来创建对象的方式就叫作原型设计模式，简称原型模式。原型模式的两种实现方法原型模式有两种实现方法，深拷贝和浅拷贝。浅拷贝只会复制对象中基本数据类型数据和引用对象的内存地址，不会递归地复制引用对象，以及引用对象的引用对象……而深拷贝得到的是一份完完全全独立的对象。所以，深拷贝比起浅拷贝来说，更加耗时，更加耗内存空间。github示例：https://github.com/yangpanyao/design-patterns/tree/master/Prototype参考书籍： 大话设计模式