Moya是在Alamofire基础上封装的网络请求库。
Alamofire提供了很多功能，但是开发者在调用上相对繁琐（或者说不够便捷）。Alamofire对Request、Response、Session等进行了抽象，Moya不仅对Request（TargetType）、Response进行抽象，而且多了MoyaProvider、Endpoint、Plugin、Stub的概念。
一. Moya的使用
Moya既可以提供网络请求，也可以提供虚拟数据。
// 提供者的初始化
public init(endpointClosure: @escaping EndpointClosure = MoyaProvider.defaultEndpointMapping,
requestClosure: @escaping RequestClosure = MoyaProvider.defaultRequestMapping,
stubClosure: @escaping StubClosure = MoyaProvider.neverStub,
callbackQueue: DispatchQueue? = nil,
manager: Manager = MoyaProvider<Target>.defaultAlamofireManager(),
plugins: [PluginType] = [],
trackInflights: Bool = false) {
self.endpointClosure = endpointClosure
self.requestClosure = requestClosure
self.stubClosure = stubClosure
self.manager = manager
self.plugins = plugins
self.trackInflights = trackInflights
self.callbackQueue = callbackQueue
}
从MoyaProvider的初始化可以看出，MoyaProvider有如下功能：
- 提供给外界创建EndPoint的闭包（让开发者自己转换Target→EndPoint），没有的话有默认闭包。
- 提供模拟数据的请求类型（无、马上、延迟）
- 提供校验URLRequest的闭包
- 持有插件数组
MoyaProvider充当的是一个管理者的作用，传入对应的Target（TargetType），获取到Result（枚举）。
gitHubProvider.request(.zen) { result in
if case let .success(response) = result {
let jsonString = try? response.mapString()
message = jsonString ?? message
}
self.showAlert("Zen", message: message)
}
TargetType是我们自己写的请求类，主要封装了一下功能：（把请求的不同点都封装在自己中）
- 请求主要的参数baseURL、Path、method，heads。
- 模拟数据。
- 任务类型（上传，下载）
- 验证类型（验证codes）
二. Moya的设计
我们在使用过程中，简单地说就是创建MoyaProvider和TargetType，MoyaProvider将TargetType作为参数去请求，获取到Result（同Alamofire）。
实际请求中我们经过这么一个步骤：
TargetType这个其实没什么好说的，就是对外模型的作用。MoyaProvider请求管理者，EndPoint端点这两个才是值得深究。
EndPoint的设计
EndPoint实际上是用来处理请求自身的。为了让TargetType更简单更纯粹，也为了让TargetType更安全。
EndPoint和TargetType一样封装了请求主要的参数url、method，heads。区别的是EndPoint封装了测试数据的模式（有无，马上或延迟），创建URLRequest。
另外，改变heads或task都是直接创建新的，所以EndPoint更为安全，不容易被外界所修改。这样也是不直接使用TargetType做完所有事情的目的，TargetType的所有东西都是只读，当我们需要修改时，通过暴露的钩子方法去修改EndPoint。
其中，比较特别的是，EndPoint的sampleResponseClosure属性，这是一个闭包() -> EndpointSampleResponse。为什么不直接用EndpointSampleResponse的属性呢？
以转换方法为例，使用闭包的好处就是可以将生成EndpointSampleResponse的方法放在闭包中。
// 端点映射方法 Target（相当于Request） → Endpoint
public final class func defaultEndpointMapping(for target: Target) -> Endpoint {
// 返回 Endpoint对象
return Endpoint(
url: URL(target: target).absoluteString,
sampleResponseClosure: { .networkResponse(200, target.sampleData) },
method: target.method,
task: target.task,
httpHeaderFields: target.headers
)
}
我们知道网络请求最终要调用AlamoRequest.resume()，所以EndPoint实际上影响了整个网络请求过程，因为它决定了URLRequest（AlamoRequest），也决定了请求数据（EndpointSampleResponse）。而TargetType替我们保存了请求的属性参数外，还保存了虚拟数据（sampleData），验证类型（validationType），所以TargetType一样重要。
当EndPoint生成URLRequest后，就完成了自己的使命，而TargetType可能得去回调sampleData，可能得去验证code。所以 Target → Endpoint后，并不是都在使用Endpoint进行工作。
MoyaProvider的设计
MoyaProvider是请求管理者，不同的MoyaProvider可以定制不一样的处理方式（对应不同的接口方式），当然我们大部分是对应同一类型的接口。
MoyaProvider<Target>会针对对应的Target:TargetType，同一种MoyaProvider可以用MultiTarget封装Target来达到一对多的目的。
以下MoyaProvider有几个属性是比较重要，也是比较难懂的。
// 通过外界传Endpoint
public let endpointClosure: EndpointClosure
// 通过外界处理Endpoint和Result
public let requestClosure: RequestClosure
// 通过外界返回StubBehavior
public let stubClosure: StubClosure
endpointClosure就是让外界自己定义TargetType怎么转换成Endpoint，如果不定义也有默认实现进行简单的转换。
requestClosure就是让外界根据EndPoint传入URLRequest。这边比较枯涩难懂，只需要把传来传去的performNetworking当做一个容器，去外面盛水进来“和面粉”就好了。
// 执行requestClosure，在外界可以获取到endpoint, performNetworking
// 这里的performNetworking会等外界传入Result后执行
// 实际上这一步是给外界机会来修改URLRequest
requestClosure(endpoint, performNetworking)
- stubClosure就是让外界通过TargetType定义测试数据的行为（有无，马上或延迟）
通过下面的初始化，我们可以看出Moya为那些所谓的钩子方法提供了默认实现。当我们需要改造我们自己的EndPoint，修改EndPoint生成URLRequest的方法，修改测试模式，甚至修改网络请求Manager时，可以通过MoyaProvider的初始化直接去改变。
// 提供者的初始化
public init(endpointClosure: @escaping EndpointClosure = MoyaProvider.defaultEndpointMapping,
requestClosure: @escaping RequestClosure = MoyaProvider.defaultRequestMapping,
stubClosure: @escaping StubClosure = MoyaProvider.neverStub,
callbackQueue: DispatchQueue? = nil,
manager: Manager = MoyaProvider<Target>.defaultAlamofireManager(),
plugins: [PluginType] = [],
trackInflights: Bool = false) {
self.endpointClosure = endpointClosure
self.requestClosure = requestClosure
self.stubClosure = stubClosure
self.manager = manager
self.plugins = plugins
self.trackInflights = trackInflights
self.callbackQueue = callbackQueue
}
MoyaProvider之所以能成为管理者，还有一个重要原因是他持有Manager（ Alamofire.SessionManager）。
简单的过程就是生成URLRequest，然后转换成Alamofire的Request，然后去response 、resume。
// 请求的底层方法
// T是泛型
func sendAlamofireRequest<T>(_ alamoRequest: T, target: Target, callbackQueue: DispatchQueue?, progress progressCompletion: Moya.ProgressBlock?, completion: @escaping Moya.Completion) -> CancellableToken where T: Requestable, T: Request {
// Give plugins the chance to alter the outgoing request
// 插件修改请求
let plugins = self.plugins
plugins.forEach { $0.willSend(alamoRequest, target: target) }
var progressAlamoRequest = alamoRequest
// 进程的代码块
let progressClosure: (Progress) -> Void = { progress in
let sendProgress: () -> Void = {
progressCompletion?(ProgressResponse(progress: progress))
}
// 在回调线程回调
if let callbackQueue = callbackQueue {
callbackQueue.async(execute: sendProgress)
} else {
sendProgress()
}
}
// Perform the actual request
if progressCompletion != nil {
switch progressAlamoRequest {
case let downloadRequest as DownloadRequest:
if let downloadRequest = downloadRequest.downloadProgress(closure: progressClosure) as? T {
progressAlamoRequest = downloadRequest
}
case let uploadRequest as UploadRequest:
if let uploadRequest = uploadRequest.uploadProgress(closure: progressClosure) as? T {
progressAlamoRequest = uploadRequest
}
case let dataRequest as DataRequest:
if let dataRequest = dataRequest.downloadProgress(closure: progressClosure) as? T {
progressAlamoRequest = dataRequest
}
default: break
}
}
// 完成的代码块
let completionHandler: RequestableCompletion = { response, request, data, error in
let result = convertResponseToResult(response, request: request, data: data, error: error)
// Inform all plugins about the response
plugins.forEach { $0.didReceive(result, target: target) }
if let progressCompletion = progressCompletion {
switch progressAlamoRequest {
case let downloadRequest as DownloadRequest:
progressCompletion(ProgressResponse(progress: downloadRequest.progress, response: result.value))
case let uploadRequest as UploadRequest:
progressCompletion(ProgressResponse(progress: uploadRequest.uploadProgress, response: result.value))
case let dataRequest as DataRequest:
progressCompletion(ProgressResponse(progress: dataRequest.progress, response: result.value))
default:
progressCompletion(ProgressResponse(response: result.value))
}
}
completion(result)
}
progressAlamoRequest = progressAlamoRequest.response(callbackQueue: callbackQueue, completionHandler: completionHandler)
progressAlamoRequest.resume()
return CancellableToken(request: progressAlamoRequest)
}
Plugin的设计
Plugin插件，这个概念在YTKNetworking也出现过。主要放在请求的各个阶段，用于插入外界的动作。
从插件协议上我们可看出它的几个重要时机（准备，即将网络请求，接收数据完成，数据接收中）
准备：这个阶段EndPoint已经生成URLRequest，我们可以通过插件来修改URLRequest和TargetType。
即将网络请求：这个阶段Alamofire已经通过URLRequest生成alamoRequest（RequestType），我们可以通过插件来修改alamoRequest和TargetType。
接收数据完成：这个阶段是在完成的回调中，我们已经将结果转换成Result。我们可以通过插件来修改Result。（这个时候修改TargetType也没啥意义吧）
数据接收中：（未完待续）
// 插件的协议，在各个时期执行的钩子
public protocol PluginType {
/// Called to modify a request before sending.
func prepare(_ request: URLRequest, target: TargetType) -> URLRequest
/// Called immediately before a request is sent over the network (or stubbed).
func willSend(_ request: RequestType, target: TargetType)
/// Called after a response has been received, but before the MoyaProvider has invoked its completion handler.
func didReceive(_ result: Result<Moya.Response, MoyaError>, target: TargetType)
/// Called to modify a result before completion.
// 处理的方法
func process(_ result: Result<Moya.Response, MoyaError>, target: TargetType) -> Result<Moya.Response, MoyaError>
}
