如何使用带有自定义标题的 Alamofire

Question

我刚刚开始了解 Mattt 的出色的新 Alamofire swift 网络库，但不太确定如何将它与自定义标头一起使用。

我试图从 AFNetworking 转换为 Alamofire 的代码是这样的：

let request = NSMutableURLRequest(URL: url)
request.setValue(authorizationToken, forHTTPHeaderField:"Authorization")

Answer 1

注意：这是 1.0 之前的版本。 它不再有效，请查看已接受的答案。

---

您使用 Manager 单例上的 defaultHeaders 属性来添加标题，如下所示：

Alamofire.Manager.sharedInstance.defaultHeaders.updateValue(authorizationToken, forKey: "Authorization")

至少它对我有用。 :)

Answer 2

根据官方文档，不建议修改会话配置：

不建议将其用于 Authorization 或 Content-Type 标头。 相反，使用 URLRequestConvertible 和 ParameterEncoding， 分别。

因此，URLRequestConvertible 用于授权的示例用法如下：

enum Router: URLRequestConvertible {
    static let baseUrlString = "some url string"

    case Get(query: String)

    var URLRequest: NSMutableURLRequest {
        let (path: String, parameters: [String: AnyObject]?) = {
            switch self {
            case .Get(let query):
                return ("/get", ["q": query])
            }
        }()

        let URL = NSURL(string: Router.baseUrlString)!
        let URLRequest = NSMutableURLRequest(URL: URL.URLByAppendingPathComponent(path))
        // set header fields
        URLRequest.setValue("a", forHTTPHeaderField: "Authorization")

        let encoding = Alamofire.ParameterEncoding.URL        
        return encoding.encode(URLRequest, parameters: parameters).0
    }
}

当你想提出请求时：

Manager.sharedInstance.request(Router.Get(query: "test"))

更多关于 URLRequestConvertible 的信息：https://github.com/Alamofire/Alamofire#urlrequestconvertible

旧答案

从 Alamofire v1.0 Pers 答案不再有效。在新版本中，应在NSURLSessionConfiguration 的HTTPAdditionalHeaders 属性中添加额外的标头

Alamofire.Manager.sharedInstance.session.configuration.HTTPAdditionalHeaders = ["Authorization": authorizationToken]

更多信息在这里：https://github.com/Alamofire/Alamofire/issues/111

Answer 3

设置以下代码仅适用于 iOS 8 及更高版本。

Alamofire.Manager.sharedInstance.session.configuration.HTTPAdditionalHeaders = headers

以下是适用于 iOS 7 和 iOS 8 的完整代码

let URL = NSURL(string: request.url!)
var mutableURLRequest = NSMutableURLRequest(URL: URL!)
mutableURLRequest.HTTPMethod = Alamofire.Method.GET.rawValue

// Adding headers
var defaultHeaders = Alamofire.Manager.sharedInstance.session.configuration.HTTPAdditionalHeaders ?? [:]
let configuration = NSURLSessionConfiguration.defaultSessionConfiguration()
configuration.HTTPAdditionalHeaders = defaultHeaders

// Adding parameters
let manager = Alamofire.Manager(configuration: configuration)
let urlReq  = ParameterEncoding.URL.encode(mutableURLRequest, parameters: request.params).0
aReq = manager.request(urlReq)
aReq!.responseJSON { (req, response, JSON, error) in }

更多信息：GitHub - Alamofire Issues

Answer 4

您可以将NSMutableURLRequest 对象直接传递给Alamofire，因为它具有NSMutableURLRequest 的扩展，采用URLRequestConvertible。因此，无需创建自己的类来添加 Authorization 标头。就这么简单：

let request = NSMutableURLRequest(URL: url)
request.setValue(authorizationToken, forHTTPHeaderField:"Authorization")

Alamofire.request(request)
    .responseJSON { (_, _, JSON, error) in }

Answer 5

因为我不喜欢全局设置这些东西（有时我发送它们，有时我不发送），所以我编写了一个包装方法来设置每次调用的标头。

import Alamofire

public class Service: NSObject {

    private class func request(method: Alamofire.Method, URLString: URLStringConvertible, parameters: [String : AnyObject]?, encoding: ParameterEncoding = .URL, headers: [String: String]? = nil) -> Request {

        let (request, error) = encoding.encode(NSURLRequest(URL: NSURL(string: URLString.URLString)!), parameters: parameters)
        let mutableURLRequest = request as! NSMutableURLRequest

        mutableURLRequest.HTTPMethod = method.rawValue

        if let heads = headers {
            for (field, value) in heads {
                mutableURLRequest.setValue(value, forHTTPHeaderField: field)
            }
        }

        return Alamofire.request(mutableURLRequest)
    }
}

可以如下调用...

Service.request(.POST, URLString: "http://httpbin.org/post", parameters: ["example-param": "example-param-value"], encoding: .JSON, headers: ["example-header-field": "example-value"])/*.whatever you want to do with it*/

它当然可以通过一些错误检查来清理，但这应该会给你它的要点。这一切都基于 Alamofire 1.2。

Answer 6

   let aManager = Manager.sharedInstance
    aManager.session.configuration.HTTPAdditionalHeaders = [
        "Authorization": "Some authentication Token here" ]


    let URL =  "some url string"

    request(.GET, URL, encoding: .JSON)
        .responseJSON {
            (request, response, data, error) -> Void in

            if(error != nil)
            {
                if let delegate = self.delegate {
                    delegate.connectionDidFinishedErrorResponceForAction!(1, andWithResponse: nil)
                }
                println("\(error!.localizedDescription)")

            }
            else {

                if let delegate = self.delegate {
                    delegate.connectionDidFinishedForAction!(1, andWithResponse: nil)
                }
               println("req:\(request) \n res:\(response) \n json:\(data!) \n \(error) ")
            }
    }

Answer 7

对于从请求到请求而变化的标头，您可以将它们直接传递给请求方法。来自the docs：

在全局请求方法中直接支持向请求添加自定义 HTTP 标头。这使得将 HTTP 标头附加到可以不断变化的请求上变得很容易。

给出的例子：

    let headers = [
        "Authorization": "Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==",
        "Content-Type": "application/x-www-form-urlencoded"
    ]

    Alamofire.request(.GET, "https://httpbin.org/get", headers: headers)
             .responseJSON { response in
                 debugPrint(response)
             }

但是，如果您希望设置不更改的标头，建议您在 NSURLConfiguration 对象上执行此操作，正如其他人在此处提到的那样。

Answer 8

此时，Swift 3.0、Xcode 8.x、Alamofire 4.x：

您可以使用如下自定义标题：

let headers: HTTPHeaders = [
    "Authorization": "Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==",
    "Accept": "application/json"
]

Alamofire.request("https://httpbin.org/headers", headers: headers).responseJSON { response in
    debugPrint(response)
}

对于reference

Answer 9

Alamofire 4.x、XCode 9.1、Swift 4.x

当 Headers 在请求中发送时出现问题时，我们需要对参数进行编码，为此我们执行 JSONEncoding.prettyPrinted 或 JSONEncoding.default 如下：

let url = "http:\your.url.string\"
let parameter = ["Username":"name", "Password":"123"]
let headers = ["Content-Type" : "application/json"]

Alamofire.request(url, method : .post, parameters : parameter, encoding : JSONEncoding.default , headers : headers).responseData { dataResponse in

     print(dataResponse.request as Any) // your request 
     print(dataResponse.response as Any) // your response
 }

Answer 10

我在单独的 APIManager 类中创建了一个静态标头方法。

import Foundation
import Alamofire

class APIManager {

    class func headers() -> HTTPHeaders {
        var headers: HTTPHeaders = [
            "Content-Type": "application/json",
            "Accept": "application/json"
        ]

        if let authToken = UserDefaults.standard.string(forKey: "auth_token") {
            headers["Authorization"] = "Token" + " " + authToken
        }

        return headers
    }
}

我在请求中使用它：

Alamofire.request(urlString,
                      method: .get,
                      headers:APIManager.headers())

Answer 11

对于 Alamofire 5：

let path = BaseServiceApi().baseUrl + "login"

let params = [
    "phone": "+92322222222",
    "password" : "123123123"
    ] as [String : Any]

let request = AF.request(path, method: .post, parameters: params, encoding: JSONEncoding.default, headers: APIManager.headers(), interceptor: nil)

request.responseDecodable(of: UserModel?.self) {(resposnse) in
    
    let user = resposnse.value
    print(user)
}

APIManger 标头类：

class APIManager
{
    class func headers() -> HTTPHeaders
    {
        let headers: HTTPHeaders = [
            "Content-Type": "application/json",
            "Accept": "application/json"
        ]
        
        return headers
    }
}