本文将继续前面的教程，讲解如何将REST API获取JSON格式的数据转换为Swift对象。
重要说明: 这是一个系列教程，非本人原创，而是翻译国外的一个教程。本人也在学习Swift，看到这个教程对开发一个实际的APP非常有帮助，所以翻译共享给大家。原教程非常长，我会陆续翻译并发布，欢迎交流与分享。
在Alamofire的GET与POST调用中使用强类型
我们使用Alamofire进行REST请求。现在让我们清理一下，通过把JSON映射到强类型类，从而构建更高级别的抽象。这将使我们的代码组织性更好，也使得我们不需要一次记住太多代码的细节。
首先，我们需要构建一个类来处理Post对象的类。创建的类为了方便进行调试，需要具有以下几个属性，一个Post对象构造函数，一个描述方法可以打印出对象的所有属性：
class Post {
var title:String?
var body:String?
var id:Int?
var userId:Int?
required init?(aTitle: String?, aBody: String?, anId: Int?, aUserId: Int?) {
self.title = aTitle
self.body = aBody
self.id = anId
self.userId = aUserId
}
func description() -> String {
return "ID: \(self.id)" +
"User ID: \(self.userId)" +
"Title: \(self.title)\n" +
"Body: \(self.body)\n"
}
}
我们将使用路由器来创建URL请求。它可以装配请求信息，包括HTTP方法和URL，并在报头中附加相应的参数。在URL请求和JSON处理方面，我们不需要对路由做任何改变。它不需要知道Post对象的任何信息。
接下来我们创建一个PostRouter.swift文件，作为我们的路由器：
import Alamofire
enum PostRouter: URLRequestConvertible {
static let baseURLString = "http://jsonplaceholder.typicode.com/"
case Get(Int)
case Create([String: AnyObject])
case Delete(Int)
var URLRequest: NSMutableURLRequest {
var method: Alamofire.Method {
switch self {
case .Get
return .GET
case .Create
return .POST
case .Delete
return .DELETE
}
}
let result: (path: String, parameters: [String: AnyObject]?) = {
switch self {
case .Get(let postNumber):
return ("posts/\(postNumber)", nil)
case .Create(let newPost):
return ("posts", newPost)
case .Delete(let postNumber)
return ("posts/\(postNumber)", nil)
}
}()
let URL = NSURL(string: PostRouter.baseURLString)!
let URLRequest = NSURLRequest(URL: URL.URLByAppendingPathComponent(result.path))
let encoding = Alamofire.ParameterEncoding.JSON
let (encodedRequest, _) = encoding.encode(URLRequest, parameters: result.parameters)
encodedRequest.HTTPMethod = method.rawValue
return encodedRequest;
}
}
当进行API调用时，我喜欢进行逆向工作。开始调用的时候，我们喜欢先搞清楚它们时怎么样工作的。首先，我们希望能够通过ID的值可以得到相应的帖子。
我们可以在视图控制器的viewWillAppear方法中进行测试：
override func viewWillAppear(animated: Bool) {
super.viewWillAppear(animated)
// MARK: 获取ID为1的Post
Post.postByID(1, completionHandler: { result in
if let error = result.error {
// 如果在调用中出现了错误，我们需要进行处理
print("调用/posts/1时出现错误")
print(error)
return
}
guard let post = result.value else {
print("调用/posts/1时出现错误：返回值为空")
return
}
// 调用成功
print(post.getDescription())
print(post.title)
})
}
postByID有相应的完成处理程序。与前面所编写代码的不同是，我们不再用一个函数编写完成处理程序，而是在方法中直接进行处理。当我们实现postByID时我们将看到它们是如何工作的，以及当函数怎么样来调用完成处理程序来处理返回的结果。
我们使用完成处理程序，可以让程序异步执行。这里你或许注意到整个程序中没有URL、没有请求，也没有JSON解析。它是由Post来完成，而不是在抽象的底层来处理。
我们也希望能够新建一个Post，并将它发送到服务器。这里我们将newPost.save方法中使用尾随闭包来进行处理，所以我们可以在代码中删除completionHandler标签：
// MARK: 保存
// 创建Post
guard let newPost =
Post(aTitle: "First Psot", aBody: "I iz first", anId: nil, aUserId: 1) else {
print("错误: newPost不是一个Post对象")
return
}
newPost.save { result in
if let error = result.error {
// 如果在调用中出现了错误，我们需要进行处理
print("调用 POST /posts时出现错误")
print(error)
return
}
guard let post = result.value else {
print("调用 POST /posts出现错误，返回值为空")
return
}
// 调用成功
print(post.description())
print(post.title)
}
我们这里将Post的创建和保存分开，创建(Post(...))是在本地，而保存(newPost.save(...))则是在服务器中执行。另外，这里将Post的ID设置为空，那是因为该值是由服务器进行分配的。
接下来，我们对Alamofire进行设置，并看看Post的调用是如何来完成的。首先我们看看GET请求（这里我们已使用顺手的路由来创建URL请求）：
Alamofire.request(PostRouter.Get(1))
.responseJSON { response in
// ...
}
使用.responseObject来代替.responseJSON会不会更好呢？Alamofire是允许我们自己定义响应序列化(response serializer)处理，这样我们就可以将API调用的结果转换成任何我们想要的。最直接的就是将返回的JSON序列化为一个对象。
响应序列化可以将URL请求返还的结果转换为我们需要型式。默认的，URL请求的返回是一个NSData，但我们愿意使用JSON或者一个对象进行相关处理。
要创建一个序列化对象，需要扩展Alamofire.Request。我们将新建一个文件，名称为：AlamofireRequest+JSONSerializable.swift。如下面所示，我们先将逐步了解它是如何运作的：
import Foundation
import Alamofire
import SwiftyJSON
extension Alamofire.Request {
public func responseObject<T: ResponseJSONObjectSerializable>(completionHandler:
Response<T, NSError> -> Void) -> Self {
let serializer = ResponseSerializer<T, NSError> { request, response, data, error in
guard error == nil else {
return .Failure(error!)
}
guard let responseData = data else {
let failureReason = "无法进行对象序列化，因为输入的数据为空。"
let error = Error.errorWithCode(.DataSerializationFailed, failureReason:
failureReason)
return .Failure(error)
}
let JSONResponseSerializer = Request.JSONResponseSerializer(options: .AllowFragments)
let result = JSONResponseSerializer.serializeResponse(request, response,
responseData, error)
switch result {
case .Success(let value):
let json = SwiftyJSON.JSON(value)
if let object = T(json: json) {
return .Success(object)
} else {
let failureReason = "无法通过JSON创建对象。"
let error = Error.errorWithCode(.JSONSerializationFailed, failureReason:
failureReason)
return .Failure(error)
}
case .Failure(let error):
return .Failure(error)
}
}
return response(responseSerializer: serializer, completionHandler: completionHandler)
}
}
responseObject<...>(...)作为Alamofire.Request的新的响应处理器。它与标准的response函数唯一的不同是，它使用了我们自定义的responseSerializer对返回数据进行序列化处理。因此，我们可以像下面这样来调用：
Alamofire.request(PostRouter.Get(id))
.responseObject{ (response: Response<Post, NSError>) in
// Post相关处理
}
我们逐渐来了解responseObject这个函数。首先，我们从函数的声明开始：
extension Alamofire.Request {
public func responseObject<T: ResponseJSONObjectSerializable>(completionHandler:
Response<T, NSError> -> Void) -> Self {
...
}
}
所定义的函数名称为：responseObject。<T>表示这是一个泛型方法，可以与不同类型的对象一起工作。<T: ResponseJSONObjectSerializable>表示，对象的类型必须实现ResponseJSONObjectSeriablizable协议(该协议是我们自己定义的)。定义这个协议，是为了能够让我们确定所传入对象的类型，必须实现一个参数是JSON的构造方法(init function)。
responseObject函数中使用唯一的参数为completionHandler。正如你所想的，当我们解析JSON并创建了对象后(也就是说作为当前函数的完成处理程序)就会调用它。这样我们就可以异步进行处理，而调用者也不用等待，当我们处理完毕后就会通知它。
完成处理程序也是只有一个参数Response<T, NSErroe>。这是Alamofire3中定义的响应结构，它帮助我们处理了一大堆的事情，把处理结果包装成Result结构(里面是我们T对象和/或错误)，这样省去了我们过去处理(NSURLRequest?, NSHTTPURLResponse?, Result<T, NSError>)的一大堆工作。
你可以把Response和Result结构想象成一个包，这个包中是我们从请求的响应中获取数据，并把它序列化为我们所使用的格式。这就像我们去买东西。支付后，你得到几样东西：你购买的东西、找零和收据，或者错误的信息，如你的“卡被拒绝“，或”还差8毛钱"等。所有这些就组合成了你购买时的响应。
你也可以想象为不论交易是否成功，都会有购买的物品和/或者错误信息。
Alamofire的这些结构是类似的。Result包含了.Success和.Failure，这样呢可以判断是否有错误。Response则封装了Result、你的原始请求及返回的原始数据。
responseObject返回了Alamofire.Request对象。-> Self则是声明返回的类型。
现在，我们来看一下`responseObject函数的结构：
public func responseObject<T: ResponseJSONObjectSerializable>(completionHandler:
Response<T, NSError> -> Void) -> Self {
let serializer = ResponseSerializer<T, NSError> { (request, response, data, error) in
// ...
}
return response(responseSerializer: serializer, completionHandler: completionHandler)
}
在responseObject中，我们创建了一个响应序列化处理器，并且与泛型T和NSError一起工作。该序列化处理器使用URL请求的返回(request, response, data, error)作为参数，使用Alamofire中定义的Result类型返回成功(包含已解析对象)或者失败(包含错误信息)。responseObject函数只是返回了我们刚刚创建的responseSerializer，并把参数的中的完成处理程序也返回，这样就可以在需要的地方使用了。
现在，我们来看一下我们最终所实现的responseSerializer：
let serializer = ResponseSerializer<T, NSError> { request, response, data, error in
guard error == nil else {
return .Failure(error!)
}
guard let responseData = data else {
let failureReason = "无法进行对象序列化，因为输入的数据为空。"
let error = Error.errorWithCode(.DataSerializationFailed, failureReason: failureReason)
return .Failure(error)
}
let JSONResponseSerializer = Request.JSONResponseSerializer(options: .AllowFragments)
let result = JSONResponseSerializer.serializeResponse(request, response,
responseData, error)
switch result {
case .Success(let value):
let json = SwiftyJSON.JSON(value)
if let object = T(json: json) {
return .Success(object)
} else {
let failureReason = "无法通过JSON创建对象。"
let error = Error.errorWithCode(.JSONSerializationFailed, failureReason:
failureReason)
return .Failure(error)
}
case .Failure(let error):
return .Failure(error)
}
}
自定义响应序列化处理首先使用guard进行数据有效性检查。然后使用SwiftyJSON将数据解析为JSON格式。接下来就是通过JSON数据来创建指定的对象：
let newObject = T(json: json)
如果不能通过JSON数据创建响应的对象，那么我们将返回相应的错误。
为了能够是序列化程序可以正常工作，我们需要定义一个ResponseJSONObjectSerializable协议：
public protocol ResponseJSONObjectSerializable {
init?(json: SwiftyJSON.JSON)
}
定义该协议就是能够确保要转换的类必须实现了响应的构造函数。这也就告诉了泛型对象需要实现哪些处理。在现在这个例子中，类必须实现一个能够从JSON数据对象进行构造的方法。下面我们在Post类中实现它：
final class Post: ResponseJSONObjectSerializable {
var title:String?
var body:String?
var id:Int?
var userId:Int?
...
required init?(json: SwiftyJSON.JSON) {
self.title = json["title"].string
self.body = json["body"].string
self.id = json["id"].int
self.userId = json["userId"].int
}
...
}
使用SwiftyJSON可以是非常方便把JSON中的内容解析为Post对象的属性。
现在我们就可以在Post.postById()中使用我们自定义的序列化了：
class Post {
...
// MARK: API调用
class func postByID(id: Int, completionHandler: (Result<Post, NSError>) -> Void) ｛
Alamofire.request(PostRouter.Get(id))
.responseObject { (response: Response<Post, NSError>) in
completionHandler(response.result)
}
}
}
这就是GET请求中所使用的了。现在我们就可以调用非常棒的Post.postByID(1)方法了。
但，是的，还有其它的需求。我们说过我们需要实现POST请求，把新建Post保存到服务上。
这种情况下，Alamofire中没有特别的限制要求，所以我们只需要保证可以把Post数据正确的序列化为API调用的格式即可。
在Post类中，我们只需要实现一个方法可以将Post转换为键为字符串类型的Dictionary即可(为了方便我们称为json):
func toJSON() -> Dictionary<String, AnyObject> {
var json = Dictionary<String, AnyObject>()
if let title = title {
json["title"] = title
}
if let body = body {
json["body"] = body
}
if let id = id {
json["id"] = id
}
if let userId = userId {
json["userId"] = userId
}
return json
}
因为在Alamofire.Request中使用Dictionary作为参数类型，所以这里我们没有使用NSDictionary。
下面我们来完成Post的save()方法：
// 创建
func save(completionHandler: (Result<Post, NSError>) -> Void) {
guard let fields:Dictionary<String, AnyObject> = self.toJSON() else {
print("error: error converting newPost fields to JSON")
return
}
Alamofire.request(PostRouter.Create(fields))
.responseObject { (response: Response<Post, NSError>) in
completionHandler(response.result)
}
}
小结
嗯，就是这样了！现在我们可以很漂亮的获取和保存Post。更进一步的是，调用者也不需要知道Post是如何获取和保存。这样我们也可以很方便的将Alamofire替换为RESTKit，或者另外一个完全不同的API调用框架，并且还不用对视图控制器做任何改变。
点击这里 获取本章代码。
现在不需要担心如何解析复杂的JSON数据。先从最简单的字符串、数字和布尔字段开始。后面我们会对复杂的数据进行解析，如数组、日期等。你可以从简单的一两个需要自定义序列化的API调用开始，或者使用本章的代码。
接下来我们将使用Alamofire来构建gists应用。我们构建我们所需要的API调用，并把结果显示到用户界面。用户界面包含一个表格视图，gists的详情页面，创建gists的表单页面及下拉刷新和滑动删除。最后我们讨论一下离线时该如何进行处理。
网友评论