ios - 处理失败的后台 API POST

Question

在我的 iOS 应用程序中，用户完成了我需要发回服务器的交易。我创建了一个函数来执行此操作:

static let configurationParam = NSURLSessionConfiguration.defaultSessionConfiguration()
static var manager = Alamofire.Manager(configuration: configurationParam)

func postItemToServer(itemToPost:DemoItem) {
    let webServiceCallUrl = "..."

    var itemApiModel:[String: AnyObject] = [
        "ItemId": 123,
        "ItemName": itemToPost.Name!,
        //...
    ]

    ApiManager.manager.request(.POST, webServiceCallUrl, parameters: itemApiModel, encoding: .JSON)
        .validate()
        .responseJSON { response in
            switch response.result {
            case .Success:
                print("post success")
            case .Failure:
                print("SERVER RESPONSE: \(response.response?.statusCode)")
            }
    }
}

目前，我在交易完成后调用此方法:

//... 

if(transactionCompleted!) {
    let apiManager = ApiManager()
    apiManager.postItemToServer(self.item)

    self.senderViewController!.performSegueWithIdentifier("TransactionCompletedSegue", sender: self)
}

//...

其中 DemoItem 是 CoreData 对象。

这一切都按预期工作。但是，如果 POST 请求失败，我需要能够重试该请求。例如，如果在尝试发布到服务器时网络连接断开，我需要在数据再次激活后自动发布数据 - 此时可能有多个 DemoItem 需要被同步。

我是 Swift 新手。在类似的 Xamarin 应用程序中，我的 SQLite 数据库中有一个状态列，我将其设置为“AwaitingSync”。然后，我有一个异步计时器，每 30 秒运行一次，查询数据库中是否有任何 status='AwaitingSync' 的项目，然后尝试发布它们(如果存在)。如果成功，它会更新数据库中的状态。我可以在这里按照同样的思路实现一些东西 - 但我对这个实现从来没有真正满意过，因为即使没有任何改变，我每 30 秒就会进行一次数据库查询。

最后，如果应用程序终止，它需要仍然工作。例如，在应用程序被终止之前未同步的任何项目都应该在应用程序恢复后同步。解决这个问题的最佳方法是什么？

<小时/>

编辑

根据汤姆的回答，我创建了以下内容:

class SyncHelper {
    let serialQueue = dispatch_queue_create("com.mycompany.syncqueue", DISPATCH_QUEUE_SERIAL)
    let managedContext = (UIApplication.sharedApplication().delegate as! AppDelegate).managedObjectContext

    func StartSync() {

        //Run on serial queue so it can't be called twice at once
        dispatch_async(serialQueue, {

            //See if there are any items pending to sync
            if let itemsToSync = self.GetItemsToSync() {

                //Sync all pending items
                for itemToSync in itemsToSync {
                    self.SyncItemToServer(itemToSync)
                }
            }
        })
    }

    private func GetItemsToSync() -> [DemoItem]? {
        var result:[DemoItem]?

        do {
            let fetchRequest = NSFetchRequest(entityName: "DemoItem")
            fetchRequest.predicate = NSPredicate(format: "awaitingSync = true", argumentArray: nil)
            result = try managedContext.executeFetchRequest(fetchRequest) as? [DemoItem]
        } catch {
            //Handle error...
        }

        return result
    }

    private func SyncItemToServer(itemToSync:DemoItem) {
        let apiManager = ApiManager()

        //Try to post to the server
        apiManager.postItemToServer(itemToSync:DemoItem, completionHandler: { (error) -> Void in
            if let _ = error {
                //An error has occurred - nothing need to happen as it will be picked up when the network is restored
                print("Sync failed")
            } else {
                print("Sync success")

                itemToSync.awaitingSync = false

                do {
                    try self.managedContext.save()
                } catch {
                    //Handle error...
                }

            }
        })
    }
}

然后，当交易完成时，我会调用它:

//...
    if(transactionCompleted!) {
        let syncHelper = SyncHelper()
        syncHelper.StartSync()
    }
//...

最后我用了 Reachability.swift每次网络连接恢复时开始同步:

class AppDelegate: UIResponder, UIApplicationDelegate {

    var window: UIWindow?
    var reachability:Reachability?

    func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {

        //...

        //Setup the sync for when the network connection resumes
        do {
            reachability = try Reachability.reachabilityForInternetConnection()

            NSNotificationCenter.defaultCenter().addObserver(self,
                selector: "reachabilityChanged:",
                name: ReachabilityChangedNotification,
                object: reachability)

            try reachability!.startNotifier()

        } catch {
            print("Unable to create Reachability")
        }

        return true
    }

    func reachabilityChanged(note: NSNotification) {

        let reachability = note.object as! Reachability

        if reachability.isReachable() {
            print("Network reachable")

            let syncHelper = SyncHelper()
            syncHelper.StartSync()
        } else {
            print("Not reachable")
        }
    }
}

这一切似乎都有效。这种方法可以吗？我是否错过了任何可以改进它的东西？我能看到的唯一差距是网络连接是否处于事件状态，但是服务器由于某种原因抛出错误 - 我想我可以添加一个按钮让用户重试任何待处理的项目。

Answer 1

首先，如果您担心网络连接是否正常，则不应定期轮询。您应该使用 iOS 的网络可达性 API 在网络状态发生变化时收到通知。 Apple 提供了一个简单的实现，并且在线有许多替代实现。

由于同步状态值应该是一个 bool 标志，因此提取请求并不是一项繁重的操作，尤其是在您使用可达性的情况下。不仅获取请求应该很快，您还可以在事后一步更新标志 - 使用 NSBatchUpdateRequest 在您刚访问的每个实例上将标志设置为 false发送到服务器。

如果您想从持久存储中获取同步状态(这不是一个坏主意，因为它是元数据)，您需要维护自己的未同步对象列表。执行此操作的最佳方法是跟踪等待同步的托管对象的 objectID。那会是这样的:

• 获取新更改的托管对象的objectID
• 使用 NSManagedObjectID 的 URIRepresentation() 方法将其转换为 NSURL。
• 将 NSURL 放在您保存在某处的列表中，这样它就会持续存在。

您可以将列表保存在文件、用户默认值或持久存储自己的元数据中。

当需要同步时，您会执行以下操作:

• 从列表中获取 NSURL
• 使用 managedObjectIDForURIRepresentation(url:NSURL)(位于 NSPersistentStoreCoordinator 上)将其转换为 NSManagedObjectID
• 获取 NSManagedObjectContext 上该 ID objectWithID: 的托管对象。
• 同步该对象的数据。

然后，同步成功后，从列表中删除条目。