我如何使用 Alamofire Router 来组织 API 调用？ [swift/Alamofire 5]

Question

我正在尝试将我的 AF 请求 转换为 Router 结构以获得更清洁的项目。我收到以下错误：

Value of protocol type 'Any' cannot conform to 'Encodable'; only struct/enum/class types can conform to protocols.

请帮助我修复代码。谢谢！

我的 URL 将有一个 用户名 的占位符，密码将在 body 中发送。响应将是 Bool (success), username and bearer token。

下面是我的AF请求:

let username = usernameTextField.text
let password = passwordTextField.text
let loginParams = ["password":"\(password)"]

AF.request("https://example.com/users/\(username)/login", 
            method: .post, 
            parameters: loginParams, 
            encoder: JSONParameterEncoder.default, 
            headers: nil, interceptor: nil).response { response in

                switch response.result {
                case .success:
                    if let data = response.data {

                        do {
                            let userLogin = try JSONDecoder().decode(UsersLogin.self, from: data)

                            if userLogin.success == true {
                                defaults.set(username, forKey: "username")
                                defaults.set(password, forKey: "password")
                                defaults.set(userLogin.token, forKey: "token")
                                print("Successfully get token.")

                            } else {
                                //show alert
                                print("Failed to get token with incorrect login info.")
                            }
                        } catch {
                            print("Error: \(error)")
                        }
                    }

                case .failure(let error):
                    //show alert
                    print("Failed to get token.")
                    print(error.errorDescription as Any)
                }
            }

到目前为止，我有什么可以转换为 AF 路由器 结构：

import Foundation
import Alamofire

enum Router: URLRequestConvertible {
    case login(username: String, password: String)

    var method: HTTPMethod {
        switch self {
        case .login:
            return .post
        }
    }

    var path: String {
        switch self {
        case .login(let username):
            return "/users/\(username)/login"
        }
    }

    var parameters: Parameters? {
        switch self {
        case .login(let password):
            return ["password": password]

        }
    }

    // MARK: - URLRequestConvertible
    func asURLRequest() throws -> URLRequest {
        let url = try Constants.ProductionServer.baseURL.asURL()
        var request = URLRequest(url: url.appendingPathComponent(path))

        // HTTP Method
        request.httpMethod = method.rawValue

        // Common Headers
        request.setValue(ContentType.json.rawValue, forHTTPHeaderField: HTTPHeaderField.acceptType.rawValue)
        request.setValue(ContentType.json.rawValue, forHTTPHeaderField: HTTPHeaderField.contentType.rawValue)

        // Parameters
        switch self {
        case .login(let password):
            request = try JSONParameterEncoder().encode(parameters, into: request) //where I got the error
        }

        return request
    }
}

class APIClient {
        static func login(password: String, username: String, completion: @escaping (Result<UsersLogin, AFError>) -> Void) {
            AF.request(Router.login(username: username, password: password)).responseDecodable { (response: DataResponse<UsersLogin, AFError>) in
                completion(response.result)
            }
        }
    }

LoginViewController Class（我替换了 AF.request 代码）

APIClient.login(password: password, username: username) { result in
                    switch result {
                    case .success(let user):
                        print(user)
                    case .failure(let error):
                        print(error.localizedDescription)
                    }

可编码UsersLogin型号

struct UsersLogin: Codable {
    let success: Bool
    let username: String
    let token: String?

    enum CodingKeys: String, CodingKey {
        case success = "success"
        case username = "username"
        case token = "token"
    }
}

Answer 1

您不能将 Parameters 词典与 Encodable 类型一起使用，因为 [String: Encodable] 的词典不是 Encodable，如错误所述。我建议将 asURLRequest 过程的那一步移到一个单独的函数中，例如：

func encodeParameters(into request: inout URLRequest) {
    switch self {
    case let .login(parameters):
        request = try JSONParameterEncoder().encode(parameters, into: request)
    }
}

不幸的是，对于具有许多路由的路由器来说，这并不能很好地扩展，所以我通常将我的路由分解成小的枚举，并将我的参数移动到单独的类型中，这些类型与路由器结合产生 URLRequest .

Answer 2

花了我一段时间但终于修好了。我也清理了代码。

enum Router: URLRequestConvertible {
    case login([String: String], String) 

    var baseURL: URL {
        return URL(string: "https://example.com")!
    }

    var method: HTTPMethod {
        switch self {
        case .login:
            return .post
        }
    }

    var path: String {
        switch self {
        case .login(_, let username):
            return "/users/\(username)/login"
        }
    }

    func asURLRequest() throws -> URLRequest {
        print(path)
        let urlString = baseURL.appendingPathComponent(path).absoluteString.removingPercentEncoding!
        let url = URL(string: urlString)
        var request = URLRequest(url: url!)
        request.method = method

        switch self {
        case let .login(parameters, _):
            request = try JSONParameterEncoder().encode(parameters, into: request)
        }

        return request
    }
}

用法

let username = usernameTextField.text

AF.request(Router.login(["password": password], username)).responseDecodable(of: UsersLogin.self) { (response) in

   if let userLogin = response.value {
      switch userLogin.success {
      case true:
           print("Successfully get token.")
      case false:
           print("Failed to get token with incorrect login info.")
      }
   } else {
      print("Failed to get token.")
   }
}

Answer 3

我用这种方法解决了类似的问题。我创建了一个协议 Routable

enum EncodeMode {
    case encoding(parameterEncoding: ParameterEncoding, parameters: Parameters?)
    case encoder(parameterEncoder: ParameterEncoder, parameter: Encodable)
}

protocol Routeable: URLRequestConvertible {
    
    var baseURL: URL { get }
    var path: String { get }
    var method: HTTPMethod { get }
    var encodeMode: EncodeMode { get }
}

extension Routeable {
    
    // MARK: - URLRequestConvertible
    
    func asURLRequest() throws -> URLRequest {
        let url = baseURL.appendingPathComponent(path)
        var urlRequest: URLRequest
        
        switch encodeMode {
        case .encoding(let parameterEncoding, let parameters):
            urlRequest = try parameterEncoding.encode(URLRequest(url: url), with: parameters)
        case .encoder(let parameterEncoder, let parameter):
            urlRequest = URLRequest(url: url)
            urlRequest = try parameterEncoder.encode(AnyEncodable(parameter), into: urlRequest)
        }

        urlRequest.method = method
        return urlRequest
    }
}

我的路由器看起来像这个

enum WifiInterfacesRouter: Routeable {
    
    case listActive(installationId: Int16?)
    case insert(interface: WifiInterface)
    
    var encodeMode: EncodeMode {
        
        switch self {
        case .listActive(let installationId):
            guard let installationId = installationId else {
                return .encoding(parameterEncoding: URLEncoding.default, parameters: nil)
            }
            return .encoding(parameterEncoding: URLEncoding.default, parameters: ["idInstallation": installationId])
        case .insert(let interface):
            return .encoder(parameterEncoder: JSONParameterEncoder.default, parameter: interface)
        }
        
    }
    
    var baseURL: URL {
        return URL(string: "www.example.com/wifiInterfaces")!
    }
    
    var method: HTTPMethod {
        switch self {
        case .listActive: return .get
        case .insert: return .post
        }
    }
    
    var path: String {
        switch self {
        case .listActive: return "listActive"
        case .insert: return "manage"
        }
    }
}

解决构建错误

Protocol 'Encodable' as a type cannot conform to the protocol itself

我使用了有用的 AnyCodable 库。 Codable.

的类型擦除实现

我如何使用 Alamofire Router 来组织 API 调用？ [swift/Alamofire 5]

How can I use Alamofire Router to organize the API call? [swift/ Alamofire5]

url

router

urlrequest

swift

alamofire