Swift中的网络请求库 Alamofire，相当于OC中的 AFNetworking，在使用的过程中，我们一般都会对Alamofire做进一步的封装，可是结果有时不太理想。
所以就引出了 Moya，它是一个网络抽象层，封装的比较充分，并且是直接调用Alamofire，借用一下Moya的图如下。
Moya
完成网络请求拿到JSON数据之后，通常都需要转模型，所以本文顺带介绍一下ObjectMapper的基本使用方法。
一、Moya的使用方法
1、创建网络层.swift文件
这里我创建了一个WHService.swift文件，并导入头文件import Moya
创建swift.文件
2、定义网络请求接口
实际上是定义一个枚举，枚举名就是每个网络请求API。
|
1
2
3
4
5
6
|
// 定义请求方法
enum WHService {
case
demo1
case
demo2(name:
String
)
case
demo3(name:
String
, score: Int)
}
|
3、扩展遵守协议，并实现协议方法
这一步我们创建一个扩展，并遵守TargetType协议，这个协议中有几个方法需要实现，具体意义看下面代码中的注释
|
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
|
extension WHService: TargetType {
// 请求服务器的根路径
var
baseURL: URL {
return
URL.init(string:
"https://httpbin.org"
)! }
// 每个API对应的具体路径
var
path:
String
{
switch
self {
case
.demo1:
return
"/get"
case
.demo2(name: _), .demo3(name: _, score: _):
return
"/post"
}
}
// 各个接口的请求方式，get或post
var
method: Moya.Method {
switch
self {
case
.demo1:
return
.
get
case
.demo2, .demo3:
return
.post
}
}
// 请求是否携带参数，如果需要参数，就做如demo2和demo3的设置
var
task: Task {
switch
self {
case
.demo1:
return
.requestPlain
// 无参数
case
let .demo2(name):
// 带有参数,注意前面的let
return
.requestParameters(parameters: [
"name"
: name], encoding: URLEncoding.
default
)
case
let .demo3(name, score):
// 带有参数,注意前面的let
return
.requestParameters(parameters: [
"name"
: name,
"score"
: score], encoding: URLEncoding.
default
)
}
}
// 单元测试使用
var
sampleData: Data {
switch
self {
case
.demo1, .demo3:
return
"just for test"
.utf8Encoded
case
.demo2(let name):
return
"{\"name\": \(name)\"}"
.utf8Encoded
}
}
// 请求头
var
headers: [
String
:
String
]? {
return
[
"Content-type"
:
"application/json"
]
}
}
|
4. 实现网络请求（推荐第5步的做法，可以忽略本条，直接查看第5步）
如下代码所示，首先创建一个MoyaProvider，并跟上，
然后直接调用request方法请求数据。
注意：request方法的参数就是上面定义的方法枚举，由此调用不同的API。达到了把网络请求封装到了WHService.swift中的需求。
|
1
2
3
4
5
6
7
8
9
10
11
12
|
let provider = MoyaProvider()
provider.request(.demo1) { (result)
in
switch
result {
case
let .success(moyaResponse):
let data = moyaResponse.data
// 获取到的数据
let statusCode = moyaResponse.statusCode
// 请求状态： 200, 401, 500, etc
case
let .failure(error):
print(error.localizedDescription)
}
}
|
5. 创建Network结构体实现网路请求
在WHService.swift中创建一个WHNetwork结构体，用单例创建MoyaProvider。
这样的好处是，可以在任何需要的地方通过WHNetwork调用任意API。
|
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
|
// 网络请求结构体
struct WHNetwork {
// 请求成功的回调
typealias successCallback = (_ result: Any) -> Void
// 请求失败的回调
typealias failureCallback = (_ error: MoyaError) -> Void
// 单例
static
let provider = MoyaProvider()
// 发送网络请求
static
func request(
target: WHService,
success: @escaping successCallback,
failure: @escaping failureCallback
) {
provider.request(target) { result
in
switch
result {
case
let .success(moyaResponse):
do
{
try
success(moyaResponse.mapJSON())
// 测试用JSON数据
}
catch
{
failure(MoyaError.jsonMapping(moyaResponse))
}
case
let .failure(error):
failure(error)
}
}
}
}
|
完成了WHService.swift中的工作之后，现在我们在ViewController.swift中进行网络访问，来看一下效果。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
override
func viewDidLoad() {
super
.viewDidLoad()
WHNetwork.request(target: .demo1, success: { (result)
in
whLog(result)
}) { (error)
in
whLog(error.localizedDescription)
}
WHNetwork.request(target: .demo2(name:
"wuhao"
), success: { (result)
in
whLog(result)
}) { (error)
in
whLog(error.localizedDescription)
}
WHNetwork.request(target: .demo3(name:
"wuhao"
, score:
100
), success: { (result)
in
whLog(result)
}) { (error)
in
whLog(error.localizedDescription)
}
|
显然比较简洁，并且用闭包的方式获取到需要的数据。
二、ObjectMapper的使用方法
1. 创建模型文件
2. 配置模型文件
首先来看一个网络请求拿到的数据
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
{
args = {
};
headers = {
Accept =
"*/*"
;
"Accept-Encoding"
=
"gzip;q=1.0, compress;q=0.5"
;
"Accept-Language"
=
"en;q=1.0"
;
Connection = close;
"Content-Type"
=
"application/json"
;
Host =
"httpbin.org"
;
"User-Agent"
=
"MoyaDemo/1.0 (com.wuhao.MoyaDemo; build:1; iOS 11.2.0) Alamofire/4.7.0"
;
};
origin =
"58.38.42.32"
;
url =
"https://httpbin.org/get"
;
}
|
下面开始写文件中的代码
创建几个需要的模型属性，导入ObjectMapper头文件，然后遵守Mappable协议，并实现两个协议方法。
func mapping(map: Map)方法就是映射属性，格式就是：属性名 -> map["数据中对应的名称"]。
如果想拿到上面数据中headers里的Host，运用点语法的方式就可以：map["headers.Host"]
完整的模型文件代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
import
UIKit
import
ObjectMapper
class
Internet: Mappable {
var
origin:
String
=
""
var
url:
String
=
""
var
Connection:
String
=
""
var
Host:
String
=
""
var
Agent:
String
=
""
required init?(map: Map) {
}
func mapping(map: Map) {
origin <- map[
"origin"
]
url <- map[
"url"
]
Connection <- map[
"headers.Connection"
]
Host <- map[
"headers.Host"
]
Agent <- map[
"headers.User-Agent"
]
}
}
|
3. 数据转模型
在网络请求拿到数据之后，可以直接进行转模型。
调用模型类的 Internet(JSON: [String : Any]) 方法实现转模型操作。
|
1
2
3
4
5
6
7
8
9
10
11
12
|
WHNetwork.request(target: .demo1, success: { (result)
in
// 字典转模型
guard let internet = Internet(JSON: (result
as
! [
String
: AnyObject]))
else
{
return
}
// 打印模型中值来验证是否成功
whLog(internet.origin)
whLog(internet.url)
whLog(internet.Connection)
whLog(internet.Host)
whLog(internet.Agent)
}) { (error)
in
whLog(error.localizedDescription)
}
|
运用ObjectMapper来转模型还是很好用的。
1866
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
