iOS 设计模式系列二：装饰者模式

引言

在介绍装饰者模式之前，我们先了解一个设计原则：

多用组合，少用继承。

在平时写代码时，我们应该减少类继承的使用，过多地使用类的继承会导致类数目过于庞大而变得难以维护，而使用组合可以让我们的系统更具弹性，更加容易修改和扩展。而的接下来将要讨论的装饰者模式正是使用了对象组合的方式，可以让我们在不修改原有代码的前提下，动态地给对象赋予新的职责。

需求场景

这里借用 《Head First 设计模式》里的一个例子。去星巴克买过咖啡的同学都知道那里有很多种类的饮料，如果我们要为星巴克开发一个结账买单的系统，那么应该怎么设计呢？

需求分析和解决方案

首先进行需求分析，星巴克里有种类繁多的咖啡，结账时我们需要知道咖啡的名称和价格。所以，我们很容易想到抽出一个咖啡基类，然后继承实现各个种类的咖啡。但是，这样做的问题是，星巴克里有几十种饮料，如果我们给每种咖啡都创建一个类，会导致类数目过于庞大，而且星巴克也在不断地推出新的品种，这会给我们系统的维护带来不小的麻烦。

接下来我们进一步分析，造成咖啡饮料价格不同的原因在于：

1. 咖啡本身的种类不同（比如，咖啡可以分为浓缩咖啡（Espresso）、无咖啡因咖啡（Decaf）、深度烘焙咖啡（DarkRoast）等）。
2. 咖啡里加的调料（牛奶、豆浆、抹茶、摩卡等）不同。
   所以，我们可以将问题简化成：

咖啡饮料的价格 ＝ 咖啡本身的价格 ＋ 各种调料的价格

比如，Espresso Macchiato（浓缩玛奇朵）的价格 ＝ Espresso（浓缩咖啡） 的价格 ＋Milk（牛奶）的价格 + Mocha（摩卡）的价格。

我们看到，Milk 就像一个“装饰者（Decorator）”，而 Espresso 就像一个“被装饰者(Component)”，可以在“被装饰者”上添加各种“装饰者”来制作出全新口味的 Espresso 咖啡，当然也可以把“装饰者”放在其它类别的“被装饰者”上。只要对“被装饰者”和“装饰品”进行组合，我们就能制作出各种各样的咖啡。

需要格外强调的是，这里的组合要求是动态地进行组合，即装饰者与被装饰者是在运行的时候绑定，而不是写死在类里（比如继承，类继承是在编译的时候增加行为，而装饰者模式是在运行时增加行为）。在接下来装饰者模式的实现过程中，很多实现细节都是为了达到这个目标。

综合以上的分析，我们给出如下的设计结构：

分析完整个结构，我们再来看一下，当顾客点一杯咖啡时，这些类之间应该如何互相协作调用。假设顾客点了一杯 Espresso Macchiato（浓缩玛奇朵），那么系统将会开始以下的工作流程：

1. 首先实例化一个被装饰者 Espresso 对象，对象里包含咖啡的基本价格和名称。
2. 实例化一个装饰者 Milk 对象，对象里包含 milk 的价格和名称，同时让 Milk 对象持有 Espresso 对象。
3. 接下来调用 Milk 对象的 cost() 方法，这个方法会去调用 Espresso 的 cost() 方法，并将返回的价格和 milk 的价格相加，这样我们就可以得到 Espresso 配 milk 的价格。
4. 实例化一个装饰者 Mocha 对象，对象里包含 mocha 的价格和名称，同时让 Mocha 对象持有上述 Milk 对象。
5. 最后调用 Mocha 对象的 cost() 方法，这个方法会去调用 Milk 对象的 cost() 方法，并将返回的价格和 mocha 的价格相加，如此我们就得到了 Espresso 配 milk 和 mocha 的价格。

这样一层一层地嵌套调用是不是很像俄罗斯套娃呢？

代码实现

下面我们给出详细的代码实现：

Beverage 协议

Beverage.h

    #import <Foundation/Foundation.h>
    
    @protocol Beverage <NSObject>
    
    @optional
    - (NSString *)getName;
    
    - (double)cost;
    
    @end

Espresso 类

Espresso.h

    #import <Foundation/Foundation.h>
    #import "Beverage.h"
    
    @interface Espresso : NSObject<Beverage>
    
    @end

Espresso.m

    #import "Espresso.h"
    
    @implementation Espresso{
        NSString *_name;
    }
    
    - (instancetype)init{
        
        if (self = [super init]) {
            _name = @"Espresso";
        }
        return self;
    }
    
    - (NSString *)getName{
        return _name;
    }
    
    - (double)cost{
        return 1.99;
    }
    
    @end

CondimentDecorator 协议

CondimentDecorator.h

    #import <Foundation/Foundation.h>
    #import "Beverage.h"
    
    @protocol CondimentDecorator <Beverage>
    
    @end

Milk 类

Milk.h

    #import <Foundation/Foundation.h>
    #import "Beverage.h"
    #import "CondimentDecorator.h"
    
    @interface Milk : NSObject <CondimentDecorator>
    
    @property (strong, nonatomic)id<Beverage> beverage;
    
    - (instancetype)initWithBeverage:(id<Beverage>) beverage;
    
    @end

Milk.m

    #import "Milk.h"
    
    @implementation Milk{
        NSString *_name;
    }
    
    - (instancetype)initWithBeverage:(id<Beverage>)beverage{
        if (self = [super init]) {
            _name = @"Milk";
            self.beverage = beverage;
        }
        return self;
    }
    
    - (NSString *)getName{
        return [NSString stringWithFormat:@"%@ + %@", [self.beverage getName], _name ];
    }
    
    - (double)cost{
        return .30 + [self.beverage cost];
    }
    
    @end

Mocha 类

Mocha.h

    #import <Foundation/Foundation.h>
    #import "Beverage.h"
    #import "CondimentDecorator.h"
    
    @interface Mocha : NSObject<CondimentDecorator>
    
    @property (strong, nonatomic)id<Beverage> beverage;
    
    - (instancetype)initWithBeverage:(id<Beverage>) beverage;
    @end

Mocha.m

    #import "Mocha.h"
    
    @implementation Mocha{
        NSString *_name;
    }
    
    - (instancetype)initWithBeverage:(id<Beverage>)beverage{
        if (self = [super init]) {
            self.beverage = beverage;
            _name = @"Mocha";
        }
        return self;
    }
    
    - (NSString *)getName{
        return [NSString stringWithFormat:@"%@ + %@", [self.beverage getName], _name];
    }
    
    - (double)cost{
        return .20 + [self.beverage cost];
    }
    
    @end

整合调用

main.m

    #import <Foundation/Foundation.h>
    #import "Espresso.h"
    #import "DarkRoast.h"
    #import "Milk.h"
    #import "Mocha.h"
    #import "Soy.h"
    
    int main(int argc, const char * argv[]) {
        @autoreleasepool {
           
            id<Beverage> espresso = [[Espresso alloc]init];
            NSLog(@"name: %@ \n cost: %f \n", [espresso getName], [espresso cost]);
            
            espresso = [[Milk alloc]initWithBeverage:espresso];
            espresso = [[Mocha alloc]initWithBeverage:espresso];
            NSLog(@"name: %@ \n cost:%f", [espresso getName], [espresso cost]);
        }
        return 0;
    }

总结

到这里我们已经对装饰者模式有了一个比较全面的了解，最后来概括一下什么是装饰者模式：

装饰者模式，是面向对象编程领域中，一种动态地往一个类中添加新的行为的设计模式。就功能而言，修饰模式相比生成子类更为灵活，这样可以给某个对象而不是整个类添加一些功能。——《设计模式：可复用面向对象软件的基础》

完整的源代码地址

Github地址: https://github.com/Zentopia/DesignPatterns

参考资料

• 《Head First 设计模式(Java)》
• 《设计模式：可复用面向对象软件的基础》