Alamofire是一个网络请求的框架，使用起来非常简单，几行代码就可以实现网络请求的功能。那么它内部到底做了些什么呢？让我们不用再写一些繁琐的代码就能够实现同样的功能。这边文章就来分析下Request模块的具体实现。
Request整个流程分析
SessionManager.default.request(urlStr, method: .get, parameters: ["name":"xxx"])
.response { (response) in
print(response)
}
- 这是一个非常简单的请求网络代码，直接进入到
request方法里面
open func request(
_ url: URLConvertible,
method: HTTPMethod = .get,
parameters: Parameters? = nil,
encoding: ParameterEncoding = URLEncoding.default,
headers: HTTPHeaders? = nil)
-> DataRequest
{
var originalRequest: URLRequest?
do {
originalRequest = try URLRequest(url: url, method: method, headers: headers)
let encodedURLRequest = try encoding.encode(originalRequest!, with: parameters)
return request(encodedURLRequest)
} catch {
return request(originalRequest, failedWith: error)
}
}
- 首先创建了一个
URLRequest对象，然后对请求参数进行编码。Alamofire支持的编码格式有三种：-
URLEncoding： URL相关的编码，有两种编码方式：1.直接拼接到URL中，2.通过request的httpBody传值 -
JSONEncoding把参数字典编码成JSONData后赋值给request的httpBody -
PropertyListEncoding把参数字典编码成PlistData后赋值给request的httpBody
-
- 进入到
encode方法查看参数编码的具体实现
public func encode(_ urlRequest: URLRequestConvertible, with parameters: Parameters?) throws -> URLRequest {
var urlRequest = try urlRequest.asURLRequest()
guard let parameters = parameters else { return urlRequest }
if let method = HTTPMethod(rawValue: urlRequest.httpMethod ?? "GET"), encodesParametersInURL(with: method) {
guard let url = urlRequest.url else {
throw AFError.parameterEncodingFailed(reason: .missingURL)
}
if var urlComponents = URLComponents(url: url, resolvingAgainstBaseURL: false), !parameters.isEmpty {
let percentEncodedQuery = (urlComponents.percentEncodedQuery.map { $0 + "&" } ?? "") + query(parameters)
urlComponents.percentEncodedQuery = percentEncodedQuery
urlRequest.url = urlComponents.url
}
} else {
if urlRequest.value(forHTTPHeaderField: "Content-Type") == nil {
urlRequest.setValue("application/x-www-form-urlencoded; charset=utf-8", forHTTPHeaderField: "Content-Type")
}
urlRequest.httpBody = query(parameters).data(using: .utf8, allowLossyConversion: false)
}
return urlRequest
}
- 先获取
urlRequest对象，然后通过请求方法判断参数怎么传递。如果是.get, .head, .delete就把参数拼接到URL后面，否则放到请求体里面。 - 因为我们的请求是通过
ASCII编码的，所以需要对参数进行百分号编码。进入到query方法。
private func query(_ parameters: [String: Any]) -> String {
var components: [(String, String)] = []
for key in parameters.keys.sorted(by: <) {
let value = parameters[key]!
components += queryComponents(fromKey: key, value: value)
}
return components.map { "\($0)=\($1)" }.joined(separator: "&")
}
- 先对参数通过
ASCII从小到大进行排序。然后循环遍历参数调用queryComponents方法。
public func queryComponents(fromKey key: String, value: Any) -> [(String, String)] {
var components: [(String, String)] = []
if let dictionary = value as? [String: Any] {
for (nestedKey, value) in dictionary {
components += queryComponents(fromKey: "\(key)[\(nestedKey)]", value: value)
}
} else if let array = value as? [Any] {
for value in array {
components += queryComponents(fromKey: arrayEncoding.encode(key: key), value: value)
}
} else if let value = value as? NSNumber {
if value.isBool {
components.append((escape(key), escape(boolEncoding.encode(value: value.boolValue))))
} else {
components.append((escape(key), escape("\(value)")))
}
} else if let bool = value as? Bool {
components.append((escape(key), escape(boolEncoding.encode(value: bool))))
} else {
components.append((escape(key), escape("\(value)")))
}
return components
}
- 判断参数类型分别处理，如果是集合类型，需要递归调用此方法。
- 把
key和value取出，然后进行了百分号编码。并把编码后的结果放进元组保存，形成参数对。然后把元组加入到数组中。 -
components.map { "\($0)=\($1)" }.joined(separator: "&")把数据中的数据通过map映射成($0)=\($1)，然后在映射之后的元素之间加入一个分隔符号&进行拼接。 - 如果是
get,head,delete方法就直接拼接到URL的后面，如果是POST等方法就是把这些编码好的参数对放入请求体中。其中还要加入Content-Type的请求头。 - 回到
request方法里面，调用了request(encodedURLRequest)这个方法，跟踪进入。
open func request(_ urlRequest: URLRequestConvertible) -> DataRequest {
var originalRequest: URLRequest?
do {
originalRequest = try urlRequest.asURLRequest()
let originalTask = DataRequest.Requestable(urlRequest: originalRequest!)
let task = try originalTask.task(session: session, adapter: adapter, queue: queue)
let request = DataRequest(session: session, requestTask: .data(originalTask, task))
delegate[task] = request
if startRequestsImmediately { request.resume() }
return request
} catch {
return request(originalRequest, failedWith: error)
}
}
- 参数
urlRequest是URLRequestConvertible类型的。URLRequestConvertible协议的目的是对URLRequest进行自定义的转换。在获得转换后的URLRequest后，需要用URLRequest生成task，这样才能发起网络请求。 - 在上边的函数中，用到了
DataRequest.Requestable，Requestable其实一个结构体，他实现了TaskConvertible协议，因此，它能够用URLRequest生成与之相对应的task。在这里是通过内部的Requestable结构体来帮助DataRequest创建Task，任务分层，架构思路更清晰。 - 绑定
task和request, 方便在SessionDelegate下发任务，task方便获取request，request也方便获取task。 - 执行任务
request.resume()启动 - 再来看看
DataRequest的初始化
init(session: URLSession, requestTask: RequestTask, error: Error? = nil) {
self.session = session
switch requestTask {
case .data(let originalTask, let task):
taskDelegate = DataTaskDelegate(task: task)
self.originalTask = originalTask
case .download(let originalTask, let task):
taskDelegate = DownloadTaskDelegate(task: task)
self.originalTask = originalTask
case .upload(let originalTask, let task):
taskDelegate = UploadTaskDelegate(task: task)
self.originalTask = originalTask
case .stream(let originalTask, let task):
taskDelegate = TaskDelegate(task: task)
self.originalTask = originalTask
}
delegate.error = error
delegate.queue.addOperation { self.endTime = CFAbsoluteTimeGetCurrent() }
}
-
Request初始化的时候利用了枚举的便利性，构造创建，相关信息保存。 - 在初始化的时候看到保存了一个
taskDelegate属性，那么这个taskDelegate是干嘛用的呢？前面不是已经通过SessionDelegate这个类来专门实现了相关代理吗？为什么这里还要有一个DataTaskDelegate？- 首先
SessionDelegate是所有Session的代理遵循者，任何的代理都会来到这里响应。但是里面不会实现具体的繁琐的任务，它会把任务下发到对应任务执行者。 -
DataTaskDelegate就是我们具体繁琐任务执行者，这里面所有方法都是由SessionDelegate下发响应的。 -
SessionDelegate是事件总响应者，它会把具体的事务交给具体的人去执行。不能因为在SessionDelegate能够拿到所有的响应，就把所有的代码都罗列在这里，那样会显得很臃肿很乱。所以我们根据不同的需求，响应总代理会根据需求的不同交给专业的人去做专业的事。耦合性大大降低，架构的分层更加明显。
- 首先
- 下面举个例子：
open func urlSession(
_ session: URLSession,
downloadTask: URLSessionDownloadTask,
didFinishDownloadingTo location: URL)
{
if let downloadTaskDidFinishDownloadingToURL = downloadTaskDidFinishDownloadingToURL {
downloadTaskDidFinishDownloadingToURL(session, downloadTask, location)
} else if let delegate = self[downloadTask]?.delegate as? DownloadTaskDelegate {
delegate.urlSession(session, downloadTask: downloadTask, didFinishDownloadingTo: location)
}
}
- 这是
task的一个代理方法，当代理回调时，会先通过task找到相应的Request，然后直接拿出Request的属性delegate来处理相关事务，SessionDelegate只是做一个中转的作用，是一个管理者，负责分发任务。从这里也就知道前面为什么要让Request和task建立一个绑定关系。
总结
调用request发起请求后：
- 首先对参数进行编码和拼接。
- 通过内部的结构体
Requestable创建task。 - 创建
request并保存了DataTaskDelegate。 - 对
request和task进行绑定，方便使用。 - 执行
resume启动任务。
整个流程下来非常的清晰，容易理解，代码阅读性高。SessionDelegate负责所有Session的响应回调，然后把任务分发给DataTaskDelegate去具体实现。实现解耦，业务下沉，提高代码的可以性。
有问题或者建议和意见，欢迎大家评论或者私信。
喜欢的朋友可以点下关注和喜欢，后续会持续更新文章。
网友评论