Richiesta POST con una semplice stringa di caratteri in corpo con Alamofire

come è possibile inviare una richiesta POST con una semplice stringa nel corpo HTTP con Alamofire nella mia app iOS?

Come predefinito Alamofire esigenze parametri per una richiesta:

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

Questi parametri contengono chiave-valore-delle coppie. Ma non voglio di inviare una richiesta con una chiave-valore stringa nel corpo HTTP.

Intendo qualcosa di simile a questo:

Alamofire.request(.POST, "http://mywebsite.com/post-request", body: "myBodyString")
InformationsquelleAutor Karl | 2015-01-09



11 Replies
  1. 82

    Tuo esempio Alamofire.request(.POST, "http://mywebsite.com/post-request", parameters: ["foo": "bar"]) contiene già “foo=bar” stringa di come il suo corpo.
    Ma se si vuole veramente stringa di formato personalizzato. Si può fare questo:

    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: parameters non dovrebbe essere nil

    AGGIORNAMENTO (Alamofire 4.0, Swift 3.0):

    In Alamofire 4.0 API è cambiato. Così, per la codifica personalizzata abbiamo bisogno di valore/oggetto conforme alle ParameterEncoding protocollo.

    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: [:])
    • Questo funziona perfettamente, non solo per la semplice ma di tutti i tipi di tipo JSON mappato le stringhe.
    • salvato la mia giornata 🙂 Grazie (y)
    • nella mia situazione posso ottenere il raw richiesta da backend solo se uso il metodo PUT, potrebbe aiutarmi, per favore, perché inviare la richiesta non può vedere nulla
    • .Personalizzata non è più disponibile in Alamofire 4 Swift 3, e io non sono in grado di trovare l’alternativa, suggerimenti?
    • Ho postato la domanda, si prega di rispondere che così posso chiudere: stackoverflow.com/questions/39573514/…
    • non funziona per me. Converte “myBody” per { myBody: '' }. Swift 3. Alamofire 4.0.0.
    • Non posso dirvi di cosa stai facendo di sbagliato. Ho appena ricontrollato e funziona. $ curl -i \ -X POST \ -H "Accept-Language: en;q=1.0" \ -H "User-Agent: TestCalendar/1.0 (com.test.alamofire; build:1; iOS 10.0.0) Alamofire/4.0.0" \ -H "Accept-Encoding: gzip;q=1.0, compress;q=0.5" \ -d "myBody" \ "http://mywebsite.com/post-request"
    • il parametro di codifica non è supposto per essere una Stringa
    • si prega di ricontrollare la mia risposta: c’è un esempio di come stringa può diventare un valido parametro di codifica con l’aiuto di estensione
    • Ho postato una domanda come questa qui, se possibile, si prega di condividere una risposta stackoverflow.com/questions/40385992/…
    • Questo è un genio 🙂 🙂 @quemeful la Stringa è fatto per ampliare ParameterEncoding nel primo pard del codice
    • Sembra una soluzione, ma funziona…
    • Funziona perfettamente. Questo dovrebbe essere contrassegnato come risposta corretta.
    • con Alamofire 4.7.3, Swift 4.2 e Xcode 10 tutto sembra perfetto
    • Puoi dire come usarlo con più dettaglio? ciò che a che fare con la codifica funzione?
    • Ultima riga Alamofire.request(.... illustra l’uso. encode metodo viene chiamato da Alamofire durante la richiesta di mettere String valore di richiesta di corpo con un aiuto encode metodo
    • Questo non è il distacco con il corpo, è la pubblicazione params

  2. 51

    Si può fare questo:

    1. Ho creato un separato richiesta Alamofire oggetto.
    2. Conversione di una stringa di Dati
    3. Mettere in httpBody i dati

      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)
      
      }
    • Questo dovrebbe essere accettato risposta. E ‘ semplice, fa esattamente ciò che è necessario, e senza inutili estensioni o conversioni. Grazie, uomo.
    • P. S. ho “preso in prestito” la tua risposta ad un’altra domanda – stackoverflow.com/a/42411188/362305
    • che cosa è attendences, potete plz posta un frammento di fuller
    • Non importa ciò che le presenze sono, il solo pensare che è importante è pjson è una stringa json. Si può mettere qualsiasi stringa json c’.
  3. 11

    Se si utilizza Alamofire, è sufficiente per il tipo di codifica per “URLEncoding.httpBody”

    Con questo, è possibile inviare i propri dati come una stringa in httpbody allthough definito json nel codice.

    Ha funzionato per me..

    AGGIORNATO per

      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"]!)
    
            }
    
        })
    • Puoi fare un esempio con il codice ?
    • i ll aggiornare la mia risposta e scrivere il codice di un usato, perché non riuscivo a trovare il modo di scrivere il codice come un commento da qui.. mi Spiace per [email protected] Filali
    • Grazie grande
    • Ha funzionato per me, ma il mio corpo ha bisogno di essere un JSON, quindi, ho cambiato la codifica: URLEncoding.httpBody di codifica: JSONEncoding.di default e tutto ha funzionato bene.
    • Sì @AngeloPolotto grazie per contrubition:) Questo è il tipo di codifica di servizio. Può essere utilizzato a seconda delle tue api rest come URLEncoding o JSONEncoding.
    • Grazie per la risposta. Ma il problema che sto affrontando è che quando invio una variabile invece di double quotes strings e ottenere il codice di errore 400. Come posso risolvere?
    • Mi puoi inviare il codice di esempio può essere che mi può aiutare a migliorare la con questo modo @viper
    • Questo è quello che ho fatto :- lasciate che i parametri = [ “password”:”[email protected]″, “grant_type”:”password”, “client_id”:”Sipradi-mbl”, “client_secret”:”295265f0-c060-4782-9688-36854dba9af5″, “ambito di applicazione”:”offline_access”, “nome”: edtEmail?.il testo ] @CemalBAYRI
    • ho voluto condividere me il recupero func che si chiama Alamofire. Non vedo alcun problema in questa riga di codice. se è possibile posso aiutarti meglio
    • Non ricevo problema durante il recupero dei dati, se si sostituisce edtEmail?.text o di qualsiasi valore dinamico con una statica virgolette stringa.
    • Hai scartare “edtMail.il testo?” ?? Può essere il tuo campi di testo o ecc. gli articoli sono a zero?

  4. 8

    Ho modificato @Silmaril la risposta di estendere Alamofire Manager.
    Questa soluzione utilizza EVReflection per serializzare un oggetto direttamente:

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

    Quindi si può usare come questa:

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

    Se si desidera post stringa come raw corpo nella richiesta

    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)
            }))
  6. 4

    L’ho fatto per array di stringhe. Questa soluzione è regolato per la stringa nel corpo.

    “Nativi” di modo da 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!
        }
    }

    E poi fai la tua richiesta con:

    Alamofire.request("your url string", method: .post, parameters: [:], encoding: JSONStringArrayEncoding.init(string: "My string for body"), headers: [:])
  7. 2
    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)
    • Che cosa è Mapper?
  8. 2

    Ho usato la risposta di @afrodev come riferimento. Nel mio caso prendo il parametro per la mia funzione come stringa che deve essere inviato nella richiesta. Così, ecco il codice:

    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)
        }
    }
    • Che cosa esattamente si non ottenere?
  9. 0

    Base Illya Krit‘s risposta

    Dettagli

    • Xcode Versione 10.2.1 (10E1001)
    • Swift 5
    • Alamofire 4.8.2

    Soluzione

    import Alamofire
    
    struct BodyStringEncoding: ParameterEncoding {
    
        private let body: String
    
        init(body: String) { self.body = body }
    
        func encode(_ urlRequest: URLRequestConvertible, with parameters: Parameters?) throws -> URLRequest {
            guard var urlRequest = urlRequest.urlRequest else { throw Errors.emptyURLRequest }
            guard let data = body.data(using: .utf8) else { throw Errors.encodingProblem }
            urlRequest.httpBody = data
            return urlRequest
        }
    }
    
    extension BodyStringEncoding {
        enum Errors: Error {
            case emptyURLRequest
            case encodingProblem
        }
    }
    
    extension BodyStringEncoding.Errors: LocalizedError {
        var errorDescription: String? {
            switch self {
                case .emptyURLRequest: return "Empty url request"
                case .encodingProblem: return "Encoding problem"
            }
        }
    }

    Utilizzo

    Alamofire.request(url, method: .post, parameters: nil, encoding: BodyStringEncoding(body: text), headers: headers).responseJSON { response in
         print(response)
    }
  10. 0

    Mio caso, la pubblicazione di alamofire con content-type “Content-Type”:”application/x-www-form-urlencoded”, ho dovuto cambiare la codifica di alampfire richiesta post

    da : JSONENCODING.Di DEFAULT
    per: URLEncoding.httpBody

    qui:

    let url = ServicesURls.register_token()
        let body = [
            "UserName": "Minus28",
            "grant_type": "password",
            "Password": "1a29fcd1-2adb-4eaa-9abf-b86607f87085",
             "DeviceNumber": "e9c156d2ab5421e5",
              "AppNotificationKey": "test-test-test",
            "RegistrationEmail": email,
            "RegistrationPassword": password,
            "RegistrationType": 2
            ] as [String : Any]
    
    
        Alamofire.request(url, method: .post, parameters: body, encoding: URLEncoding.httpBody , headers: setUpHeaders()).log().responseJSON { (response) in
  11. -3

    Xcode 8.X , Swift 3.X

    Facilità Di Utilizzo;

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

Lascia un commento