前段时间，公司项目重构，决定采用RxSwift，这是一个函数式响应编程的框架，我差不多也是提前学习了一点，然后就边学习边开始了，期间也是遇到了各种问题，还好项目也算是按时交付测试了。这篇文章主要是用来讲述RxSwift网络请求的用法。
RxSwift+Moya+ObjectMapper 网络请求与处理
Moya简单的介绍
Moya是一个基于Alamofire的Networking library，并且添加了对于ReactiveCocoa和RxSwift的接口支持。
Moya使用
1.首先需要通过枚举对请求进行明确分类
public enum XYJHomeRouter {
/// 刷新首页
case refreshHome(parameters: [String:Any])
/// 获取bannar
case getBannar(parameters: [String:Any])
}
2.让XYJHomeRouter枚举遵守TargetType协议,这个Target便是你网络请求相关行为的定义,也可以自定义协议,我们实现这些协议,也就相当于完成了网络请求需要的endpoint.
自定义的协议
public protocol XYJTargetType {
var isShow: Bool { get }
}
XYJHomeRouter的实现
extension XYJHomeRouter: TargetType,XYJTargetType {
public var baseURL: URL {
return URL(string: baseHostString)!
}
public var path: String {
switch self {
case .refreshHome:
return "yd/app/home"
case .getBannar:
return "yd/app/common/banners"
}
}
public var method: Moya.Method {
switch self {
case .refreshHome:
return .post
case .getBannar:
return .post
}
}
public var parameters: [String: Any]? {
switch self {
case .refreshHome(parameters: let dict):
return dict
case .getBannar(parameters: let dict):
return dict
}
}
public var parameterEncoding: ParameterEncoding {
return JSONEncoding.default
}
public var task: Task {
return .request
}
public var validate: Bool {
return false
}
//自己定义的协议实现,是否显示正在加载，有的接口在后台请求，不需要告诉用户
public var isShow: Bool {
switch self {
case .refreshHome:
return false
case .getBannar:
return false
}
}
3.在viewmodel中进行网络请求方法的封装
// 获取banner数据
func getBanner(paramaters: [String: Any]) -> Observable<XYJResultList<XYJBanner>> {
return XYJMoyaHttp<XYJHomeRouter>().sendRequest().request(.getBannar(parameters: paramaters)).mapObject(XYJResultList.self)
}
我们看下XYJMoyaHttp<XYJHomeRouter>()的实现
参数:
EndpointClosure:可以对请求参数做进一步的修改,如可以修改endpointByAddingParameters endpointByAddingHTTPHeaderFields等
RequestClosure:你可以在发送请求前，做点手脚.判断有无网络做气泡提示 ,修改超时时间，打印一些数据等
StubClosure:可以设置请求的延迟时间,可以当做模拟慢速网络
Manager:请求网络请求的方式。默认是Alamofire
[PluginType] :Moya提供了一个插件机制，使我们可以建立自己的插件类来做一些额外的事情。比如写Log，显示“菊花”等。抽离出Plugin层的目的,就是把和自己网络无关的行为抽离。避免各种业务揉在一起不利于扩展
public class XYJMoyaHttp<T:TargetType> {
func sendRequest() -> RxMoyaProvider<T> {
return RxMoyaProvider<T>.init(endpointClosure: endpointClosure ,requestClosure: requestClosure,stubClosure: stubClosure,plugins: [NetworkLoggerPlugin.init(verbose: true,responseDataFormatter: {JSONResponseDataFormatter($0)}),spinerPlugin,XYJMoyaResponseNetPlugin()])
}
func sendUploadMultipart() -> RxMoyaProvider<T> {
return RxMoyaProvider<T>.init(endpointClosure: endpointClosure ,requestClosure: requestClosure ,plugins: [NetworkLoggerPlugin.init(verbose: true,responseDataFormatter: {JSONResponseDataFormatter($0)}),spinerPlugin,XYJMoyaResponseNetPlugin()])
}
// MARK: - 设置请求头部信息
let endpointClosure = { (target: T) -> Endpoint<T> in
let url = target.baseURL.appendingPathComponent(target.path).absoluteString
let endpoint = Endpoint<T>(
url: url,
sampleResponseClosure: { .networkResponse(200, target.sampleData) },
method: target.method,
parameters: target.parameters,
parameterEncoding: target.parameterEncoding
)
//在这里设置你的HTTP头部信息
return endpoint.adding(newHTTPHeaderFields: [
:])
}
// 发请求之前判断是否有网络
let requestClosure = { (endpoint: Endpoint<T>, done: MoyaProvider.RequestResultClosure) in
if var request = endpoint.urlRequest {
if(XYJNetworkMonitor.shareInstance.hasNetwork()) {
done(Result.success(request))
} else {
done(Result.failure(MoyaError.requestMapping(noNetWorkTipsString)))
}
}
}
/// 单元测试代码
let stubClosure: (_ type: T) -> Moya.StubBehavior = { type1 in
return StubBehavior.never
}
}
/// 日志
///
/// - Parameter data: data数据
/// - Returns: Data数据类型
private func JSONResponseDataFormatter(_ data: Data) -> Data {
do {
let dataAsJSON = try JSONSerialization.jsonObject(with: data)
let prettyData = try JSONSerialization.data(withJSONObject: dataAsJSON, options: .prettyPrinted)
return prettyData
} catch {
return data // fallback to original data if it can't be serialized.
}
}
/// 指示灯的配置的初始化
let spinerPlugin = XYJNetworkActivityPlugin { state in
guard let currentView = XYJLogVC.instance.currentVC?.view else {
return
}
if state == .began {
XYJProgressHUD.hide(view: currentView)//失把指示灯关掉，再显示
XYJProgressHUD.showAdded(view: currentView)
} else {
XYJProgressHUD.hide(view: currentView)
}
}
class XYJLogVC {
var currentVC: UIViewController?
//声明一个单例对象
static let instance = XYJLogVC()
private init() {}
}
public protocol XYJTargetType {
var isShow: Bool { get }
}
网络请求reposne的处理插件
可以根据返回响应的状态码判断业务成功或者失败，还可以再这里进行某个特殊状态码的全局逻辑业务处理，比如某个状态码，要进行弹出登录处理等
/// reposne的处理(net)
public final class XYJMoyaResponseNetPlugin: PluginType {
/// 成功的状态码
let normalCode = ["0","0000"]
//// 修改response的值
public func process(_ result: Result<Moya.Response, MoyaError>, target: TargetType) -> Result<Moya.Response, MoyaError> {
var result = result
//JSONSerialization
if case .success(let response) = result {
let processedResponse = Response(statusCode: -1, data: response.data, request: response.request, response: response.response)
guard let json = try? JSONSerialization.jsonObject(with: response.data, options: .allowFragments) as? [String:Any] , let code = json?["code"] as? String else {
return .failure(.jsonMapping(processedResponse))
}
if( !normalCode.contains(code) ) { //业务失败
if code == "C0001" {
//清理缓存，弹出登录框的逻辑
}
result = .failure(.statusCode(processedResponse))
} else { //业务成功
let data = json?["data"]
if let jsonDatas = data as? Data {
guard let jsonData = try? JSONSerialization.data(withJSONObject: jsonDatas, options: []) else {
return .failure(.jsonMapping(processedResponse))
}
result = .success(Response(statusCode: -1, data: jsonData, request: response.request, response: response.response))
} else {
result = .success(Response(statusCode: -1, data: response.data, request: response.request, response: response.response))
}
}
}
return result
}
4.在控制器中进行调用
vm.getBanner(paramaters: paras as! [String : Any]).asObservable().subscribe(onNext: { (result) in
guard let bannars = result.data else {
return
}
self.vm.cacheBanner(datas: bannars)
self.bannerView.datas = bannars
}, onError: { (_) in
XYJLog(message: "获取bannar数据失败")
}).disposed(by: self.disposeBag)
JSON解析
我们可以单独新建一个文件，用来对Moya的Response和ObservableType进行扩展
extension Response {
// 这一个主要是将JSON解析为单个的Model
public func mapObject<T: BaseMappable>(_ type: T.Type) throws -> T {
guard let json = try? JSONSerialization.jsonObject(with: self.data, options: .allowFragments) as? [String:Any] else {
throw MoyaError.jsonMapping(self)
}
guard let object = Mapper<T>().map(JSONObject:json) else {
throw MoyaError.jsonMapping(self)
}
return object
}
// 这个主要是将JSON解析成多个Model并返回一个数组，不同的json格式写法不相同
public func mapArray<T: BaseMappable>(_ type: T.Type) throws -> [T] {
guard let json = try? JSONSerialization.jsonObject(with: self.data, options: .allowFragments) as? [String:Any] else {
throw MoyaError.jsonMapping(self)
}
guard let jsonDic = json?["data"] as? [[String: Any]] else {
throw MoyaError.jsonMapping(self)
}
guard let objects = Mapper<T>().mapArray(JSONArray: jsonDic) else {
throw MoyaError.jsonMapping(self)
}
return objects
}
}
extension ObservableType where E == Response {
// 这个是将JSON解析为Observable类型的Model
public func mapObject<T: BaseMappable>(_ type: T.Type) -> Observable<T> {
return flatMap { response -> Observable<T> in
return Observable.just(try response.mapObject(T.self))
}
}
// 这个是将JSON解析为Observable类型的[Model]
public func mapArray<T: BaseMappable>(_ type: T.Type) -> Observable<[T]> {
return flatMap { response -> Observable<[T]> in
return Observable.just(try response.mapArray(T.self))
}
}
ObjectMapper
ObjectMapper是用Swift语言实现对象和JSON相互转换的框架，自定义的model需要实现Mappable协议,ObjectMapper可以很好的处理泛型类型的数据，不过这个泛型需要实现Mappable协议，也可以处理好嵌套的数据结构
下面我们看下具体的使用
原始数据
{
"code": "0",
"data": {
"expected_credit": "0",
"noread_msg": "4",
"role_type": "1",
"total_credit": "0",
"nick_name": "哦哦哦",
"wait_bill": "1",
"total_bill": "6"
},
"message": "成功"
}
数据模型处理
/// 返回结果模型
//T为泛型，遵循Mappable协议
class XYJResult<T: Mappable>: Mappable {
var code: String?
var message: String?
var data: T?
required init?(map: Map) {
}
init() {
}
func mapping(map: Map) {
code <- map["code"]
message <- map["message"]
data <- map["data"]
}
}
import UIKit
import ObjectMapper
class XYJHomeModel: Mappable {
var nickName: String?
var noReadMsg: String?
var expectedCred: String?
var totalBill: String?
var totalCredit: String?
var waitBill: String?
var monthBill: String?
//必须要实现的方法
required init?(map: Map) {
}
//手动创建model时要写
init() {}
//建立映射关系--
func mapping(map: Map) {
nickName <- map["nick_name"]
noReadMsg <- map["noread_msg"]
expectedCred <- map["expected_credit"]
totalBill <- map["total_bill"]
totalCredit <- map["total_credit"]
monthBill <- map["month_bill"]
waitBill <- map["wait_bill"]
}
}
参考资料：
https://github.com/Hearst-DD/ObjectMapper
http://www.codertian.com/2017/02/04/iOS-Moya-RxSwift-better-networking/
网友评论