Moya 刷新Token

时间  2019-11-15
标签 moya 刷新 token 繁體版
原文   原文链接

应用场景,需求：

调用接口A，若是token过时，那么就调用能够刷新token的接口B，从新获取token。获取到新的token之后自动调用接口A，完成接口A的请求。 本文用两种方法实现。json

实现方法一

思路：

建立一个MoyaProvider 的子类，重写init的初始化方法，在初始化方法里判断statusCode为401的时候，去调用刷新token的B接口，B接口获取到token之后再调用A接口swift

实现

import Moya
import SwiftyJSON

class RefreshbleMoyaProvider<T: TargetType>: MoyaProvider<T>{
    
    // 重写MoyaProvider的初始化方法，在初始化方法里作相应的判断
    @discardableResult
    open override func request(_ target: T,
                               callbackQueue: DispatchQueue? = .none,
                               progress: ProgressBlock? = .none,
                               completion: @escaping Completion) -> Cancellable {
        
        return super.request(target, callbackQueue: callbackQueue, progress: progress, completion: { response in
            print(response,"3")
            switch response {
            case .success(let result):
            do {
                // 若是调用原来的接口直接成功，没有401，没有token 过时，那就直接回调completion
                let res = try result.filterSuccessfulStatusAndRedirectCodes()
                print(res,"4")
                completion(response)
            } catch  {
                // 若是调用原来的接口返回401，token过时
                if result.statusCode >= 400 {
                    // 那就去刷新token
                    self.refreshTokenSyncRequest(success: {
                        // 刷新token成功之后，再次请求以前的接口
                        self.request(target, callbackQueue: callbackQueue, progress: progress) { (newResponse) in
                            completion(newResponse)
                        }
                    }, failure: {
                        // 会无限递归
                        //  completion(response)
                    })
                }
            }

            case .failure(_):
                // 若是不是401，是请求超时啊，断网啊之类的错误，直接回调completion，不去刷新token
                completion(response)
            }
        })
    }
    
    // 刷新token的接口调用方法
    func refreshTokenSyncRequest(success: @escaping ()->(),failure: @escaping ()->()) {
        // 判断refreshToken 是否存在
        guard let refreshToken = UserDefaults.standard.string(forKey: refresh_token) else{
            // 直接登陆
            
            return
        }
       // 使用moya调用刷新token的接口（这个地方请实现你本身的刷新token的接口。其余地方都不用动）
        refreshProvider.request(.refreshToken(refreshToken: refreshToken)) { (response) in
           switch response {
           case .success(let result):
               print(result,"5")
               do {
                    // 获取token成功之后，存储token
                    let res = try result.filterSuccessfulStatusAndRedirectCodes()
                    let json = JSON(res.data)
                    UserDefaults.standard.set(json["data"]["access_token"].string, forKey: access_token)
                    UserDefaults.standard.set(json["data"]["refresh_token"].string, forKey: refresh_token)
                    UserDefaults.standard.set(json["data"]["user"].string, forKey: user)
                    UserDefaults.standard.set(json["data"]["jti"].string, forKey: jti)
                    UserDefaults.standard.set(json["data"]["token_type"].string, forKey: tokenType)
                    // 闭包回调成功
                    success()
               } catch  {
                    // 若是刷新token都失败了。。。那就登陆吧
                    if result.statusCode == 401 {
                        // 直接登陆
                    }
               }
           case .failure(let err):
                // 直接登陆
                SVProgressHUD.showError(withStatus: err.localizedDescription)
                print(err.localizedDescription,"6")
           }
        }
    }
}


复制代码

使用方法

let afterSaleProvider = RefreshbleMoyaProvider<TargetType>()api

和MoyaProvider的使用方法同样，只不过使用RefreshbleMoyaProvider来建立，TargetType是你本身建立的那个TargetType。而后就正常使用。bash

实现方法二

思路：

使用RxSwift+Moya,利用RxSwift的retryWhen来进行刷新token，而后再请求以前的接口。 主要思路来源于这里session

须要导入的库闭包

pod ‘Moya’, ’13.0.0’
 pod ‘SwiftyJSON’
 pod ‘RxSwift’,    ‘~> 4.0’
 pod ‘RxCocoa’,    ‘~> 4.0’
 pod ‘Moya/RxSwift’, ‘~> 13.0’
复制代码

实现

// 定义一个协议
public protocol SessionProtocol {
    // 刷新token的协议
    func getTokenRefreshService() -> Single<Response>
    // 获取token失败的协议
    func didFailedToRefreshToken()
    // token刷新成功的协议
    func tokenDidRefresh (response : JSON)
}


extension PrimitiveSequence where TraitType == SingleTrait, ElementType == Response {

    public func refreshAuthenticationTokenIfNeeded(sessionServiceDelegate : SessionProtocol) -> Single<Response> {
        
        return self.retryWhen { responseFromFirstRequest in
            
            
            responseFromFirstRequest.flatMap { originalRequestResponseError -> PrimitiveSequence<SingleTrait, ElementType> in
                
                
                if let lucidErrorOfOriginalRequest : MoyaError = originalRequestResponseError as? MoyaError {
                    // MoyaError是一个枚举
                    let moyaError = lucidErrorOfOriginalRequest
                    switch moyaError {
                        
                    case .statusCode(let res ):
                        //拿到Response
                        let response = res
                        print(response)
                        // 判断是否是401，token过时
                        if response.statusCode == 401 {
                            // token 过时，去请求新的token
                            // sessionServiceDelegate 代理的方法getTokenRefreshService 来获得刷新token的接口的请求客观察序列
                            return sessionServiceDelegate
                                .getTokenRefreshService()
                                // 对可观察序列进行筛选，筛选 statusCode 再200-399之间的请求结果
                                .filterSuccessfulStatusAndRedirectCodes()
                                .catchError { tokeRefreshRequestError -> Single<Response> in
                                    // 若是请求新的接口筛选失败
                                    if let lucidErrorOfTokenRefreshRequest : MoyaError = tokeRefreshRequestError as? MoyaError {
                                        
                                        // 这个时候只能从新登陆
                                        sessionServiceDelegate.didFailedToRefreshToken()
                                        // 并返回失败
                                        return Single.error(lucidErrorOfTokenRefreshRequest)
                                    }
                                    // 返回失败
                                    return Single.error(tokeRefreshRequestError)
                                }
                                .flatMap { tokenRefreshResponse -> Single<Response> in
                                    // 若是请求新的接口筛选成功 那么刷新token成功
                                    let result = tokenRefreshResponse
                                    
                                    let json = JSON(result.data)
                                    // 判断接口返回中的code是否是成功，若是成功
                                    if json[“code”] == “000000” {
                                        if json["data"].exists() {
                                            
                                            // 回调成功之后拿到的json，并在sessionServiceDelegate 协议的 tokenDidRefresh 方法中 保存这个新的token
                                            sessionServiceDelegate.tokenDidRefresh(response: json)
                                            //而后从新请求以前的接口
                                            return self.retry(1)
                                        }
                                    }else {
                                        // 若是code不成功，返回错误
                                        return Single.error(lucidErrorOfOriginalRequest)
                                    }
                                    // 返回错误，由于成功只有 json["code"] == "000000" 的时候
                                return Single.error(lucidErrorOfOriginalRequest)
                            }
                        }
                    default:
                        // 其余不为401的时候  返回错误，
                        return Single.error(lucidErrorOfOriginalRequest)
                    }
                }
                
                // 若是第一个接口返回的错误 没法解析，那就返回失败，不须要刷新token
                return Single.error(originalRequestResponseError)
            }
            
        }

    }
}



// MARK: - SwiftyJSON
extension ObservableType where E == Response {

    func mapSwiftyJSON(_ failsOnEmptyData: Bool = true) -> Observable<JSON> {
        return flatMap { response -> Observable<JSON> in
            return Observable.just(try JSON(response.mapJSON(failsOnEmptyData: failsOnEmptyData)))
        }
    }
}

// MARK: - SwiftyJSON
extension PrimitiveSequence where TraitType == SingleTrait, ElementType == Response {

    func mapSwiftyJSON(_ failsOnEmptyData: Bool = true) -> Single<JSON> {
        return flatMap { response -> Single<JSON> in
            return Single.just(try JSON(response.mapJSON(failsOnEmptyData: failsOnEmptyData)))
        }
    }
}




复制代码

使用

  1. 初始化一个provider let provider = MoyaProvider <TargetType>()ide

  2. 建立一个结构体，实现协议，经过provider实现接口的调用封装ui

// 建立一个结构体，遵循SessionProtocol 协议
struct Network: SessionProtocol {

    
    func getTokenRefreshService() -> Single<Response> {
			// 
        guard let refreshToken = UserDefaults.standard.string(forKey: refresh_token) else{
            return Single.just(Response.init(statusCode: 401, data: Data()))
        }
	// return 刷新token的rx方法
        return refreshProvider.rx.request(.refreshToken(refreshToken: refreshToken))
    }

    func didFailedToRefreshToken() {
        print(“didFailedToRefreshToken”)
			// 刷新token失败之后的操做，能够从新登陆
//        let vc = getCurrentController()
//
//        let loginVC = UIStoryboard(name: "Login", bundle: nil).instantiateViewController(withIdentifier: "LoginVC") as! LoginVC
//
//        vc?.present(loginVC, animated: true, completion: nil)
    }

    func tokenDidRefresh(response: JSON) {
        print(“tokenDidRefresh=========\n”,response)
			// 刷新成功之后存储token和 refresh_token
        UserDefaults.standard.set(response["data"]["access_token"].string, forKey: access_token)
        UserDefaults.standard.set(response["data"]["refresh_token"].string, forKey: refresh_token)

    }

// 定义一个request方法，封装实现接口的调用
    func request(
                    target: YNETCAfterSalesService,
                    success successCallback: @escaping (JSON) -> Void,
                    failure failureCallback: @escaping (MoyaError) -> Void) {
// 调用接口 provider 是定义的MoyaProvider
        let _ = provider.rx.request(target)
        .filterSuccessfulStatusAndRedirectCodes()
        .refreshAuthenticationTokenIfNeeded(sessionServiceDelegate: self)
        .mapSwiftyJSON(true)
        .subscribe { event in
            switch event {
            case .success(let res) :
               
                successCallback(res)
            case .error(let error):
                let err = error
                failureCallback(err as! MoyaError)
            }
        }
        
    }

}
复制代码
  1. 请求接口
Network().request(target: .getList, success: { (json) in
			// 此时的json是彻底成功以后的json，直接用来转为model，不用再去判断乱七八糟的成功失败
            print(json)
        }, failure: { (err) in
				// 此时的失败就是全部的失败的状况
            print(err)
        })
复制代码

以上就是实现的moya刷新token的所有接口，有时间会上传demo.spa

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程