行为型

行为型解决的是不同对象之间的通信挑战。它们描述了不同的对象和类之间如何相互发送消息以使事情发生。以下是我们归类为行为型的模式列表。

  • 责任链模式
  • 命令模式
  • 解析器模式
  • 迭代器模式
  • 中介者模式
  • 备忘录模式
  • 观察者模式
  • 状态模式
  • 策略模式
  • 模板方法模式
  • 访问者模式

责任链模式

责任链模式通过使一个以上的对象以链式方式处理请求，将请求的发送方与接收方解耦。各种类型的处理对象可以动态地添加到链中。使用递归组成链，可以实现无限数量的处理对象。

下面是一个责任链模式的实现例子。

  1. abstract class SocialNotifier {
  2.     private $notifyNext = null;
  4.     public function notifyNext(SocialNotifier $notifier) {
  5.         $this->notifyNext = $notifier;
  6.         return $this->notifyNext;
  7.     }
  9.     final public function push($message) {
  10.         $this->publish($message);
  12.         if ($this->notifyNext !== null) {
  13.             $this->notifyNext->push($message);
  14.         }
  15.     }
  17.     abstract protected function publish($message);
  18. }
  20. class TwitterSocialNotifier extends SocialNotifier {
  21.     public function publish($message) {
  22.         // Implementation...
  23.     }
  24. }
  26. class FacebookSocialNotifier extends SocialNotifier {
  27.     protected function publish($message) {
  28.         // Implementation...
  29.     }
  30. }
  32. class PinterestSocialNotifier extends SocialNotifier {
  33.     protected function publish($message) {
  34.         // Implementation...
  35.     }
  36. }
  38. // Client
  39. $notifier = new TwitterSocialNotifier();
  41. $notifier->notifyNext(new FacebookSocialNotifier())
  42.     ->notifyNext(new PinterestSocialNotifier());
  44. $notifier->push('Awesome new product available!');

我们首先创建了一个抽象的SocialNotifier类，并实现了抽象方法publish、notifyNext和push方法。然后我们定义了TwitterSocialNotifier、FacebookSocialNotifier和PinterestSocialNotifier，它们都是对抽象SocialNotifier的扩展。客户端首先实例化TwitterSocialNotifier，然后是两次notifyNext调用，在调用最后的push方法之前，向它传递另外两个notifier类型的实例。

命令模式

命令模式将执行某些操作的对象与知道如何使用它的对象解耦。它通过封装以后执行某个操作所需的所有相关信息来实现。这意味着对象、方法名和方法参数的信息。

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

  1. interface LightBulbCommand {
  2.     public function execute();
  3. }
  5. class LightBulbControl {
  6.     public function turnOn() {
  7.         echo 'LightBulb turnOn';
  8.     }
  10.     public function turnOff() {
  11.         echo 'LightBulb turnOff';
  12.     }
  13. }
  15. class TurnOnLightBulb implements LightBulbCommand {
  16.     private $lightBulbControl;
  18.     public function __construct(LightBulbControl $lightBulbControl) {
  19.         $this->lightBulbControl = $lightBulbControl;
  20.     }
  22.     public function execute() {
  23.         $this->lightBulbControl->turnOn();
  24.     }
  25. }
  27. class TurnOffLightBulb implements LightBulbCommand {
  28.     private $lightBulbControl;
  30.     public function __construct(LightBulbControl $lightBulbControl) {
  31.         $this->lightBulbControl = $lightBulbControl;
  32.     }
  34.     public function execute() {
  35.         $this->lightBulbControl->turnOff();
  36.     }
  37. }
  39. // Client
  40. $command = new TurnOffLightBulb(new LightBulbControl());
  41. $command->execute();

我们首先创建一个LightBulbCommand接口。然后我们定义了LightBulbControl类，它提供了两个简单的turnOn/turnOff方法。然后，我们定义了TurnOnLightBulb和TurnOffLightBulb类，它们实现了LightBulbCommand接口。最后，客户端是用LightBulbControl的实例实例化TurnOffLightBulb对象，并对其调用执行方法。

解析器模式

解释器模式规定了如何评价语言语法或表达式。我们在定义解释器的同时，也定义了语言语法的表示方法。语言语法的表示使用复合类层次结构，其中规则被映射到类。然后，解释器使用表示法来解释语言中的表达式。

下面是一个解释器模式实现的例子。

  1. interface MathExpression
  2. {
  3.     public function interpret(array $values);
  4. }
  6. class Variable implements MathExpression {
  7.     private $char;
  9.     public function __construct($char) {
  10.         $this->char = $char;
  11.     }
  13.     public function interpret(array $values) {
  14.         return $values[$this->char];
  15.     }
  16. }
  18. class Literal implements MathExpression {
  19.     private $value;
  21.     public function __construct($value) {
  22.         $this->value = $value;
  23.     }
  25.     public function interpret(array $values) {
  26.         return $this->value;
  27.     }
  28. }
  30. class Sum implements MathExpression {
  31.     private $x;
  32.     private $y;
  34.     public function __construct(MathExpression $x, MathExpression $y) {
  35.         $this->x = $x;
  36.         $this->y = $y;
  37.     }
  39.     public function interpret(array $values) {
  40.         return $this->x->interpret($values) + $this->y->interpret($values);
  41.     }
  42. }
  44. class Product implements MathExpression {
  45.     private $x;
  46.     private $y;
  48.     public function __construct(MathExpression $x, MathExpression $y) {
  49.         $this->x = $x;
  50.         $this->y = $y;
  51.     }
  53.     public function interpret(array $values) {
  54.         return $this->x->interpret($values) * $this->y->interpret($values);
  55.     }
  56. }
  58. // Client
  59. $expression = new Product(
  60.     new Literal(5),
  61.     new Sum(
  62.         new Variable('c'),
  63.         new Literal(2)
  64.     )
  65. );
  67. echo $expression->interpret(array('c' => 3)); // 25

我们首先创建一个MathExpression接口，有一个 interpret 方法。然后我们添加Variable、Literal、Sum和Product类，所有这些类都实现了MathExpression接口。然后，客户端从Product类中实例化，将Literal和Sum的实例传递给它，并以一个 interpret 方法调用结束。

迭代器模式

迭代器模式用于遍历一个容器并访问其元素。换句话说，一个类可以遍历另一个类的元素。PHP对迭代器有一个本地支持，作为内置的\Iterator和\IteratorAggregate接口的一部分。

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

  1. class ProductIterator implements \Iterator {
  2.     private $position = 0;
  3.     private $productsCollection;
  5.     public function __construct(ProductCollection $productsCollection) {
  6.         $this->productsCollection = $productsCollection;
  7.     }
  9.     public function current() {
  10.         return $this->productsCollection->getProduct($this->position);
  11.     }
  13.     public function key() {
  14.         return $this->position;
  15.     }
  17.     public function next() {
  18.         $this->position++;
  19.     }
  21.     public function rewind() {
  22.         $this->position = 0;
  23.     }
  25.     public function valid() {
  26.         return !is_null($this->productsCollection->getProduct($this->position));
  27.     }
  28. }
  30. class ProductCollection implements \IteratorAggregate {
  31.     private $products = array();
  33.     public function getIterator() {
  34.         return new ProductIterator($this);
  35.     }
  37.     public function addProduct($string) {
  38.         $this->products[] = $string;
  39.     }
  41.     public function getProduct($key) {
  42.         if (isset($this->products[$key])) {
  43.             return $this->products[$key];
  44.         }
  45.         return null;
  46.     }
  48.     public function isEmpty() {
  49.         return empty($products);
  50.     }
  51. }
  53. $products = new ProductCollection();
  54. $products->addProduct('T-Shirt Red');
  55. $products->addProduct('T-Shirt Blue');
  56. $products->addProduct('T-Shirt Green');
  57. $products->addProduct('T-Shirt Yellow');
  59. foreach ($products as $product) {
  60.     var_dump($product);
  61. }

首先创建了一个ProductIterator，它实现了标准的PHP \Iterator接口，然后我们添加了ProductCollection，它实现了标准的PHP \IteratorAggregate接口。客户端创建了一个ProductCollection的实例，通过addProduct方法调用将值堆积到其中，并循环浏览整个集合。

中介者模式

我们的软件中的类越多，它们的通信就越复杂。中介者模式通过将其封装成一个中介者对象来解决这种复杂性。对象不再直接通信，而是通过中介对象进行通信，因此降低了整体的耦合度。

下面是一个中介者模式实现的例子。

  1. interface MediatorInterface {
  2.     public function fight();
  3.     public function talk();
  4.     public function registerA(ColleagueA $a);
  5.     public function registerB(ColleagueB $b);
  6. }
  8. class ConcreteMediator implements MediatorInterface {
  9.     protected $talk; // ColleagueA
  10.     protected $fight; // ColleagueB
  12.     public function registerA(ColleagueA $a) {
  13.         $this->talk = $a;
  14.     }
  16.     public function registerB(ColleagueB $b) {
  17.         $this->fight = $b;
  18.     }
  20.     public function fight() {
  21.         echo 'fighting...';
  22.     }
  24.     public function talk() {
  25.         echo 'talking...';
  26.     }
  27. }
  29. abstract class Colleague {
  30.     protected $mediator; // MediatorInterface
  31.     public abstract function doSomething();
  32. }
  34. class ColleagueA extends Colleague {
  36.     public function __construct(MediatorInterface $mediator) {
  37.         $this->mediator = $mediator;
  38.         $this->mediator->registerA($this);
  39.     }
  41. public function doSomething() {
  42.         $this->mediator->talk();
  43. }
  44. }
  46. class ColleagueB extends Colleague {
  48.     public function __construct(MediatorInterface $mediator) {
  49.         $this->mediator = $mediator;
  50.         $this->mediator->registerB($this);
  51.     }
  53.     public function doSomething() {
  54.         $this->mediator->fight();
  55.     }
  56. }
  58. // Client
  59. $mediator = new ConcreteMediator();
  60. $talkColleague = new ColleagueA($mediator);
  61. $fightColleague = new ColleagueB($mediator);
  63. $talkColleague->doSomething();
  64. $fightColleague->doSomething();

我们首先创建了一个带有多个方法的MediatorInterface，由ConcreteMediator类实现。然后，我们定义了抽象类Colleague，强制在下面的ColleagueA和ColleagueB类上实现doSomething方法。客户端首先实例化ConcreteMediator，并将其实例传递给ColleagueA和ColleagueB的实例，并根据这些实例调用doSomething方法。

备忘录模式

备忘录模式提供了对象还原功能。通过三个不同的对象来实现：originator、caretaker和memento，其中originator是保存以后还原所需的内部状态的对象。

以下是备忘录模式实现的一个例子。

  1. class Memento {
  2.     private $state;
  4.     public function __construct($state) {
  5.         $this->state = $state;
  6.     }
  8.     public function getState() {
  9.         return $this->state;
  10.     }
  11. }
  13. class Originator {
  14.     private $state;
  16.     public function setState($state) {
  17.         return $this->state = $state;
  18.     }
  20.     public function getState() {
  21.         return $this->state;
  22.     }
  24.     public function saveToMemento() {
  25.         return new Memento($this->state);
  26.     }
  28.     public function restoreFromMemento(Memento $memento) {
  29.         $this->state = $memento->getState();
  30.     }
  31. }
  33. // Client - Caretaker
  34. $savedStates = array();
  36. $originator = new Originator();
  37. $originator->setState('new');
  38. $originator->setState('pending');
  39. $savedStates[] = $originator->saveToMemento();
  40. $originator->setState('processing');
  41. $savedStates[] = $originator->saveToMemento();
  42. $originator->setState('complete');
  43. $originator->restoreFromMemento($savedStates[1]);
  44. echo $originator->getState(); // processing

我们首先创建一个Memento类，它将通过getState方法提供对象的当前状态。然后我们定义了Originator类，将状态推送给Memento。最后，客户端通过实例化Originator来扮演 caretaker 的角色，在它的几个状态之间进行杂耍，从Memento中保存和恢复这些状态。

观察者模式

观察者模式实现了对象之间一对多的依赖关系。持有依赖列表的对象被称为subject，而依赖者被称为observer。当subject对象改变状态时，所有的依赖对象都会得到通知并自动更新。

下面是一个观察者模式的实现例子。

  1. class Customer implements \SplSubject {
  2.     protected $data = array();
  3.     protected $observers = array();
  5.     public function attach(\SplObserver $observer) {
  6.         $this->observers[] = $observer;
  7.     }
  9.     public function detach(\SplObserver $observer) {
  10.         $index = array_search($observer, $this->observers);
  12.         if ($index !== false) {
  13.             unset($this->observers[$index]);
  14.         }
  15.     }
  17.     public function notify() {
  18.         foreach ($this->observers as $observer) {
  19.             $observer->update($this);
  20.             echo 'observer updated';
  21.         }
  22.     }
  24.     public function __set($name, $value) {
  25.         $this->data[$name] = $value;
  27.         // notify the observers, that user has been updated
  28.         $this->notify();
  29.     }
  30. }
  32. class CustomerObserver implements \SplObserver {
  33.     public function update(\SplSubject $subject) {
  34.         /* Implementation... */
  35.     }
  36. }
  38. // Client
  39. $user = new Customer();
  40. $customerObserver = new CustomerObserver();
  41. $user->attach($customerObserver);
  43. $user->name = 'John Doe';
  44. $user->email = 'john.doe@fake.mail';

我们首先创建一个Customer类，它实现了标准的PHP \SplSubject接口。然后我们定义了CustomerObserver类，它实现了标准的PHP \SplObserver接口。最后，客户端实例化Customer和CustomerObserver对象，并将CustomerObserver对象附加到Customer上。任何对姓名和电子邮件属性的改变都会被观察者捕获。

状态模式

状态模式封装了同一对象根据其内部状态而产生的不同行为，使对象看起来像是改变了它的类。

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

  1. interface Statelike {
  2.     public function writeName(StateContext $context, $name);
  3. }
  5. class StateLowerCase implements Statelike {
  6.     public function writeName(StateContext $context, $name) {
  7.         echo strtolower($name);
  8.         $context->setState(new StateMultipleUpperCase());
  9.     }
  10. }
  12. class StateMultipleUpperCase implements Statelike {
  13.     private $count = 0;
  15.     public function writeName(StateContext $context, $name) {
  16.         $this->count++;
  17.         echo strtoupper($name);
  18.         /* Change state after two invocations */
  19.         if ($this->count > 1) {
  20.             $context->setState(new StateLowerCase());
  21.         }
  22.     }
  23. }
  25. class StateContext {
  26.     private $state;
  28.     public function setState(Statelike $state) {
  29.         $this->state = $state;
  30.     }
  32.     public function writeName($name) {
  33.         $this->state->writeName($this, $name);
  34.     }
  35. }
  37. // Client
  38. $stateContext = new StateContext();
  39. $stateContext->setState(new StateLowerCase());
  40. $stateContext->writeName('Monday');
  41. $stateContext->writeName('Tuesday');
  42. $stateContext->writeName('Wednesday');
  43. $stateContext->writeName('Thursday');
  44. $stateContext->writeName('Friday');
  45. $stateContext->writeName('Saturday');
  46. $stateContext->writeName('Sunday');

我们首先创建了一个Statelike接口，然后是实现该接口的StateLowerCase和StateMultipleUpperCase。StateMultipleUpperCase在它的writeName中加入了一点计数逻辑，所以它在两次调用之后就会启动新的状态。然后我们定义了StateContext类，我们将用它来切换上下文。最后，客户端实例化StateContext，并通过setState方法将StateLowerCase的一个实例传递给它，然后是几个writeName方法。

策略模式

策略模式定义了一个算法家族，每个算法都被封装起来，并可与该家族中的其他成员互换。

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

  1. interface PaymentStrategy {
  2.     public function pay($amount);
  3. }
  5. class StripePayment implements PaymentStrategy {
  6.     public function pay($amount) {
  7.         echo 'StripePayment...';
  8.     }
  10. }
  12. class PayPalPayment implements PaymentStrategy {
  13.     public function pay($amount) {
  14.         echo 'PayPalPayment...';
  15.     }
  16. }
  18. class Checkout {
  19.     private $amount = 0;
  21.     public function __construct($amount = 0) {
  22.         $this->amount = $amount;
  23.     }
  25.     public function capturePayment() {
  26.         if ($this->amount > 99.99) {
  27.             $payment = new PayPalPayment();
  28.         } else {
  29.             $payment = new StripePayment();
  30.         }
  32.         $payment->pay($this->amount);
  33.     }
  34. }
  36. $checkout = new Checkout(49.99);
  37. $checkout->capturePayment(); // StripePayment...
  39. $checkout = new Checkout(199.99);
  40. $checkout->capturePayment(); // PayPalPayment...

我们首先创建了一个PaymentStrategy接口，然后是实现它的具体类StripePayment和PayPalPayment。然后我们定义了Checkout类，并在capturePayment方法中加入了一些决策逻辑。最后，客户端实例化Checkout，通过其构造函数传递一定的金额。根据金额，Checkout内部在调用capturePayment时，会触发一个或另一个付款。

模板方法模式

模板方法模式在方法中定义了算法的程序骨架。它让我们通过使用类重载，重新定义算法的某些步骤，而不真正改变算法的结构。

下面是一个模板方法模式实现的例子。

  1. abstract class Game {
  2.     private $playersCount;
  4.     abstract function initializeGame();
  5.     abstract function makePlay($player);
  6.     abstract function endOfGame();
  7.     abstract function printWinner();
  9.     public function playOneGame($playersCount)
  10.     {
  11.         $this->playersCount = $playersCount;
  12.         $this->initializeGame();
  13.         $j = 0;
  14.         while (!$this->endOfGame()) {
  15.             $this->makePlay($j);
  16.             $j = ($j + 1) % $playersCount;
  17.         }
  18.         $this->printWinner();
  19.     }
  20. }
  22. class Monopoly extends Game {
  23.     public function initializeGame() {
  24.         // Implementation...
  25.     }
  27.     public function makePlay($player) {
  28.         // Implementation...
  29.     }
  31.     public function endOfGame() {
  32.         // Implementation...
  33.     }
  35.     public function printWinner() {
  36.         // Implementation...
  37.     }
  38. }
  40. class Chess extends Game {
  41.     public function  initializeGame() {
  42.         // Implementation...
  43.     }
  45.     public function  makePlay($player) {
  46.         // Implementation...
  47.     }
  50.     public function  endOfGame() {
  51.         // Implementation...
  52.     }
  54.     public function  printWinner() {
  55.         // Implementation...
  56.     }
  57. }
  59. $game = new Chess();
  60. $game->playOneGame(2);
  62. $game = new Monopoly();
  63. $game->playOneGame(4);

我们首先创建了一个抽象的Game类，该类提供了所有封装游戏玩法的实际抽象方法。然后我们定义了Monopoly和Chess类，这两个类都是由Game类扩展而来，为每个类实现了特定的游戏方法game-play。客户端只需实例化Monopoly和Chess对象，对每个对象调用playOneGame方法。

访问者模式

访问者模式是一种将算法与其操作的对象结构分离的方法。因此，我们能够在现有的对象结构上添加新的操作，而不实际修改这些结构。

下面是一个访问者模式的实现例子。

  1. interface RoleVisitorInterface {
  2.     public function visitUser(User $role);
  3.     public function visitGroup(Group $role);
  4. }
  6. class RolePrintVisitor implements RoleVisitorInterface {
  7.     public function visitGroup(Group $role) {
  8.         echo 'Role: ' . $role->getName();
  9.     }
  11.     public function visitUser(User $role) {
  12.         echo 'Role: ' . $role->getName();
  13.     }
  14. }
  16. abstract class Role {
  17.     public function accept(RoleVisitorInterface $visitor) {
  18.         $klass = get_called_class();
  19.         preg_match('#([^\\\\]+)$#', $klass, $extract);
  20.         $visitingMethod = 'visit' . $extract[1];
  22.         if (!method_exists(__NAMESPACE__ . '\RoleVisitorInterface', $visitingMethod)) {
  23.             throw new \InvalidArgumentException("The visitor you provide cannot visit a $klass instance");
  24.         }
  26.         call_user_func(array($visitor, $visitingMethod), $this);
  27.     }
  28. }
  30. class User extends Role {
  31.     protected $name;
  33.     public function __construct($name) {
  34.         $this->name = (string)$name;
  35.     }
  37.     public function getName() {
  38.         return 'User ' . $this->name;
  39.     }
  40. }
  42. class Group extends Role {
  43.     protected $name;
  45.     public function __construct($name) {
  46.         $this->name = (string)$name;
  47.     }
  49.     public function getName() {
  50.         return 'Group: ' . $this->name;
  51.     }
  52. }
  54. $group = new Group('my group');
  55. $user = new User('my user');
  57. $visitor = new RolePrintVisitor;
  59. $group->accept($visitor);
  60. $user->accept($visitor);

我们首先创建一个RoleVisitorInterface，然后是RolePrintVisitor，它实现了RoleVisitorInterface本身。然后我们定义了一个抽象类Role，它有一个接受方法来接受RoleVisitorInterface的参数类型。我们进一步定义了具体的User和Group类，这两个类都是从Role扩展而来的。客户端实例化User、Group和RolePrintVisitor；将 visitor 传入User和Group实例的accept方法调用。