189 8069 5689
今天就跟大家聊聊有关使用RxSwift怎么实现网络请求，可能很多人都不太了解，为了让大家更加了解，小编给大家总结了以下内容，希望大家根据这篇文章可以有所收获。
为肇州等地区用户提供了全套网页设计制作服务，及肇州网站建设行业解决方案。主营业务为网站设计、成都做网站、肇州网站设计，以传统方式定制建设网站，并提供域名空间备案等一条龙服务，秉承以专业、用心的态度为用户提供真诚的服务。我们深信只要达到每一位用户的要求，就会得到认可，从而选择与我们长期合作。这样，我们也可以走得更远！
1.使用RxSwift相关库的版本
ObjectMapper (3.2.0)
HandyJSON (4.1.1)
Moya (11.0.2)
RxCocoa (4.2.0)
RxSwift (4.2.0)
2.在Swift语言中，我们使用Alamofire 作为网络库，moya 是对Alamofire 更抽象一层的封装，RxSwift把Moya封装后作为网络请求的接口，我们在使用的时候只需要实现 TargetType 协议就好，用一个例子来看下怎么使用：
import Foundation
import Moya
enum APIService{
case mainClassList
}
extension APIService:TargetType{
var baseURL: URL {
return URL(string:"http://cmsadmin.fotoable.net")!
}
var path: String {
switch self {
case .mainClassList:
return "/sandboxColor/category"
}
}
var method: Moya.Method {
switch self {
case .mainClassList:
return .get
}
}
var parameters: [String : Any]? {
switch self {
case .mainClassList:
return nil
}
}
var parameterEncoding: ParameterEncoding {
return URLEncoding.default
}
var sampleData: Data {
return "{}".data(using: String.Encoding.utf8)!
}
var task: Task {
return .requestPlain
}
var headers: [String : String]? {
return nil
}
}首先，我们定义了一个 枚举 APIService ，作用主要是在内部定义网络请求的接口，然后，就是对协议 TargetType进行扩展，我们一一解读下里面的参数
baseURL：网络请求的基本URL
path：用于匹配具体网络请求接口
method：网络请求方式，常用就是 get/post 两种
parameters：接口请求时要带的参数
parameterEncoding：参数编码方式(这里使用URL的默认方式)
sampleData：这里用于单元测试
task：执行网络请求的任务
validationType：是否执行Alamofire验证，默认值为false
headers：网络请求时需要的header，如果和后台没有特殊的验证处理，默认传nil 就可以
APIService 作为网络请求的统一接口,里面封装了网络请求所需的一些基本数据
3.在进行网络请求之前，需要做一些准备工作，把网络请求回的数据通过JSON 转化成 Model , 这里我们使用了两种方式进行转换（根据项目的情况，灵活选择使用），一种通过 ObjectMapper库进行转换，一种是通过 HandyJSON 库 进行转换 ，分别通过对 Response 类 扩展 ，以下是对这两种方式的封装
其一：使用 ObjectMapper库 把JSON 转换成 Model
import Foundation
import RxSwift
import Moya
import ObjectMapper
// MARK: - Json -> Model
extension Response {
func mapObjectModel(_ type: T.Type, context: MapContext? = nil) throws -> T {
guard let object = Mapper(context: context).map(JSONObject: try mapJSON()) else {
throw MoyaError.jsonMapping(self)
}
return object
}
func mapObjectArray(_ type: T.Type, context: MapContext? = nil) throws -> [T] {
guard let array = try mapJSON() as? [[String : Any]] else {
throw MoyaError.jsonMapping(self)
}
return Mapper(context: context).mapArray(JSONArray: array)
}
}
// MARK: - Json -> Observable
extension ObservableType where E == Response {
// 将Json解析为Observable
public func mapObjectModel(_ type: T.Type) -> Observable {
return flatMap { response -> Observable in
return Observable.just(try response.mapObjectModel(T.self))
}
}
// 将Json解析为Observable<[Model]>
public func mapObjectArray(_ type: T.Type) -> Observable<[T]> {
return flatMap { response -> Observable<[T]> in
return Observable.just(try response.mapObjectArray(T.self))
}
}
} 其二 : 使用 HandyJSON 库 把JSON 转化成 Model
import Foundation
import RxSwift
import Moya
import HandyJSON
extension ObservableType where E == Response {
public func mapHandyJsonModel(_ type: T.Type) -> Observable {
return flatMap { response -> Observable in
return Observable.just(response.mapHandyJsonModel(T.self))
}
}
}
extension Response {
func mapHandyJsonModel(_ type: T.Type) -> T {
let jsonString = String.init(data: data, encoding: .utf8)
if let modelT = JSONDeserializer.deserializeFrom(json: jsonString) {
return modelT
}
return JSONDeserializer.deserializeFrom(json: "{\"msg\":\"请求有误\"}")!
}
} 4.在MainClassViewModel中，使用已经封装好的接口进行网络请求，代码如下:
import RxSwift
import Moya
import ObjectMapper
import HandyJSON
import RxCocoa
class MainClassViewModel {
private let provider = MoyaProvider()
let disposeBag = DisposeBag()
var dataSource = BehaviorRelay<[MainClassModelMapObject_sub]>(value:[])
var networkError = BehaviorRelay(value: Error.self)
}
//MARK: -- 网络
extension MainClassViewModel {
//网络请求-- ObjectMapper
func getClassListWithMapObject(){
provider.rx.request(.mainClassList).asObservable().mapObjectModel(MainClassModelMapObject.self).subscribe({ [unowned self] (event) in
switch event {
case let .next(classModel):
print("ObjectMapper -- 加载网络成功")
self.dataSource.accept(classModel.data)
case let .error( error):
print("error:", error)
self.networkError.accept(error as! Error.Protocol)
case .completed: break
}
}).disposed(by: self.disposeBag)
}
//网络请求-- HandyJSON
func getClassListWithMapHandyJson(){
provider.rx.request(.mainClassList).asObservable().mapHandyJsonModel(MainClassModel.self).subscribe({ [unowned self] (event) in
switch event {
case let .next(classModel):
print("HandyJSON -- 加载网络成功")
case let .error( error):
print("error:", error)
self.networkError.accept(error as! Error.Protocol)
case .completed: break
}
}).disposed(by: self.disposeBag)
}
} 这里用了两种方式，分别对 mainClassList API 接口进行了网络请求，唯一不同的是，在得到到网络请求回来数据的时候，一个是使用 mapObjectModel 把JSON 转化成 Model ，一个是使用 mapHandyJsonModel 把 JSON转化成Model ，由于我们使用的是不同的库，把JSON 转化成 Model，这两种实现的方式还是有一些差别，下面是这两种 Model 的具体实现方式：
其一、实现协议 Mappable
import UIKit
import ObjectMapper
class MainClassModelMapObject: Mappable {
var code:NSInteger?
var data:[MainClassModelMapObject_sub]!
required init?(map: Map) {}
func mapping(map: Map) {
code <- map["code"]
data <- map["data"]
}
}
class MainClassModelMapObject_sub: Mappable {
var ID:String?
var name:String?
var desc:String?
var imgUrl:String?
var gifUrl:String?
var isUpdate:Bool?
var backgroundGroup:NSInteger?
required init?(map: Map) {}
func mapping(map: Map) {
ID <- map["ID"]
name <- map["name"]
desc <- map["desc"]
imgUrl <- map["imgUrl"]
gifUrl <- map["gifUrl"]
isUpdate <- map["isUpdate"]
backgroundGroup <- map["backgroundGroup"]
}
}其二、实现协议 HandyJSON
import UIKit
import HandyJSON
struct MainClassModel: HandyJSON {
var code:NSInteger?
var data:[MainClassModel_sub]!
}
struct MainClassModel_sub: HandyJSON {
var ID:String?
var name:String?
var desc:String?
var imgUrl:String?
var gifUrl:String?
var isUpdate:Bool?
var backgroundGroup:NSInteger?
}5、以上是使用 RxSwift 进行网络请求的分析，接下来看一个示例如何使用，在MainClassViewModel 中我们使用 dataSource 保存了网络请求回来的数据，我们要在 ViewController里 用tableview 把这个数据展示出来，需要提前把数据源和TableView进行绑定，以下是示例代码：
//cell
viewModel.dataSource.bind(to: tableView.rx.items) { (tableView, row, element) in
let cell = tableView.dequeueReusableCell(withIdentifier: "MainClassTableViewCell", for: IndexPath(row: row, section: 0)) as! MainClassTableViewCell
cell.setModel(model: element)
// configure cell
return cell
}
.disposed(by: disposeBag)看完上述内容，你们对使用RxSwift怎么实现网络请求有进一步的了解吗？如果还想了解更多知识或者相关内容，请关注创新互联行业资讯频道，感谢大家的支持。