Alamofire 源码赏析（一）基础篇

发表于 | 分类于 | | 阅读次数: |
字数统计: 25k | 阅读时长 ≈ 25 mins.

Alamofire是Swift编写的网络库，如果你的项目使用Swift编写的，则可以用它来替代AFNetworking。Alamofire和AFNetworking都是由Mattt Thompson发起的。Alamofire相比AFNetworking而言，利用了Swift语言的特性，来使得代码更加优雅，并具有一些强大的特性。

下面我们从源码中来一一赏析这些。

结构设计

基于Swift语言的简洁，Alamofire的文件并不多，分成了两个目录Core和Feature，非常的清晰。

Core目录中包含了核心的2个类和3个枚举和2个结构体。
2个核心类：

类名 职责
Manager 提供对外接口，处理NSURLSession的delegate
Request 对请求的处理

3个枚举：

枚举名 职责
Method HTTP Method
ParameterEncoding 参数编码方式（JSON、PropertyList）
Result 定义了请求成功或失败的数据结构

2个结构体：

结构体名 职责
Response 封装了响应需要包含的数据结构
Error 错误码定义；创建NSError对象；

Features目录中则是对这些核心数据结构的扩展：

文件名 职责
Upload 处理上传相关操作，是Manager类的扩展
Download 处理下载相关操作，是Manager类的扩展
Stream 处理输入输出流，是Manager类的扩展
Validation 对Response数据进行校验，是Request类的扩展
ResponseSerialization Response的序列化处理，是Request类的扩展
MultipartFormData 自己是一个类，被Request的Upload引用，处理MultipartFormData
ServerTrustPolicyManager 自己是一个类，被NSURLSession引用，处理安全策略

可以看到并不是每个文件都是一个类，Upload、Download、Stream这些操作都以extension的形式放到单独的文件中，做到了不仅由Manager类来统一管理，也按职责进行了拆分。
同样Validation和ResponseSerialization也以Request类的扩展的形式存在，并支持Request类的链式调用。

类图如下：

职责划分明确，有着很好的内聚性。

枚举

凡是需要类型划分的都用枚举来实现，例如：

1
2
3
4
5
6
public enum ParameterEncoding {
    case URL
    case URLEncodedInURL
    case JSON
    case PropertyList(NSPropertyListFormat, NSPropertyListWriteOptions)
    case Custom((URLRequestConvertible, [String: AnyObject]?) -> (NSMutableURLRequest, NSError?))

基于Swift的特性，在枚举中可以定义方法来实现“对外统一接口，内部根据自己当前的枚举值有着不同的实现”，这是Swift中很常见的写法。

1
2
3
4
5
6
7
8
9
10
public func encode(...) {
    ...
    switch self {
    case .JSON:
        ...
    case .PropertyList(let format, let options):
        ...
    }
    ...
}

再举个Result的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public enum Result<Value, Error: ErrorType> {
    case Success(Value)
    case Failure(Error)

    /// Returns `true` if the result is a success, `false` otherwise.
    public var isSuccess: Bool {
        switch self {
        case .Success:
            return true
        case .Failure:
            return false
        }
    }
	...    
}

结构体

对于那些没有复杂业务逻辑，主要用来保存数据的结构，用结构体来实现，例如Response：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public struct Response<Value, Error: ErrorType> {
    /// The URL request sent to the server.
    public let request: NSURLRequest?

    /// The server's response to the URL request.
    public let response: NSHTTPURLResponse?

    /// The data returned by the server.
    public let data: NSData?

    /// The result of response serialization.
    public let result: Result<Value, Error>

    /**
        Initializes the `Response` instance with the specified URL request, URL response, server data and response
        serialization result.
    
        - parameter request:  The URL request sent to the server.
        - parameter response: The server's response to the URL request.
        - parameter data:     The data returned by the server.
        - parameter result:   The result of response serialization.
    
        - returns: the new `Response` instance.
    */
    public init(request: NSURLRequest?, response: NSHTTPURLResponse?, data: NSData?, result: Result<Value, Error>) {
        self.request = request
        self.response = response
        self.data = data
        self.result = result
    }
}

泛型

Alamofire中有着大量对泛型的使用

1
public func validate<S: SequenceType where S.Generator.Element == Int>(statusCode acceptableStatusCode: S) -> Self {
1
public enum Result<Value, Error: ErrorType> {

命名空间

Alamofire是一个Framework，享有独立的命名空间，因此所有的类、结构体、枚举等的命名都不需要加前缀。

链式调用

对于Request类，其中的很多方法都使用了返回-> Self的方式。

请求

1
2
3
4
5
6
7
public func request(
    method: Method,
    _ URLString: URLStringConvertible,
    parameters: [String: AnyObject]? = nil,
    encoding: ParameterEncoding = .URL,
    headers: [String: String]? = nil)
    -> Request

鉴权

1
2
3
4
5
public func authenticate(
    user user: String,
    password: String,
    persistence: NSURLCredentialPersistence = .ForSession)
    -> Self

进度

1
public func progress(closure: ((Int64, Int64, Int64) -> Void)? = nil) -> Self

响应

1
2
3
4
public func response(
    queue queue: dispatch_queue_t? = nil,
    completionHandler: (NSURLRequest?, NSHTTPURLResponse?, NSData?, NSError?) -> Void)
    -> Self

验证

1
public func validate(validation: Validation) -> Self

调用示例：

1
2
3
4
5
6
Alamofire.request(.GET, "https://httpbin.org/get", parameters: ["foo": "bar"])
         .validate(statusCode: 200..<300)
         .validate(contentType: ["application/json"])
         .response { response in
             print(response)
         }

Alamofire.request(...)
这一步首先会创建一个Request实例，这个实例中启动了一个NSURLSessionTask，这时，一个请求已经被发出。
Request类中有个内部类TaskDelegate用来处理与这个Task相对应的NSURLSession回调，TaskDelegate维护了一个Serial的 NSOperationQueue（maxConcurrentOperationCount = 1），TaskDelegate会随着Request一起创建，这个queue同时也被加载到内存中。
接下来的链式调用创建的操作闭包都会追加到这个queue中。

.validate(statusCode: 200..<300)
把一个用来验证StatusCode的操作闭包追加到queue，如果验证失败，会在TaskDelegate中保存一个NSError

.validate(contentType: ["application/json"])
把一个用来验证contentType的操作闭包追加到queue，如果验证失败，会在TaskDelegate中保存一个NSError

1
2
3
.response { response in
    print(response)
}

把一个操作闭包（内部创建的闭包，不是response之后跟随的这个闭包）添加到queue，这个闭包中做了如下处理：

  1. 检查TaskDelegate中是否保存了NSError，如果有，则直接把NSError放到response中，并且回调给调用方
  2. 选择一种方式来序列化response
  3. 把序列化的结果放到response参数中，并在主线程调用response之后跟随的这个闭包。

至此链式调用完成。

有个小细节是，request之后追加到queue中的这些操作闭包都是对response进行处理的。所以在queue创建的时候要把queue挂起。

1
operationQueue.suspended = true

在NSURLSession回调结束（URLSession(_:task:didCompleteWithError:)）后恢复queue。

1
queue.suspended = false

一句话总结：
Alamofire使用了-> Self和顺序队列来实现链式调用。

处理多请求并发

Alamofire的最外层是一个Manager，通过这个Manager来为每一个请求创建Request实例（Request实例背后是NSURLSessionTask）。

Manager中有个实例变量queue，是一个Serial Dispatch Queue。 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public func request(URLRequest: URLRequestConvertible) -> Request {
    var dataTask: NSURLSessionDataTask!

    dispatch_sync(queue) {
        dataTask = self.session.dataTaskWithRequest(URLRequest.URLRequest)
    }

    let request = Request(session: session, task: dataTask)
    delegate[request.delegate.task] = request.delegate

    if startRequestsImmediately {
        request.resume()
    }

    return request
}

当同时有多个请求被创建时，每个Task的创建操作被同步追加到queue中，并等待它创建完成后，才执行后面的代码。 

1
2
3
dispatch_sync(queue) {
    dataTask = self.session.dataTaskWithRequest(URLRequest.URLRequest)
}

就是说，每个请求是按照顺序一个接一个创建的。

Manager有个内部类SessionDelegate，用来处理NSURLSession的回调方法。Manager在创建时，把Manager引用的NSURLSession对象的delegate赋值为这个SessionDelegate对象。

前面说到，每个请求创建的同时，一个对应的TaskDelegate实例也会创建，这个实例中保存了请求对应的NSURLSessionTask，
请求被创建后，会把相应的TaskDelegate以task为key保存在SessionDelegate中的一个实例变量字典中。
（这里有点绕，如果难以理解可以去参考下源码。）

当发出多次请求后，SessionDelegate中会保存多个TaskDelegate，每个TaskDelegate中都有一个NSURLSessionTask。

每次NSURLSession的回调回来以后，Manager会根据回调参数中的task（例如URLSession(_:task:didCompleteWithError:)中的task参数），以这个task为key，取出对应的TaskDelegate，并把回调分发给它。

（以task为key通过Swift语法的中下标subscript来实现。）

这就是Alamofire的并发请求处理方式。

总结：

  1. 顺序创建Task，以Task为key保存TaskDelegate。
  2. 由Manager统一并发地处理NSURLSession的回调。
  3. 在NSURLSession的回调中根据task把回调分发给对应的TaskDelegate。

（本篇完）

下篇预告：
《Alamofire 源码赏析（二）安全篇》