本文实例讲述了PHP设计模式之适配器模式（Adapter）原理与用法，分享给大家供大家参考，具体如下：

这个适配器模式，就是为了将一个类的接口转换成客户希望的另外一个接口，并且使用原本不兼容的而不能在一起工作的那些类可以在一起工作。它的核心思想就是把对某些相似的类的操作转化为一个统一的“接口”(这里是比喻的说话)--适配器，或者比喻为一个“界面”，统一或屏蔽了那些类的细节。适配器模式还构造了一种“机制”，使“适配”的类可以很容易的增减，而不用修改与适配器交互的代码，符合“减少代码间耦合”的设计原则。

我们来考虑下开发过程中，我们引用一个第三方类库的场景，这个类库随着版本的改变，它提供的API也可能会改变。如果很不幸的是，你的应用里引用的某个API已经发生改变的时候，除了在心中默默地骂“wocao”之外，你还得去硬着头皮去改大量的代码，这个时候，为了减少工作量，我们就可以使用适配器模式。

先来看一个网上的案例：

假如我们原始的有一个UserInfo的类，提供用户信息的类，早起设计该类的时候，只实现了一个getUserName获取用户名的方法。

我们的MyOldObject类中，将从UserInfo这个类中获取用户信息，并且输出用户名

随着时间的推移，我们旧的UserInfo这个类只提供的获取用户名的方法，已经没法满足需求，我们同时需要获取用户的年龄等信息。

为了不改变原本UserInfo这个类，我们就继承UserInfo，建立一个UserInfoAdapter类，实现getAge获取年龄这样的方法。

在我们的MyNewObject新的类中，我们实例化UserInfoAdapter，打印出用户姓名和年龄。

这样，随着我们的扩展，我们没有改变原先UserInfo这个类和使用这个类的接口，我们通过适配的方法，将UserInfo类扩展出来

代码实现过程如下：

1. <?php 
2. //早期的一个用户类，只实现获取用户名的方法 
3. class UserInfo { 
4.     public function getUserName() { 
5.         return 'initphp'; 
6.     } 
7. } 
8.  
9. //MyOldObject类，从UserInfo类中获取信息，输出用户名 
10. <?php 
11. include_once("UserInfo.php"); 
12. class MyOldObject { 
13.     public function write() { 
14.         $UserInfo = new UserInfo; 
15.         echo $UserInfo->getUserName(); 
16.     } 
17. } 
18. $a = new MyOldObject; 
19. $a->write(); 

上述代码是早期的时候，我们使用的案例，然而UserInfoAdapter类，随着时间推移，项目需求在变化，UserInfo类无法满足需求，我们做了UserInfo类的适配器，满足新功能的需求，如下：

1. <?php 
2. include_once("UserInfo.php"); 
3. class UserInfoAdapter extends UserInfo{ 
4.     public function getUserAge() { 
5.         return 28; 
6.     } 
7.     public function getUser() { 
8.         return array( 
9.             'username' => $this->getUserName(), 
10.             'age' => $this->getUserAge() 
11.         ); 
12.     } 
13. } 

MyNewObject类，新功能的类，需要打印出用户年龄和姓名，UserInfo类无法满足需求，需要调用UserInfoAdapter适配器这个类，如下：

1. <?php 
2. include_once("UserInfoAdapter.php"); 
3. class MyNewObject { 
4.     public function write() { 
5.         $UserInfoAdapter = new UserInfoAdapter; 
6.         print_r($UserInfoAdapter->getUser()); 
7.     } 
8. } 
9. $a = new MyNewObject; 
10. $a->write(); 

大概了解了哈，接下来咱们通过一个故事来了解下。

开始的时候，黑枣玩具公司专门生产玩具，生产的玩具不限于狗、猫、狮子，鱼等动物，并且每个玩具都可以进行“张嘴”与“闭嘴”操作，分别调用了openMouth与closeMouth方法。在这个时候，黑枣玩具公司的程序猿就定义一个抽象类Toy,甚至是接口Toy，完事其他的类去继承父类，实现父类的方法，很和谐的是吧。

后来，为了扩大业务，也因为红枣遥控公司可以使用遥控设备对动物进行嘴巴控制，黑枣玩具公司打算与红枣遥控公司合作。不过，麻烦的是，红枣遥控公司的遥控设备是调用的动物的doMouthOpen及doMouthClose方法。所以，黑枣玩具公司的程序员现在必须要做的是对Toy系列类进行升级改造，使Toy能调用doMouthOpen及doMouthClose方法。

在考虑实现的方法时，黑枣玩具公司的程序猿可以再在他们的父类子类里给红枣遥控公司添加这么两个方法就好啦。但是，当黑枣玩具公司的程序猿一次又一次在父类子类里面重复添加着这两个方法的时候，总会想着如此重复的工作，难道不能解决么？当有数百个子类的时候，程序员会改疯的。程序员往往比的是谁在不影响效率的时候更会“偷懒”，这样做下去程序员会觉得自己很傻。

咱也不废话了，先来看下最开始的时候的代码：

1. abstract class Toy 
2. { 
3.   public abstract function openMouth(); 
4.   public abstract function closeMouth(); 
5. } 
6. class Dog extends Toy 
7. { 
8.   public function openMouth() 
9.   { 
10.     echo "Dog open Mouth\n"; 
11.   } 
12.   public function closeMouth() 
13.   { 
14.     echo "Dog open Mouth\n"; 
15.   } 
16. } 
17. class Cat extends Toy 
18. { 
19.   public function openMouth() 
20.   { 
21.     echo "Cat open Mouth\n"; 
22.   } 
23.   public function closeMouth() 
24.   { 
25.     echo "Cat open Mouth\n"; 
26.   } 
27. } 

完事，因为绿枣遥控公司遥控设备更便宜稳定，所以黑枣玩具公司又打算要与绿枣遥控公司合作。

不过绿枣遥控公司的遥控设备是调用的动物的operMouth(type)方法来实现嘴巴控制。如果type)方法来实现嘴巴控制。如果type为0则“闭嘴”，反之张嘴。这下好了，程序员又得对Toy及其子类进行升级，使Toy能调用operMouth()方法。

在这个时候，程序员必须要动脑子想办法了，就算自己勤快，万一哪天紫枣青枣黄枣山枣这些遥控公司全来的时候，忽略自己不断增多的工作量不说，这个Toy类可是越来越大，总有一天程序员不崩溃，系统也会崩溃的。

那么，问题出在哪里呢？

其实就是一开始的代码设计实现违反了“开-闭”原则，也就是一个软件实体应当对扩展开放，对修改关闭。也就是说，在设计一个模块的时候，应当使这个模块可以在不被修改的前提下被扩展。也就是说每个尸体都是一个小王国，你让我参与你的事情这个可以，但你不能修改我的内部，除非我的内部代码确实可以优化。

来看下最后的结果：

1. <?php 
2. abstract class Toy 
3. { 
4.   public abstract function openMouth(); 
5.   public abstract function closeMouth(); 
6. } 
7. class Dog extends Toy 
8. { 
9.   public function openMouth() 
10.   { 
11.     echo "Dog open Mouth\n"; 
12.   } 
13.   public function closeMouth() 
14.   { 
15.     echo "Dog close Mouth\n"; 
16.   } 
17. } 
18. class Cat extends Toy 
19. { 
20.   public function openMouth() 
21.   { 
22.     echo "Cat open Mouth\n"; 
23.   } 
24.   public function closeMouth() 
25.   { 
26.     echo "Cat close Mouth\n"; 
27.   } 
28. } 
29. //目标角色:红枣遥控公司 
30. interface RedTarget 
31. { 
32.   public function doMouthOpen(); 
33.   public function doMouthClose(); 
34. } 
35. //目标角色:绿枣遥控公司及 
36. interface GreenTarget 
37. { 
38.   public function operateMouth($type = 0); 
39. } 
40. //类适配器角色:红枣遥控公司 
41. class RedAdapter implements RedTarget 
42. { 
43.   private $adaptee; 
44.   function __construct(Toy $adaptee) 
45.   { 
46.     $this->adaptee = $adaptee; 
47.   } 
48.   //委派调用Adaptee的sampleMethod1方法 
49.   public function doMouthOpen() 
50.   { 
51.     $this->adaptee->openMouth(); 
52.   } 
53.   public function doMouthClose() 
54.   { 
55.     $this->adaptee->closeMouth(); 
56.   } 
57. } 
58. //类适配器角色:绿枣遥控公司 
59. class GreenAdapter implements GreenTarget 
60. { 
61.   private $adaptee; 
62.   function __construct(Toy $adaptee) 
63.   { 
64.     $this->adaptee = $adaptee; 
65.   } 
66.   //委派调用Adaptee：GreenTarget的operateMouth方法 
67.   public function operateMouth($type = 0) 
68.   { 
69.     if ($type) { 
70.       $this->adaptee->openMouth(); 
71.     } else { 
72.       $this->adaptee->closeMouth(); 
73.     } 
74.   } 
75. } 
76. class testDriver 
77. { 
78.   public function run() 
79.   { 
80.      //实例化一只狗玩具 
81.     $adaptee_dog = new Dog(); 
82.     echo "给狗套上红枣适配器\n"; 
83.     $adapter_red = new RedAdapter($adaptee_dog); 
84.     //张嘴 
85.     $adapter_red->doMouthOpen(); 
86.     //闭嘴 
87.     $adapter_red->doMouthClose(); 
88.     echo "给狗套上绿枣适配器\n"; 
89.     $adapter_green = new GreenAdapter($adaptee_dog); 
90.     //张嘴 
91.     $adapter_green->operateMouth(1); 
92.     //闭嘴 
93.     $adapter_green->operateMouth(0); 
94.   } 
95. } 
96. $test = new testDriver(); 
97. $test->run(); 

大概了解了使用方式之后，我们来看下适配器模式之中的主要角色：

目标(Target)角色：定义客户端使用的与特定领域相关的接口，这也就是我们所期待得到的

源(Adaptee)角色：需要进行适配的接口

适配器(Adapter)角色：对Adaptee的接口与Target接口进行适配；适配器是本模式的核心，适配器把源接口转换成目标接口，此角色为具体类

使用场景如下：

1、你想使用一个已经存在的类，而它的接口不符合你的需求

2、你想创建一个可以复用的类，该类可以与其他不相关的类或不可预见的类协同工作

3、你想使用一个已经存在的子类，但是不可能对每一个都进行子类化以匹配它们的接口。对象适配器可以适配它的父类接口（仅限于对象适配器）

再来看下类适配器和对象适配器的一些解释和区别：

类适配器：Adapter与Adaptee是继承关系

1、用一个具体的Adapter类和Target进行匹配。结果是当我们想要一个匹配一个类以及所有它的子类时，类Adapter将不能胜任工作

2、使得Adapter可以重定义Adaptee的部分行为，因为Adapter是Adaptee的一个子集

3、仅仅引入一个对象，并不需要额外的指针以间接取得adaptee

对象适配器：Adapter与Adaptee是委托关系

1、允许一个Adapter与多个Adaptee同时工作。Adapter也可以一次给所有的Adaptee添加功能

2、使用重定义Adaptee的行为比较困难

再来看下其它和适配器模式的对比：

桥梁模式(bridge模式)：桥梁模式与对象适配器类似，但是桥梁模式的出发点不同，桥梁模式目的是将接口部分和实现部分分离，从而对它们可以较为容易也相对独立的加以改变。而对象适配器模式则意味着改变一个已有对象的接口

装饰器模式(decorator模式)：装饰模式增强了其他对象的功能而同时又不改变它的接口。因此装饰模式对应用的透明性比适配器更好。

最后来看下类适配器和对象适配器案例，如下：

1. //类适配器使用的是继承 
2. <?php 
3. /** 
4.  * 目标角色 
5.  */ 
6. interface Target { 
7.  /** 
8.   * 源类也有的方法1 
9.   */ 
10.  public function sampleMethod1(); 
11.  /** 
12.   * 源类没有的方法2 
13.   */ 
14.  public function sampleMethod2(); 
15. } 
16. /** 
17.  * 源角色 
18.  */ 
19. class Adaptee { 
20.  /** 
21.   * 源类含有的方法 
22.   */ 
23.  public function sampleMethod1() { 
24.   echo 'Adaptee sampleMethod1 <br />'; 
25.  } 
26. } 
27. /** 
28.  * 类适配器角色 
29.  */ 
30. class Adapter extends Adaptee implements Target { 
31.  /** 
32.   * 源类中没有sampleMethod2方法，在此补充 
33.   */ 
34.  public function sampleMethod2() { 
35.   echo 'Adapter sampleMethod2 <br />'; 
36.  } 
37. } 
38. class Client { 
39.  /** 
40.   * Main program. 
41.   */ 
42.  public static function main() { 
43.   $adapter = new Adapter(); 
44.   $adapter->sampleMethod1(); 
45.   $adapter->sampleMethod2(); 
46.  } 
47. } 
48. Client::main(); 
49. ?> 
50.  
51. //对象适配器使用的是委派 
52. <?php 
53. /** 
54.  * 目标角色 
55.  */ 
56. interface Target { 
57.  /** 
58.   * 源类也有的方法1 
59.   */ 
60.  public function sampleMethod1(); 
61.  /** 
62.   * 源类没有的方法2 
63.   */ 
64.  public function sampleMethod2(); 
65. } 
66. /** 
67.  * 源角色 
68.  */ 
69. class Adaptee { 
70.  /** 
71.   * 源类含有的方法 
72.   */ 
73.  public function sampleMethod1() { 
74.   echo 'Adaptee sampleMethod1 <br />'; 
75.  } 
76. } 
77. /** 
78.  * 类适配器角色 
79.  */ 
80. class Adapter implements Target { 
81.  private $_adaptee; 
82.  public function __construct(Adaptee $adaptee) { 
83.   $this->_adaptee = $adaptee; 
84.  } 
85.  /** 
86.   * 委派调用Adaptee的sampleMethod1方法 
87.   */ 
88.  public function sampleMethod1() { 
89.   $this->_adaptee->sampleMethod1(); 
90.  } 
91.  /** 
92.   * 源类中没有sampleMethod2方法，在此补充 
93.   */ 
94.  public function sampleMethod2() { 
95.   echo 'Adapter sampleMethod2 <br />'; 
96.  } 
97. } 
98. class Client { 
99.  /** 
100.   * Main program. 
101.   */ 
102.  public static function main() { 
103.   $adaptee = new Adaptee(); 
104.   $adapter = new Adapter($adaptee); 
105.   $adapter->sampleMethod1(); 
106.   $adapter->sampleMethod2(); 
107.  } 
108. } 
109. Client::main(); 
110. ?> 

好啦，本次记录就到这里了。

Tags: PHP适配器模式 Adapter

分享到：