如何将第三方库与业务代码解耦

日常开发中我们经常会用到各种第三方库，而如何使用别人的代码其实也有一点讲究。如果直接在业务代码中使用第三方库，导致项目对某个第三方库的依赖过重，那一旦因为各种原因需要更换方案的时候，所需要修改的代码量之大可能还不如直接重写了。

所以关键就在于如何将第三方库与业务代码进行解耦，常见的思路就是对第三方库进行二度封装。而具体怎么封装，可以有很多方案，比较简单粗暴的是使用继承。譬如我们在项目中集成了 AFNetworking，但我们不直接使用AFHTTPRequestOperationManager来进行网络请求，而是新建一个MyHTTPRequestOperationManager继承自AFHTTPRequestOperationManager，声明一系列方法供业务方调用，这些方法可以执行一些额外的操作，然后将请求消息转发给父类。这样如果以后不准备使用 AFNetworking 了，只需要改写AFHTTPRequestOperationManager这个类，而不用去修改其它地方。这是可行的，但是我们可以有更好的解决方案。

2015年的 WWDC 有一个 topic 是 Protocol-Oriented Programming in Swift，苹果宣称 Swift 是一门面向协议的语言，说是这将颠覆人们写代码的方式。这多少有点夸大其辞，毕竟所谓的面向协议编程其实跟几十年前就被提出的设计原则——面向接口编程而不是面向实现编程，是有异曲同工之妙的。

那接下来，我就运用面向协议的思维来进行解耦。举个真实的案例吧，最近我准备在项目中集成 Realm 来做缓存，于是我先声明了一个CacheManagerType：

typealias Handler = () -> Void
protocol CacheManagerType {
    associatedtype Cacheable
    
    static var defaultManager: Self { get }
    
    func addItem(item: Cacheable)
    func updateItem(item: Cacheable)
    func deleteItem(item: Cacheable)
    
    func addItems(items: [Cacheable])
    func updateItems(items: [Cacheable])
    func deleteItems(items: [Cacheable])
    func deleteAllItems()
    
    func itemWithId(id: Int) -> Cacheable?
    
    func updateWithHandler(handler: Handler)
}

Swift 不直接支持范型协议，不过可以用associatedtype达到相同的效果，这边的Cacheable就是一个范型，代表了可以被缓存的类型。接下来我定义一个RealmCacheManager，它遵守CacheManagerType协议：

private let errorMessage = "Realm exception: write failed."
private let cacheQueueName = "cn.sheepy.CacheManager"
private let cacheQueue = dispatch_queue_create(cacheQueueName, DISPATCH_QUEUE_CONCURRENT)

private let instance = CacheManager()

final class RealmCacheManager: NSObject, CacheManagerType {
    
    static var defaultManager: RealmCacheManager {
        return instance
    }
    
    private var cache: RLMRealm {
        // The default `RLMRealm` instance for the current thread
        return RLMRealm.defaultRealm()
    }
    
    // MARK: - Handle item
    
    func addItem(item: RLMObject) {
        invokeInCacheQueue {
            self.cache.addObject(item)
        }
    }
    
    func updateItem(item: RLMObject) {
        invokeInCacheQueue {
            self.cache.addOrUpdateObject(item)
        }
    }
    
    func deleteItem(item: RLMObject) {
        invokeInCacheQueue {
            self.cache.deleteObject(item)
        }
    }
    
    // MARK: - Handle items
    
    func addItems(items: [RLMObject]) {
        invokeInCacheQueue {
            self.cache.addObjects(items)
        }
    }
    
    func updateItems(items: [RLMObject]) {
        invokeInCacheQueue {
            self.cache.addOrUpdateObjectsFromArray(items)
        }
    }
    
    func deleteItems(items: [RLMObject]) {
        invokeInCacheQueue {
            self.cache.deleteObjects(items)
        }
    }
    
    func deleteAllItems() {
        invokeInCacheQueue {
            self.cache.deleteAllObjects()
        }
    }
    
    // MARK: - Handle with closure
    
    func updateWithHandler(handler: Handler) {
        invokeInCacheQueue {
            handler()
        }
    }
    
    // MARK: - Query
    
    func itemWithId<T: RLMObject>(id: Int) -> T? {
        if let result = T.objectsWhere("id == \(id)").firstObject() as? T {
            return result
        } else {
            return nil
        }
    }
    
    // MARK: - Private methods
    
    private func invokeInCacheQueue(handler: Handler) {
        dispatch_async(cacheQueue) {
            self.invoke(handler)
        }
    }
    
    private func invoke(handler: Handler) {
        do {
            try cache.transactionWithBlock {
                handler()
            }
        } catch {
            printLog(errorMessage)
        }
    }
}

这个类是CacheManagerType的 Realm 版本的实现，我们可以定义生成方法：

fun genericCacheManager<T: CacheManagerType>() -> T {
    return T.defaultManager
}

func cacheManager() -> RealmCacheManager {
    return genericCacheManager()
}

在业务方需要进行缓存操作的时候，只需要调用生成方法拿到一个defaultManager单例即可使用：

let cacheManager = cacheManager()

如果要以它作为方法参数，那该方法应该声明为范型方法：

func doSometihingWithCacheManager<T: CacheManagerType>(cacheManager: T)

这样，一旦以后需要更换缓存方案，譬如还是准备使用 CoreData，那只需要创建一个CoreDataCacheManager，让它遵守CacheManagerType，然后把cacheManager方法的返回类型改为CoreDataCacheManager即可：

func cacheManager() -> CoreDataCacheManager {
    return genericCacheManager()
}

这样原先业务代码中得到的cacheManager就自动变成CoreDataCacheManager的一个单例了。用了一段时间如果觉得还是 Realm 好用，依旧只要把cacheManager方法的返回类型改为RealmCacheManager就可以了，非常方便。

以上方案还有一个问题，就是RealmCacheManager的一系列方法的参数都使用了RLMObject，这是Realm中 Model 的基类，业务代码中需要生成具体RLMObject对象才能使用这些缓存方法，这也是一种紧耦合。一旦移除了 Realm，还是需要修改许多业务代码。更合适的方法是声明一个Cacheable协议：

protocol Cacheable {
    var entity: RLMObject { get }
}

然后让一个原先就在项目中用来表示 Model 的类型来遵守这个协议，譬如 JOSN、Dictionary、MTLModel 等等都行。譬如这样：

extension XXXModel: Cacheable {
    var entity: RLMObject {
        return RLMObject(object: self)
    }
}

具体的转换逻辑可以用 extension 加到 RLMObject 中去，这样就把转换逻辑和 RLMObject 对象从业务代码中剥离出来。而且CacheManagerType中的associatedtype和defaultManager也可以去掉了，CacheManagerType可以作为类型使用了（Swift 中使用了associatedtype和Self的协议不能作为类型，只能作为范型约束）。相应的在RealmCacheManager中相关的方法要进行一点修改，以addItem为例：

func addItem(item: Cacheable) {
    invokeInCacheQueue {
        self.cache.addObject(item.entity)
    }
}

生成方法只要这样就行了：

func cacheManager() -> CacheManagerType {
    return RealmCacheManager.defaultManager
}

以后要换缓存方案的时候，只需要修改Cacheable中entity的返回类型（譬如 CoreData 中的NSManagedObject），然后相应地添加转换逻辑就行了。cacheManager实例的替换跟之前差不多，把cacheManager中的RealmCacheManager换成CoreDataCacheManager就行了。

说了这么多，其实主要目的就是在工具库和业务代码间设置一层抽象屏障，不让业务代码对某个类库依赖过重（当然，如果是确定会一直使用，中途不会有任何变更的第三方库，那大可不必如此）。具体的做法不必拘泥于我文中的思路，大家尽可各展神通。