Moya是一个基于 Alamofire 的更高层网络请求封装抽象层
一、cocoapods安装
Moya依赖 Alamofire 库
pod 'Moya', '~> 13.0'
# or
pod 'Moya/RxSwift', '~> 13.0'
# or
pod 'Moya/ReactiveSwift', '~> 13.0'
二、基本使用
注意：Moya中Provider对象在销毁的时候会去Cancel网络请求。为了得到正确的结果，你必须保证在网络请求的时候你的Provider不会被释放。否者你会得到下面的错误 “But don’t forget to keep a reference for it in property. If it gets deallocated you’ll see -999 “cancelled” error on response” 。通常为了避免这种情况，你可以将Provider实例设置为类成员变量，或者shared实例
1、定义一个 provider，即请求发起对象。往后我们如果要发起网络请求就使用这个 provider。
let ApiProvider = MoyaProvider<LCYApi>()
2、声明一个 enum 来对请求进行明确分类。
enum LCYApi {
case login(name: String, password: String)
}
3、让这个 enum 实现 TargetType 协议，在这里面定义我们各个请求的 url、参数、header 等信息。
extension LCYApi: TargetType {
var baseURL: URL {
return NSURL.init(string: "http://test.com")! as URL
}
var path: String {
switch self {
case .login:
return "/login"
}
}
var method: Method {
return .post
}
//这个是做单元测试模拟的数据，必须要实现，只在单元测试文件中有作用
var sampleData: Data {
return "".data(using: String.Encoding.utf8)!
}
var task: Task {
var parmeters: [String : Any] = [:]
switch self {
case .login(let name, let password):
parmeters["name"] = name
parameters["password"] = password
}
return .requestParameters(parameters: parmeters, encoding: URLEncoding.default)
}
//在请求头内添加公共请求参数，也可以通过自定义closure返回endpoint，在provider中添加
var headers: [String : String]? {
return ["Content-type": "application/json"]
}
}
4、调用
ApiProvider.request(LCYApi.login(name: "name", password: "password")) { result in
switch result {
case let .success(response):
let data = response.data
let statusCode = response.statusCode
break
case let .failure(error):
break
}
}
三、Providers
Providers是Moya中的核心，Moya中所有的API请求都是通过Provider来发起的。
Provider真正做的事情可以用一个流来表示：==Target -> Endpoint -> Request== 。
Provider的构造函数
provider构造
1、3个Closure
（1）endpointClosure（target -> endpoint）
EndpointClosure这个闭包，输入是一个Target，返回Endpoint
Moya提供一个默认EndpointClosure的函数，来实现这个Target到Endpoint的转换
//Moya.swift
public final class func DefaultEndpointMapping(target: Target) -> Endpoint<Target> {
let url = target.baseURL.URLByAppendingPathComponent(target.path).absoluteString
return Endpoint(URL: url, sampleResponseClosure: {.NetworkResponse(200, target.sampleData)}, method: target.method, parameters: target.parameters)
}
也可以自定义这个闭包来根据业务需求定制网络请求，比如：用stub模拟API请求失败的场景，给客户端返回一个非200的状态码
let endpointClosure = {(target: LBUApi) -> Endpoint in
let url = target.baseURL.appendingPathComponent(target.path).absoluteString
return Endpoint.init(url: url, sampleResponseClosure: {.networkResponse(200, target.sampleData)}, method: target.method, task: target.task, httpHeaderFields: nil)
}
let ApiProvider = MoyaProvider<LBUApi>(endpointClosure: endpointClosure)
（2）requestClosure（Endpoint -> NSURLRequest）
RequestClosure这个闭包就是实现将Endpoint -> NSURLRequest
默认实现
public final class func DefaultRequestMapping(endpoint: Endpoint<Target>, closure: NSURLRequest -> Void) {
return closure(endpoint.urlRequest)
}
自定义实现，可以在这里修改这个请求Request，比如设置超时时间
let timeoutClosure = {(endpoint: Endpoint, closure: MoyaProvider<LBUApi>.RequestResultClosure) -> Void in
if var urlRequest = try? endpoint.urlRequest() {
urlRequest.timeoutInterval = 20
closure(.success(urlRequest))
} else {
closure(.failure(MoyaError.requestMapping(endpoint.url)))
}
}
let ApiProvider = MoyaProvider<LBUApi>(endpointClosure: endpointClosure, requestClosure: timeoutClosure)
（3）stubClosure
StubClosure返回一个StubBehavior的枚举值，表示是否使用Stub返回数据或者怎样使用Stub返回数据
/*
这里的stub数据就是之前定义的sampleData
*/
public enum StubBehavior {
case Never //不使用Stub返回数据
case Immediate //立即使用Stub返回数据
case Delayed(seconds: NSTimeInterval) //一段时间间隔后使用Stub返回的数据
}
使用
let stubClosure = {(target: LBUApi) -> Moya.StubBehavior in
switch target {
case .searchHot:
return .immediate
default:
return .never
}
}
let ApiProvider = MoyaProvider<LBUApi>(stubClosure: stubClosure)
四、Plugins插件
-
Moya在初始化Provider的时候可以传入一些插件，Moya库中默认有4个插件。
1、AccessTokenPlugin 管理AccessToken的插件
（1）把 AccessTokenPlugin 添加到新建的的MoyaProvider中
let token: String = "tokenstring"
let accessTokenPlugin = AccessTokenPlugin { () -> String in
return token
}
let provider = MoyaProvider<YourAPI>(plugins: [accessTokenPlugin])
（2）TargetType 需要遵循AccessTokenAuthorizable 协议
extension YourAPI: TargetType, AccessTokenAuthorizable {
var authorizationType: AuthorizationType {
}
2、CredentialsPlugin 管理认证的插件
let credentualsPlugin = CredentialsPlugin { target -> URLCredential? in
switch target {
case .targetThatNeedsAuthentication:
return URLCredential(user: "user", password: "passwd", persistence: .none)
default:
return nil
}
}
3、NetworkActivityPlugin 管理网络状态的插件
let LoadingPlugin = NetworkActivityPlugin { (type, target) in
guard let vc = topVC else { return }
switch type {
case .began:
MBProgressHUD.hide(for: vc.view, animated: false)
MBProgressHUD.showAdded(to: vc.view, animated: true)
case .ended:
MBProgressHUD.hide(for: vc.view, animated: true)
}
}
4、NetworkLoggerPlugin 管理网络log的插件
直接NetworkLoggerPlugin()添加到provider中即可
5、自己也可以创建自定义插件
process方法不进去
解决：需要import Result
（1）、prepare：准备发起请求。我们可以在这里对请求进行修改，比如再增加一些额外的参数。
（2）、willSend：开始发起请求。我们可以在这里显示网络状态指示器。
（3）、didReceive：收到请求响应。可以在这里根据结果自动进行一些处理，比如请求失败时将失败信息告诉用户，或者记录到日志中。
（4）、process：处理请求结果。我们可以在 completion 前对结果进行进一步处理。
//自定义插件
class RequestAlertPlugin: PluginType {
private let vc: UIViewController
init(viewController: UIViewController) {
self.vc = viewController
}
func prepare(_ request: URLRequest, target: TargetType) -> URLRequest {
//可以在准备阶段设置超时时间
print("prepare")
var mRequest = request
mRequest.timeoutInterval = 60
return mRequest
}
func willSend(_ request: RequestType, target: TargetType) {
//do your things
//make sure we have a URL string to display
guard let requestURLString = request.request?.url?.absoluteString else { return }
}
func didReceive(_ result: Result<Response, MoyaError>, target: TargetType) {
//only continue if result is a failure
guard case Result.failure(_) = result else { return }
}
public func process(_ result: Result<Response, MoyaError>, target: TargetType) -> Result<Response, MoyaError> {
_ = result.map { (response) -> Response in
// 趁机添加相关数据
return response
}
return result
}
}
五、处理请求结果
我写了个MoyaProvider的扩展，添加了一个新的request方法，传model进去，返回解析好的数据
extension MoyaProvider {
/*
当有返回值的方法未得到接收和使用时通常会出现"Result of call to "getSome()" is unused"的提示
虽然不会报错，但是影响美观，加上@discardableResult就可以取消这种警告
*/
@discardableResult
/*
<T>泛型函数语法
<T: HandyJSON>在下面的方法的使用表示model这个参数的类型是HandyJSON类型或者继承自它的
*/
open func request<T: HandyJSON>(_ target: Target,
model: T.Type,
completion: ((_ returnData: T?) -> Void)?) -> Cancellable? {
return request(target, completion: { (result) in
guard completion != nil else { return }
/*
Moya 会将 Alamofire 成功或失败的响应包裹在 Result 枚举中返回
.success(Moya.Response)：成功的情况。我们可以从 Moya.Response 中得到返回数据（data）和状态（status ）
.failure(MoyaError)：失败的情况。这里的失败指的是服务器没有收到请求（例如可达性/连接性错误）或者没有发送响应（例如请求超时）。我们可以在这里设置个延迟请求，过段时间重新发送请求。
*/
switch result {
case let .success(response):
let statusCode = response.statusCode // 响应状态码：200, 401, 500...
let data = response.data // 响应数据
//继续做一些其它事情....
do {
//过滤成功的状态码响应
try response.filterSuccessfulStatusCodes()
let data = try response.mapJSON()
//继续做一些其它事情....
}
catch {
//处理错误状态码的响应...
}
case let .failure(error):
//错误处理....
//对于 .failure(error) 情况下，我们还可以通过 switch 语句判断具体的 MoyaError 错误类型：
switch error {
case .imageMapping(let response):
print("错误原因：\(error.errorDescription ?? "")")
print(response)
case .jsonMapping(let response):
print("错误原因：\(error.errorDescription ?? "")")
print(response)
case .statusCode(let response):
print("错误原因：\(error.errorDescription ?? "")")
print(response)
case .stringMapping(let response):
print("错误原因：\(error.errorDescription ?? "")")
print(response)
case .underlying(let error0, let response):
print("错误原因：\(error.errorDescription ?? "")")
print(error)
print(response as Any)
case .requestMapping:
print("错误原因：\(error.errorDescription ?? "")")
print("nil")
case .objectMapping(_, _):
print("错误原因：\(error.errorDescription ?? "")")
print("nil")
case .encodableMapping(_):
print("错误原因：\(error.errorDescription ?? "")")
print("nil")
case .parameterEncoding(_):
print("错误原因：\(error.errorDescription ?? "")")
print("nil")
}
break
}
guard let resultData = try? result.value?.mapModel(LCYResponseData<T>.self) else {
completion!(nil)
return
}
completion!(resultData.data?.returnData)
})
}
}
//对Response写了个扩展方法，方便解析model
extension Response {
func mapModel<T: HandyJSON>(_ type: T.Type) throws -> T {
let jsonString = String(data: data, encoding: .utf8)
guard let model = JSONDeserializer<T>.deserializeFrom(json: jsonString) else {
//json反序列化失败，抛出异常
throw MoyaError.jsonMapping(self)
}
return model
}
}
请求的时候
ApiProvider.request(. login(name: "123", password: "123"), model: LCYModel.self) { (returnData) in
}
网友评论