行为型模式(二)

kailian 2014-09-06

类的状态：备忘录模式、状态模式

通过中间类：访问者模式、中介者模式、解释器模式

备忘录模式（Memento）

在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样就可以将该对象恢复到原先保存的状态

经常需要保存对象的中间状态，当需要的时候，可以恢复到这个状态。类似编辑器的ctrl+z回退操作，ctrl+y恢复操作。

备忘录模式的结构

  • 发起人：记录当前时刻的内部状态，负责定义哪些属于备份范围的状态，负责创建和恢复备忘录数据。

  • 备忘录：负责存储发起人对象的内部状态，在需要的时候提供发起人需要的内部状态。

  • 管理角色：对备忘录进行管理，保存和提供备忘录。

代码示例

  1. class Originator {  
  2.     private $state = "";  
  3.       
  4.     public function getState() {  
  5.         return $this->state;  
  6.     } 
  8.     public function setState( $state ) {  
  9.         $this->state = $state;  
  10.     }
  12.     public function createMemento(){  
  13.         return new Memento( $this->state );  
  14.     }
  16.     public function restoreMemento( $memento ) {  
  17.         $this->setState( $memento->getState() );  
  18.     }  
  19. }  
  20.   
  21. class Memento {  
  22.     private $state = "";  
  23.     public function Memento( $state ) {  
  24.         $this->state = $state;  
  25.     }  
  26.     public function getState() {  
  27.         return $this->state;  
  28.     }  
  29.     public function setState( $state ) {  
  30.         $this->state = $state;  
  31.     }  
  32. }
  33.   
  34. class Caretaker {  
  35.     private $memento; 
  37.     public function getMemento() {  
  38.         return $this->memento;  
  39.     } 
  41.     public function setMemento( $memento ) {  
  42.         $this->memento = $memento;  
  43.     }  
  44. }
  46. class Client {  
  47.     public static function main() {  
  48.         $originator = new Originator();  
  49.         $originator->setState( "状态1" );
  50.         echo( "初始状态:".$originator->getState()."<br>" );  
  51.         $caretaker = new Caretaker();
  52.         $caretaker->setMemento( $originator->createMemento() );  
  53.         $originator->setState( "状态2" );  
  54.         echo( "改变后状态:".$originator->getState()."<br>" );  
  55.         $originator->restoreMemento( $caretaker->getMemento() );  
  56.         echo( "恢复后状态:".$originator->getState()."<br>" );  
  57.     }  
  58. }    
  60. Client::main();

单状态单备份，Originator类中的state变量需要备份，以便在需要的时候恢复；Memento类中，也有一个state变量，用来存储Originator类中state变量的临时状态；而Caretaker类就是用来管理备忘录类的，用来向备忘录对象中写入状态或者取回状态。

备忘录模式的优点有：

  • 当发起人角色中的状态改变时，有可能这是个错误的改变，我们使用备忘录模式就可以把这个错误的改变还原。

  • 备份的状态是保存在发起人角色之外的，这样，发起人角色就不需要对各个备份的状态进行管理。

备忘录模式的缺点：

在实际应用中，备忘录模式都是多状态和多备份的，发起人角色的状态需要存储到备忘录对象中，对资源的消耗是比较严重的。

状态模式（State）

当对象的状态改变时，同时改变其行为

状态模式结构

  • State类是个状态类

  • Context类可以实现切换

代码示例

  1. class State {  
  2.       
  3.     private $value;  
  4.       
  5.     public function getValue() {  
  6.         return $this->value;  
  7.     }  
  8.   
  9.     public function setValue( $value ) {  
  10.         $this->value = $value;  
  11.     }  
  12.   
  13.     public function method1(){  
  14.         echo("execute the first opt!"."<br>");  
  15.     }  
  16.       
  17.     public function method2(){  
  18.         echo("execute the second opt!"."<br>");  
  19.     }  
  20. }
  22. class Context {  
  23.   
  24.     private $state;  
  25.   
  26.     public function Context( $state ) {  
  27.         $this->state = $state;  
  28.     }  
  29.   
  30.     public function getState() {  
  31.         return $this->state;  
  32.     }  
  33.   
  34.     public function setState( $state ) {  
  35.         $this->state = $state;  
  36.     }
  37.   
  38.     public function method() {  
  39.         if ( $this->state->getValue() == "state1" ) {  
  40.             $this->state->method1();  
  41.         } else if ( $this->state->getValue() == "state2" ) {  
  42.             $this->state->method2();
  43.         }  
  44.     }  
  45. } 
  47. class Client {  
  48.   
  49.     public static function main() {  
  50.           
  51.         $state = new State();  
  52.         $context = new Context( $state );  
  53.           
  54.         //设置第一种状态  
  55.         $state->setValue( "state1" );  
  56.         $context->method();  
  57.           
  58.         //设置第二种状态  
  59.         $state->setValue( "state2" );  
  60.         $context->method();  
  61.     }  
  62. }       
  64. Client::main();

访问者模式（Visitor）

封装某些作用于某种数据结构中各元素的操作，它可以在不改变数据结构的前提下定义作用于这些元素的新的操作。

  1. class A {  
  2.     public function method1() {  
  3.         echo("我是A");  
  4.     }  
  5.       
  6.     public function method2( $b ) {  
  7.         $b->showA( $this );  
  8.     }  
  9. }  
  10.   
  11. class B {  
  12.     public function showA( $a ) {  
  13.         $a->method1();  
  14.     }  
  15. } 
  17. class Client {  
  18.     public static function main() {  
  19.         $a = new A();  
  20.         $a->method1();  
  21.         $a->method2( new B() );  
  22.     }  
  23. }   
  25. Client::main();

对于类A来说，类B就是一个访问者。这个例子可扩展性比较差，并不是访问者模式的全部。

访问者模式的结构

  • 抽象访问者：抽象类或者接口，声明访问者可以访问哪些元素

  • 访问者：实现抽象访问者所声明的方法

  • 抽象元素类：接口或者抽象类，声明接受哪一类访问者访问，程序上是通过accept方法中的参数来定义的。

  • 元素类：实现抽象元素类所声明的accept方法

  • 结构对象：一个元素的容器，一般包含一个容纳多个不同类、不同接口的容器

代码示例

  1. //抽象访问者
  2. abstract class Element {  
  3.     public abstract function accept( $visitor );  
  4.     public abstract function doSomething();  
  5. }  
  6.   
  7. //抽象元素类
  8. interface IVisitor {  
  9.     public function visit1( $el1 );  
  10.     public function visit2( $el2 );  
  11. }  
  12.   
  13. //访问者
  14. class ConcreteElement1 extends Element {
  15.     public function doSomething() {
  16.         echo("这是元素1"."<br>");  
  17.     }
  18.       
  19.     public function accept( $visitor ) {
  20.         $visitor->visit1( $this );  
  21.     }
  22. }  
  23.   
  24. class ConcreteElement2 extends Element {
  25.     public function doSomething() {
  26.         echo("这是元素2"."<br>");  
  27.     }
  28.       
  29.     public function accept( $visitor ) {
  30.         $visitor->visit2( $this );
  31.     }
  32. } 
  34. //元素类
  35. class Visitor implements IVisitor {
  36.   
  37.     public function visit1( $el1 ) {
  38.         $el1->doSomething();
  39.     }
  40.       
  41.     public function visit2( $el2 ) {
  42.         $el2->doSomething();
  43.     }
  44. }  
  45.   
  46. //结构对象
  47. class ObjectStruture {
  48.     public static function getList() {
  49.         $list = array();
  50.         list($msec, $sec) = explode( ' ', microtime() );
  51.         srand((float) $sec);
  52.         
  53.         for( $i = 0; $i < 10; $i++ ) {
  54.             $a = rand( 10,100 );
  55.             if( $a > 50 ) {
  56.                 array_push($list, new ConcreteElement1());
  57.             } else {  
  58.                 array_push($list, new ConcreteElement2()); 
  59.             }  
  60.         }  
  61.         return $list;  
  62.     }  
  63. }
  64.   
  65. class Client {  
  66.     public static function main(){ 
  67.         $lists = ObjectStruture::getList();
  68.         foreach ( $lists as $key => $list ) {
  69.             $list->accept( new Visitor() );
  70.         } 
  71.     }  
  72. }     
  74. Client::main();

访问者模式的优点

  • 符合单一职责原则

  • 扩展性好

访问者模式并不是那么完美，它也有着致命的缺陷：增加新的元素类比较困难。通过访问者模式的代码可以看到，在访问者类中，每一个元素类都有它对应的处理方法，也就是说，每增加一个元素类都需要修改访问者类（也包括访问者类的子类或者实现类），修改起来相当麻烦。也就是说，在元素类数目不确定的情况下，应该慎用访问者模式。

中介者模式（Mediator）

用一个中介者对象封装一系列的对象交互，中介者使各对象不需要显示地相互作用，从而使耦合松散，而且可以独立地改变它们之间的交互。

中介者模式又称为调停者模式，减少系统耦合，任何一个类的变动，只会影响的类本身，以及中介者。

  • 抽象中介者：定义好同事类对象到中介者对象的接口，用于各个同事类之间的通信。

  • 中介者实现类：从抽象中介者继承而来，实现抽象中介者中定义的事件方法。从一个同事类接收消息，然后通过消息影响其他同时类。

  • 同事类：如果一个对象会影响其他的对象，同时也会被其他对象影响，那么这两个对象称为同事类。同事类一般由多个组成，他们之间相互影响，相互依赖。同事类越多，关系越复杂。在中介者模式中，同事类之间必须通过中介者才能进行消息传递。

注：修改自java代码，PHP不支持重载实现多态，将setNumber改为changeNumber

  1. abstract class AbstractColleague {  
  2.     protected $number;
  3.   
  4.     public function getNumber() {  
  5.         return $this->number;  
  6.     }
  8.     public function setNumber( $number ) {  
  9.         $this->number = $number;  
  10.     }
  11.    
  12.     //注意这里的参数不再是同事类，而是一个中介者  
  13.     public abstract function changeNumber($number, $abstractMediator);  
  14. }
  16. class ColleagueA extends AbstractColleague{  
  17.   
  18.     public function changeNumber( $number, $abstractMediator ) {  
  19.         $this->number = $number;
  20.         $abstractMediator->AaffectB();  
  21.     }  
  22. }  
  23.   
  24. class ColleagueB extends AbstractColleague{  
  25.   
  26.     public function changeNumber( $number, $abstractMediator ) {  
  27.         $this->number = $number;
  28.         $abstractMediator->BaffectA();
  29.     }  
  30. }
  32. abstract class AbstractMediator {  
  33.     protected $A;  
  34.     protected $B;  
  35.       
  36.     public function AbstractMediator( $a, $b ) {  
  37.         $this->A = $a;  
  38.         $this->B = $b;  
  39.     }  
  40.   
  41.     public abstract function AaffectB();  
  42.       
  43.     public abstract function BaffectA();  
  44.   
  45. }
  47. class Mediator extends AbstractMediator {
  48.     //处理A对B的影响  
  49.     public function AaffectB() {  
  50.         $number = $this->A->getNumber();  
  51.         $this->B->setNumber( $number * 100 );  
  52.     }  
  53.   
  54.     //处理B对A的影响  
  55.     public function BaffectA() {  
  56.         $number = $this->B->getNumber();  
  57.         $this->A->setNumber( $number / 100 );  
  58.     }  
  59. }
  61. class Client {  
  62.     public static function main() {  
  63.         $collA = new ColleagueA();  
  64.         $collB = new ColleagueB();  
  65.           
  66.         $am = new Mediator( $collA, $collB );  
  67.           
  68.         echo("==========通过设置A影响B=========="."<br>");  
  69.         $collA->changeNumber( 1000, $am );  
  70.         echo("collA的number值为：".$collA->getNumber()."<br>");  
  71.         echo("collB的number值为A的100倍：".$collB->getNumber()."<br>");  
  72.   
  73.         echo("==========通过设置B影响A=========="."<br>");  
  74.         $collB->changeNumber( 1000, $am );  
  75.         echo("collB的number值为：".$collB->getNumber()."<br>");
  76.         echo("collA的number值为B的0.01倍：".$collA->getNumber()."<br>");  
  77.           
  78.     }  
  79. }  
  81. Client::main();

处理对象关系的代码重新封装到一个中介类中，通过这个中介类来处理对象间的关系。

中介者模式的优点

  • 适当地使用中介者模式可以避免同事类之间的过度耦合，使得各同事类之间可以相对独立地使用。

  • 使用中介者模式可以将对象间一对多的关联转变为一对一的关联，使对象间的关系易于理解和维护。

  • 使用中介者模式可以将对象的行为和协作进行抽象，能够比较灵活的处理对象间的相互作用。

解释器模式（Interpreter）

给定一种语言，定义他的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中句子。

解释器模式的结构：

  • 抽象解释器：声明一个所有具体表达式都要实现的抽象接口（或者抽象类），接口中主要是一个interpret()方法，称为解释操作。具体解释任务由它的各个实现类来完成，具体的解释器分别由终结符解释器TerminalExpression和非终结符解释器NonterminalExpression完成。

  • 终结符表达式：实现与文法中的元素相关联的解释操作，通常一个解释器模式中只有一个终结符表达式，但有多个实例，对应不同的终结符。终结符一半是文法中的运算单元，比如有一个简单的公式R=R1+R2，在里面R1和R2就是终结符，对应的解析R1和R2的解释器就是终结符表达式。

  • 非终结符表达式：文法中的每条规则对应于一个非终结符表达式，非终结符表达式一般是文法中的运算符或者其他关键字，比如公式R=R1+R2中，+就是非终结符，解析+的解释器就是一个非终结符表达式。非终结符表达式根据逻辑的复杂程度而增加，原则上每个文法规则都对应一个非终结符表达式。

  • 环境角色：这个角色的任务一般是用来存放文法中各个终结符所对应的具体值，比如R=R1+R2，我们给R1赋值100，给R2赋值200。这些信息需要存放到环境角色中，很多情况下我们使用Map来充当环境角色就足够了。

代码示例

  1. interface Expression {  
  2.     public function interpret( $context );  
  3. }
  4.   
  5. class Plus implements Expression {   
  6.     public function interpret( $context ) {  
  7.         return $context->getNum1() + $context->getNum2();  
  8.     }  
  9. }  
  11. class Minus implements Expression {    
  12.     public function interpret( $context ) {  
  13.         return $context->getNum1() - $context->getNum2();  
  14.     }  
  15. }  
  17. class Context {        
  18.     private $num1;  
  19.     private $num2;  
  20.       
  21.     public function Context( $num1, $num2 ) {  
  22.         $this->num1 = $num1;  
  23.         $this->num2 = $num2;  
  24.     }  
  25.       
  26.     public function getNum1() {  
  27.         return $this->num1;  
  28.     }
  30.     public function setNum1( $num1 ) {  
  31.         $this->num1 = $num1;  
  32.     }
  34.     public function getNum2() {  
  35.         return $this->num2;  
  36.     }
  38.     public function setNum2( $num2 ) {  
  39.         $this->num2 = $num2;  
  40.     }   
  41. }
  43. class Client {   
  44.     public static function main() {  
  45.         // 计算9+2-8的值
  46.         $plus = new Plus();
  47.         $minus = new Minus();
  48.         $context = new Context( 9, 2 );
  49.         $result = $plus->interpret( $context );
  50.         $context = new Context( $result, 8 );
  51.         $result = $minus->interpret( $context );
  52.         echo($result);  
  53.     }  
  54. }
  56. Client::main();

解释器是一个简单的语法分析工具。

公式千变万化，但是都是由加减乘除四个非终结符来连接的，可以使用解释器模式。

设计模式5 行为型模式2