alamofire swift 4 pod

Cómo usar Alamofire con encabezados personalizados.

Question

Estoy empezando a echar un vistazo a la nueva y maravillosa biblioteca de redes de Alamofire swift de Mattt y no estoy seguro de cómo se usaría con encabezados personalizados.

El código que estoy intentando convertir de AFNetworking a Alamofire es el siguiente:

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

Answer 1

Como no me gusta configurar estas cosas globalmente (y algunas veces las envío, a veces no), escribí un método de envoltorio para configurar los encabezados con cada llamada.

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

Puede ser llamado como sigue ...

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

Ciertamente, se podría limpiar con una comprobación de errores, pero esto debería darle una idea de ello. Todo está basado en Alamofire 1.2.

Answer 2

En este momento, Swift 3.0, Xcode 8.x, Alamofire 4.x:

Puede utilizar el encabezado personalizado de la siguiente manera:

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

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

Para reference

Answer 3

He creado un método de encabezados estáticos en una clase APIManager separada.

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

Y lo uso en peticiones:

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

Answer 4

La configuración del código siguiente solo funcionará en iOS 8 y superior.

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

A continuación se muestra el código completo que funciona para iOS 7 y 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 }

Más información: https://github.com/Alamofire/Alamofire/issues/111

Answer 5

Para los encabezados que cambian de solicitud a solicitud, puede pasarlos directamente al método de solicitud. De la documentación:

Agregar un encabezado HTTP personalizado a una Solicitud se admite directamente en el método de solicitud global. Esto facilita la asignación de encabezados HTTP a una solicitud que puede cambiar constantemente.

Y el ejemplo dado:

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

Sin embargo, si desea establecer encabezados que no cambien, se recomienda que lo haga en el objeto NSURLConfiguration, como otros han mencionado aquí.

Answer 6

Puede pasar un objeto NSMutableURLRequest directamente a Alamofire, ya que tiene una extensión para NSMutableURLRequest que adopta URLRequestConvertible . Por lo tanto, no es necesario crear su propia clase para simplemente agregar un encabezado de Autorización. Es tan simple como esto:

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

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

Answer 7

Según la documentación oficial, no se recomienda modificar la configuración de la sesión:

Esto no se recomienda para los encabezados de Autorización o Tipo de Contenido. En su lugar, use URLRequestConvertible y ParameterEncoding, respectivamente.

Por lo tanto, un ejemplo de uso de URLRequestConvertible para la autorización sería:

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

y cuando quieras hacer una petición:

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

Más información sobre URLRequestConvertible: https://github.com/Alamofire/Alamofire#urlrequestconvertible

Respuesta antigua

A partir de Alamofire v1.0 Pers la respuesta ya no funciona. En la nueva versión, se deben agregar encabezados adicionales a la propiedad NSURLSessionConfiguration de NSURLSessionConfiguration

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

Más información aquí: https://github.com/Alamofire/Alamofire/issues/111

Answer 8

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

Cuando los Encabezados causan problemas al enviarlo en la solicitud, necesitamos codificar el parámetro, para esto hacemos JSONEncoding.prettyPrinted o JSONEncoding.default como:

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 9

NOTA : esto fue antes de la 1.0. Ya no funciona , mira la respuesta aceptada en su lugar.

Utiliza la propiedad defaultHeaders en el administrador de singleton para agregar encabezados, como este:

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

Al menos funciona para mí. :)

Answer 10

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