[Swift 开发] async/await异步编程封装Alamofire

随着 iOS 开发的发展，异步编程已经成为日常开发的一项必备技能。在 iOS 中，最常见的异步编程方式是使用 Alamofire 框架。Alamofire 是一个强大的网络请求库，可以轻松实现异步编程。本文将介绍如何使用 async/await 封装 Alamofire，以实现更加优雅的异步编程。

首先，我们用Alamofire的URLRequestConvertible封装我们的数据
 

1.  
   import Alamofire
2.  
    
3.  
   enum Router: URLRequestConvertible {
4.  
    
5.  
   static let baseURLString = "https://jsonplaceholder.typicode.com"
6.  
    
7.  
   case getUserByPostID(postID: Int)
8.  
   case comments
9.  
   case getUserByID(userID: Int)
10.  
     
11.  
    var method: Alamofire.HTTPMethod {
12.  
    switch self {
13.  
    case .getUserByPostID:
14.  
    return .get
15.  
     
16.  
    case .comments:
17.  
    return .get
18.  
     
19.  
    case .getUserByID:
20.  
    return .post
21.  
    }
22.  
    }
23.  
     
24.  
    var path: String {
25.  
    switch self {
26.  
     
27.  
    case .comments:
28.  
    return "/comments"
29.  
     
30.  
    // get请求，参数拼接在URL上
31.  
    case .getUserByPostID(postID: let postId):
32.  
    return "/comments?postId=\(postId)"
33.  
     
34.  
    case .getUserByID:
35.  
    return "/posts"
36.  
    }
37.  
    }
38.  
     
39.  
    func asURLRequest() throws -> URLRequest {
40.  
    let url = URL(string: Router.baseURLString path)!
41.  
    var request = URLRequest(url: url)
42.  
    request.method = method
43.  
    request.timeoutInterval = 30 //15s超时
44.  
     
45.  
    switch self {
46.  
    case .comments:
47.  
    break
48.  
     
49.  
    case .getUserByPostID(postID: _):
50.  
    break
51.  
     
52.  
    //post 请求，参数加在这里
53.  
    case .getUserByID(userID: let userID):
54.  
    let para = ["userID": userID]
55.  
    request = try JSONParameterEncoder().encode(para, into: request)
56.  
    }
57.  
     
58.  
    return request
59.  
     
60.  
    }
61.  
    }

上面的函数实现了 Alamofire 的URLRequestConvertible协议。它将返回一个URLRequest 参数

1. 接下来，我们扩展一下Alamofire.DataRequest
2. 它提供了一种简单的方法来管理HTTP网络请求。它提供了基本的HTTP方法，如GET，PUT，POST，DELETE等，以及一些高级的网络功能，如请求超时，文件上传， 数据解析等
3. 我们把具体的网络请求业务代码，封装到一个函数中。这样代码看起来会很简洁

1.  
   extension Alamofire.DataRequest {
2.  
    
3.  
   func serializingDecodable<Value: Decodable>(_ type: Value.Type = Value.self) async throws -> Value {
4.  
   let result = await serializingData().result
5.  
   switch result {
6.  
   case .success(let data):
7.  
   do {
8.  
   return try JSONDecoder().decode(Value.self, from: data)
9.  
   } catch let error {
10.  
    throw error
11.  
    }
12.  
     
13.  
    case .failure(let error):
14.  
    throw error
15.  
    }
16.  
    }
17.  
    }

然后，我们封装一下逻辑层，模拟了3个网络请求，其中包括(无参get, 有参get，无参post )

1.  
   struct NetWork {
2.  
   static func getUserInfo() async throws -> [Todo] {
3.  
   let task = AF.request(Router.comments)
4.  
   return try await task.serializingDecodable([Todo].self)
5.  
   }
6.  
    
7.  
   static func getUserInfoByPostId(_ postID:Int) async throws -> [Todo] {
8.  
   let task = AF.request(Router.getUserByPostID(postID: postID))
9.  
   return try await task.serializingDecodable([Todo].self)
10.  
    }
11.  
     
12.  
    static func getUserInfoByID(_ userID:Int) async throws -> [String:Int] {
13.  
    let task = AF.request(Router.getUserByID(userID: userID))
14.  
    return try await task.serializingDecodable([String:Int].self)
15.  
    }
16.  
    }

最后，我们可以使用 async/await 封装的函数来获取网络数据：

1.  
   Task {
2.  
   do{
3.  
   let users1 = try await NetWork.getUserInfo()
4.  
   print("AllUsersCount: \(users1.count)")
5.  
    
6.  
   let users2 = try await NetWork.getUserInfoByPostId(3)
7.  
   print("UserInfoByPostIdCount: \(users2.count)")
8.  
    
9.  
   let users3 = try await NetWork.getUserInfoByID(1)
10.  
    print("UserInfoByID: \(users3)")
11.  
     
12.  
    }catch{
13.  
    print(error)
14.  
    }
15.  
    }
16.  
     
17.  
     
18.  
    // 打印结果：
19.  
    // AllUsersCount: 500
20.  
    // UserInfoByPostIdCount: 5
21.  
    // UserInfoByID: ["userID": 1, "id": 101]

总结一下，本文介绍了如何使用 async/await 封装 Alamofire，以实现更加优雅的异步网络请求。通过使用 async/await，可以使得网络请求变得更加简洁、优雅，让开发者更加轻松地实现异步编程。

这篇好文章是转载于：学新通技术网