谈谈Swift面向协议编程

从一个具体需求说起

应用中有多个页面内的UICollectionViewCell需要实现一个相同的小动画：被选中时，先缩小到原来的0.8倍，再回弹到0.9倍。动画本身实现起来不难：

    func selectWithBounce(select:Bool, animated:Bool = true){
        let bounce = CAKeyframeAnimation(keyPath: "transform")
        
        let origin = CATransform3DIdentity
        let smallest = CATransform3DMakeScale(0.8, 0.8, 1)
        let small = CATransform3DMakeScale(0.9, 0.9, 1)
        
        let originValue = NSValue(CATransform3D: origin)
        let smallestValue = NSValue(CATransform3D:smallest)
        let smallValue = NSValue(CATransform3D:small)
        
        if animated {
            bounce.duration = 0.2
            bounce.removedOnCompletion = false
            if select {
                bounce.values = [originValue, smallestValue, smallValue]
                self.layer.addAnimation(bounce, forKey: "bounce")
            }else{
                bounce.values = [smallestValue, originValue]
                self.layer.addAnimation(bounce, forKey: "bounce")
            }
        }
        if select {
            self.layer.transform = small
        }else{
            self.layer.transform = origin
        }
    }

然而不同的页面有不同的UICollectionViewCell子类，怎样方便地让它们都能复用这个动画实现呢？

面向对象的复用方式

• 继承

如果用面向对象的思维解决问题，最容易想到的就是定义个一个继承自UICollectionViewCell的类，比如叫MYCollectionViewCell，实现这个动画，然后所有需要这个动画的cell都继承它。

能解决问题，但缺点也很明显：继承很容易带来耦合。

比如，现在需要给UICollectionViewCell再增加一个功能，这个功能的接口声明了依赖ABC另外三个类。Swift/Objective-C只能单继承，如果把新的功能实现也放到这个MYCollectionViewCell里，就引入了不必要的耦合。这时我们想用这个动画功能，依赖MYCollectionViewCell的同时也跟着依赖了和动画毫无关系的ABC三个类。代码就开始僵化了。

有的项目里定义了继承UIViewController的父类，实现了很多功能，要求项目里所有的页面都要继承它。这种僵化的毛病就很明显了，下面的子类代码全都依赖这个父类，想抽出来复用非常难。而且往这个自定义UIViewController里塞代码实在太方便了，这个类很容易随着功能迭代逐渐膨胀，越来越难以维护。

而且，假如一个UITableViewCell也需要这个功能，使用继承无法实现。UITableViewCell和UICollectionViewCell已经是UIView的不同子类，除非改动UIView，否则无法同时给它们增加功能。然而我们拿不到UIView的实现文件。

• Extension/Category

严格意义上讲这个不能算典型的面向对象，而是Swift/Objective-C特有的功能。使用它，可以不修改类的实现文件的情况下，给它增加新的方法。我们恰好可以通过给UIView添加category解决UITableViewCell和UICollectionViewCell同时增加功能的问题。缺点也是Extension/Category固有的，给一个类加上这东西会污染所有的对象，即使他们根本不需要这个功能。对于Objective-C，即使在一个文件中没有 import这个category，使用runtime还是可以访问到category中的方法的。

• 组合

组合优于继承这是老生常谈了，用在这里就要定义一个类专门负责做这个动画，然后把layer作为方法参数或者成员变量传进来。缺点嘛，就是有点麻烦。这种小工具类多了，要写很多胶水代码。

面向协议的复用方式

协议扩展这个特性的引入，使得Swift支持了一种新的编程范式：面向协议编程。针对某个要实现的功能，我们可以使用协议定义出接口，然后利用协议扩展提供默认的实现。

上代码：

protocol BounceSelect {
    func selectWithBounce(select:Bool, animated:Bool)
}

extension BounceSelect where Self:UIView {
    
    func selectWithBounce(select:Bool, animated:Bool = true){
        let bounce = CAKeyframeAnimation(keyPath: "transform")
        
        let origin = CATransform3DIdentity
        let smallest = CATransform3DMakeScale(0.8, 0.8, 1)
        let small = CATransform3DMakeScale(0.9, 0.9, 1)
        
        let originValue = NSValue(CATransform3D: origin)
        let smallestValue = NSValue(CATransform3D:smallest)
        let smallValue = NSValue(CATransform3D:small)
        
        if animated {
            bounce.duration = 0.2
            bounce.removedOnCompletion = false
            if select {
                bounce.values = [originValue, smallestValue, smallValue]
                self.layer.addAnimation(bounce, forKey: "bounce")
            }else{
                bounce.values = [smallestValue, originValue]
                self.layer.addAnimation(bounce, forKey: "bounce")
            }
        }
        if select {
            self.layer.transform = small
        }else{
            self.layer.transform = origin
        }
    }
}

这样，一个UICollectionViewCell或UITableViewCell需要这个功能，只需要声明遵守了这个协议即可，其他什么都不用做，直接就可以调用func selectWithBounce(select:Bool, animated:Bool)这个方法：

class XYZCollectionViewCell : UICollectionViewCell, BounceSelect {
    ...
}

let cell: XYZCollectionViewCell
cell.selectWithBounce(true)

遵守某个协议的类的对象调用协议声明的方法时，如果类本身没有提供实现，协议扩展提供的默认实现会被调用。

事实上，我们还可以进一步解除耦合。这个方法依赖的只有layer，不一定要是UIView，还可以是NSView，甚至可以是CALayer本身。

另外我们可以允许用户自定义动画的时长，并提供默认的时长。

稍微改下代码：

protocol BounceSelect {
    var layer:CALayer {get}
    var animationDuration:NSTimeInterval {get}
    func selectWithBounce(select:Bool, animated:Bool)
    
}

extension BounceSelect {
    
    var animationDuration:NSTimeInterval {
        return 0.2
    }
    
    func selectWithBounce(select:Bool, animated:Bool = true){
        let bounce = CAKeyframeAnimation(keyPath: "transform")
        
        let origin = CATransform3DIdentity
        let smallest = CATransform3DMakeScale(0.8, 0.8, 1)
        let small = CATransform3DMakeScale(0.9, 0.9, 1)
        
        let originValue = NSValue(CATransform3D: origin)
        let smallestValue = NSValue(CATransform3D:smallest)
        let smallValue = NSValue(CATransform3D:small)
        
        if animated {
            bounce.duration = animationDuration
            bounce.removedOnCompletion = false
            if select {
                bounce.values = [originValue, smallestValue, smallValue]
                self.layer.addAnimation(bounce, forKey: "bounce")
            }else{
                bounce.values = [smallestValue, originValue]
                self.layer.addAnimation(bounce, forKey: "bounce")
            }
        }
        if select {
            self.layer.transform = small
        }else{
            self.layer.transform = origin
        }
    }
}

这个协议通过var layer:CALayer {get}定义了接入的条件，通过func selectWithBounce(select:Bool, animated:Bool)方法的声明和实现，定义了它的功能。它就像一个插件，只要提供一个 CALayer 属性，任何类都可以方便地接入这个功能。这样就可以在不同的类之间复用这段代码了，解除了对类型的依赖。这是继承和
Extension/Category都无法做到的。

如果是CALayer本身呢？很简单：

class XYZLayer : CALayer, BounceSelect {

    //如果想修改动画时长就重载这个属性
    var animationDuration:NSTimeInterval {
        return 0.3
    }
    var layer:CALayer {
        return self
    }
}

面向协议编程的好处在于，通过协议+扩展实现一个功能，能够定义所需要的充分必要条件，不多也不少。这样就最大程度减少了耦合。使用者可以像搭积木一样随意组合这些协议，写一个class或struct来完成复杂的功能。实际上，Swift的标准库几乎是everything is starting out as a protocol。

传统的协议（比如Objective-C的protocol，Java的Interface）只能定义接口，不能复用实现，遵守同一个协议的不同的类，只能分别实现协议接口，使用场景受限了很多。Swift只是多了一个协议扩展的特性，但却带来了编程范式的进化。