Enviando o json array via Alamofire

Gostaria de saber se é possível enviar diretamente uma matriz (não envolvida em um dictionary) em uma solicitação POST. Aparentemente, o parameters parameters deve obter um mapa de: [String: AnyObject]? Mas eu quero poder enviar o seguinte exemplo json:

 [ "06786984572365", "06644857247565", "06649998782227" ] 

Você pode simplesmente codificar o JSON com NSJSONSerialization e depois construir o NSURLRequest própria. Por exemplo, no Swift 3:

 var request = URLRequest(url: url) request.httpMethod = "POST" request.setValue("application/json", forHTTPHeaderField: "Content-Type") let values = ["06786984572365", "06644857247565", "06649998782227"] request.httpBody = try! JSONSerialization.data(withJSONObject: values) Alamofire.request(request) .responseJSON { response in // do whatever you want here switch response.result { case .failure(let error): print(error) if let data = response.data, let responseString = String(data: data, encoding: .utf8) { print(responseString) } case .success(let responseObject): print(responseObject) } } 

Para o Swift 2, veja a revisão anterior desta resposta.

Para o swift 3 e o Alamofire 4, uso a seguinte extensão ParametersEncoding and Array :

 import Foundation import Alamofire private let arrayParametersKey = "arrayParametersKey" /// Extenstion that allows an array be sent as a request parameters extension Array { /// Convert the receiver array to a `Parameters` object. func asParameters() -> Parameters { return [arrayParametersKey: self] } } /// Convert the parameters into a json array, and it is added as the request body. /// The array must be sent as parameters using its `asParameters` method. public struct ArrayEncoding: ParameterEncoding { /// The options for writing the parameters as JSON data. public let options: JSONSerialization.WritingOptions /// Creates a new instance of the encoding using the given options /// /// - parameter options: The options used to encode the json. Default is `[]` /// /// - returns: The new instance public init(options: JSONSerialization.WritingOptions = []) { self.options = options } public func encode(_ urlRequest: URLRequestConvertible, with parameters: Parameters?) throws -> URLRequest { var urlRequest = try urlRequest.asURLRequest() guard let parameters = parameters, let array = parameters[arrayParametersKey] else { return urlRequest } do { let data = try JSONSerialization.data(withJSONObject: array, options: options) if urlRequest.value(forHTTPHeaderField: "Content-Type") == nil { urlRequest.setValue("application/json", forHTTPHeaderField: "Content-Type") } urlRequest.httpBody = data } catch { throw AFError.parameterEncodingFailed(reason: .jsonEncodingFailed(error: error)) } return urlRequest } } 

Basicamente, ele converte a matriz em um Dictionary para ser aceito como argumento Parameters e, em seguida, recupera a matriz do dictionary, converte-a em JSON Data e a adiciona como o corpo da solicitação.

Uma vez que você tenha, você pode criar um pedido desta maneira:

 let values = ["06786984572365", "06644857247565", "06649998782227"] Alamofire.request(url, method: .post, parameters: values.asParameters(), encoding: ArrayEncoding()) 

Aqui está um exemplo de codificação de uma Matriz do tipo Thing para JSON, usando um roteador, e Ogra para fazer a codificação JSON:

 import Foundation import Alamofire import Orga class Thing { ... } enum Router: URLRequestConvertible { static let baseURLString = "http://www.example.com" case UploadThings([Thing]) private var method: Alamofire.Method { switch self { case .UploadThings: return .POST } } private var path: String { switch self { case .UploadThings: return "upload/things" } } var URLRequest: NSMutableURLRequest { let r = NSMutableURLRequest(URL: NSURL(string: Router.baseURLString)!.URLByAppendingPathComponent(path)) r.HTTPMethod = method.rawValue switch self { case .UploadThings(let things): let custom: (URLRequestConvertible, [String:AnyObject]?) -> (NSMutableURLRequest, NSError?) = { (convertible, parameters) in var mutableRequest = convertible.URLRequest.copy() as! NSMutableURLRequest do { let jsonObject = things.encode().JSONObject() let data = try NSJSONSerialization.dataWithJSONObject(jsonObject, options: NSJSONWritingOptions.PrettyPrinted) mutableRequest.setValue("application/json", forHTTPHeaderField: "Content-Type") mutableRequest.HTTPBody = data return (mutableRequest, nil) } catch let error as NSError { return (mutableRequest, error) } } return ParameterEncoding.Custom(custom).encode(r, parameters: nil).0 default: return r } } } 

Swift 2.0
Este código abaixo da matriz de object de postagem.Este código é testado no swift 2.0

 func POST(RequestURL: String,postData:[AnyObject]?,successHandler: (String) -> (),failureHandler: (String) -> ()) -> () { print("POST : \(RequestURL)") let request = NSMutableURLRequest(URL: NSURL(string:RequestURL)!) request.HTTPMethod = "POST" request.setValue("application/json", forHTTPHeaderField: "Content-Type") var error: NSError? do { request.HTTPBody = try NSJSONSerialization.dataWithJSONObject(postData!, options:[]) } catch { print("JSON serialization failed: \(error)") } Alamofire.request(request) .responseString{ response in switch response.result { case .Success: print(response.response?.statusCode) print(response.description) if response.response?.statusCode == 200 { successHandler(response.result.value!) }else{ failureHandler("\(response.description)") } case .Failure(let error): failureHandler("\(error)") } } } 

A resposta do @manueGE está certa. Eu tenho uma abordagem semelhante de acordo com a instrução do alamofire github: `

 struct JSONDocumentArrayEncoding: ParameterEncoding { private let array: [Any] init(array:[Any]) { self.array = array } func encode(_ urlRequest: URLRequestConvertible, with parameters: Parameters?) throws -> URLRequest { var urlRequest = urlRequest.urlRequest let data = try JSONSerialization.data(withJSONObject: array, options: []) if urlRequest!.value(forHTTPHeaderField: "Content-Type") == nil { urlRequest!.setValue("application/json", forHTTPHeaderField: "Content-Type") } urlRequest!.httpBody = data return urlRequest! } } 

Então, chame isso personalizando uma solicitação, em vez de usar a opção padrão com o parâmetro. Basicamente descartar o parâmetro, pois é um dictionary.

 let headers = getHeaders() var urlRequest = URLRequest(url: URL(string: (ServerURL + Api))!) urlRequest.httpMethod = "post" urlRequest.allHTTPHeaderFields = headers let jsonArrayencoding = JSONDocumentArrayEncoding(array: documents) let jsonAryEncodedRequest = try? jsonArrayencoding.encode(urlRequest, with: nil) request = customAlamofireManager.request(jsonAryEncodedRequest!) request?.validate{request, response, data in return .success } .responseJSON { /*[unowned self] */(response) -> Void in ... } 

Além disso, a maneira de lidar com erros nos dados é muito útil.

Existem 2 abordagens para enviar o conteúdo do envio de JSON como parâmetro.

  1. Você pode enviar json como string e seu serviço da web irá analisá-lo no servidor.

      d["completionDetail"] = "[{"YearOfCompletion":"14/03/2017","Completed":true}]" 
  2. Você pode passar cada valor dentro do seu json ( YearOfCompletion e Completed ) em forma de array sequencial. E seu serviço da web inserirá esses dados na mesma sequência. A syntax para isso será semelhante

     d["YearOfCompletion[0]"] = "1998" d["YearOfCompletion[1]"] = "1997" d["YearOfCompletion[2]"] = "1996" d["Completed[0]"] = "true" d["Completed[1]"] = "false" d["Completed[2]"] = "true" 

Eu tenho usado a seguinte function de chamada de serviço da web com o dictionary, para acionar o pedido do Alamofire Swift3.0 .

 func wsDataRequest(url:String, parameters:Dictionary) { debugPrint("Request:", url, parameters as NSDictionary, separator: "\n") //check for internete collection, if not availabale, don;t move forword if Rechability.connectedToNetwork() == false {SVProgressHUD.showError(withStatus: NSLocalizedString("No Network available! Please check your connection and try again later.", comment: "")); return} // self.request = Alamofire.request(url, method: .post, parameters: parameters) if let request = self.request as? DataRequest { request.responseString { response in var serializedData : Any? = nil var message = NSLocalizedString("Success!", comment: "")//MUST BE CHANGED TO RELEVANT RESPONSES //check content availability and produce serializable response if response.result.isSuccess == true { do { serializedData = try JSONSerialization.jsonObject(with: response.data!, options: JSONSerialization.ReadingOptions.allowFragments) //print(serializedData as! NSDictionary) //debugPrint(message, "Response Dictionary:", serializedData ?? "Data could not be serialized", separator: "\n") }catch{ message = NSLocalizedString("Webservice Response error!", comment: "") var string = String.init(data: response.data!, encoding: .utf8) as String! //TO check when html coms as prefix of JSON, this is hack mush be fixed on web end. do { if let index = string?.characters.index(of: "{") { if let s = string?.substring(from: index) { if let data = s.data(using: String.Encoding.utf8) { serializedData = try JSONSerialization.jsonObject(with: data, options: JSONSerialization.ReadingOptions.allowFragments) debugPrint(message, "Courtesy SUME:", serializedData ?? "Data could not be serialized", separator: "\n") } } } }catch{debugPrint(message, error.localizedDescription, "Respone String:", string ?? "No respone value.", separator: "\n")} //let index: Int = text.distance(from: text.startIndex, to: range.lowerBound) debugPrint(message, error.localizedDescription, "Respone String:", string ?? "No respone value.", separator: "\n") } //call finised response in all cases self.delegate?.finished(succes: response.result.isSuccess, and: serializedData, message: message) }else{ if self.retryCounter < 1 {//this happens really frequntly so in that case this fn being called again as a retry self.wsDataRequest(url: url, parameters: parameters) }else{ message = response.error?.localizedDescription ?? (NSLocalizedString("No network", comment: "")+"!") SVProgressHUD.showError(withStatus: message);//this will show errror and hide Hud debugPrint(message) //call finised response in all cases self.delay(2.0, closure: {self.delegate?.finished(succes: response.result.isSuccess, and: serializedData, message:message)}) } self.retryCounter += 1 } } } } 
 let url = try Router.baseURL.asURL() // Make Request var urlRequest = URLRequest(url: url.appendingPathComponent(path)) urlRequest.httpMethod = "post" // let dictArray: [[String: Any]] = [] urlRequest = try! JSONEncoding.default.encode(urlRequest, withJSONObject: dictArray) 

Algo que eu faço no meu projeto para fazer upload de um array JSON

Eu acho que com base na documentação do Alamofire você pode escrever o código da seguinte forma:

 let values = ["06786984572365", "06644857247565", "06649998782227"] Alamofire.request(.POST, url, parameters: values, encoding:.JSON) .authenticate(user: userid, password: password) .responseJSON { (request, response, responseObject, error) in // do whatever you want here if responseObject == nil { println(error) } else { println(responseObject) } }