Solicitud POST con una cadena simple en el cuerpo con Alamofire

¿Cómo es posible enviar una solicitud POST con una cadena simple en el cuerpo HTTP con Alamofire en mi aplicación iOS?

Como predeterminado, Alamofire necesita parámetros para una solicitud:

Alamofire.request(.POST, "http://mywebsite.com/post-request", parameters: ["foo": "bar"]) 

Estos parámetros contienen pares clave-valor. Pero no deseo enviar una solicitud con una cadena de valor-clave en el cuerpo HTTP.

Quiero decir algo como esto:

 Alamofire.request(.POST, "http://mywebsite.com/post-request", body: "myBodyString") 

Su ejemplo Alamofire.request(.POST, "http://mywebsite.com/post-request", parameters: ["foo": "bar"]) ya contiene la cadena “foo = bar” como su cuerpo. Pero si realmente quieres una cadena con formato personalizado. Puedes hacerlo:

 Alamofire.request(.POST, "http://mywebsite.com/post-request", parameters: [:], encoding: .Custom({ (convertible, params) in var mutableRequest = convertible.URLRequest.copy() as NSMutableURLRequest mutableRequest.HTTPBody = "myBodyString".dataUsingEncoding(NSUTF8StringEncoding, allowLossyConversion: false) return (mutableRequest, nil) })) 

Nota: los parameters no deben ser nil

ACTUALIZACIÓN (Alamofire 4.0, Swift 3.0):

En Alamofire 4.0 API ha cambiado. Entonces, para la encoding personalizada necesitamos un valor / objeto que se ajuste al protocolo ParameterEncoding .

 extension String: ParameterEncoding { public func encode(_ urlRequest: URLRequestConvertible, with parameters: Parameters?) throws -> URLRequest { var request = try urlRequest.asURLRequest() request.httpBody = data(using: .utf8, allowLossyConversion: false) return request } } Alamofire.request("http://mywebsite.com/post-request", method: .post, parameters: [:], encoding: "myBody", headers: [:]) 

Puedes hacerlo:

  1. Creé un objeto Alamofire de solicitud separada.
  2. Convierte cadena a Datos
  3. Ponga en httpBody los datos

     var request = URLRequest(url: URL(string: url)!) request.httpMethod = HTTPMethod.post.rawValue request.setValue("application/json", forHTTPHeaderField: "Content-Type") let pjson = attendences.toJSONString(prettyPrint: false) let data = (pjson?.data(using: .utf8))! as Data request.httpBody = data Alamofire.request(request).responseJSON { (response) in print(response) } 

Si usa Alamofire, es suficiente con codificar el tipo de “URLEncoding.httpBody”

Con eso, puede enviar sus datos como una cadena en el httpbody aunque lo haya definido en su código.

Funcionó para mí …

ACTUALIZADO para

  var url = "http://..." let _headers : HTTPHeaders = ["Content-Type":"application/x-www-form-urlencoded"] let params : Parameters = ["grant_type":"password","username":"mail","password":"pass"] let url = NSURL(string:"url" as String) request(url, method: .post, parameters: params, encoding: URLEncoding.httpBody , headers: _headers).responseJSON(completionHandler: { response in response let jsonResponse = response.result.value as! NSDictionary if jsonResponse["access_token"] != nil { access_token = String(describing: jsonResponse["accesstoken"]!) } }) 

Modifiqué la respuesta de @ Silmaril para extender el Administrador de Alamofire. Esta solución usa EVReflection para serializar un objeto directamente:

 //Extend Alamofire so it can do POSTs with a JSON body from passed object extension Alamofire.Manager { public class func request( method: Alamofire.Method, _ URLString: URLStringConvertible, bodyObject: EVObject) -> Request { return Manager.sharedInstance.request( method, URLString, parameters: [:], encoding: .Custom({ (convertible, params) in let mutableRequest = convertible.URLRequest.copy() as! NSMutableURLRequest mutableRequest.HTTPBody = bodyObject.toJsonString().dataUsingEncoding(NSUTF8StringEncoding, allowLossyConversion: false) return (mutableRequest, nil) }) ) } } 

Entonces puedes usarlo así:

 Alamofire.Manager.request(.POST, endpointUrlString, bodyObject: myObjectToPost) 

Si desea publicar una cadena como cuerpo sin procesar a pedido

 return Alamofire.request(.POST, "http://mywebsite.com/post-request" , parameters: [:], encoding: .Custom({ (convertible, params) in let mutableRequest = convertible.URLRequest.copy() as! NSMutableURLRequest let data = ("myBodyString" as NSString).dataUsingEncoding(NSUTF8StringEncoding) mutableRequest.HTTPBody = data return (mutableRequest, nil) })) 
 func paramsFromJSON(json: String) -> [String : AnyObject]? { let objectData: NSData = (json.dataUsingEncoding(NSUTF8StringEncoding))! var jsonDict: [ String : AnyObject]! do { jsonDict = try NSJSONSerialization.JSONObjectWithData(objectData, options: .MutableContainers) as! [ String : AnyObject] return jsonDict } catch { print("JSON serialization failed: \(error)") return nil } } let json = Mapper().toJSONString(loginJSON, prettyPrint: false) Alamofire.request(.POST, url + "/login", parameters: paramsFromJSON(json!), encoding: .JSON) 

Lo he hecho para una matriz de cadenas. Esta solución se ajusta para la cuerda en el cuerpo.

La forma “nativa” de Alamofire 4:

 struct JSONStringArrayEncoding: ParameterEncoding { private let myString: String init(string: String) { self.myString = string } func encode(_ urlRequest: URLRequestConvertible, with parameters: Parameters?) throws -> URLRequest { var urlRequest = urlRequest.urlRequest let data = myString.data(using: .utf8)! if urlRequest?.value(forHTTPHeaderField: "Content-Type") == nil { urlRequest?.setValue("application/json", forHTTPHeaderField: "Content-Type") } urlRequest?.httpBody = data return urlRequest! }} 

Y luego haga su pedido con:

 Alamofire.request("your url string", method: .post, parameters: [:], encoding: JSONStringArrayEncoding.init(string: "My string for body"), headers: [:]) 

He usado la respuesta de @afrodev como referencia. En mi caso, tomo el parámetro para mi función como una cadena que se debe publicar en la solicitud. Entonces, aquí está el código:

 func defineOriginalLanguage(ofText: String) { let text = ofText let stringURL = basicURL + "identify?version=2018-05-01" let url = URL(string: stringURL) var request = URLRequest(url: url!) request.httpMethod = HTTPMethod.post.rawValue request.setValue("text/plain", forHTTPHeaderField: "Content-Type") request.httpBody = text.data(using: .utf8) Alamofire.request(request) .responseJSON { response in print(response) } } 

Xcode 8.X, Swift 3.X

Uso fácil;

  let params:NSMutableDictionary? = ["foo": "bar"]; let ulr = NSURL(string:"http://mywebsite.com/post-request" as String) let request = NSMutableURLRequest(url: ulr! as URL) request.httpMethod = "POST" request.setValue("application/json", forHTTPHeaderField: "Content-Type") let data = try! JSONSerialization.data(withJSONObject: params!, options: JSONSerialization.WritingOptions.prettyPrinted) let json = NSString(data: data, encoding: String.Encoding.utf8.rawValue) if let json = json { print(json) } request.httpBody = json!.data(using: String.Encoding.utf8.rawValue); Alamofire.request(request as! URLRequestConvertible) .responseJSON { response in // do whatever you want here print(response.request) print(response.response) print(response.data) print(response.result) }