Moya + RxSwift

Moya + RxSwift 最简单的使用方法是这样的:

1
2
3
4
5
6
7
8
9
10
11
provider = RxMoyaProvider<ApiService>()
provider.request(ApiService.Function("param")).subscribe { (event) -> Void in
switch event {
case .Next(let response):
// do something like refresh ui
case .Error(let error):
print(error)
default:
break
}
}

Object Mapper

结合 Object Mapper 可以很方便的将 Moya.Response 转换成对象输出。Moya 官方也给出了几个典型的 ObjectMapper Extension :

  • Moya-ObjectMapper - ObjectMapper bindings for Moya for easier JSON serialization
  • Moya-SwiftyJSONMapper - SwiftyJSON bindings for Moya for easier JSON serialization
  • Moya-Argo - Argo bindings for Moya for easier JSON serialization
  • Moya-ModelMapper - ModelMapper bindings for Moya for easier JSON serialization
  • Moya-Gloss - Gloss bindings for Moya for easier JSON serialization
  • Moya-JASON - JASON bindings for Moya for easier JSON serialization

然而前段开发遇到的接口往往是这样的:

1
2
3
4
5
6
7
8
9
{
"resultCode":200,
"resultMsg":"查询成功!",
"data":{
"city":"北京",
"temperature":"8℃~20℃",
"weather":"晴转霾"
}
}

或者这样的:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
{
"resultCode":200,
"resultMsg":"查询成功!",
"data":[
{
"city":"北京",
"temperature":"8℃~20℃",
"weather":"晴转霾"
},
{
"city":"南京",
"temperature":"12℃~21℃",
"weather":"晴"
}
]
}

也就是说,接口想要返回的业务数据外总是“包裹”了一层状态数据来标记这一次业务返回的成功、失败以及失败的原因。

那么,对 Moya.Response 做 map 处理后直接得到业务对象(也就是 “data” 下的数据,或为 object,或为 array) 岂不是更优雅?类似的问题在 Android 开放中有讨论过:

Retrofit + RxJava 业务状态重定向及分离

这篇文章就来讨论在 Moya + RxSwift 环境下如何实现这样的 mapper 数据分离

Moya + RxSwift + SwiftyJSON 业务状态重定向及分离

首先我们以聚合数据提供的电影票房查询接口为例:
对照 Moya Docs,很容易的建立以下 ApiService:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
let apiProvider = RxMoyaProvider<ApiService>()
enum ApiService {
case GetRank(area: String?)
}
extension ApiService: TargetType {
var baseURL: NSURL {return NSURL(string: "http://v.juhe.cn")!}
var path: String {
switch self {
case .GetRank(_):
return "/boxoffice/rank"
}
}
var method: Moya.Method {
return .GET
}
var parameters: [String: AnyObject]? {
switch self {
case .GetRank(let area):
return [
"area": nil == area ? "" : area!,
// 这里是我的测试 key,理论上是免费的,如果失效,请自行申请替换
// 接口详情地址: https://www.juhe.cn/docs/api/id/44
"key": "e8ec41002b1441dc9126d7bbf259b747"
]
}
}
var sampleData: NSData {
return "".dataUsingEncoding(NSUTF8StringEncoding)!
}
}

这里补充一点,如果想要在每一次请求的 header 或者 params 中插入一些公关参数(如 platform, sys_ver 和 uid 等等),可以通过自定义 Endpoint Closure 方式实现。类似于 Android Okhttp 中的 Network Intercepor:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
let headerFields: Dictionary<String, String> = [
"platform": "iOS",
"sys_ver": String(UIDevice.version())
]
let appendedParams: Dictionary<String, AnyObject> = [
"uid": "123456"
]
let endpointClosure = { (target: ApiService) -> Endpoint<ApiService> in
let url = target.baseURL.URLByAppendingPathComponent(target.path).absoluteString
return Endpoint(URL: url, sampleResponseClosure: {.NetworkResponse(200, target.sampleData)}, method: target.method, parameters: target.parameters)
.endpointByAddingParameters(appendedParams)
.endpointByAddingHTTPHeaderFields(headerFields)

然后 apiProvider 的初始化就是这样的:

1
let apiProvider = RxMoyaProvider<ApiService>(endpointClosure: endpointClosure)

更多的,我们还可以自定义 requestClosure, stubClosure, manager 和 plugins 来实现更多的需求。具体可参见 Moya Docs

好了,言归正传。

分析接口返回的 json 数据:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
{
"resultcode": "200",
"reason": "success",
"result": [
{
"rid": "1",
"name": "惊天魔盗团2",
"wk": "2016.6.20 - 2016.6.26(单位:万元)",
"wboxoffice": "28690",
"tboxoffice": "28690"
},
{
"rid": "2",
"name": "独立日:卷土重来",
"wk": "2016.6.20 - 2016.6.26(单位:万元)",
"wboxoffice": "23924",
"tboxoffice": "23924"
}
],
"error_code": 0
}

我们选用 SwiftyJSON 来 map json,创建一个 Protocol:

1
2
3
public protocol Mapable {
init?(jsonData:JSON)
}

建立 BoxofficeModel 模型:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
struct BoxofficeModel: Mapable {
let rid: String?
let name: String?
let wk: String?
let wboxoffice: String?
let tboxoffice: String?
init?(jsonData: JSON) {
self.rid = jsonData["rid"].string
self.name = jsonData["name"].string
self.wk = jsonData["wk"].string
self.wboxoffice = jsonData["wboxoffice"].string
self.tboxoffice = jsonData["tboxoffice"].string
}
}

下面就是关键点了,怎样分离业务并且 map to objectArray?Show me the code:

首先定义集中错误:

1
2
3
4
5
6
7
enum ORMError : ErrorType {
case ORMNoRepresentor
case ORMNotSuccessfulHTTP
case ORMNoData
case ORMCouldNotMakeObjectError
case ORMBizError(resultCode: Int?, resultMsg: String?)
}

其中 ORMBizError(resultCode: Int?, resultMsg: String?) 是业务错误, 是前台与后台约定好如果 resultCode == “200” 表示业务成功,可以去 data 中取数据。其他数值表示失败,resultMsg 告知失败原因,比如“认真失败”、“key 过期”等等。

接下里,我们对上面的 json 进行处理,既然是使用 RxSwift,map 处理可以是扩展 Observable 方法实现,这样可以在 Rx chain 中调用 map 方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
enum ORMError : ErrorType {
case ORMNoRepresentor
case ORMNotSuccessfulHTTP
case ORMNoData
case ORMCouldNotMakeObjectError
case ORMBizError(resultCode: String?, resultMsg: String?)
}
enum BizStatus: String {
case BizSuccess = "200"
case BizError
}
public protocol Mapable {
init?(jsonData:JSON)
}
let RESULT_CODE = "resultcode"
let RESULT_MSG = "reason"
let RESULT_DATA = "result"
extension Observable {
private func resultFromJSON<T: Mapable>(jsonData:JSON, classType: T.Type) -> T? {
return T(jsonData: jsonData)
}
func mapResponseToObjArray<T: Mapable>(type: T.Type) -> Observable<[T]> {
return map { response in
// get Moya.Response
guard let response = response as? Moya.Response else {
throw ORMError.ORMNoRepresentor
}
// check http status
guard ((200...209) ~= response.statusCode) else {
throw ORMError.ORMNotSuccessfulHTTP
}
// unwrap biz json shell
let json = JSON.init(data: response.data)
// check biz status
if let code = json[RESULT_CODE].string {
if code == BizStatus.BizSuccess.rawValue {
// bizSuccess -> wrap and return biz obj array
var objects = [T]()
let objectsArrays = json[RESULT_DATA].array
if let array = objectsArrays {
for object in array {
if let obj = self.resultFromJSON(object, classType:type) {
objects.append(obj)
}
}
return objects
} else {
throw ORMError.ORMNoData
}
} else {
throw ORMError.ORMBizError(resultCode: json[RESULT_CODE].string, resultMsg: json[RESULT_MSG].string)
}
} else {
throw ORMError.ORMCouldNotMakeObjectError
}
}
}
}

最后在业务层,调用就很方便了:

1
2
3
4
5
6
7
8
9
10
11
12
let disposeBag = DisposeBag()
apiProvider.request(ApiService.GetRank(area: "CN"))
.mapResponseToObjArray(BoxofficeModel)
.subscribe(
onNext: { boxofficeModelArray in
// do somethong like refresh ui
},
onError: { error in
print(error)
}
)
.addDisposableTo(disposeBag)

如果 json data 下的业务数据不是一个 array 而只是一个 object 怎么办呢?其实方法大同小异;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
func mapResponseToObj<T: Mapable>(type: T.Type) -> Observable<T?> {
return map { representor in
// get Moya.Response
guard let response = representor as? Moya.Response else {
throw ORMError.ORMNoRepresentor
}
// check http status
guard ((200...209) ~= response.statusCode) else {
throw ORMError.ORMNotSuccessfulHTTP
}
// unwrap biz json shell
let json = JSON.init(data: response.data)
// check biz status
if let code = json[RESULT_CODE].string {
if code == BizStatus.BizSuccess.rawValue {
// bizSuccess -> return biz obj
return self.resultFromJSON(json[RESULT_DATA], classType:type)
} else {
// bizError -> throw biz error
throw ORMError.ORMBizError(resultCode: json[RESULT_CODE].string, resultMsg: json[RESULT_MSG].string)
}
} else {
throw ORMError.ORMCouldNotMakeObjectError
}
}
}

好了,到这里任务算是完成了。

Demo

本文全部代码可运行示例已开源在 Github, 如果我讲的不够明白或者你有更好的解决方法,欢迎斧正、PR:
https://github.com/jkyeo/RxMoyaMapperDemo

Reference: Observable+Networking