本文通过一个get请求，追踪代码流程，来进入到整个框架的学习。

1.创建请求

Alamofire.request("https://httpbin.org/get")

• 通过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
    )
}

• 关键字@discardableResult，在方法没有返回值时不会报出警告
• swift参数是支持默认值的，调用时值传了一个url参数，继承URLConvertible协议，用来生成URL类型
• HTTPMethod是一个枚举类型，这里默认值使用get
• Parameters定义为[String: Any]，默认是nil。它的定义使用typealias关键字，用来为已经存在的类型重新定义名字的，通过命名，可以使代码变得更加清晰。HTTPHeaders亦是如此
• Alamofire只是一个入口，内部调用SessionManager来完成创建

@discardableResult
    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)
        }
    }

• 声明originalRequest变量，类型是URLRequest。Swift里不会自动给变量赋初始值，也就是说变量不会有默认值，所以要求使用变量之前必须要对其初始化，如果没有初始化就会报错。这时候可以使用optional类型，也就是后面跟一个"？"。
• 试着创建URLRequest，这里加try是因为asURL可能会抛出异常
• 然后调用ParameterEncoding.swift的方法对参数进行编码
• 最后进入request方法来生成DataRequest

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)
        }
    }

• originalTask值是一个结构体，这个结构体继承TaskConvertible协议。该协议定义了task方法，让每种不同类型的request实现自己创建task的逻辑。这里创建NSURLSessionDataTask类型task的实现代码是session.dataTask(with: urlRequest)
• 用session和.data(originalTask, task)创建DataRequest。URLRequest（DataRequest的父类）初始化方法会根据task的不同生成对应的taskDelegate
• 把task和request的关系存到delegate中，调用request的resume方法发出请求，内部会触发task.resume()方法发请求，最后并返回request

整个过程大致是，调用SessionManager.request()方法，获取URLRerequest，获取对应的task，创建DataRequest，发起请求。

2.接收请求

if let request = request as? DataRequest {
            request.responseString { response in
                requestComplete(response.response, response.result)
            }
        }

• 这里刚开始可能看不太懂，这是尾随闭包的写法。这个闭包是request.responseString方法的最后一个参数。
• 这个闭包会被加入到DataRequest的delegate.queue中。TaskDelegate的queue是一个串行队列，存放task结束之后需要执行的任务

@discardableResult
    public func response<T: DataResponseSerializerProtocol>(
        queue: DispatchQueue? = nil,
        responseSerializer: T,
        completionHandler: @escaping (DataResponse<T.SerializedObject>) -> Void)
        -> Self
    {
        delegate.queue.addOperation {
            let result = responseSerializer.serializeResponse(
                self.request,
                self.response,
                self.delegate.data,
                self.delegate.error
            )

            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
    }

• 最终传进来的闭包会加入到delegate的queue队列中，并且这个队列初始化时设置了isSuspend=true，所以它会在改为false才会执行
• 这个opration里会生成result和response，供回调使用，也就是requestComplete(response.response, response.result)的参数

open func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data) {
        if let dataTaskDidReceiveData = dataTaskDidReceiveData {
            dataTaskDidReceiveData(session, dataTask, data)
        } else if let delegate = self[dataTask]?.delegate as? DataTaskDelegate {
            delegate.urlSession(session, dataTask: dataTask, didReceive: data)
        }
    }

• SessionDelegate继承URLSessionDataDelegate，实现请求的各种回调
• 下面的判断会走到else，前面在delegate存储过task和delegate，所以这里self[dataTask]会得到之前发请求的request，并且是DataTaskDelegate类型
• 于是执行delegate（DataTaskDelegate）的对应方法

func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data) {
        if initialResponseTime == nil { initialResponseTime = CFAbsoluteTimeGetCurrent() }

        if let dataTaskDidReceiveData = dataTaskDidReceiveData {
            dataTaskDidReceiveData(session, dataTask, data)
        } else {
            if let dataStream = dataStream {
                dataStream(data)
            } else {
                mutableData.append(data)
            }

            let bytesReceived = Int64(data.count)
            totalBytesReceived += bytesReceived
            let totalBytesExpected = dataTask.response?.expectedContentLength ?? NSURLSessionTransferSizeUnknown

            progress.totalUnitCount = totalBytesExpected
            progress.completedUnitCount = totalBytesReceived

            if let progressHandler = progressHandler {
                progressHandler.queue.async { progressHandler.closure(self.progress) }
            }
        }
    }

• dataStream为((_ data: Data) -> Void)?类型，mutableData被初始化为Data()，它们都是是DataTaskDelegate的实例变量。这里会走到mutableData.append(data)
• bytesReceived计算接收数据的大小
• totalBytesExpected将可选类型dataTask.response解包，然后获取expectedContentLength.“??"运算符可以用于判断变量或常量的数值是否是nil，不为nil则取变量或者常量本身的值,如果是nil则使用后面的值替代
• 判断是否有progressHandler，这不会调用。因为demo中并没有传

open func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
        let completeTask: (URLSession, URLSessionTask, Error?) -> Void = { [weak self] session, task, error in
            guard let strongSelf = self else { return }

            strongSelf.taskDidComplete?(session, task, error)

            strongSelf[task]?.delegate.urlSession(session, task: task, didCompleteWithError: error)

            NotificationCenter.default.post(
                name: Notification.Name.Task.DidComplete,
                object: strongSelf,
                userInfo: [Notification.Key.Task: task]
            )

            strongSelf[task] = nil
        }

        guard let request = self[task], let sessionManager = sessionManager else {
            completeTask(session, task, error)
            return
        }

        request.validations.forEach { $0() }

        var error: Error? = error

        if request.delegate.error != nil {
            error = request.delegate.error
        }

        if let retrier = retrier, let error = error {
            retrier.should(sessionManager, retry: request, with: error) { [weak self] shouldRetry, timeDelay in
                guard shouldRetry else { completeTask(session, task, error) ; return }

                DispatchQueue.utility.after(timeDelay) { [weak self] in
                    guard let strongSelf = self else { return }

                    let retrySucceeded = strongSelf.sessionManager?.retry(request) ?? false

                    if retrySucceeded, let task = request.task {
                        strongSelf[task] = request
                        return
                    } else {
                        completeTask(session, task, error)
                    }
                }
            }
        } else {
            completeTask(session, task, error)
        }
    }

• SessionDelegate内实现的回调，表示task已经完成数据传输
• completeTask，如果请求不需要重试，就会执行这个闭包
• sessionManager没有被赋值，所以不会走到第一个判断里
• validations是[() -> Void] = []一种闭包类型的数组，放一些检查的方法。$0()表示第一个参数，也就是数组里的每一个值
• 用request.delegate.error取到错误，如果设置了retrier并有error，就执行重试的方法。否则执行completeTask
• 在completeTask中，首选判断taskDidComplete有无值然后执行，然后通过strongSelf[task]得到request并调用其urlSession方法
• 最后发通知并把task置为nil

@objc(URLSession:task:didCompleteWithError:)
    func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
        if let taskDidCompleteWithError = taskDidCompleteWithError {
            taskDidCompleteWithError(session, task, error)
        } else {
            if let error = error {
                if self.error == nil { self.error = error }

                if
                    let downloadDelegate = self as? DownloadTaskDelegate,
                    let resumeData = (error as NSError).userInfo[NSURLSessionDownloadTaskResumeData] as? Data
                {
                    downloadDelegate.resumeData = resumeData
                }
            }

            queue.isSuspended = false
        }
    }

• 上述代码 strongSelf[task]?.delegate.urlSession(session, task: task, didCompleteWithError: error) 的方法实现
• 这里在有错误时，对DownloadTaskDelegate做了一些处理。
• queue.isSuspended这里是关键，isSuspended设置为false后，回调传进来operation将会开始执行
• @objc 作用：1，fileprivate 或者 private 保证方法私有 能在同一个类 或者 同一个文件（extension）中访问这个方法 如果定义为private 那么只能在一个类中访问 不能在类扩展中访问；2，允许这个函数在“运行时”通过oc的消息机制调用

open subscript(task: URLSessionTask) -> Request? {
        get {
            lock.lock() ; defer { lock.unlock() }
            return requests[task.taskIdentifier]
        }
        set {
            lock.lock() ; defer { lock.unlock() }
            requests[task.taskIdentifier] = newValue
        }
    }

• 上述代码strongSelf[task] = nil的实现
• 使用lock，保证赋值是线程安全的
• open关键字，访问控制在权限。在swift3中，fileprivate来显式的表明，这个元素的访问权限为文件内私有，即extension也可以访问到。private则是真正的私有，离开了这个类或者结构体的作用域外面就无法访问。open在module内可以被override，在被import到其他地方后其他用户使用的时候不能被override。通过open和public标记区别一个元素在其他module中是只能被访问还是可以被override
• defer关键字，推迟执行，会在return之前执行。记得react cocoa里面oc有写过一个黑魔法来实现这个方法，swift可以直接用关键字解决了

整理一下整个过程，把完成的闭包传入，然后被加到queue中，请求返回后出发queue执行，最终调用最初传入的闭包

这篇文章从demo里的Alamofire.request("https://httpbin.org/get")开始分析了整个发送和接收请求的过程，有一个大概流程的概念。后面再去逐个分析每个类