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秒运行一次的异步计时器，向DB查询状态='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提供了一个简单的实现，并且在线有许多替代实现。

由于同步状态值应该是一个布尔标志，因此它不像是一个重载操作，特别是如果你使用可达性。获取请求不仅应该快，您可以在一步之后更新标志 - 使用NSBatchUpdateRequest在您刚刚发送到服务器的每个实例上将标志设置为false。 / p>

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

获取新更改的托管对象的objectID
使用NSURL的{{1}}方法将其转换为NSManagedObjectID。
将URIRepresentation()放在您保存的列表中，因此它会保留。

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

当需要同步时，您可以执行以下操作：

从列表中获取NSURL
使用NSURL（NSManagedObjectID上的<{1}}将其转换为managedObjectIDForURIRepresentation(url:NSURL)
在NSPersistentStoreCoordinator上获取该ID objectWithID:的托管对象。
同步该对象的数据。

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

处理失败的后台API POST

修改

1 个答案: