跟着Alamofire(4.0.0)学Swift3(二)

2016-10-02 本文已影响4066人纸简书生

建议先看跟着Alamofire(4.0.0)学Swift3(一)。再看本文。

在跟着Alamofire(4.0.0)学Swift3(一)中，分析到了类Request(请求)。今天主要分析下面几个：

1.Response
2.SessionDelegate
3.SessionManager

Response

类和结构体的使用

这个类给自己最大的启发就是在Swift中类和结构体的使用。大家对结构体和类应该并不陌生，但是在OC中，我们在写代码的时候很少用到结构体。或许是个人的习惯，就我身边的同事大部分是这样的。但是在Swift的中，结构体出现的频率相当高。在文件Response.swift中没有定义一个类，全是结构体。

先来回顾一下Swift中结构体和类的关系:

1.都可以有属性和方法；
2.都有构造器；
3.都支持附属脚本；
4.都支持扩展；
5.都支持协议。

然后我们来看看他们的不同之处：

1.类有继承；
2.结构体有一个自动生成的逐一初始化构造器；
3.在做赋值操作时，结构体总是被拷贝（Array有特殊处理）；
4.结构体可以声明静态的属性和方法；
5.从设计模式的角度来分析，类的设计更侧重于对功能的封装，而结构体的设计更侧重于对数据的封装。

关于属性的对比可以参考下面这张图。

说明:类的静态属性表示用class修饰的变量，别和用static修饰的搞混了。用static是没问题的

结构体上场

很多同学可能很疑惑，什么时候用结构体，什么时候用类。这点上可以根据类的设计更侧重于对功能的封装，而结构体的设计更侧重于对数据的封装。为了便于代码组织，一般在结构体的扩展里面添加方法比如在Response.swift中:

public struct DefaultDataResponse {
    public let request: URLRequest?
    public let response: HTTPURLResponse?
    public let data: Data?
    public let error: Error?

    var _metrics: AnyObject?

    init(request: URLRequest?, response: HTTPURLResponse?, data: Data?, error: Error?) {
        self.request = request
        self.response = response
        self.data = data
        self.error = error
    }
}

结构体DefaultDataResponse完全满足对数据的封装，当然这里用类来封装这些数据其实也可以，但是就感觉没有那么完美。
同样在文件中出现的。DataResponse也是结构体。然后通过扩展给结构体添加方法，或者应该算是属性

extension DataResponse: CustomStringConvertible, CustomDebugStringConvertible {
    /// The textual representation used when written to an output stream, which includes whether the result was a
    /// success or failure.
    public var description: String {
        return result.debugDescription
    }
    /// The debug textual representation used when written to an output stream, which includes the URL request, the URL
    /// response, the server data, the response serialization result and the timeline.
    public var debugDescription: String {
        var output: [String] = []

        output.append(request != nil ? "[Request]: \(request!)" : "[Request]: nil")
        output.append(response != nil ? "[Response]: \(response!)" : "[Response]: nil")
        output.append("[Data]: \(data?.count ?? 0) bytes")
        output.append("[Result]: \(result.debugDescription)")
        output.append("[Timeline]: \(timeline.debugDescription)")

        return output.joined(separator: "\n")
    }
}

注意一下这两个协议CustomStringConvertible, CustomDebugStringConvertible。

DefaultDownloadResponse，DownloadResponseDownloadResponse和上面讲的一样。

Response协议

这个协议里面其实没什么，特别点的就是学学协议里面怎么规定要实现的属性。
这里有个关键字mutating似乎不是很熟悉，来看看他的作用：

mutating：修饰方法是为了能在该方法中修改 struct 或是 enum 的变量，在设计接口的时候，也要考虑到使用者程序的扩展性。所以要多考虑使用mutating来修饰方法。如果将Response中修饰方法的mutating去掉，编译器会报错说没有实现protocol。如果将struct中的mutating去掉，则会报错不能改变结构体的成员。

protocol Response {
    /// The task metrics containing the request / response statistics.
    var _metrics: AnyObject? { get set }
    mutating func add(_ metrics: AnyObject?)
}

通过这样定义之后，就可以让结构体实现这个协议，然后修改结构体里面的变量了。

让我们俩一步一步看看。
通过扩展协议，在扩展里面判断当前系统版本环境。代码如下：

extension Response {
    mutating func add(_ metrics: AnyObject?) {
        #if !os(watchOS)
            guard #available(iOS 10.0, macOS 10.12, tvOS 10.0, *) else { return }
            guard let metrics = metrics as? URLSessionTaskMetrics else { return }

            _metrics = metrics
        #endif
    }
}

在结构体的扩展里面实现协议。

@available(iOS 10.0, macOS 10.12, tvOS 10.0, *)
extension DefaultDataResponse: Response {
#if !os(watchOS)
    /// The task metrics containing the request / response statistics.
    public var metrics: URLSessionTaskMetrics? { return _metrics as? URLSessionTaskMetrics }
#endif
}

这里需要注意一下@available关键字。不用我讲，也知道他的作用吧。

Summary

结构体和类的区别
结构体、类使用场景
扩展是个好东西，在Alamofire中，很多地方都用到结构体里面定义数据结构，在结构体的扩展里面定义方法。各司其责，优化代码组织。非常值得学习。
关键字mutating和available的作用。

SessionDelegate

看名字刚开始还以为这是一个代理。结果这是一个类。前面说到类一般是对功能的封装。现在就来看看什么是对功能的封装。

这个类的作用是用闭包(也就是OC中的block)来替代系统中的代理回调。大致分三个部分:

1.声明替代系统代理回调方法的闭包
2.定义需要的属性及方法。比如lock,sessionManager.
3.在类的扩展里面实现系统代理，实现自定义闭包代替系统回调代理。

声明替代系统代理回调方法的闭包

// MARK: URLSessionDelegate Overrides

    /// Overrides default behavior for URLSessionDelegate method `urlSession(_:didBecomeInvalidWithError:)`.
    open var sessionDidBecomeInvalidWithError: ((URLSession, Error?) -> Void)?

    /// Overrides default behavior for URLSessionDelegate method `urlSession(_:didReceive:completionHandler:)`.
    open var sessionDidReceiveChallenge: ((URLSession, URLAuthenticationChallenge) -> (URLSession.AuthChallengeDisposition, URLCredential?))?
    
    ...
    
    /// Overrides default behavior for URLSessionStreamDelegate method `urlSession(_:streamTask:didBecome:outputStream:)`.
    open var streamTaskDidBecomeInputAndOutputStreams: ((URLSession, URLSessionStreamTask, InputStream, OutputStream) -> Void)?

注意这里定的闭包在下面的扩展里面讲对系统的代理进行包装一次，然后外面通过定义的闭包使用。

这一部分能学到的差不多就是如果对闭包进行声明吧。顺便注意下关键字open

定义需要的属性及方法

这部分不算多，关键是定义了一个sessionManager关于这个类后面会说到。有一点需要注意就是subscript的使用方式。这里定义了一个requests字典。通过subscript来返回指定key的Request。注意一下用法。关键字defer的作用上一篇已经提到过这里不再重复了。

    var retrier: RequestRetrier?
    weak var sessionManager: SessionManager?

    private var requests: [Int: Request] = [:]
    private let lock = NSLock()

    /// Access the task delegate for the specified task in a thread-safe manner.
    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
        }
    }

在类的扩展里面实现系统代理

这部分比较简单，格式就是，实现代理，在代理方法中调用定义好的闭包，传递参数。通过对系统的代理方法包装一层，然后外部通过定义的闭包来调用。这样我想到了OC中的一个牛逼的第三方BlockKit。原理和这里有些类似

extension SessionDelegate: URLSessionDelegate {
    /// Tells the delegate that the session has been invalidated.
    ///
    /// - parameter session: The session object that was invalidated.
    /// - parameter error:   The error that caused invalidation, or nil if the invalidation was explicit.
    open func urlSession(_ session: URLSession, didBecomeInvalidWithError error: Error?) {
         // 调用自己的闭包
        sessionDidBecomeInvalidWithError?(session, error)
    }
    
    ...
    
    open func urlSession(
        _ session: URLSession,
        streamTask: URLSessionStreamTask,
        didBecome inputStream: InputStream,
        outputStream: OutputStream)
    {
        streamTaskDidBecomeInputAndOutputStreams?(session, streamTask, inputStream, outputStream)
    }
}

SessionManager

这个类就比较重要了，算是包含了上面介绍的大部分东西。

一共分为如下几个部分：

1.调用结果枚举定义。Helper
2.属性定义。Properties
3.生命周期。Lifecycle
4.数据请求。Data Request
5.下载请求。Download Request
6.上传请求。Upload Request
7.流式请求。Stream Request
8.重试。Retry Request

有点多，没关系一个一个的来。

调用结果枚举定义

这个类似于在OC中定义成功回调和失败回调。知识现在把回调放到了枚举里面，这样更加合理。这种方式得益于case可以传递参数。

public enum MultipartFormDataEncodingResult {
        case success(request: UploadRequest, streamingFromDisk: Bool, streamFileURL: URL?)
        case failure(Error)
    }

那后面怎么使用这种回调的方式呢。

 let encodingResult = MultipartFormDataEncodingResult.success(
                        request: self.upload(data, with: urlRequestWithContentType),
                        streamingFromDisk: false,
                        streamFileURL: nil
                    )

 DispatchQueue.main.async { encodingCompletion?(encodingResult) }

具体会在后面用到。

属性定义

这里需要弄明白有哪几种属性。计算属性和存储属性，然后静态属性和实力属性。最开始定义的就是所谓的静态计算属性。如下：

open static let `default`: SessionManager = {
        let configuration = URLSessionConfiguration.default
        configuration.httpAdditionalHeaders = SessionManager.defaultHTTPHeaders

        return SessionManager(configuration: configuration)
    }()

类似的还有defaultHTTPHeaders也是这样定义的。不仅只有属性才能用这种形式，局部变量也可以通过这种中括号方式定义。比如：

let osNameVersion: String = {
                    let version = ProcessInfo.processInfo.operatingSystemVersion
                    let versionString = "\(version.majorVersion).\(version.minorVersion).\(version.patchVersion)"

                    let osName: String = {
                        #if os(iOS)
                            return "iOS"
                        #elseif os(watchOS)
                            return "watchOS"
                        #elseif os(tvOS)
                            return "tvOS"
                        #elseif os(macOS)
                            return "OS X"
                        #elseif os(Linux)
                            return "Linux"
                        #else
                            return "Unknown"
                        #endif
                    }()

属性这部分新的知识点不多。个人觉得可以看看属性的get/set方法

open var retrier: RequestRetrier? {
        get { return delegate.retrier }
        set { delegate.retrier = newValue }
    }

这种方式类似于OC中重写属性的get/set方法。最常见的将model改变和UI绑定在一起。

生命周期

差点忘了一个非常重要的知识点就，Swift中属性在初始化之后必须有值。这点和OC不一样。所以在init方法中做了如下事情:

public init(
        configuration: URLSessionConfiguration = URLSessionConfiguration.default,
        delegate: SessionDelegate = SessionDelegate(),
        serverTrustPolicyManager: ServerTrustPolicyManager? = nil)
    {
        self.delegate = delegate
        self.session = URLSession(configuration: configuration, delegate: delegate, delegateQueue: nil)

        commonInit(serverTrustPolicyManager: serverTrustPolicyManager)
    }

关于初始方法，Swift3中有init 和 init?，前者代码一定会走的，后者代表可能会走的初始化方法。除了这两个之外，还需要注意一个deinit。

关于闭包的实现：为了防止循环引用用了weak。具体实现可以仿照下面的写法

delegate.sessionDidFinishEventsForBackgroundURLSession = { [weak self] session in
        guard let strongSelf = self else { return }
        DispatchQueue.main.async { strongSelf.backgroundCompletionHandler?() }
    }

数据请求

关键字@discardableResult的作用，在上一篇提到过。表示这个方法可以不用接受返回值。那就是说如果没有这个修饰，如果方法有返回值则必须接收哦。😁

这部分在定义方法上可以学习一下，具体的内容就是先定义一个最为基础的方法，参数比较多但是一定要有默认值，然后后续的方法在参数上做减法，最终都是调用最为基本的方法。具体的例子如：

基本的方法定义

open func request(
        _ url: URLConvertible,
        method: HTTPMethod = .get,
        parameters: Parameters? = nil,
        encoding: ParameterEncoding = URLEncoding.default,
        headers: HTTPHeaders? = nil)
        -> DataRequest {
    ...        
}

省略了部分参数的方法。

 open func request(_ urlRequest: URLRequestConvertible) -> DataRequest {
 ...
 
  let request = DataRequest(session: session, requestTask: .data(originalTask, task))
  
 ...
 }

在实际开发中这样的方式还是比较常用的。那具体来看看代码中可以学到的知识点。

1.省略外部参数用_
2.在方法中定义默认参数的方式

3.异常捕获，注意这里的do catch。try放在你觉得可以会抛出异常的地方。比如:

 do {
        let originalRequest = try urlRequest.asURLRequest()
        
       ...
       
        return request
    } catch {
        return request(failedWith: error)
    }

4.方法第一的层次关系，一个基本方法参数带有默认值，同类型的在此基础上减少参数。

下载请求、上传请求、流式请求。

这部分代码和上面的数据请求方式及代码组织方式一样，所以没必要在说一次了。

重试

重试的部分比较简单，将请求（request）传进来。然后取出任务，重新给任务传递所需要的参数，拼装好之后开始任务。具体代码如下：

func retry(_ request: Request) -> Bool {
        guard let originalTask = request.originalTask else { return false }

        do {
            let task = try originalTask.task(session: session, adapter: adapter, queue: queue)

            request.delegate.task = task // resets all task delegate data

            request.startTime = CFAbsoluteTimeGetCurrent()
            request.endTime = nil

            task.resume()

            return true
        } catch {
            request.delegate.error = error
            return false
        }
    }

Suammary

这部分比较多，简单总结下，大致可以学到如下知识点。

1.枚举传递参数，如果在代码中调用。网络请求中，以后就可以直接传递枚举作为返回结果，并且包含了请求结果
2.属性定义及相关概念，静态属性，实例属性，计算属性，存储属性等，及快速返回值的写法。
3.初始化方法几种形式，注意走完初始化方法之后所有属性必须有值
4.方法的参数形式，什么内部外部参数，参数默认值。
5.闭包使用方式，如何防止循环引用。
6.如何进行异常捕获。

参考

站在OC的基础上快速理解Swift的类与结构体

Swift静态属性