Swift：Cachable一个协议抽象持久化

前言

以前在这篇文章里 咱们定义了一个Parsable 用于反序列化

protocol Parsable {
  static func parse(data: Data) -> Result<Self>
}
复制代码

若是咱们要给自定义的类型添加一个持久化的功能，一样也能够定义一个协议，使得遵照这个协议的类型都拥有持久化这个功能。

Cachable

public protocol Cachable {
  /// 存入沙盒
  ///
  /// - Parameter path: 路径
  /// - Returns: 结果
  @discardableResult
  func save(at path: String) -> Result<Void, Error>

  /// 从沙盒中取
  ///
  /// - Parameter path: 路径
  /// - Returns: 结果
  static func get(fromCache path: String) -> Self?
}
复制代码

Cachable定义了两个方法 存和取，接下来咱们给Cachable添加默认实现。

Codable

大部分的反序列化与序列化都会使用很是方便的Codable

extension Cachable where Self: Codable {
  @discardableResult
  public func save(at path: String) -> Result<Void, Error> {
    let url = URL(fileURLWithPath: path)
    do {
      let data = try JSONEncoder().encode(self)
      try data.write(to: url)
      return .success(())
    } catch {
      print("Cachable: 存储沙盒失败 - \(error.localizedDescription)")
      return .failure(error)
    }
  }

  public static func get(fromCache path: String) -> Self? {
    let url = URL(fileURLWithPath: path)
    do {
      let data = try Data(contentsOf: url)
      return try JSONDecoder().decode(self, from: data)
    } catch {
      print("Cachable: 从沙盒中获取失败 - \(error.localizedDescription)")
      return nil
    }
  }
}
复制代码

如此一来当一个类型遵循了Codable且也想遵循Cachable就能够无偿使用上面的两个方法。

struct Car: Codable {
  var engine: String
  var name: String
  var type: String
}

extenstion Car: Cachale {}

// 获取沙盒中缓存的car
let carCachePath = getMyCarCachePath()
let myCacheCar = Car.get(fromCache: carCachePath)

// 缓存bmw
let bmw = Car(engine: "V8", name: "X7", type: "xDrive50i")
bmw.save(at: carCachePath)
复制代码

注：咱们使用@discardableResult标记了save(at:)方法，目的是让编译器不警告咱们没有使用save(at:)方法的返回值。不少链式调用的方法都有这个标记，例如Alamofire就使用了这个标记。

String、Data

咱们也能够给String和Data也添加这个功能。

extension Cachable where Self == String {
  @discardableResult
  public func save(at path: String) -> Result<Void, Error> {
    let url = URL(fileURLWithPath: path)
    do {
      if let data = self.data(using: .utf8) {
        try data.write(to: url)
        return .success(())
      } else {
        return .failure(WWError.stringToDataError)
      }
    } catch {
      print("Cachable: 存储沙盒失败 - \(error.localizedDescription)")
      return .failure(error)
    }
  }

  public static func get(fromCache path: String) -> Self? {
    let url = URL(fileURLWithPath: path)
    do {
      let data = try Data(contentsOf: url)
      return self.init(data: data, encoding: .utf8)
    } catch {
      print("Cachable: 从沙盒中获取失败 - \(error.localizedDescription)")
      return nil
    }
  }
}
复制代码

Data也是同样的，你们能够自行去实现。

SwiftProtobuf

若是有使用SwiftProtobuf也能够给SwiftProtobuf的Message添加这个功能。

extension Cachable where Self: SwiftProtobuf.Message {
  @discardableResult
  func save(at path: String) -> Result<Void, Error> {
    let url = URL(fileURLWithPath: path)
    do {
      let data = try serializedData()
      try data.write(to: url)
      return .success(())
    } catch {
      print("Cachable: 存储沙盒失败 - \(error.localizedDescription)")
      return .failure(error)
    }
  }

  static func get(fromCache path: String) -> Self? {
    let url = URL(fileURLWithPath: path)
    do {
      let data = try Data(contentsOf: url)
      return try self.init(serializedData: data)
    } catch {
      print("Cachable: 从沙盒中获取失败 - \(error.localizedDescription)")
      return nil
    }
  }
}
复制代码

添加了默认实现后，咱们的Cachable已经能够大展身手了，只要是知足Codable或是SwiftProtobuf里的Message而且遵循了Cachable就能够免费持久化了。

总结

protocol绝对是用来描述某种功能的利器，并且不受类型的限制，万物皆可遵循。想要JSON转model就遵循Decodable，想要持久化某个对象就遵循咱们的Cachable...

只要你想提供某种功能，使用protocol抽象，给它添加默认实现，谁想用这个功能就遵循它，不想用也不会多余。