thinking in Swift：从新审视装饰器模式

若是在swift中循序渐进的谈Gof设计模式，这在一开始就是错误的命题。缘由主要有两个：

• 设计模式是基于面向对象的编程范式
• 实现基于当时的主流编程语言：C++ 和 Java

现在的swift的推荐编程范式并非面向对象，不少人都大谈面向协议、函数式编程我就不展开了；现代的swift中有一些语法特性是当时的语言所不具有的，好比protocol extension，高阶函数等。

因此本文将利用swift的语法来谈下装饰器模式在swift下的解决思路。

Decorator pattern

有人翻做装饰器模式，也有翻成装饰者模式，英文的名称就是Decorator pattern。

装饰器模式可以实现动态的为对象添加功能，是从一个对象外部来给对象添加功能。装饰器模式就是基于对象组合的方式，能够很灵活的给对象添加所须要的功能。

直接用代码来讲明。

用Dish表示菜肴，一道菜有两个属性，名称和价格。而后为了方便测试重写了description属性，返回名称和价格。

class Dish: CustomStringConvertible {

    var name: String
    var price: Int

    init(name: String, price: Int) {
        self.name = name
        self.price = price
    }

    var description: String {
        get {
            return "\(name): \(price)元"
        }
    }
}复制代码

再假设有一个菜的订单对象，接收一个Dish对象后，最后能够经过total方法返回这些菜的总价钱。具体就不实现了，大概这个逻辑。

class DishOrder {

    func append(dish: Dish) {

    }

    func total() -> Int {

    }
}复制代码

假设在一个饭馆里，老板发现这里的客人点菜的时候喜欢让厨师多放点盐，你们都知道非典时期盐很贵，因此老板以为很亏，决定若是一道菜多加盐就要贵一块钱。接着又来了一个需求，若是打包带走，一道菜再加两块钱。若是咱们不能改变Dish的源码（在实际项目中常会遇到这种状况，可能这类定义在第三方的库里），要怎么实现这两个需求呢？

能够定义两个装饰器，注意这两个装饰器都要继承Dish：

// 加盐的装饰器
class SaltDishDecorator: Dish {

    init(dish: Dish) {
        super.init(name:"加糖 \(dish.name)", price: dish.price + 1)
    }

}

// 外带打包的装饰器
class PackageDishDecorator: Dish {

    init(dish: Dish) {
        super.init(name:"打包 \(dish.name)", price: dish.price + 2)
    }

}复制代码

如今咱们要表示一道打包带走的松鼠桂鱼就这样表示了：

let dish = PackageDishDecorator(dish: SaltDishDecorator(dish: Dish(name: "松鼠桂鱼", price: 15)))复制代码

这样咱们就能够给任意一道菜增长一些装饰性的功能。也有人用咖啡举例子，一杯咖啡可能要加糖，加奶，加巧克力等等。一层包一层。若是取名字的是中国人可能就叫洋葱模式了。最后使用的时候行为和Dish是同样的。由于这些Decorator是继承自Dish的。只是在初始化过程当中改变了原有的一些属性。

缺陷：继承不是一个优秀的解决方案

编程时经常提到的一个指导思想就是组合优于继承。

继承最大的问题就在于你只能有一个爹。一个爹的结果就是能力有限，不够灵活。因此最后还得认一些干爹。

就拿上面的例子来说，如今是给Dish作了几个装饰功能，若是有一天说店里的点心也要支持这两个功能（给我来一个加盐的馒头！），是否是有要继承点心类写两个装饰器呢？

利用Swift中的Extension

咱们能够这么理解这个需求，须要有这么一个方法，接受一个Dish类型的参数，通过处理后返回一个Dish。咱们彻底能够把这个方法经过extension写在Dish身上。

extension Dish {

    func salted() -> Dish {
        return Dish(name:"加盐 \(name)", price: price + 1)
    }

    func packaged() -> Dish {
        return Dish(name:"打包 \(name)", price: price + 2)
    }
}复制代码

而后咱们就能够链式调用：

let extenedDish = Dish(name: "松鼠桂鱼", price: 15).salted().packaged()复制代码

更进一步：protocol extension

若是为了未来的扩展灵活，也能够把这个装饰写到protocol的extension里。

protocol Product {
    var name: String { get set }
    var price: Int { get set }
}

protocol Salteable: Product {
     func salted() -> Self
}复制代码

上面先定义了一个产品的协议，有名称和价格两个属性。 接着再定义了一个继承Product的Salteable的协议。里面有一个返回自身的salted方法。接着给这个protocol增长扩展实现：

extension Salteable {
  func salted() -> Self {
        var newProduct = self
        newProduct.name = "加盐 \(name)"
        newProduct.price = price + 1
        return newProduct
    }
}复制代码

而后咱们再定义一个表示小吃的Snack，和菜同样也有两个属性。

struct Snack: CustomStringConvertible {

    var name: String
    var price: Int

    init(name: String, price: Int) {
        self.name = name
        self.price = price
    }

    var description: String {
        get {
            return "\(name): \(price)元"
        }
    }
}复制代码

若是咱们要给这个Snack增长加盐的效果，只要声明他实现Salteable协议就能够了。

extension Snack: Salteable {

}复制代码

这样就够啦！ 看下输出：

欢迎关注个人微博：@没故事的卓同窗