我正在尝试创建一个 PFQuery，其中查询的响应同时存储在服务器和本地数据存储中。我想创建一个带有约束的查询 (query.whereKey())，它将首先查看响应是否存储在设备上，如果没有，它将查询服务器.

例如，我正在加载一个帖子列表。该应用程序存储当前用户关注的一组用户。对于存储在设备上的用户发布的帖子，我想从数据存储而不是服务器加载用户详细信息(如他们的个人资料图片和用户名)。但是，如果帖子是由未存储在设备上的用户发布的，它将查询服务器。我只能想象这是用 2 个不同的查询来完成的，但我更愿意在一个查询中完成。

最佳答案

我在我自己的项目中写了以下内容并发布它以防有人正在寻找完整的答案。

参数如下:

1. query:您要对其执行查询的 PFQuery。
2. queryBoth:一个 Bool 值，表示如果有从本地数据存储返回的数据，您是否要查询 Parse 服务器。 true 将查询两者，false 将仅在本地数据存储未返回任何内容时才查询服务器。
3. toCallUponCompletion:当从服务器、本地数据存储或两者收到响应时将调用的闭包(函数)。该函数应接受一个 PFObjects 数组并且不返回任何内容。此功能的实现将显示在以下功能下方。

函数:

func findObjectsInBackgroundFromLocalDataStoreIfPossible (query: PFQuery, queryBoth: Bool, toCallUponCompletion: ([PFObject]) -> ()){
    var response = [PFObject]()

    let queryCopy = query.copy() as! PFQuery
    queryCopy.fromLocalDatastore()
    queryCopy.findObjectsInBackgroundWithBlock{
        (objects: [AnyObject]?, error: NSError?) -> Void in
        if error == nil{
            if objects?.count == 0{
                query.findObjectsInBackgroundWithBlock{
                     (objects2: [AnyObject]?, error: NSError?) -> Void in
                    if error == nil{
                        response = objects2 as! [PFObject]
                        toCallUponCompletion(response)
                    }
                }
            }
            else if queryBoth{
                response = objects as! [PFObject]
                var responseObjectIds = [String]()
                for x in response{
                    responseObjectIds.append(x.objectId)
                }
                query.whereKey("objectId", notContainedIn: responseObjectIds)
                query.findObjectsInBackgroundWithBlock{
                    (objects2: [AnyObject]?, error: NSError?) -> Void in
                    if error == nil{
                        response += objects2 as! [PFObject]
                        toCallUponCompletion(response)
                    }
                    else{
                        toCallUponCompletion(response)
                    }
                }
            }
            else{
                response = objects as! [PFObject]
                toCallUponCompletion(response)
            }
        }
        else{
            println("Error being called in 'findObjectInBackgroundFromLocalDataStoreIfPossible' Error is: \(error)")
        }
    }
}

闭包实现:

func storeResponse (response: [PFObject]){
    println(response)
}

要实现与上述功能相同但具有多个 PFQueries 的功能，请使用以下内容:

参数区别如下:

1. queries:这是您要对其执行查询的 PFQueries 数组。顺序很重要。
2. toCallUponCompletion:这个闭包取一个带有 Int 键和 PFObject 值的字典作为参数，不返回任何内容。这样做的原因是因为发送查询时，它们可能无法完成并以相同的顺序返回。因此字典中每个键值对的键是它发送的顺序，因此可以在不知道响应的实际内容的情况下使用响应。再次，引用函数后面函数闭包的实现。

函数:

func findObjectsInBackgroundFromMultipleQueriesFromLocalDataStoreIfPossible (queries: [PFQuery], queryBoth: Bool, toCallUponCompletion: ([Int: [PFObject]]) -> ()){
    var responses = [Int: [PFObject]]()
    for query in queries{
        var response = [PFObject]()
        let queryCopy = query.copy() as! PFQuery
        queryCopy.fromLocalDatastore()
        queryCopy.findObjectsInBackgroundWithBlock{
            (objects: [AnyObject]?, error: NSError?) -> Void in
            if error == nil{
                if objects?.count == 0{
                    query.findObjectsInBackgroundWithBlock{
                        (objects2: [AnyObject]?, error: NSError?) -> Void in
                        if error == nil{
                            response = objects2 as! [PFObject]
                            responses[find(queries, query)!] = response  
                            if responses.count == queries.count{
                                toCallUponCompletion(responses)
                            }
                        }
                    }
                }
                else if queryBoth{
                    response = objects as! [PFObject]
                    var ids = [String]()
                    for x in response{
                        ids.append(x.objectId)
                    }
                    query.whereKey("objectId", notContainedIn: ids)
                    query.findObjectsInBackgroundWithBlock{
                        (objects2: [AnyObject]?, error: NSError?) -> Void in
                        if error == nil{
                            response += objects2 as! [PFObject]
                            responses[find(queries, query)!] = response
                            if responses.count == queries.count{
                                toCallUponCompletion(responses)
                            }
                         }
                     }
                 }
                 else{
                     response = objects as! [PFObject]
                     responses[find(queries, query)!] = response
                     if responses.count == queries.count{
                         toCallUponCompletion(responses)
                     }
                }
            }
        }
    }
}

闭包实现:

func storeResponses (responses: [Int: PFObject]){
    println("The response to the first query is: \(responses[0])")
    println("The response to the second query is: \(responses[1])")
    println("The response to the third query is: \(responses[2])")
}

非常感谢任何编辑建议。

关于swift - 同时查询解析服务器和本地数据存储，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/30055476/