[关闭]
@qidiandasheng 2021-01-11T13:59:35.000000Z 字数 16613 阅读 1081

设计模式(三):结构型模式之代理、桥接、装饰器、适配器(😁)

架构


四种结构型模式

介绍

代理、桥接、装饰器、适配器,这4种模式是比较常用的结构型设计模式。它们的代码结构非常相似。笼统来说,它们都可以称为 Wrapper 模式,也就是通过 Wrapper 类二次封 装原始类。

尽管代码结构相似,但这 4 种设计模式的用意完全不同,也就是说要解决的问题、应用场景不同,这也是它们的主要区别。

代理模式和装饰器的区别

代理模式和装饰器模式其实很想,都是使用“组合关系”这种代码结构的设计模式,只是他们的使用场景稍微有点不同。

代理模式中,代理类附加的是跟原始类无关的功能,而在装饰器模式中,装饰器类附加的是跟原始类相关的增强功能。

  1. // 代理模式的代码结构(下面的接口也可以替换成抽象类)
  2. public interface IA {
  3. void f();
  4. }
  5. public class A impelements IA {
  6. public void f() { //... }
  7. }
  8. public class AProxy impements IA {
  9. private IA a;
  10. public AProxy(IA a) {
  11. this.a = a;
  12. }
  13. public void f() {
  14. // 新添加的代理逻辑
  15. a.f();
  16. // 新添加的代理逻辑
  17. }
  18. }
  1. // 装饰器模式的代码结构(下面的接口也可以替换成抽象类)
  2. public interface IA {
  3. void f();
  4. }
  5. public class A impelements IA {
  6. public void f() { //... }
  7. }
  8. public class ADecorator impements IA {
  9. private IA a;
  10. public ADecorator(IA a) {
  11. this.a = a;
  12. }
  13. public void f() {
  14. // 功能增强代码
  15. a.f();
  16. // 功能增强代码
  17. }
  18. }

代理模式

定义

代理模式(Proxy Pattern) :为某个对象提供一个代理,并由这个代理对象控制对原对象的访问。

定义解读:使用代理模式以后,客户端直接访问代理,代理在客户端和目标对象之间起到中介的作用。

适用场景

在某些情况下,一个客户不想或者不能直接引用一个对象,此时可以通过一个称之为“代理”的第三者来实现间接引用。

因为代理对象可以在客户端和目标对象之间起到中介的作用,因此可以通过代理对象去掉客户不能看到的内容和服务或者添加客户需要的额外服务。

代理模式常用在业务系统中开发一些非功能性需求,比如:监控、统计、鉴权、限流、事务、幂等、日志。我们将这些附加功能与业务功能解耦,放到代理类统一处理,让程序员只需要关注业务方面的开发。

成员与类图

代理模式算上客户端一共有四个成员:

类图

代码示例

场景概述

在这里举一个买房者通过买房中介买房的例子。现在一般我们买房子不直接接触房东,而是先接触中介,买房的相关合同和一些事宜可以先和中介进行沟通。

在本例中,我们在这里让买房者直接支付费用给中介,然后中介收取一部分的中介费,再将剩余的钱交给房东。中介作为房东的代理,与买房者直接接触。而且中介还需要在真正交易前做其他的事情(收取中介费,帮买房者check房源的真实性等等),因此该场景比较适合使用代理模式。

根据上面的代理模式的成员:

代码实现

定义房东和代理需要实现的抽象接口PaymentInterface

  1. @protocol PaymentInterface <NSObject>
  2. - (void)getPayment:(double)money;
  3. @end

代理类HouseProxy

  1. @interface HouseProxy : NSObject<PaymentInterface>
  2. @end
  3. const float agentFeeRatio = 0.35;
  4. @interface HouseProxy()
  5. @property (nonatomic, copy) HouseOwner *houseOwner;
  6. @end
  7. @implementation HouseProxy
  8. - (void)getPayment:(double)money{
  9. double agentFee = agentFeeRatio * money;
  10. NSLog(@"Proxy get payment : %.2lf",agentFee);
  11. [self.houseOwner getPayment:(money - agentFee)];
  12. }
  13. - (HouseOwner *)houseOwner{
  14. if (!_houseOwner) {
  15. _houseOwner = [[HouseOwner alloc] init];
  16. }
  17. return _houseOwner;
  18. }
  19. @end

HouseProxy里面,持有了房东,也就是被代理者的实例。然后在的getPayment:方法里,调用了房东实例的getPayment:方法。而且我们可以看到,在调用房东实例的getPayment:方法,代理先拿到了中介费(中介费比率agentFeeRatio定义为0.35,即中介费的比例占35%)。

这里面除了房东实例的getPayment:方法之外的一些操作就是代理存在的意义:它可以在真正被代理对象做事情之前,之后做一些其他额外的事情。比如类似AOP编程一样,定义类似的before***Method或是after**Method方法等等。

房东类(HouseOwner):

  1. @interface HouseOwner : NSObject<PaymentInterface>
  2. @end
  3. @implementation HouseOwner
  4. - (void)getPayment:(double)money{
  5. NSLog(@"House owner get payment : %.2lf",money);
  6. }
  7. @end

房东类HouseOwner按照自己的方式实现了getPayment:方法。

很多时候被代理者(委托者)可以完全按照自己的方式去做事情,而把一些额外的事情交给代理来做,这样可以保持原有类的功能的纯粹性,符合开闭原则。

使用:

  1. //客户端支付给了中介100元。
  2. HouseProxy *proxy = [[HouseProxy alloc] init];
  3. [proxy getPayment:100];

下面我们看一下打印结果,中介费收取了35%的中介费,剩下的交给了房东:

  1. Proxy get payment : 35.00
  2. House owner get payment : 65.00

代码对应的类图

优点

缺点

Objective-C 的实践

桥接模式

定义

桥接模式(Simple Factory Pattern):将抽象部分与它的实现部分分离,使它们都可以独立地变化。

定义解读:桥接模式的核心是两个抽象以组合的形式关联到一起,从而他们的实现就互不依赖了。

适用场景

如果一个系统存在两个独立变化的维度,而且这两个维度都需要进行扩展的时候比较适合使用桥接模式。

成员与类图

桥接模式一共只有三个成员:

注意:这里提到的内容与编程语言中的接口或抽象类无关,它们并不是一回事。

导出图片Mon Apr 13 2020 10_55_20 GMT+0800 (中国标准时间).png-157.3kB

从类图中可以看出Abstraction持有Implementor,但是二者的实现类互不依赖。这就是桥接模式的核心。

代码示例

场景概述

创建一些不同的形状,这些形状带有不同的颜色。

三种形状:

三种颜色:

场景分析

根据上述需求,可能有的朋友会这么设计:

这样的设计确实可以实现上面的需求。但是设想一下,如果后来增加了一种颜色或者形状的话,是不是要多出来很多类?如果形状的种类数是m,颜色的种类数是n,以这种方式创建的总类数就是m*n,当m或n非常大的时候,它们相乘的结果就会变得很大。

我们观察一下这个场景:形状和颜色这二者的是没有关联性的,二者可以独立扩展和变化,这样的组合比较适合用桥接模式来做。

根据上面提到的桥接模式的成员:

代码实现

首先我们创建形状的基类Shape

  1. //================== Shape.h ==================
  2. @interface Shape : NSObject
  3. {
  4. @protected Color *_color;
  5. }
  6. - (void)renderColor:(Color *)color;
  7. - (void)show;
  8. @end
  9. //================== Shape.m ==================
  10. @implementation Shape
  11. - (void)renderColor:(Color *)color{
  12. _color = color;
  13. }
  14. - (void)show{
  15. NSLog(@"Show %@ with %@",[self class],[_color class]);
  16. }
  17. @end

由上面的代码可以看出:

  • 形状类Shape持有Color类的实例,二者是以组合的形式结合到一起的。而且Shape类定义了供外部传入Color实例的方法renderColor::在这个方法里面接收从外部传入的Color实例并保存起来。
  • 另外一个公共接口show实际上就是打印这个图形的名称及其所搭配的颜色,便于我们后续验证。

接着我们创建三种不同的图形类,它们都继承于Shape类:

  1. //正方形类
  2. @interface Square : Shape
  3. @end
  4. @implementation Square
  5. - (void)show{
  6. [super show];
  7. }
  8. @end
  9. //长方形类
  10. @interface Rectangle : Shape
  11. @end
  12. @implementation Rectangle
  13. - (void)show{
  14. [super show];
  15. }
  16. @end
  17. //圆形类
  18. @interface Circle : Shape
  19. @end
  20. @implementation Circle
  21. - (void)show{
  22. [super show];
  23. }
  24. @end

所有颜色类的父类Color

  1. @interface Color : NSObject
  2. @end
  3. @implementation Color
  4. @end

接着我们创建继承这个Color类的三个颜色类:

  1. //红色类
  2. @interface RedColor : Color
  3. @end
  4. @implementation RedColor
  5. @end
  6. //绿色类
  7. @interface GreenColor : Color
  8. @end
  9. @implementation GreenColor
  10. @end
  11. //蓝色类
  12. @interface BlueColor : Color
  13. @end
  14. @implementation BlueColor
  15. @end

我们看一下客户端是如何使用它们来组合成不同的带有颜色的形状的:

  1. //create 3 shape instances
  2. Rectangle *rect = [[Rectangle alloc] init];
  3. Circle *circle = [[Circle alloc] init];
  4. Square *square = [[Square alloc] init];
  5. //create 3 color instances
  6. RedColor *red = [[RedColor alloc] init];
  7. GreenColor *green = [[GreenColor alloc] init];
  8. BlueColor *blue = [[BlueColor alloc] init];
  9. //rect & red color
  10. [rect renderColor:red];
  11. [rect show];
  12. //rect & green color
  13. [rect renderColor:green];
  14. [rect show];
  15. //circle & blue color
  16. [circle renderColor:blue];
  17. [circle show];
  18. //circle & green color
  19. [circle renderColor:green];
  20. [circle show];
  21. //square & blue color
  22. [square renderColor:blue];
  23. [square show];
  24. //square & red color
  25. [square renderColor:red];
  26. [square show];

上面的代码里,我们先声明了所有的形状类和颜色类的实例,然后自由搭配,形成不同的形状+颜色的组合。

下面我们通过打印的结果来看一下组合的效果:

  1. Show Rectangle with RedColor
  2. Show Rectangle with GreenColor
  3. Show Circle with BlueColor
  4. Show Circle with GreenColor
  5. Show Square with BlueColor
  6. Show Square with RedColor

从打印的接口可以看出组合的结果是没问题的。

跟上面没有使用桥接模式的设计相比,使用桥接模式需要的类的总和是 m + n:当m或n的值很大的时候是远小于 m * n(没有使用桥接,而是使用继承的方式)的。

而且如果后面还要增加形状和颜色的话,使用桥接模式就可以很方便地将原有的形状和颜色和新的形状和颜色进行搭配了,新的类和旧的类互不干扰。

代码对应的类图

导出图片Mon Apr 13 2020 10_55_38 GMT+0800 (中国标准时间).png-161.9kB

从UML类图可以看出,该设计是由两个抽象层的类ShapeColor构建的,正因为依赖的双方都是抽象类(而不是具体的实现),而且二者是以组合的方式联系到一起的,所以扩展起来非常方便,互不干扰。这对于今后我们对代码的设计有比较好的借鉴意义。

代码示例二

场景概述

利用桥接模式拆分程序中同时管理遥控器及其设备的庞杂代码。遥控器Remote类则作为抽象部分,设备Device类作为实现部分。

遥控器基类声明了一个指向设备对象的引用成员变量。所有遥控器通过通用设备接口与设备进行交互,使得同一个遥控器可以支持不同类型的设备。

你可以开发独立于设备类的遥控器类,只需新建一个遥控器子类即可。例如基础遥控器可能只有两个按钮,但你可在其基础上扩展新功能,比如开关设备。

客户端代码通过遥控器构造函数将特定种类的遥控器与设备对象连接起来。

代码实现

遥控器(抽象部分)

  1. /*
  2. “抽象部分”定义了两个类层次结构中“控制”部分的接口。它管理着一个指向
  3. “实现部分”层次结构中对象的引用,并会将所有真实工作委派给该对象
  4. */
  5. class RemoteControl is
  6. protected field device: Device
  7. constructor RemoteControl(device: Device) is
  8. this.device = device
  9. method togglePower() is
  10. if (device.isEnabled()) then
  11. device.disable()
  12. else
  13. device.enable()
  14. method volumeDown() is
  15. device.setVolume(device.getVolume() - 10)
  16. method volumeUp() is
  17. device.setVolume(device.getVolume() + 10)
  18. method channelDown() is
  19. device.setChannel(device.getChannel() - 1)
  20. method channelUp() is
  21. device.setChannel(device.getChannel() + 1)
  22. // 从抽象层中扩展遥控器子类
  23. class AdvancedRemoteControl extends RemoteControl is
  24. method mute() is
  25. device.setVolume(0)

设备(实现部分)

  1. /*
  2. “实现部分”接口声明了在所有具体实现类中通用的方法。它不需要与抽象接口相
  3. 匹配。实际上,这两个接口可以完全不一样。通常实现接口只提供原语操作,而
  4. 抽象接口则会基于这些操作定义较高层次的操作。
  5. */
  6. interface Device is
  7. method isEnabled()
  8. method enable()
  9. method disable()
  10. method getVolume()
  11. method setVolume(percent)
  12. method getChannel()
  13. method setChannel(channel)
  14. //所有设备都遵循相同的接口。
  15. class Tv implements Device is
  16. // ...
  17. class Radio implements Device is
  18. // ...

客户端调用:

  1. tv = new Tv()
  2. remote = new RemoteControl(tv)
  3. remote.togglePower()
  4. radio = new Radio()
  5. remote = new AdvancedRemoteControl(radio)

优点

缺点

装饰者模式

定义

装饰模式(Decorator Pattern) :不改变原有对象的前提下,动态地给一个对象增加一些额外的功能。

适用场景

成员与类图

成员

装饰者模式一共有四个成员:

  1. 抽象构件(Component):抽象构件定义一个对象(接口),可以动态地给这些对象添加职责。
  2. 具体构件(Concrete Component):具体构件是抽象构件的实例。
  3. 装饰(Decorator):装饰类也继承于抽象构件,它持有一个具体构件对象的实例,并实现一个与抽象构件接口一致的接口。
  4. 具体装饰(Concrete Decorator):具体装饰负责给具体构建对象实例添加上附加的责任。

模式类图

导出图片Mon Apr 13 2020 10_56_35 GMT+0800 (中国标准时间).png-197.1kB

代码示例

场景概述

对敏感数据进行压缩和加密, 从而将数据从使用数据的代码中独立出来。

程序使用一对装饰来封装数据源对象。 这两个封装器都改变了从磁盘读写数据的方式:

代码实现

抽象构件(数据读写的抽象接口):

  1. @protocol DataSource <NSObject>
  2. - (void)writeData:(NSData *)data;
  3. - (NSData *)readData;
  4. @end

具体构件:

  1. //具体构件提供操作的默认实现。这些类在程序中可能会有几个变体(比如写入数据库)
  2. @interface FileDataSource : NSObject<DataSource>
  3. - (void)writeData:(NSData *)data;
  4. - (NSData *)readData;
  5. @end
  6. @implementation FileDataSource
  7. - (void)writeData:(NSData *)data{
  8. // 将数据写入文件
  9. }
  10. - (NSData *)readData{
  11. // 从文件读取数据
  12. NSData *data = nil;
  13. return data;
  14. }
  15. @end

装饰(Decorator):

  1. /*
  2. 装饰基类和其他组件遵循相同的接口。该类的主要任务是定义所有具体装饰的封
  3. 装接口。封装的默认实现代码中可能会包含一个保存被封装组件的成员变量,并
  4. 且负责对其进行初始化
  5. */
  6. @interface DataSourceDecorator : NSObject<DataSource>
  7. - (void)writeData:(NSData *)data;
  8. - (NSData *)readData;
  9. @end
  10. ==================================================
  11. @interface DataSourceDecorator(){
  12. id<DataSource> _wrappee;
  13. }
  14. @end
  15. @implementation DataSourceDecorator
  16. - (instancetype)initWithDataSource:(id<DataSource>)data{
  17. self = [super init];
  18. if (self) {
  19. _wrappee = data;
  20. }
  21. return self;
  22. }
  23. - (void)writeData:(NSData *)data{
  24. [_wrappee writeData:data];
  25. }
  26. - (NSData *)readData{
  27. return [_wrappee readData];
  28. }
  29. @end

具体装饰:

  1. ====================加密装饰器====================
  2. @interface EncryptionDecorator : DataSourceDecorator
  3. @end
  4. @implementation EncryptionDecorator
  5. - (void)writeData:(NSData *)data{
  6. // 1. 对传递数据进行加密。
  7. data = [Encryption encrypt:data];
  8. // 2. 将加密后数据传递给被封装对象 writeData(写入数据)方法。
  9. [super writeData:data];
  10. }
  11. - (NSData *)readData{
  12. // 1. 通过被封装对象的 readData(读取数据)方法获取数据。
  13. NSData *data = [super readData];
  14. // 2. 如果数据被加密就尝试解密。
  15. data = [Decryption decrypt:data];
  16. // 3. 返回结果。
  17. return data;
  18. }
  19. @end
  20. ====================压缩装饰器====================
  21. @interface CompressionDecorator : DataSourceDecorator
  22. @end
  23. @implementation CompressionDecorator
  24. - (void)writeData:(NSData *)data{
  25. // 1. 压缩传递数据
  26. data = [Compression compress:data];
  27. // 2. 将压缩后数据传递给被封装对象 writeData(写入数据)方法
  28. [super writeData:data];
  29. }
  30. - (NSData *)readData{
  31. // 1. 通过被封装对象的 readData(读取数据)方法获取数据
  32. NSData *data = [super readData];
  33. // 2. 如果数据被压缩就尝试解压
  34. data = [Decompression decompress:data];
  35. // 3. 返回结果
  36. return data;
  37. }
  38. @end

客户端使用:

  1. NSData *orderData = [NSData new];
  2. // 已将明码数据写入目标文件
  3. id<DataSource> source = [FileDataSource new];
  4. [source writeData:orderData];
  5. // 已将压缩数据写入目标文件
  6. source = [[EncryptionDecorator alloc] initWithDataSource:source];
  7. [source writeData:orderData];
  8. // 已将压缩且加密的数据写入目标文件
  9. source = [[CompressionDecorator alloc] initWithDataSource:source];
  10. [source writeData:orderData];

优点

缺点

适配器模式

定义

适配器模式(Adapter Pattern) :将一个接口转换成客户希望的另一个接口,使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。适配器模式的别名是包装器模式(Wrapper),是一种结构型设计模式。

定义解读:适配器模式又分为对象适配器和类适配器两种。

适用场景

成员与类图

成员

适配器模式有三个成员:

代码示例

场景概述

模拟一个替换缓存组件的场景:目前客户端已经依赖于旧的缓存组件的接口,而后来发现有一个新的缓组件的性能更好一些,需要将旧的缓存组件替换成新的缓存组件,但是新的缓存组件的接口与旧的缓存接口不一致,所以目前来看客户端是无法直接与新缓存组件一起工作的。

场景分析

由于客户端在很多地方依赖了旧缓存组件的接口,将这些地方的接口都换成新缓存组件的接口会比较麻烦,而且万一后面还要换回旧缓存组件或者再换成另外一个新的缓存组件的话就还要做重复的事情,这显然是不够优雅的。

因此该场景比较适合使用适配器模式:创建一个适配器,让原本与旧缓存接口的客户端可以与新缓存组件一起工作。

在这里,新的缓存组件就是Adaptee,旧的缓存组件(接口)就是Target,因为它是直接和客户端接触的。而我们需要创建一个适配器类Adaptor来让客户端与新缓存组件一起工作。

代码实现

首先我们创建旧缓存组件,并让客户端正常使用它。
先创建旧缓存组件的接口OldCacheProtocol

对应Java的接口,Objective-C中叫做协议,也就是protocol。

  1. //================== OldCacheProtocol.h ==================
  2. @protocol OldCacheProtocol <NSObject>
  3. - (void)old_saveCacheObject:(id)obj forKey:(NSString *)key;
  4. - (id)old_getCacheObjectForKey:(NSString *)key;
  5. @end

可以看到该接口包含了两个操作缓存的方法,方法前缀为old

再简单创建一个缓存组件类OldCache,它实现了OldCacheProtocol接口:

  1. //================== OldCache.h ==================
  2. @interface OldCache : NSObject <OldCacheProtocol>
  3. @end
  4. //================== OldCache.m ==================
  5. @implementation OldCache
  6. - (void)old_saveCacheObject:(id)obj forKey:(NSString *)key{
  7. NSLog(@"saved cache by old cache object");
  8. }
  9. - (id)old_getCacheObjectForKey:(NSString *)key{
  10. NSString *obj = @"get cache by old cache object";
  11. NSLog(@"%@",obj);
  12. return obj;
  13. }
  14. @end

为了读者区分方便,将新旧两个缓存组件取名为NewCacheOldCache。实现代码也比较简单,因为不是本文介绍的重点,只需区分接口名称即可。

现在我们让客户端来使用这个旧缓存组件:

  1. //================== client.m ==================
  2. @interface ViewController ()
  3. @property (nonatomic, strong) id<OldCacheProtocol>cache;
  4. @end
  5. @implementation ViewController
  6. - (void)viewDidLoad {
  7. [super viewDidLoad];
  8. //使用旧缓存
  9. [self useOldCache];
  10. //使用缓存组件操作
  11. [self saveObject:@"cache" forKey:@"key"];
  12. }
  13. //实例化旧缓存并保存在``cache``属性里
  14. - (void)useOldCache{
  15. self.cache = [[OldCache alloc] init];
  16. }
  17. //使用cache对象
  18. - (void)saveObject:(id)object forKey:(NSString *)key{
  19. [self.cache old_saveCacheObject:object forKey:key];
  20. }
  • 在这里的客户端就是ViewController,它持有一个遵从OldCacheProtocol协议的实例,也就是说它目前依赖于OldCacheProtocol的接口。
  • useOldCache方法用来实例化旧缓存并保存在cache属性里。
  • saveObject:forKey:方法是真正使用cache对象来保存缓存。

运行并打印一下结果输出是:saved cache by old cache object。现在看来客户端使用旧缓存是没有问题的。

新的缓存组件:

首先定义新缓存组件的接口NewCacheProtocol

  1. //================== NewCacheProtocol.h ==================
  2. @protocol NewCacheProtocol <NSObject>
  3. - (void)new_saveCacheObject:(id)obj forKey:(NSString *)key;
  4. - (id)new_getCacheObjectForKey:(NSString *)key;
  5. @end

可以看到,NewCacheProtocolOldCacheProtocol接口大致是相似的,但是名称还是不同,这里使用了不同的方法前缀做了区分。

接着看一下新缓存组件是如何实现这个接口的:

  1. //================== NewCache.h ==================
  2. @interface NewCache : NSObject <NewCacheProtocol>
  3. @end
  4. //================== NewCache.m ==================
  5. @implementation NewCache
  6. - (void)new_saveCacheObject:(id)obj forKey:(NSString *)key{
  7. NSLog(@"saved cache by new cache object");
  8. }
  9. - (id)new_getCacheObjectForKey:(NSString *)key{
  10. NSString *obj = @"saved cache by new cache object";
  11. NSLog(@"%@",obj);
  12. return obj;
  13. }
  14. @end

现在我们拿到了新的缓存组件,但是客户端类目前依赖的是旧的接口,因此适配器类应该上场了:

  1. //================== Adaptor.h ==================
  2. @interface Adaptor : NSObject <OldCacheProtocol>
  3. - (instancetype)initWithNewCache:(NewCache *)newCache;
  4. @end
  5. //================== Adaptor.m ==================
  6. @implementation Adaptor
  7. {
  8. NewCache *_newCache;
  9. }
  10. - (instancetype)initWithNewCache:(NewCache *)newCache{
  11. self = [super init];
  12. if (self) {
  13. _newCache = newCache;
  14. }
  15. return self;
  16. }
  17. - (void)old_saveCacheObject:(id)obj forKey:(NSString *)key{
  18. //transfer responsibility to new cache object
  19. [_newCache new_saveCacheObject:obj forKey:key];
  20. }
  21. - (id)old_getCacheObjectForKey:(NSString *)key{
  22. //transfer responsibility to new cache object
  23. return [_newCache new_getCacheObjectForKey:key];
  24. }
  25. @end
  • 首先,适配器类也实现了旧缓存组件的接口;目的是让它也可以接收到客户端操作旧缓存组件的方法。
  • 然后,适配器的构造方法里面需要传入新组件类的实例;目的是在收到客户端操作旧缓存组件的命令后,将该命令转发给新缓存组件类,并调用其对应的方法。
  • 最后我们看一下适配器类是如何实现两个旧缓存组件的接口的:在old_saveCacheObject:forKey:方法中,让新缓存组件对象调用对应的new_saveCacheObject:forKey:方法;同样地,在old_getCacheObjectForKey方法中,让新缓存组件对象调用对应的new_getCacheObjectForKey:方法。

这样一来,适配器类就定义好了。
那么最后我们看一下在客户端里面是如何使用适配器的:

  1. //================== client ==================
  2. - (void)viewDidLoad {
  3. [super viewDidLoad];
  4. //使用新缓存组件
  5. [self useNewCache];
  6. [self saveObject:@"cache" forKey:@"key"];
  7. }
  8. - (void)useOldCache{
  9. self.cache = [[OldCache alloc] init];
  10. }
  11. //使用新缓存组件
  12. - (void)useNewCache{
  13. self.cache = [[Adaptor alloc] initWithNewCache:[[NewCache alloc] init]];
  14. }
  15. //使用cache对象
  16. - (void)saveObject:(id)object forKey:(NSString *)key{
  17. [self.cache old_saveCacheObject:object forKey:key];
  18. }

我们可以看到,在客户端里面,只需要改一处就可以了:将我们定义好的适配器类保存在原来的cache属性中就可以了(useNewCache方法的实现)。而真正操作缓存的方法saveObject:forKey不需要有任何改动。

我们可以看到,使用适配器模式,客户端调用旧缓存组件接口的方法都不需要改变;只需稍作处理,就可以在新旧缓存组件中来回切换,也不需要原来客户端对缓存的操作。

而之所以可以做到这么灵活,其实也是因为在一开始客户端只是依赖了旧缓存组件类所实现的接口,而不是旧缓存组件类的类型。有心的读者可能注意到了,上面viewController的属性是@property (nonatomic, strong) id<OldCacheProtocol>cache;。正因为如此,我们新建的适配器实例才能直接用在这里,因为适配器类也是实现了<OldCacheProtocol>接口。相反,如果我们的cache属性是这么写的:@property (nonatomic, strong) OldCache *cache;,即客户端依赖了旧缓存组件的类型,那么我们的适配器类就无法这么容易地放在这里了。因此为了我们的程序在将来可以更好地修改和扩展,依赖接口是一个前提。

代码对应的类图

导出图片Mon Apr 13 2020 10_55_04 GMT+0800 (中国标准时间).png-203.3kB

两种适配器代码示例

类适配器

类适配器模式:
导出图片Mon Apr 13 2020 10_54_45 GMT+0800 (中国标准时间).png-123.6kB

类适配器中采用了多继承的方式(多继承在Objective-C中可以通过遵循多个协议来实现):适配器同时继承了目标类和被适配者类,也就都持有了者二者的方法。

如果 Adaptee 接口很多,而且AdapteeITarget接口定义大部分都相同,那我们推 荐使用类适配器,因为Adaptor复用父类Adaptee的接口,比起对象适配器的实现方式,Adaptor 的代码量要少一些。

  1. // 类适配器: 基于继承
  2. public interface ITarget {
  3. void f1();
  4. void f2();
  5. void fc();
  6. }
  7. public class Adaptee
  8. public void fa() { //.....}
  9. public void fb() { //.....}
  10. public void fc() { //.....}
  11. }
  12. public class Adaptor extends Adaptee implements ITarget {
  13. public void f1() {
  14. super.fa();
  15. }
  16. public void f2() {
  17. //...重新实现f2()...
  18. }
  19. // 这里fc()不需要实现,直接继承自Adaptee,这是跟对象适配器最大的不同点
  20. }

对象适配器

导出图片Mon Apr 13 2020 10_54_24 GMT+0800 (中国标准时间).png-137.7kB

对象适配器中,被适配者的对象被适配器所持有。当适配器的request方法被调用时,在这个方法内部再调用被适配者对应的方法。

如果 Adaptee接口很多,而且AdapteeITarget接口定义大部分都不相同,那我们推荐使用对象适配器,因为组合结构相对于继承更加灵活。

  1. // 对象适配器:基于组合
  2. public interface ITarget {
  3. void f1();
  4. void f2();
  5. void fc();
  6. }
  7. public class Adaptee {
  8. public void fa() { //... }
  9. public void fb() { //... }
  10. public void fc() { //... }
  11. }
  12. public class Adaptor implements ITarget {
  13. private Adaptee adaptee;
  14. public Adaptor(Adaptee adaptee) {
  15. this.adaptee = adaptee;
  16. }
  17. public void f1() {
  18. adaptee.fa(); //委托给Adaptee
  19. }
  20. public void f2() {
  21. //...重新实现f2()...
  22. }
  23. public void fc() {
  24. adaptee.fc();
  25. }
  26. }

优点

缺点

参考

结构型模式

添加新批注
在作者公开此批注前,只有你和作者可见。
回复批注