结构型

结构型处理的是类和对象的组成。利用接口或抽象类和方法，它们定义了组成对象的方法，进而获得新的功能。以下是我们归类为结构型的模式列表。

  • 适配器模式
  • 桥接模式
  • 组合模式
  • 装饰器模式
  • 门面模式
  • 享元模式
  • 代理模式

{% hint style=”info” %} 有关结构型的更多信息，请参见https://en.wikipedia.org/wiki/Structural\_pattern。 {% endhint %}

适配器模式

适配器模式允许从另一个接口使用现有类的接口，基本上是通过将一个类的接口转换为另一个类所期望的接口，帮助两个不兼容的接口一起工作。

下面是一个适配器模式的实现例子。

  1. class Stripe {
  2.     public function capturePayment($amount) {
  3.         /* Implementation... */
  4.     }
  6.     public function authorizeOnlyPayment($amount) {
  7.         /* Implementation... */
  8.     }
  10.     public function cancelAmount($amount) {
  11.         /* Implementation... */
  12.     }
  13. }
  15. interface PaymentService {
  16.     public function capture($amount);
  17.     public function authorize($amount);
  18.     public function cancel($amount);
  19. }
  21. class StripePaymentServiceAdapter implements PaymentService {
  22.     private $stripe;
  24.     public function __construct(Stripe $stripe) {
  25.         $this->stripe = $stripe;
  26.     }
  28.     public function capture($amount) {
  29.         $this->stripe->capturePayment($amount);
  30.     }
  32.     public function authorize($amount) {
  33.         $this->stripe->authorizeOnlyPayment($amount);
  34.     }
  36.     public function cancel($amount) {
  37.         $this->stripe->cancelAmount($amount);
  38.     }
  39. }
  41. // Client
  42. $stripe = new StripePaymentServiceAdapter(new Stripe());
  43. $stripe->authorize(49.99);
  44. $stripe->capture(19.99);
  45. $stripe->cancel(9.99);

我们首先创建一个具体的Stripe类。然后我们定义了PaymentService接口与一些基本的支付处理方法。StripePaymentServiceAdapter实现了PaymentService接口，提供了支付处理方法的具体实现。最后，客户端实例化StripePaymentServiceAdapter并执行支付处理方法。

桥接模式

当我们想把一个类或抽象从它的实现中解耦出来时，就会用到桥接模式，让它们都能独立地改变。当类和它的实现经常变化时，这很有用。

下面是一个桥模式实现的例子。

  1. interface MailerInterface {
  2.     public function setSender(MessagingInterface $sender);
  3.     public function send($body);
  4. }
  6. abstract class Mailer implements MailerInterface {
  7.     protected $sender;
  9.     public function setSender(MessagingInterface $sender) {
  10.         $this->sender = $sender;
  11.     }
  12. }
  14. class PHPMailer extends Mailer {
  15.     public function send($body) {
  16.         $body .= "\n\n Sent from a phpmailer.";
  17.         return $this->sender->send($body);
  18.     }
  19. }
  21. class SwiftMailer extends Mailer {
  22.     public function send($body) {
  23.         $body .= "\n\n Sent from a SwiftMailer.";
  24.         return $this->sender->send($body);
  25.     }
  26. }
  28. interface MessagingInterface {
  29.     public function send($body);
  30. }
  32. class TextMessage implements MessagingInterface {
  33.     public function send($body) {
  34.         echo 'TextMessage > send > $body: ' . $body;
  35.     }
  36. }
  38. class HtmlMessage implements MessagingInterface {
  39.     public function send($body) {
  40.         echo 'HtmlMessage > send > $body: ' . $body;
  41.     }
  42. }
  44. // Client
  45. $phpmailer = new PHPMailer();
  46. $phpmailer->setSender(new TextMessage());
  47. $phpmailer->send('Hi!');
  49. $swiftMailer = new SwiftMailer();
  50. $swiftMailer->setSender(new HtmlMessage());
  51. $swiftMailer->send('Hello!');

我们首先创建一个MailerInterface。然后，具体的Mailer类实现了MailerInterface，为PHPMailer和SwiftMailer提供了一个基类。然后我们定义MessagingInterface，它由TextMessage和HtmlMessage类实现。最后，客户端实例化PHPMailer和SwiftMailer，在调用发送方法之前传递TextMessage和HtmlMessage的实例。

组合模式

组合模式就是将对象的层次结构作为一个对象，通过一个公共接口来处理。其中，对象组成三个结构，客户端因为只消耗公共接口，所以对底层结构的变化一无所知。

下面是一个组合模式的实现例子。

  1. interface Graphic {
  2.     public function draw();
  3. }
  5. class CompositeGraphic implements Graphic {
  6.     private $graphics = array();
  8.     public function add($graphic) {
  9.         $objId = spl_object_hash($graphic);
  10.         $this->graphics[$objId] = $graphic;
  11.     }
  13.     public function remove($graphic) {
  14.         $objId = spl_object_hash($graphic);
  15.         unset($this->graphics[$objId]);
  16.     }
  18.     public function draw() {
  19.         foreach ($this->graphics as $graphic) {
  20.             $graphic->draw();
  21.         }
  22.     }
  23. }
  25. class Circle implements Graphic {
  26.     public function draw()
  27.     {
  28.         echo 'draw-circle';
  29.     }
  30. }
  32. class Square implements Graphic {
  33.     public function draw() {
  34.         echo 'draw-square';
  35.     }
  36. }
  38. class Triangle implements Graphic {
  39.     public function draw() {
  40.         echo 'draw-triangle';
  41.     }
  42. }
  44. $circle = new Circle();
  45. $square = new Square();
  46. $triangle = new Triangle();
  48. $compositeObj1 = new CompositeGraphic();
  49. $compositeObj1->add($circle);
  50. $compositeObj1->add($triangle);
  51. $compositeObj1->draw();
  53. $compositeObj2 = new CompositeGraphic();
  54. $compositeObj2->add($circle);
  55. $compositeObj2->add($square);
  56. $compositeObj2->add($triangle);
  57. $compositeObj2->remove($circle);
  58. $compositeObj2->draw();

我们首先创建了一个Graphic接口。然后我们创建了CompositeGraphic、Circle、Square和Triangle，它们都实现了Graphic接口。除了仅仅实现了Graphic接口中的draw方法外，CompositeGraphic还增加了两个方法，用于跟踪添加到它的图形的内部集合。然后客户端将这些Graphic类全部实例化，将它们全部添加到CompositeGraphic中，然后由CompositeGraphic调用draw方法。

装饰器模式

装饰器模式允许将行为添加到单个对象实例中，而不影响同一类的其他实例的行为。我们可以定义多个装饰器，其中每个装饰器都会增加新的功能。

下面是一个装饰器模式实现的例子。

  1. interface LoggerInterface {
  2.     public function log($message);
  3. }
  5. class Logger implements LoggerInterface {
  6.     public function log($message) {
  7.         file_put_contents('app.log', $message, FILE_APPEND);
  8.     }
  9. }
  11. abstract class LoggerDecorator implements LoggerInterface {
  12.     protected $logger;
  14.     public function __construct(Logger $logger) {
  15.         $this->logger = $logger;
  16.     }
  18.     abstract public function log($message);
  19. }
  21. class ErrorLoggerDecorator extends LoggerDecorator {
  22.     public function log($message) {
  23.         $this->logger->log('ERROR: ' . $message);
  24.     }
  26. }
  28. class WarningLoggerDecorator extends LoggerDecorator {
  29.     public function log($message) {
  30.         $this->logger->log('WARNING: ' . $message);
  31.     }
  32. }
  34. class NoticeLoggerDecorator extends LoggerDecorator {
  35.     public function log($message) {
  36.         $this->logger->log('NOTICE: ' . $message);
  37.     }
  38. }
  40. $logger = new Logger();
  41. $logger->log('Resource not found.');
  43. $logger = new Logger();
  44. $logger = new ErrorLoggerDecorator($logger);
  45. $logger->log('Invalid user role.');
  47. $logger = new Logger();
  48. $logger = new WarningLoggerDecorator($logger);
  49. $logger->log('Missing address parameters.');
  51. $logger = new Logger();
  52. $logger = new NoticeLoggerDecorator($logger);
  53. $logger->log('Incorrect type provided.');

我们首先创建了一个LoggerInterface，其中有一个简单的log方法，然后我们定义了Logger和LoggerDecorator，两者都实现了LoggerInterface。然后我们定义了Logger和LoggerDecorator，它们都是实现LoggerInterface的。其次是ErrorLoggerDecorator、WarningLoggerDecorator和NoticeLoggerDecorator，它们实现了LoggerDecorator。最后，客户端部分三次实例化Logger，传递给它不同的装饰器。

门面模式

当我们想通过一个更简单的接口来简化大型系统的复杂性时，就会用到门面模式。它通过为大多数常见任务提供方便的方法，通过一个客户端使用的单一封装类来实现。

下面是一个门面模式实现的例子。

  1. class Product {
  2.     public function getQty() {
  3.         // Implementation
  4.     }
  5. }
  7. class QuickOrderFacade {
  8.     private $product = null;
  9.     private $orderQty = null;
  11.     public function __construct($product, $orderQty) {
  12.         $this->product = $product;
  13.         $this->orderQty = $orderQty;
  14.     }
  16.     public function generateOrder() {
  17.         if ($this->qtyCheck()) {
  18.             $this->addToCart();
  19.             $this->calculateShipping();
  20.             $this->applyDiscount();
  21.             $this->placeOrder();
  22.         }
  23.     }
  25.     private function addToCart() {
  26.         // Implementation...
  27.     }
  29.     private function qtyCheck() {
  30.         if ($this->product->getQty() > $this->orderQty) {
  31.             return true;
  32.         } else {
  33.             return true;
  34.         }
  35.     }
  37.     private function calculateShipping() {
  38.         // Implementation...
  39.     }
  41.     private function applyDiscount() {
  42.         // Implementation...
  43.     }
  45.     private function placeOrder() {
  46.         // Implementation...
  47.     }
  48. }
  50. // Client
  51. $order = new QuickOrderFacade(new Product(), $qty);
  52. $order->generateOrder();

我们首先创建一个Product类，并提供一个单一的getQty方法。然后，我们创建了一个QuickOrderFacade类，通过构造函数接受产品实例和数量，并进一步提供generateOrder方法，聚合所有的订单生成动作。最后，客户端实例化产品，将其传递给QuickOrderFacade的实例，对其调用generateOrder。

享元模式

享元模式是关于性能和资源的减少，在相似的对象之间共享尽可能多的数据。这意味着在一个实现中，一个类的相同实例被共享。当预计要创建大量相同的类实例时，这种模式效果最好。

下面是一个享元模式实现的例子。

  1. interface Shape {
  2.     public function draw();
  3. }
  5. class Circle implements Shape {
  6.     private $colour;
  7.     private $radius;
  9.     public function __construct($colour) {
  10.         $this->colour = $colour;
  11.     }
  13.     public function draw() {
  14.         echo sprintf('Colour %s, radius %s.', $this->colour, $this->radius);
  15.     }
  17.     public function setRadius($radius) {
  18.         $this->radius = $radius;
  19.     }
  20. }
  22. class ShapeFactory {
  23.     private $circleMap;
  25.     public function getCircle($colour) {
  26.         if (!isset($this->circleMap[$colour])) {
  27.             $circle = new Circle($colour);
  28.             $this->circleMap[$colour] = $circle;
  29.         }
  31.         return $this->circleMap[$colour];
  32.     }
  33. }
  35. // Client
  36. $shapeFactory = new ShapeFactory();
  37. $circle = $shapeFactory->getCircle('yellow');
  38. $circle->setRadius(10);
  39. $circle->draw();
  41. $shapeFactory = new ShapeFactory();
  42. $circle = $shapeFactory->getCircle('orange');
  43. $circle->setRadius(15);
  44. $circle->draw();
  46. $shapeFactory = new ShapeFactory();
  47. $circle = $shapeFactory->getCircle('yellow');
  48. $circle->setRadius(20);
  49. $circle->draw();

我们首先创建了一个Shape接口，有一个单一的 draw 方法。然后我们定义了实现Shape接口的Circle类，接着是ShapeFactory类。在ShapeFactory中，getCircle方法根据颜色选项返回一个新Circle的实例。最后，客户端实例化多个ShapeFactory对象，向getCircle方法调用传递不同的颜色。

代理模式

代理模式的功能是作为一个原始对象的幕后接口。它可以作为一个简单的转发包装器，甚至可以围绕它所包装的对象提供额外的功能。额外附加功能的例子可能是懒加载或缓存，这可能会补偿原始对象的资源密集操作。

下面是一个代理模式实现的例子。

  1. interface ImageInterface {
  2.     public function draw();
  3. }
  5. class Image implements ImageInterface {
  6.     private $file;
  8.     public function __construct($file) {
  9.         $this->file = $file;
  10.         sleep(5); // Imagine resource intensive image load
  11.     }
  13.     public function draw() {
  14.         echo 'image: ' . $this->file;
  15.     }
  16. }
  18. class ProxyImage implements ImageInterface {
  19.     private $image = null;
  20.     private $file;
  22.     public function __construct($file) {
  23.         $this->file = $file;
  24.     }
  26.     public function draw() {
  27.         if (is_null($this->image)) {
  28.             $this->image = new Image($this->file);
  29.         }
  31.         $this->image->draw();
  32.     }
  33. }
  35. // Client
  36. $image = new Image('image.png'); // 5 seconds
  37. $image->draw();
  39. $image = new ProxyImage('image.png'); // 0 seconds
  40. $image->draw();

我们首先创建了一个ImageInterface，有一个单一的draw方法。然后我们定义了Image和ProxyImage类，这两个类都是ImageInterface的扩展。在Image类的 __construct 中，我们用sleep方法调用模拟了资源紧张的操作。最后，客户端同时实例化Image和ProxyImage，显示出两者的执行时间差异。