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发起请求后：

1. 首先对参数进行编码和拼接。
2. 通过内部的结构体Requestable创建task。
3. 创建request并保存了DataTaskDelegate。
4. 对request和task进行绑定，方便使用。
5. 执行resume启动任务。

整个流程下来非常的清晰，容易理解，代码阅读性高。SessionDelegate负责所有Session的响应回调，然后把任务分发给DataTaskDelegate去具体实现。实现解耦，业务下沉，提高代码的可以性。

有问题或者建议和意见，欢迎大家评论或者私信。
喜欢的朋友可以点下关注和喜欢，后续会持续更新文章。