ios - 链接依赖的API调用

Question

我正在尝试链接两个API请求。一个用于生成新 token ，另一个用于获取元素列表(一个需要有效 token )。

这些方法的调用如下所示:

    AuthService.shared().authenticate() { result in
        DispatchQueue.main.async {
            switch result {
               case .failure (let error):
                    // error processing
                    self.alertError(errorTitle: "", errorText: NSLocalizedString("Error generating token", comment: "Signup"))
               case .success (let result):
                    self.alertError(errorTitle: "", errorText: NSLocalizedString("Token collected \(result)", comment: "Signup"))
            }
        }
    }

    ListService.shared().listAll() { result in
        DispatchQueue.main.async {
            switch result {
               case .failure (let error):
                    // error processing
                    self.alertError(errorTitle: "", errorText: NSLocalizedString("Error fetching list", comment: "List"))
               case .success (let result):
                    self.alertError(errorTitle: "", errorText: NSLocalizedString("List fetched \(result)", comment: "List"))
            }
        }
    }

我想做的是尝试调用 ListService.shared().listAll()，如果失败并显示错误，我想调用 AuthService.shared().authenticate()，然后再次调用 ListService.shared().listAll()。

您认为这是个好方法吗？

Answer 1

混乱的方式-只需按照您指定的顺序将所有3个调用嵌套在一起即可:

ListService.shared().listAll() { result in
    switch result {
    case .failure (let error):
        // error processing
        DispatchQueue.main.async {
            self.alertError(errorTitle: "", errorText: NSLocalizedString("Error fetching list", comment: "List"))
        }

        AuthService.shared().authenticate() { result in
            switch result {
            case .failure (let error):
                DispatchQueue.main.async {
                    // error processing
                    self.alertError(errorTitle: "", errorText: NSLocalizedString("Error generating token", comment: "Signup"))
                }
            case .success (let result):
                DispatchQueue.main.async {
                    self.alertError(errorTitle: "", errorText: NSLocalizedString("Token collected \(result)", comment: "Signup"))
                }

                ListService.shared().listAll() { result in
                    DispatchQueue.main.async {
                        switch result {
                        case .failure (let error):
                            // error processing
                            self.alertError(errorTitle: "", errorText: NSLocalizedString("Error fetching list", comment: "List"))
                        case .success (let result):
                            self.alertError(errorTitle: "", errorText: NSLocalizedString("List fetched \(result)", comment: "List"))
                        }
                    }
                }
            }
        }

    case .success (let result):
        self.alertError(errorTitle: "", errorText: NSLocalizedString("List fetched \(result)", comment: "List"))
    }
}

始终尝试首先进行身份验证-这可能会导致不必要的身份验证调用，但将使您免于嵌套太多代码，并且比第一次失败的listAll()方法的最坏情况更好，因为它总共导致3个API调用(再次listAll()，authenticate()，listAll())

AuthService.shared().authenticate() { result in
    DispatchQueue.main.async {
        switch result {
        case .failure (let error):
            // error processing
            self.alertError(errorTitle: "", errorText: NSLocalizedString("Error generating token", comment: "Signup"))
        case .success (let result):
            self.alertError(errorTitle: "", errorText: NSLocalizedString("Token collected \(result)", comment: "Signup"))

            ListService.shared().listAll() { result in
                DispatchQueue.main.async {
                    switch result {
                    case .failure (let error):
                        // error processing
                        self.alertError(errorTitle: "", errorText: NSLocalizedString("Error fetching list", comment: "List"))
                    case .success (let result):
                        self.alertError(errorTitle: "", errorText: NSLocalizedString("List fetched \(result)", comment: "List"))
                    }
                }
            }
        }
    }
}

更新您的authenticate()方法以将 token 存储在本地，并在访问API之前检查其是否存在。然后更新您的listAll()方法，使其始终始终先调用authenticate()。假设您的 token 可用于多个API调用，两次调用之间不会过期，等等:

    class AuthService {
        private var token: String?

        static func shared() -> AuthService {
            return AuthService()
        }

        func authenticate(completion: @escaping (Result<String, Error>) -> Void) {
            if let token = token { 
                completion(.success(token))
                return
            }

            // Make your API call here and store the token when it completes
        }
    }

    class ListService {
        static func shared() -> ListService {
            return ListService()
        }

        func listAll(completion: @escaping (Result<Any, Error>) -> Void) {
            AuthService.shared().authenticate() { authResult in
                switch authResult {
                    case .failure (let error):
                        completion(.failure(error))
                    case .success (let token): 
                    // Make your list API call here
                }
            }
        }
    }

现在，您可以像平常一样调用 listAll()方法，它将始终通过身份验证:

    ListService.shared().listAll() { result in
        DispatchQueue.main.async {
            switch result {
            case .failure (let error):
                // error processing
                self.alertError(errorTitle: "", errorText: NSLocalizedString("Error fetching list", comment: "List"))
            case .success (let result):
                self.alertError(errorTitle: "", errorText: NSLocalizedString("List fetched \(result)", comment: "List"))
            }
        }
    }