Swift 使用RX仅调用refreshtoken WS一次

在一个屏幕上，我用一个令牌调用了多个WS，当令牌过期时，调用一个名为refreshTokens的函数：

  func postItemImpersonation(parameters: [String: Any]?) -> Observable<(HTTPURLResponse, T)> {
    let absolutePath = Constants.URL.Impersonation.url
    let impersonationHeader: [String: String] = [
    "Content-Type": "application/json",
    "X-Api-Key": "xxxxxxx"
    ]
    return self.manager.rx.request(.post, absolutePath, parameters: parameters, encoding: JSONEncoding.default, headers: impersonationHeader)
        .responseJSON()
        .timeout(RxTimeInterval.seconds(self.timeOutValue), scheduler: scheduler)
        .observeOn(self.scheduler)
        .map({ response -> (HTTPURLResponse, T) in
            if response.response?.statusCode == 500 {
                throw Error_Code_Network.REST_KO_TECHNIQUE_ERROR
            }
            else if response.response?.statusCode == 204 {
                throw Error_Code_Network.REST_NO_CONTENT
            }else if response.response?.statusCode == 401 {
               
                throw TokenError.unauthorized
            }
            
            let object = Mapper<T>().map(JSONObject: response.value)
            if let object = object, let response = response.response {
                return (response, object)
            }
            throw Error_Code_Network.REST_KO_TECHNIQUE_ERROR
        })
        .retryWhen({ errorObservable in
            errorObservable.enumerated().flatMap({ ( index , error ) -> Observable<Void> in
                if let e = error as? TokenError, e == TokenError.unauthorized, index < self.maxRequestRetry {
                    return self.refreshTokens().asObservable()
                        .map({ succeded -> Void in
                            if succeded {
                                return Void()
                            } else {
                                SessionManager.GetInstance().forceDeconnexion.accept(true)
                                throw TokenError.expired
                            }
                        })
                }
                throw error
            })
        })
}

func postItemImpersonation（参数：[字符串：任意]？）->可观察{
设absolutePath=Constants.URL.Impersonation.URL
let impersonationHeader:[字符串：字符串]=[
“内容类型”：“应用程序/json”，
“X-Api-Key”：“xxxxxxx”
]
返回self.manager.rx.request（.post，absolutePath，参数：参数，编码：JSONEncoding.default，头：impersonationHeader）
.responseJSON（）
.timeout（rxtimeeval.seconds（self.timeOutValue），调度程序：调度程序）
.observeOn（self.scheduler）
.map（{response->（HTTPURLResponse，T）在
如果响应.response？.statusCode==500{
抛出错误\u代码\u网络。剩余\u KO\u技术\u错误
}
如果响应？响应？.statusCode==204，则为else{
抛出错误\u代码\u网络。剩余\u无\u内容
}否则如果响应.response？.statusCode==401{
抛出错误。未经授权
}
让object=Mapper（）.map（JSONObject:response.value）
如果let object=object，则let response=response.response{
返回（响应、对象）
}
抛出错误\u代码\u网络。剩余\u KO\u技术\u错误
})
.retryWhen（{errorobserved in
errorObservable.enumerated（）
如果让e=error作为？TokenError，e==TokenError.unauthorized，indexVoid in）
如果成功{
返回Void（）
}否则{
SessionManager.GetInstance（）.forceDeconnexion.accept（true）
抛出令牌错误。已过期
}
})
}
抛出错误
})
})
}

}

但当调用两个或多个ws并且令牌过期时，会多次调用refreshTokens，我希望只调用一次

---

我该怎么做呢？

我写了一篇文章详细介绍了这个问题的解决方案：

---

关键是创建一个跟踪当前令牌值的服务，并在必要时进行更新。

我写了一篇文章，详细介绍了这个问题的解决方案：

关键是创建一个跟踪当前令牌值并在必要时进行更新的服务