web-dev-qa-db-fra.com

comment utiliser Alamofire avec des en-têtes personnalisés

Je commence tout juste à jeter un coup d'œil à la merveilleuse nouvelle bibliothèque de réseaux Alamofire Swift de Mattt) de Mattt et je ne sais pas trop comment l'utiliser avec des en-têtes personnalisés.

Le code que je tente de convertir de AFNetworking à Alamofire est le suivant:

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

Selon la documentation officielle, il n'est pas recommandé de modifier la configuration de la session:

Ceci n'est pas recommandé pour les en-têtes d'autorisation ou de type de contenu. À la place, utilisez respectivement URLRequestConvertible et ParameterEncoding.

Ainsi, un exemple d'utilisation de URLRequestConvertible pour l'autorisation serait:

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
    }
}

et quand vous voulez faire une demande:

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

Plus d'infos sur URLRequestConvertible: https://github.com/Alamofire/Alamofire#urlrequestconvertible

Ancienne réponse

À partir d'Alamofire v1.0, la réponse ne fonctionne plus. Dans la nouvelle version, des en-têtes supplémentaires doivent être ajoutés à la propriété HTTPAdditionalHeaders de NSURLSessionConfiguration.

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

Plus d'infos ici: https://github.com/Alamofire/Alamofire/issues/111

48
Nikola Lajic

Pour les en-têtes qui changent de requête en requête, vous pouvez les transmettre directement à la méthode de requête. De les docs :

L'ajout d'un en-tête HTTP personnalisé à une demande est pris en charge directement dans la méthode de demande globale. Cela facilite l'attachement des en-têtes HTTP à une demande qui peut changer constamment.

Et l'exemple donné:

    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)
             }

Si, toutefois, vous souhaitez définir des en-têtes qui ne changent pas, il est recommandé de le faire sur l'objet NSURLConfiguration, comme d'autres l'ont mentionné ici.

35
kcstricks

A cette époque, Swift 3.0, Xcode 8.x, Alamofire 4.x:

Vous pouvez utiliser un en-tête personnalisé comme ci-dessous:

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

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

Pour référence

28
Nhat Dinh

Parce que je n'aime pas placer ces choses globalement (et parfois je les envoie, parfois non), j'ai écrit une méthode d'emballage pour définir les en-têtes à chaque appel.

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)
    }
}

On peut l'appeler comme suit ...

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*/

Il pourrait certainement être nettoyé avec une vérification d'erreur, mais cela devrait vous en donner l'essentiel. Tout est basé sur Alamofire 1.2.

5
Travis

NOTE : c'était avant la 1.0. Cela ne fonctionne plus, regardez plutôt la réponse acceptée.

Vous utilisez la propriété defaultHeaders sur le singleton Manager pour ajouter des en-têtes, comme ceci:

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

Au moins ça marche pour moi. :)

5
Per Ejeklint

Le réglage sous le code ne fonctionne que sous iOS 8 et supérieur.

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

Vous trouverez ci-dessous le code complet qui fonctionne pour iOS 7 et 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 }

Plus d'infos: GitHub - Alamofire Issues

3
San

J'ai créé une méthode d'en-tête statique dans une classe APIManager séparée.

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
    }
}

Et je l'utilise dans les requêtes:

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

Vous pouvez passer un objet NSMutableURLRequest directement à Alamofire, car il possède une extension pour NSMutableURLRequest qui adopte URLRequestConvertible. Il n'est donc pas nécessaire de créer votre propre classe pour simplement ajouter un en-tête d'autorisation. C'est aussi simple que ça:

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

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

Alamofire 4.x, XCode 9.1, Swift 4.x

Lorsque les en-têtes posent un problème lors de l'envoi de la requête, nous devons encoder le paramètre. Pour ce faire, JSONEncoding.prettyPrinted ou JSONEncoding.default comme:

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
 }
3
Pankaj Nigam
   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) ")
            }
    }
2
Saumil Shah