Alamofire를 통해 json 배열 보내기

Alamofire를 통해 json 배열 보내기

---

POST 요청에서 (사전에 래핑되지 않은) 배열을 직접 보낼 수 있는지 궁금합니다. 분명히 parameters매개 변수는 [String : AnyObject]? 하지만 다음 예제 json을 보낼 수 있기를 원합니다.

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

---

JSON을 인코딩 NSJSONSerialization한 다음 NSURLRequest직접 빌드 할 수 있습니다 . 예를 들어 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)
        }
}

Swift 2 의 경우이 답변의 이전 개정판 을 참조하십시오 .

---

swift 3 및 Alamofire 4의 경우 다음 ParametersEncoding및 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
    }
}

기본적 Dictionary으로 Parameters인수 로 받아들이 기 위해 배열을 a로 변환 한 다음 사전에서 배열을 가져 와서 JSON으로 변환 Data하고 요청 본문으로 추가합니다.

요청을 받으면 다음과 같이 요청할 수 있습니다.

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

---

다음은 라우터를 사용하여 Thing 유형의 배열을 JSON으로 인코딩하고 Ogra를 사용하여 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
post object array 아래이 코드는 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)")
                }
        }

    }

---

@manueGE의 대답이 맞습니다. 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!
    }
}

`그런 다음 매개 변수가있는 기본 요청을 사용하는 대신 요청을 사용자 정의하여 호출하십시오. 매개 변수는 사전이기 때문에 기본적으로 버립니다.

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

또한 데이터 오류를 처리하는 방법도 매우 유용합니다.

---

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)

JSON 배열을 업로드하기 위해 프로젝트에서 수행하는 작업

---

매개 변수로 JSON 콘텐츠를 전송하는 방법에는 두 가지가 있습니다.

1. json을 문자열로 보낼 수 있으며 웹 서비스가 서버에서 구문 분석합니다.

    d["completionDetail"] = "[{"YearOfCompletion":"14/03/2017","Completed":true}]"
   

2. You can pass each value within your json (YearOfCompletion and Completed) in form of sequential array. And your web service will insert that data in same sequence. Syntax for this will look a like

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

I have been using following web service call function with dictionary, to trigger Alamofire request Swift3.0.

func wsDataRequest(url:String, parameters:Dictionary<String, Any>) {
    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
            }
        }
    }
}

---

I think based on Alamofire documentation you can write the code as following:

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

참고URL : https://stackoverflow.com/questions/27026916/sending-json-array-via-alamofire