Alamofire是AFNetWorking在Swift中版本，其作用和地位就不多做介绍。
本文主要记录下Alamofire的设计思路和swift下不同的设计理念，关于框架的原理简单带过。
一. Alamofire的使用
Alamofire的使用方法都在Alamofire这个文件中，直接方法调用。
Alamofire.request...
Alamofire.upload...
Alamofire.download...
而内部实际是SessionManager.default去request、upload、download。可以说Alamofire只是为了封装细节的一个外表（好看，调用简单）。
但是，request的返回值是DaRequest（包含返回的数据），要获取我们的需要的数据还得我们自己去处理。
Alamofire.request(/**/).validate(/**/).responseJSON {/**/}
从Alamofire的请求中，我们可以看到需要的参数：
@discardableResult
public func request(
_ url: URLConvertible,
method: HTTPMethod = .get,
parameters: Parameters? = nil,
encoding: ParameterEncoding = URLEncoding.default,
headers: HTTPHeaders? = nil)
-> DataRequest
{
return SessionManager.default.request(
url,
method: method,
parameters: parameters,
encoding: encoding,
headers: headers
)
}
// 参数在有默认值的情况，调用可以忽略这个参数，让方法调用变得简单，比如
Alamofire.request("https://httpbin.org/get")
在Alamofire中，也定义了两个参数中使用到的协议URLRequestConvertible和URLConvertible。
URLConvertible简单说就是改变成URL的协议，遵守该协议的String或URLComponents都获取出需要的部分（url）。
URLRequestConvertible就是改变成URLRequest的协议，与URLConvertible差不多，唯一的区别就是用了一个urlRequest来封装asURLRequest方法。
public protocol URLRequestConvertible {
func asURLRequest() throws -> URLRequest
}
extension URLRequestConvertible {
public var urlRequest: URLRequest? { return try? asURLRequest() }
}
extension URLRequest: URLRequestConvertible {
public func asURLRequest() throws -> URLRequest { return self }
}
另外Alamofire中为URLRequest添加了拓展方法（初始化和改变）。
public init(url: URLConvertible, method: HTTPMethod, headers: HTTPHeaders? = nil) throws {
// 获取url
let url = try url.asURL()
self.init(url: url)
httpMethod = method.rawValue
if let headers = headers {
for (headerField, headerValue) in headers {
setValue(headerValue, forHTTPHeaderField: headerField)
}
}
}
// 请求适配器（传入适配器，生成新的URLRequest）
func adapt(using adapter: RequestAdapter?) throws -> URLRequest {
guard let adapter = adapter else { return self }
return try adapter.adapt(self)
}
二. Alamofire的实现（主要是SessionManager）
这是我对Alamofire流程总结的一张图：
可以看出Alamofire的功能都是SessionManager提供的。所谓的SessionManager实际上就是管理URLSession的Manager。了解iOS网络请求的都知道app网络请求都是通过URLSession进行。Session是一个网络通过，建立通道，派发task，回调，这就是一个网络请求的大概过程。大概步骤如下：
- 建立NSURLSessionTask，并且resume。
- 检查cache策略，如果有需要从本地cache中直接返回数据。
- 通过DNS进行域名查找。
- 建立TCP连接。
- 如果是HTTPS，进行TLS握手（如有资源需要认证访问，可能需要客户端提供证书，用户名密码等信息）。
- 请求开始，收到HTTP的Response。
- 接收HTTP的Data。
以普通网络请求为例：
// 普通网络请求
// 你给我url，method，parameters，header，我给你生成对应的DataRequest
@discardableResult
open func request(
_ url: URLConvertible,
method: HTTPMethod = .get,
parameters: Parameters? = nil,
encoding: ParameterEncoding = URLEncoding.default,
headers: HTTPHeaders? = nil)
-> DataRequest
{
var originalRequest: URLRequest?
do {
// 初始化URLRequest
originalRequest = try URLRequest(url: url, method: method, headers: headers)
// 将参数编码生成新的URLRequest
let encodedURLRequest = try encoding.encode(originalRequest!, with: parameters)
return request(encodedURLRequest)
} catch {//生成URLRequest失败，这边originalRequest有可能是nil也有可能是未拼接参数的
return request(originalRequest, failedWith: error)
}
}
// 给一个urlRequest，生成一个DataRequest
// 前面的方法也会跳到这一步，前面的相当于多了url，method等参数转换成urlRequest的过程
@discardableResult
open func request(_ urlRequest: URLRequestConvertible) -> DataRequest {
var originalRequest: URLRequest?
do {
// 生成urlRequest
originalRequest = try urlRequest.asURLRequest()
// 生成task生成器（生成器封装了URLRequest转换器的转换功能）
let originalTask = DataRequest.Requestable(urlRequest: originalRequest!)
// 生成器生成task（旧task变成新task，对应的是转换前和转换后的urlRequest）
let task = try originalTask.task(session: session, adapter: adapter, queue: queue)
// 这边是DataRequest
// DataRequest相对于urlRequest封装了一层，有delegate，进度等
//
let request = DataRequest(session: session, requestTask: .data(originalTask, task))
// 将DataRequest保存起来
delegate[task] = request
// 请求开始
if startRequestsImmediately { request.resume() }
return request
} catch {// 生成urlRequest失败。。。这边的originalRequest可能是nil
return request(originalRequest, failedWith: error)
}
}
在SessionManager中，主要有两部分功能：1.请求（交给Request），2.回调（交给SessionDelegate）。
1. Request的设计
Request是一种命令式请求类，隐藏对Task的操作。了解Request主要看Request怎么创建，Request怎么处理网络回调，Request怎么处理响应数据。
- Request的创建
原理简单来讲就是将URL，Method，header 和Parameter通过编码器（ParameterEncoding）编码成对应的URLRequest。编码器有URL，JSON，Property三种类型。如URLEncoding就是将Parameter处理成键值对拼接在URL后面，JSONEncoding就是将Parameter转成JSON数据放在HTTPBody中。
有了URLRequest，通过Task生成器生成对应的Task（实际上是session去创建Task），在Task生成器中可以传入URLRequest改变器去修改URLRequest。有了Task，Request也因此诞生。
- Request处理网络请求
实际上Request也算是一个“主管”，他将获取数据的工作交给Task，处理网络回调的工作交给TaskDelegate。从全局来看，在SessionDelegate保存着所有的Request，当网络回调过来，自己能处理的处理，不能处理的就交给Request的代理人（TaskDelegate）。TaskDelegate担任着处理网络回调数据的重任，Request需要提供的属性，也是叫TaskDelegate提供。
- Request处理数据
Alamofire返回的是Request，也提供了各种处理方法。方便于各种定制，不过也加大了使用的难度。
看名字好像ResponseSerialization提供了处理数据的功能，其实不然。这只是一个空工厂（你放什么机器进来就成为什么工厂），处理数据的方法还是不同种类的Request自己提供。
以DataRequest为例：
通过不同的ResponseSerialization（编码器）去生成不同的Result，不同的Result生成不同的Response。
// 获取DataResponse
@discardableResult
public func response<T: DataResponseSerializerProtocol>(
queue: DispatchQueue? = nil,
responseSerializer: T,
completionHandler: @escaping (DataResponse<T.SerializedObject>) -> Void)
-> Self
{
//在代理人的队列中进行？
delegate.queue.addOperation {
// 响应编码器去生成Result
let result = responseSerializer.serializeResponse(
self.request,
self.response,
self.delegate.data,
self.delegate.error
)
// 通过Result创建响应
var dataResponse = DataResponse<T.SerializedObject>(
request: self.request,
response: self.response,
data: self.delegate.data,
result: result,
timeline: self.timeline
)
dataResponse.add(self.delegate.metrics)
// 回调出响应
(queue ?? DispatchQueue.main).async { completionHandler(dataResponse) }
}
return self
}
}
可以说编码器决定了我们获取到的Response。我们可能获取Data，Json，String（实际Json和String都是由Data转换过来的），我们调用时传入对应的编码器（当然，决定编码器的还是之中有区别的编码方法，这些方法分布在各个Request的拓展中），就会得到对应的结果。
2. SessionDelegate的设计
SessionDelegate是SessionManager的代理人，也持有（拥有）着所有的Request。
SessionDelegate遵守Session的协议，负责Session相关代理的回调。SessionDelegate提供了多个闭包供外界调用修改，有的代理方法在没有外界修改的情况是扔给Request的Delegate。
SessionDelegate算是代理的集散中心，负责分配代理回调任务。
三. Alamofire的设计Tips
1. 类（枚举，结构体）的设计思路
相较于OC，swift设计类的思路（枚举，结构体）总是习惯以协议为基础，当然也不是不能使用继承。
以ResponseSerializer为例：
ResponseSerializer是用来处理响应数据的，不同的请求类型有不同的响应数据，所以有两种协议和两种响应处理器（这边我们拿一个出来讲）。
public protocol DataResponseSerializerProtocol {
associatedtype SerializedObject
// 编码出结果
var serializeResponse: (URLRequest?, HTTPURLResponse?, Data?, Error?) -> Result<SerializedObject> { get }
}
public struct DataResponseSerializer<Value>: DataResponseSerializerProtocol {
public typealias SerializedObject = Value
public var serializeResponse: (URLRequest?, HTTPURLResponse?, Data?, Error?) -> Result<Value>
public init(serializeResponse: @escaping (URLRequest?, HTTPURLResponse?, Data?, Error?) -> Result<Value>) {
self.serializeResponse = serializeResponse
}
}
这边协议抽离出响应处理器的本质，处理响应方法，这边使用一个serializeResponse闭包属性，用于外界传入。使用associatedtype便于定义后面的泛型。
遵守该协议的结构体使用泛型，这样作为一个响应处理器可以处理出各种Result<Value>。那serializeResponse是谁提供的呢？实际上是Request自己提供，自己获取响应处理器，自己提供响应处理方法。响应处理器在这边只是一个空壳。
获取responseData就带入Data响应处理器，使用处理Data的方法。
获取responseJSON就带入Json响应处理器，使用处理Json的方法。
获取responseString就带入String响应处理器，使用处理String的方法。
// 获取DataResponse
@discardableResult
public func responseData(
queue: DispatchQueue? = nil,
completionHandler: @escaping (DataResponse<Data>) -> Void)
-> Self
{
// 通过响应数据序列化器生成DataResponse
return response(
queue: queue,
responseSerializer: DataRequest.dataResponseSerializer(),
completionHandler: completionHandler
)
}
// 获取响应数据序列化器（生成器）
public static func dataResponseSerializer() -> DataResponseSerializer<Data> {
// 创建DataResponseSerializer
return DataResponseSerializer { _, response, data, error in
// 这边为什么又跳来Request？
// 这边固定的，所以这边当做一个固定方法就好理解
return Request.serializeResponseData(response: response, data: data, error: error)
}
}
// 这就是一个类方法（当做属性使用就可以）
// 获取Result
public static func serializeResponseData(response: HTTPURLResponse?, data: Data?, error: Error?) -> Result<Data> {
guard error == nil else { return .failure(error!) }
if let response = response, emptyDataStatusCodes.contains(response.statusCode) { return .success(Data()) }
guard let validData = data else {
return .failure(AFError.responseSerializationFailed(reason: .inputDataNil))
}
return .success(validData)
}
最终根据相应处理器的类型，统一到同一个方法执行（泛型方法接受泛型作为参数）：
// 获取DataResponse
@discardableResult
public func response<T: DataResponseSerializerProtocol>(
queue: DispatchQueue? = nil,
responseSerializer: T,
completionHandler: @escaping (DataResponse<T.SerializedObject>) -> Void)
-> Self
{
//在代理人的队列中进行？
delegate.queue.addOperation {
// 响应编码器去生成Result
let result = responseSerializer.serializeResponse(
self.request,
self.response,
self.delegate.data,
self.delegate.error
)
// 通过Result创建响应
var dataResponse = DataResponse<T.SerializedObject>(
request: self.request,
response: self.response,
data: self.delegate.data,
result: result,
timeline: self.timeline
)
dataResponse.add(self.delegate.metrics)
// 回调出响应
// 在queue队列回调（如果queue是主队列，那就串行回调）
(queue ?? DispatchQueue.main).async { completionHandler(dataResponse) }
}
return self
}
另外，Alamofire中枚举的使用也是挺有特点，大枚举嵌套小枚举。将所有的Error封装起来。
- 1.Error枚举中包含局部Error枚举（用于枚举值的参数）
- 2.判断枚举类型的属性（bool）
- 3.获取枚举参数的属性（方法）
- 4.添加枚举类型的描述
2. 多线程的使用
Alamofire中有两个特别的queue。
一个是SessionManager的queue。传入到Task生成器中在该队列中同步创建Task。
// 全局队列（用于创建task）
let queue = DispatchQueue(label: "org.alamofire.session-manager." + UUID().uuidString)
一个是TaskDelegate的queue。
// 创建队列
self.queue = {
let operationQueue = OperationQueue()
operationQueue.maxConcurrentOperationCount = 1
// 挂起
operationQueue.isSuspended = true
// 服务质量（不急）
operationQueue.qualityOfService = .utility
return operationQueue
}()
这个队列一开始是挂起状态，当网络回调完成时，开始执行队列的任务。也就是我们之前可能加入的responseJSON任务。你要想Alamofire.request(/**/)这个函数是即时返回对应的Request给你，那数据还没请求下来就执行responseJSON怎么可能处理得到数据。所以一开始队列挂起，任务暂停，直到请求完成，有数据了，才开始执行数据处理。另外validate方法不是加载队列中，是保存在SessionManager中，在验证时期到了去做校验。
Alamofire.request(/**/).validate(/**/).responseJSON {/**/}
像response方法，生成回调DefaultDataResponse都是添加在TaskDelegate的队列中。
@discardableResult
public func response(queue: DispatchQueue? = nil, completionHandler: @escaping (DefaultDataResponse) -> Void) -> Self {
delegate.queue.addOperation {
// 创建响应，回调响应（普通响应，没有Reult）
(queue ?? DispatchQueue.main).async {
var dataResponse = DefaultDataResponse(
request: self.request,
response: self.response,
data: self.delegate.data,
error: self.delegate.error,
timeline: self.timeline
)
dataResponse.add(self.delegate.metrics)
completionHandler(dataResponse)
}
}
3. 设计模式的使用
在Alamofire中，Request用了命令模式。封装了创建Task，执行取消Task的操作。
SessionManager的adapter是用了适配器模式，传入adapter，让adapter去执行对应的方法。
