背景
由于后端采用 meteor.js 进行开发，移动端适配方案很容易让人想到 web app 的开发模式。但这种直接适配的方法有很强的局限性。虽然 hybrid 也已经不是什么稀奇的方案，但 web 功能依旧和本地功能有一定的分离感。比如，meteor 监听的某个资源想要和本地 API 获取的其他资源在同一个列表中显示。那单纯的使用 web 是没法解决的。唯一的办法就是分别加载 meteor 和 API 资源，然后将他们整合在一起。那我们又该如何加载 meteor 的资源呢？
相关知识
通过调研发现 meteor 的客户端和服务端是通过 DDP 进行交互的。
DDP定义
DDP是一个客户端和服务端之间的协议，他支持两种操作:
- 由客户端向服务端发起远程调用
- 客户端订阅数据，在服务端数据变化时，服务器保持向客户端发起通知。
也就是说客户端只需要监听（通过 WebSocket 长连接）服务端的数据，当服务端的 DB 发生数据变化的时候，就会通过 DDP 将变化的数据返回给客户端。
在 github 上找了一些资料和开源库。发现已经有前辈提供了底层 iOS 设备与 meteor 服务端交互的库。以下将会以 SwiftDDP 为例来分享一下，对她的使用和二次封装。
正文
我们先来看一下 SwiftDDP 的目录结构
图一.png
这里面最重要的文件是 Meteor.swift 和 DDPClient.swift。客户端与服务端连接以及数据交互的主要逻辑都在这里。
二次封装
对第三方库进行二次封装的好处在于：
- 根据业务需要过滤不需要的接口
- 如果后期需要更换第三方库，可以减少对上层调用者的修改
以下是对 SwiftDDP 进行的简单封装
/// MeteorWrapper.swift 暴露所有与 Meteor 相关的接口。对上层使用者来说只需要知道这一个类即可。
/// 在 AppDelegate 中调用 initMeteor(:)。需要注意在调用 login(:) 之前必须先 connectServer(:) ，且要保证连接成功
public typealias InitCollectionCallback = () -> ()
class MeteorWrapper {
// UI 界面需要实现 ContentLoading protocol
var contentLoading: ContentLoading?
// 用于管理 subscribers
var subscriberLoader: SubscriberLoader = SubscriberLoader()
// 单例
class var shared: MeteorWrapper {
struct Static {
static let instance: MeteorWrapper = MeteorWrapper()
}
return Static.instance
}
func initMeteor(collections: InitCollectionCallback?) {
Meteor.client.allowSelfSignedSSL = false
Meteor.client.logLevel = .debug
NotificationCenter.default.addObserver(self, selector: #selector(ddpUserDidLogin), name: NSNotification.Name(rawValue: DDP_USER_DID_LOGIN), object: nil)
NotificationCenter.default.addObserver(self, selector: #selector(ddpUserDidLogout), name: NSNotification.Name(rawValue: DDP_USER_DID_LOGOUT), object: nil)
NotificationCenter.default.addObserver(self, selector: #selector(ddpWebSocketClose), name: NSNotification.Name(rawValue: DDP_WEBSOCKET_CLOSE), object: nil)
NotificationCenter.default.addObserver(self, selector: #selector(ddpWebSocketError), name: NSNotification.Name(rawValue: DDP_WEBSOCKET_ERROR), object: nil)
NotificationCenter.default.addObserver(self, selector: #selector(ddpDisconnected), name: NSNotification.Name(rawValue: DDP_DISCONNECTED), object: nil)
NotificationCenter.default.addObserver(self, selector: #selector(ddpFailed), name: NSNotification.Name(rawValue: DDP_FAILED), object: nil)
collections?()
}
open func connectServer(callback: DDPCallback? = nil) {
Meteor.connect(MeteorConfig.webSocketURL) {
self.contentLoading?.contentLoadingState = .connected
callback?()
}
}
open func login(callback: DDPMethodCallback?) {
guard let email = MeteorConfig.loginEmail, let password = MeteorConfig.loginPassword else {
return
}
Meteor.loginWithPassword(email, password: password, callback: callback)
}
open func login() {
guard let email = MeteorConfig.loginEmail, let password = MeteorConfig.loginPassword else {
return
}
Meteor.loginWithPassword(email, password: password)
}
open func logout(callback: DDPMethodCallback? = nil) {
Meteor.logout(callback)
}
open func getUserId() -> String? {
return Meteor.client.userId()
}
/**
获取collection的results
*/
open func getCollectionRealm<T: MeteorDocumentRealm>(_ name: String, className: T.Type) -> Results<T> {
return (Meteor.collection(name) as! MeteorCollectionRealm<T>).getCollection()
}
// MARK: - Websocket/DDP connection failure events
@objc fileprivate func ddpUserDidLogin() {
}
@objc fileprivate func ddpUserDidLogout() {
}
@objc fileprivate func ddpWebSocketClose() {
contentLoading?.contentLoadingState = .websocket_close
}
@objc fileprivate func ddpWebSocketError() {
contentLoading?.contentLoadingState = .websocket_error
}
@objc fileprivate func ddpDisconnected() {
contentLoading?.contentLoadingState = .disconnected
}
@objc fileprivate func ddpFailed() {
contentLoading?.contentLoadingState = .failed
}
}
客户端监听器的封装，向服务端发起监听请求和清除监听。
/// SubscriberLoader.swift
/*
SubscriberLoader 用于创建 collection 的监听和管理
*/
class SubscriberLoader {
// store subscriber id
fileprivate var subscribers: [String] = []
func addSubscribers(_ withName: String, params: [Any]?, readyCallback: DDPCallback?) -> String?{
var ids:String? = nil
if let params = params {
ids = Meteor.subscribe(withName, params: params, callback: readyCallback)
} else {
ids = Meteor.subscribe(withName, callback: readyCallback)
}
guard ids != nil else {
return nil
}
subscribers.append(ids!)
return ids
}
func removeAllSubscribers() {
for id in subscribers {
Meteor.unsubscribe(withId: id)
}
}
func removeSubscriber(withName name: String) {
Meteor.unsubscribe(name, callback: nil)
}
func removeSubscriber(withId id: String) {
Meteor.unsubscribe(withId: id)
}
}
对应 DDP 的各种连接状态。实现 ContentLoading 协议，向上层通知 DDP 的状态
// 用于存储 DDP WebSocket 状态，并且更新状态给 UI
protocol ContentLoading {
var contentLoadingState: ContentLoadingState { get set }
func loadContentIfNeeded()
}
enum ContentLoadingState: CustomStringConvertible {
case initial
case loading
case loaded
case error
case offline
case connected
case disconnected
case websocket_close
case websocket_error
case failed
var description: String {
switch self {
case .initial:
return "Initial"
case .loading:
return "Loading"
case .loaded:
return "Loaded"
case .error:
return "Error"
case .offline:
return "Offline"
case .connected:
return "Connected"
case .disconnected:
return "Disconnected"
case .websocket_close:
return "DDP Websocket Close"
case .websocket_error:
return "DDP Websocket Error"
case .failed:
return "DDP Failed"
}
}
}
如果你已经了解过 SwiftDDP 的使用方法，你一定知道她的数据都是存放在缓存里的。那如果需要将数据持久化到本地该如何呢？没错，那就需要重写 MeteorDocument 和 MeteorCollection。
/// 与 MeteorDocument 基本一致，唯一的区别就是继承了 RealmSwift 的 Object，并配置 _id 为 主键。
/// 她的使用方法和 MeteorDocument 也一样。
/// 之所在字段前面加了下划线，是因为自己的项目中有一个字段和swift关键字产生冲突
class MeteorDocumentRealm: Object{
dynamic var _id:String = ""
open override class func primaryKey() -> String? {
return "_id"
}
// MARK: -- 借用 MeteorDecument 处理数据的方法
open func initData(id: String, fields: NSDictionary?) {
self._id = id
if let properties = fields {
for (key,value) in properties {
if !(value is NSNull) {
self.setValue(value, forKey: "_"+(key as! String))
}
}
}
}
open func update(_ fields: NSDictionary?, cleared: [String]?) {
if let properties = fields {
for (key,value) in properties {
print("Key: \(key), Value: \(value)")
self.setValue(value, forKey: "_"+(key as! String))
}
}
if let deletions = cleared {
for property in deletions {
self.setNilValueForKey("_"+property)
}
}
}
/*
Limitations to propertyNames:
- Returns an empty array for Objective-C objects
- Will not return computed properties, i.e.:
- If self is an instance of a class (vs., say, a struct), this doesn't report its superclass's properties, i.e.:
see http://stackoverflow.com/questions/24844681/list-of-classs-properties-in-swift
*/
func propertyNames() -> [String] {
return Mirror(reflecting: self).children.filter { $0.label != nil }.map { $0.label! }
}
/*
This method should be public so users of this library can override it for parsing their variables in their MeteorDocument object when having structs and such in their Document.
*/
open func fields() -> NSDictionary {
let fieldsDict = NSMutableDictionary()
let properties = propertyNames()
for name in properties {
if var value = self.value(forKey: name) {
if value as? Date != nil {
value = EJSON.convertToEJSONDate(value as! Date)
}
fieldsDict.setValue(value, forKey: name)
}
}
fieldsDict.setValue(self._id, forKey: "_id")
print("fields \(fieldsDict)")
return fieldsDict as NSDictionary
}
}
MeteorCollectionRealm 看起来就精简了很多。可能你会问这里没有了变更通知，上层该怎么知道数据发生了变化呢？因为我们用了 Realm。这里先留个悬念~~
class MeteorCollectionRealm<T: MeteorDocumentRealm>: AbstractCollection{
public override init(name: String) {
super.init(name: name)
}
/**
获取 collection 的所有结果
*/
var realm: Realm?
open func getCollection() -> Results<T> {
if realm == nil {
realm = try! Realm()
}
return realm!.objects(T.self)
}
override func documentWasAdded(_ collection: String, id: String, fields: NSDictionary?) {
let document = T()
document.initData(id: id, fields: fields)
let realm = try? Realm()
try! realm?.write {
realm?.add(document, update: true)
}
}
override func documentWasChanged(_ collection: String, id: String, fields: NSDictionary?, cleared: [String]?) {
let realm = try? Realm()
let document = realm?.objects(T.self).filter(NSPredicate(format: "_id = %@", id))
if document != nil && (document?.count)! > 0 {
try! realm?.write {
document?.first?.update(fields, cleared: cleared)
realm?.add((document?.first)!, update: true)
}
}
}
override func documentWasRemoved(_ collection: String, id: String) {
let realm = try? Realm()
let document = realm?.objects(T.self).filter(NSPredicate(format: "_id = %@", id))
if document != nil && (document?.count)! > 0 {
try! realm?.write {
realm?.delete((document?.first)!)
}
}
}
// todo : insert 、update、 remove 等本地请求更新数据到服务器端的方法
}
基本的封装做完了，接下来举个例子来说说该怎么用吧。
/// AppDelegate.swift
func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
...
// 初始化 MeteorWarper 组件
MeteorConfig.loginEmail = "robertzhangsh@gmail.com"
MeteorConfig.loginPassword = "password"
MeteorWrapper.shared.initMeteor {
// XXFields 继承 MeteorDocumentRealm ，并遵循 Realm object 的构建即可
_ = MeteorCollectionRealm<ThreadFields>(name: "threads")
_ = MeteorCollectionRealm<MessageFields>(name: "messages")
....
MeteorWrapper.shared.contentLoading = self
}
...
}
/// login.swift 登陆相关的操作类，当然也可以根据具体的情况而定
// 登陆成功后的返回操作中
// meteor ddp
MeteorWrapper.shared.connectServer {
MeteorWrapper.shared.login() { (result , error) in
if error == nil {
let listsPage = 4
TSProgressHUD.ts_showWithStatus("加载数据中.....")
// 这里的参数是根据服务器需要给的，视情况而定
_ = MeteorWrapper.shared.subscriberLoader.addSubscribers("threads", params: [[:], ["limit":listsPage * 15,"sort":["lastMessageAt":-1]]], readyCallback: {
TSProgressHUD.ts_dismiss()
})
}
}
}
// 合适的地方注销监听
_ = MeteorWrapper.shared.subscriberLoader.removeSubscriber(withName: "threads")
封装的思路
看完代码后，终于要说说封装的思路了。其实二次封装没什么可说的，就是一个类似 Helper 的单例类。更有意思的地方应该是 Realm 和 SwiftDDP 的结合。这种火花的摩擦很美妙，让人欲罢不能。
我们将业务划分成两个方面，一个是写（通过 Meteor DPP 获取服务端的数据，并将之写入数据库），另一个是读（上层展示只需要读取数据库，不关心数据怎么来的）。写和读是独立的相互之间并不关心。她们只关注自己对数据库的操作。对于上层展示，Realm天生提供了数据更新的解决方案，一切都变的如此简单。这让人想起 Android 中的 ContentProvider。内容提供者不会关心谁用了数据，她只关注数据的存储和数据更新后的广播通知。任务分离后，写和读也就隔离开来。
MeteorCollectionRealm 的角色就是写入者，代码也很简单。唯一的问题就是要注意 Realm 操作线程的问题。
最后
项目结构的设计是一件很有意思的事情，不同的人有不同的方法和技巧。殊途同归都是为了能更清晰的划分结构。
ps：最近状态不佳，写的有点乱。
