建议先看跟着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.如何进行异常捕获。
网友评论