使用RxSwift怎么實現網絡請求

今天就跟大家聊聊有關使用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<T: BaseMappable>(_ type: T.Type, context: MapContext? = nil) throws -> T {
    guard let object = Mapper<T>(context: context).map(JSONObject: try mapJSON()) else {
      throw MoyaError.jsonMapping(self)
    }
    return object
  }
  
  func mapObjectArray<T: BaseMappable>(_ type: T.Type, context: MapContext? = nil) throws -> [T] {
    guard let array = try mapJSON() as? [[String : Any]] else {
      throw MoyaError.jsonMapping(self)
    }
    return Mapper<T>(context: context).mapArray(JSONArray: array)
  }
}

// MARK: - Json -> Observable<Model>

extension ObservableType where E == Response {
  // 將Json解析為Observable<Model>
  public func mapObjectModel<T: BaseMappable>(_ type: T.Type) -> Observable<T> {
    return flatMap { response -> Observable<T> in
      return Observable.just(try response.mapObjectModel(T.self))
    }
  }
  // 將Json解析為Observable<[Model]>
  public func mapObjectArray<T: BaseMappable>(_ 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<T: HandyJSON>(_ type: T.Type) -> Observable<T> {
    return flatMap { response -> Observable<T> in
      return Observable.just(response.mapHandyJsonModel(T.self))
    }
  }
}

extension Response {
  func mapHandyJsonModel<T: HandyJSON>(_ type: T.Type) -> T {
    let jsonString = String.init(data: data, encoding: .utf8)
    if let modelT = JSONDeserializer<T>.deserializeFrom(json: jsonString) {
      return modelT
    }
    return JSONDeserializer<T>.deserializeFrom(json: "{\"msg\":\"請求有誤\"}")!
  }
}

4.在MainClassViewModel中，使用已經封裝好的接口進行網絡請求，代碼如下:

import RxSwift
import Moya
import ObjectMapper
import HandyJSON
import RxCocoa

class MainClassViewModel {

  private let provider = MoyaProvider<APIService>()
  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怎么實現網絡請求有進一步的了解嗎？如果還想了解更多知識或者相關內容，請關注億速云行業資訊頻道，感謝大家的支持。