日常开发中我们经常会用到各种第三方库，而如何使用别人的代码其实也有一点讲究。如果直接在业务代码中使用第三方库，导致项目对某个第三方库的依赖过重，那一旦因为各种原因需要更换方案的时候，所需要修改的代码量之大可能还不如直接重写了。
所以关键就在于如何将第三方库与业务代码进行解耦，常见的思路就是对第三方库进行二度封装。而具体怎么封装，可以有很多方案，比较简单粗暴的是使用继承。譬如我们在项目中集成了 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就行了。
说了这么多，其实主要目的就是在工具库和业务代码间设置一层抽象屏障，不让业务代码对某个类库依赖过重（当然，如果是确定会一直使用，中途不会有任何变更的第三方库，那大可不必如此）。具体的做法不必拘泥于我文中的思路，大家尽可各展神通。
