Alamofire进行OAuth2认证

本文使用的是Alamofire4 + PromisKit/Alamofire。

最后的成果代码如下

class STNet: RequestAdapter, RequestRetrier {
   
    typealias RefreshCompletion = (_ succeed: Bool) -> Void
    
    /// 用于刷新token
    private let tokenManager: SessionManager = {
        let configuration = URLSessionConfiguration.ephemeral
        configuration.httpAdditionalHeaders = SessionManager.defaultHTTPHeaders
        return SessionManager(configuration: configuration)
    }()
    lazy var tokenDelegate: Alamofire.SessionDelegate = tokenManager.delegate

    private let lock = NSLock()
    
    private var isRefreshing = false
    // 需要重连的请求
    private var requestsToRetry: [RequestRetryCompletion] = []
    
    /// 用于请求
    private lazy var sessionManager: SessionManager = {
        let configuration = URLSessionConfiguration.default
        configuration.httpAdditionalHeaders = SessionManager.defaultHTTPHeaders
        let sm = SessionManager(configuration: configuration)
        sm.adapter = self
        sm.retrier = self
        return sm
    }()
    lazy var sessionDelegate: Alamofire.SessionDelegate = sessionManager.delegate

    
    static let share = STNet()
    static let sessionManager = STNet().sessionManager
    
    init() {
        tokenDelegate.taskWillPerformHTTPRedirection = { session, task, response, request in
            let finalRequest = request
            
            // 如果是重定向到 http://www.senergychina.com.cn:15280/stjnhr-web/;JSESSIONID=  不允许
            if let urlString = request.url?.absoluteString,
                urlString.contains("http://www.senergychina.com.cn:15280/stjnhr-web/;JSESSIONID=") || urlString.contains("redirect_uri=http://senergychina.com.")
            {
                return nil
            }
            
            return finalRequest
        }
        // 请求过程中出现302，拦截
        sessionDelegate.taskWillPerformHTTPRedirection = { _, _, _, request in
            if let urlString = request.url?.absoluteString,
                urlString.contains("http://www.senergychina.com.cn:15280/stjnhr-web/;JSESSIONID=") || urlString.contains("redirect_uri=http://senergychina.com.")
            {
                return nil
            }
            return request
        }
        // 请求Manager设置请求适配器和请求重连
        sessionManager.adapter = self
        sessionManager.retrier = self
    }

    //  请求之前将cookie放到header中
    func adapt(_ urlRequest: URLRequest) throws -> URLRequest {
        var ur = urlRequest
        let cookie = Storage.share.readCookie()
        if cookie.count > 0 {
            ur.setValue(cookie, forHTTPHeaderField: "cookie")
        }
        return ur
    }
    
    // 如果接口返回Error，Alamofire会重连，重连的时候会调用该函数，我们可以在这里进行认证
    func should(_ manager: SessionManager, retry request: Request, with error: Error, completion: @escaping RequestRetryCompletion) {
        
        lock.lock() ; defer { lock.unlock() }
        
        if let response = request.task?.response as? HTTPURLResponse,
            response.statusCode == 401 || response.statusCode == 302 {
            requestsToRetry.append(completion)
            
            if !isRefreshing {
                refreshTokens { [weak self] succeeded in
                    guard let `self` = self else { return }
                    
                    self.lock.lock() ; defer { self.lock.unlock() }
                    self.requestsToRetry.forEach{ $0(succeeded, 0.0)}
                    self.requestsToRetry.removeAll()
                }
            }
        }
        else {
            completion(false, 0.0)
        }
    }
    
    // PromiseKit 串联请求
    func refreshTokens(completion: @escaping RefreshCompletion) {
        guard !isRefreshing else { return }
        isRefreshing = true

        tokenManager.request(firstPath, method: .get)
            .responseString()
            .then { res -> Promise<(string: String, response: PMKAlamofireDataResponse)> in
                let cookie = self.cookieFromResponse(response: res.response.response!)
                let header = ["cookie": cookie]
                return self.tokenManager.request(secondPath, method: .post, parameters: self.secondParam, headers: header).responseString()
            }
            .then { res -> Promise<(string: String, response: PMKAlamofireDataResponse)> in
                print(res.string)
                let thirdParam = ["code": res.string]
                return self.tokenManager.request(thirdPath, method: .get, parameters:thirdParam).responseString()
            }
            .done{ res in
                let cookie = self.cookieFromResponse(response: res.response.response!)
                Storage.share.saveCookie(cookie: cookie)
                completion(true)
            }
            .catch { error in
                completion(false)
                print(error)
        }
    }

    // 获取response的cookie
    private func cookieFromResponse(response: HTTPURLResponse) -> String {
        for (key, value) in response.allHeaderFields {
            if (key as! String) == "Set-Cookie" {
                let cookie = value as! String
                return cookie
            }
        }
        return ""
    }
    
    
}

-----正文

公司的OAuth2认证使用的是网页端的认证过程。
请求正式接口的时候，如果没有认证，默认直接重定向到登录界面。

认证过程如下：

请求http://www.senergychina.com.cn:15280/oauth-server/oauth!login.action?username=--&password=--"接口，获取该接口返回的cookie。如果账号密码正确，总会返回cookie
使用第一步拿到的cookie作为header，继续以post方式请求 http://www.senergychina.com.cn:15280/oauth-server/oauth!authorize2.action，这一步的参数为 [ "clientId": "---", "responseType": "code" ]，clientId对应子系统。这一步成功，会返回一个直接返回一个code。该code作为第三步的参数
使用第二步的code，构造参数["code": code] ,请求http://www.senergychina.com.cn:15280/stjnhr-web/oauth2-login，我们需要的是这一步返回的cookie，将这个cookie保存下来，作为正式请求的header中的cookie即可。这一步成功之后会重定向.

解决的困难

Alamofire请求完成以后，cookie存放在response.allHeaderFields里面。返回值response一般是通过封装的。使用response.response 获取HTTPURLResponse，然后再解析得到需要的cookie。

  private func cookieFromResponse(response: HTTPURLResponse) -> String {
        for (key, value) in response.allHeaderFields {
            if (key as! String) == "Set-Cookie" {
                let cookie = value as! String
                return cookie
            }
        }
        return ""
    }

重定向：认证过程最后一步会进行重定向，Alamofire默认会自动重定向，如果重定向后的接口返回200，那么该请求结果中的reponse就是重定向以后的response，而不是重定向之前的，所以，不能让它重定向！！
重定向的code是302。Alamofire的重定向的拦截在sessionManager的delegate中。可以自定义请求manager的代理，重写重定向回调的闭包。如果不需要重定向，直接返回nil，这时候请求的结果就是我们需要的了。

    // 定义用于刷新token的manager
    private let tokenManager: SessionManager = {
        let configuration = URLSessionConfiguration.ephemeral
        configuration.httpAdditionalHeaders = SessionManager.defaultHTTPHeaders
        return SessionManager(configuration: configuration)
    }()
    // 定义manager的代理
    lazy var tokenDelegate: Alamofire.SessionDelegate = tokenManager.delegate

    // 在init等方法中执行该回调
    tokenDelegate.taskWillPerformHTTPRedirection = { session, task, response, request in
            let finalRequest = request
            
            // 如果是重定向到  登录界面 不允许
            if let urlString = request.url?.absoluteString,
                urlString.contains("http://www.senergychina.com.cn:15280/stjnhr-web/;JSESSIONID=") || urlString.contains("redirect_uri=http://senergychina.com.")
            {
                return nil
            }
            
            return finalRequest
        }

请求串联：认证过程是串联着发送三个请求，所以如果能使用Promise或者Future，将会比在closure中直接写观感要好的多。幸好swift有PromiseKit库。使用PromiseKit串联请求看起来是这样的，下面代码也是认证的核心代码

     tokenManager.request(firstPath, method: .get)
        .responseString()
        .then { res -> Promise<(string: String, response: PMKAlamofireDataResponse)> in
            let cookie = self.cookieFromResponse(response: res.response.response!)
            let header = ["cookie": cookie]
            return self.tokenManager.request(secondPath, method: .post, parameters: self.secondParam, headers: header).responseString()
        }
        .then { res -> Promise<(string: String, response: PMKAlamofireDataResponse)> in
            print(res.string)
            let thirdParam = ["code": res.string]
            return self.tokenManager.request(thirdPath, method: .get, parameters:thirdParam).responseString()
        }
        .done{ res in
            let cookie = self.cookieFromResponse(response: res.response.response!)
            Storage.share.saveCookie(cookie: cookie)
            completion(true)
        }
        .catch { error in
            completion(false)
            print(error)
    }

认证的时机：只有在后台返回错误的时候才进行重新认证。如果后台直接返回400+的错误，那么就可以直接使用Alamofire4的重连机制来做。也就是Request Retrier (请求重连)。默认情况下，当接口返回Error的时候，会在设定的时间之后进行重连。要使用Retrier，遵循RequestRetrier协议，实现其方法即可。

public typealias RequestRetryCompletion = (_ shouldRetry: Bool, _ timeDelay: TimeInterval) -> Void

public protocol RequestRetrier {
    func should(_ manager: SessionManager, retry request: Request, with error: Error, completion: @escaping RequestRetryCompletion)
}

实际问题是：请求过程中，如果认证超时或者没有认证，后台会直接重定向到登录界面！！！不会进Error。所以问题的导向就变成了，怎么将302变成错误返回。
解决方法是Alamofire的validate方法:

    STNet.sessionManager.request(fourthPath, method: .get)
        .validate({ (request, response, _) -> Request.ValidationResult in
            if response.statusCode == 302 {
    //                    let error = Error()
                return .failure(AFError.invalidURL(url: request?.url ?? ""))
            }
            else {
                return .success
            }
        })
        .responseString(completionHandler: { (res) in
            print("请求结果：\(res)")
        }

当然，这里要配合tokenDelegate.taskWillPerformHTTPRedirection来做，禁止重定向之后，这里才能拦截到302。
把302当作错误处理后，Alamofire就会进重连，我们就可以在重连方法里，判断状态码是302的时候进行认证。

为正式请求增加Cookie的时机：
实际的每次请求都需要认证结果得到的cookie，所以最好是在每次请求之前，手动添加（因为我不确定，认证成功接口的cookie会被自动带入）。Alamofire4增加了Request Adapter (请求适配器)，

public protocol RequestAdapter {
    func adapt(_ urlRequest: URLRequest) throws -> URLRequest
}

它可以让每一个 SessionManager 生成的 Request 都在生成之前被解析并且按照规则适配. 一个使用适配器很典型的场景就是给请求添加一个 Authorization 的请求头。没有比在这个地方添加cookie更合适的了。

// 代码与本次认证无关...
class AccessTokenAdapter: RequestAdapter {
    private let accessToken: String

    init(accessToken: String) {
        self.accessToken = accessToken
    }

    func adapt(_ urlRequest: URLRequest) throws -> URLRequest {
        var urlRequest = urlRequest

        if urlRequest.urlString.hasPrefix("https://httpbin.org") {
            urlRequest.setValue("Bearer " + accessToken, forHTTPHeaderField: "Authorization")
        }

        return urlRequest
    }
}

let sessionManager = SessionManager()
sessionManager.adapter = AccessTokenAdapter(accessToken: "1234")

sessionManager.request("https://httpbin.org/get")

如果一个 Error 在适配过程中产生的话, 它会逐层抛出, 最后传递到 Request 的请求回调里.

---完毕

需要解决的问题大概就这么多，将所有的串联起来就能得到正确的认证，实际的脱敏代码在文章开头。

使用的时候是这样的：

      STNet.sessionManager.request(fourthPath, method: .get)
        .validate({ (request, response, _) -> Request.ValidationResult in
            if response.statusCode == 302 {
                //                    let error = Error()
                return .failure(AFError.invalidURL(url: request?.url ?? ""))
            }
            else {
                return .success
            }
        })
        .responseString(completionHandler: { (res) in
            print("请求结果：\(res)")
        })

em...应该还需要进一步封装下..

代码虽然没有dio那么清晰明了易操作，但是还算可以吧....

后来，这个东西刚研究完的时候，后台准备给移动端重写认证，使用accessToken和refeshToken来做认证....

参考文献： Alamofire的document，看不懂...所以看的这个

Alamofire进行OAuth2认证

-----正文

认证过程如下：

解决的困难

---完毕

你可能感兴趣的:(Alamofire进行OAuth2认证)