带有Alamofire正文的简单字符串的POST请求

84

在iOS应用中，如何使用Alamofire在HTTP正文中使用简单字符串发送POST请求？

默认情况下，Alamofire需要用于请求的参数：

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

这些参数包含键值对。但是我不想在HTTP正文中发送带有键值字符串的请求。

我的意思是这样的：

Alamofire.request(.POST, "http://mywebsite.com/post-request", body: "myBodyString")
ios  http  swift  request  alamofire 
— 卡尔
source

Answers:

88

您的示例Alamofire.request(.POST, "http://mywebsite.com/post-request", parameters: ["foo": "bar"])已经包含“ foo = bar”字符串作为其主体。但是，如果您真的要使用自定义格式的字符串。你可以这样做：

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

注意：parameters不应该nil

更新（Alamofire 4.0，Swift 3.0）：

在Alamofire 4.0中，API已更改。因此，对于自定义编码，我们需要符合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: [:])
— 西尔马里尔
source
这不仅适用于简单的JSON类型映射字符串，而且适用于所有类型的JSON字符串。
— 萨希尔·卡普尔
拯救了我的一天:)谢谢（y）
— ishhhh 2015年
1
@silmaril在我的情况下，只有使用PUT方法时，我才能从后端获取原始请求，请您帮我，为什么POST请求看不到任何东西
— AJ
1
.Alamofire 4 Swift 3中不再提供自定义功能，我无法找到替代方法，有任何提示吗？
— Raheel Sadiq
@Silmaril我贴出的问题太多，请回答这个问题，所以我可以关闭它：stackoverflow.com/questions/39573514/...
— Raheel萨迪克
64

你可以这样做：

  1. 我创建了一个单独的请求Alamofire对象。
  2. 将字符串转换为数据

  3. 将数据放入httpBody

    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)

}
— 非洲机器人
source
5
这应该是公认的答案。它很简单，可以完全满足需要，并且没有不必要的扩展或转换。谢啦。
— 西藏沿海地区
2
附注：我已经“借用”了您的另一个问题的答案-stackoverflow.com/a/42411188/362305
— 西藏沿海地区
2
出席
— 人数
@SyraKozZ出席人数无关紧要，唯一重要的是pjson是json字符串。您可以在其中放置任何json字符串。
— afrodev
13

如果您使用Alamofire，将类型编码为“ URLEncoding.httpBody”就足够了

这样，尽管您在代码中将其定义为json，也可以将数据作为字符串在httpbody中发送。

它对我有用。

更新于 

  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"]!)

        }

    })
— 塞马尔·巴里
source
1
我会更新我的回答，写一个使用的代码，因为我无法找到如何编写代码从这里评论..对不起，我迟到@巴德尔菲拉利。
— 杰马尔BAYRI
非常感谢
— Badr Filali
1
为我工作，但我的身体需要为JSON，因此，我将编码：URLEncoding.httpBody更改为编码：JSONEncoding.default，一切正常。
— 恩戈洛·波洛托
是的@AngeloPolotto感谢您的构造：）这是关于服务类型的编码。可以根据您的其他api用作URLEncoding或JSONEncoding。
— Cemal BAYRI '18
谢谢你的回答。但是我面临的问题是当我发送变量而不是double quotes strings并获得错误代码时400。我该如何解决？
— 毒蛇
8

我修改了@Silmaril的答案以扩展Alamofire的Manager。此解决方案使用EVReflection直接序列化对象：

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

然后，您可以像这样使用它： 

Alamofire.Manager.request(.POST, endpointUrlString, bodyObject: myObjectToPost)
— 拉夫
source
5

如果要在请求中将字符串作为原始正文发布

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)
        }))
— JR
source
嗨，JITHINRAJ，我在这里stackoverflow.com/questions/40385992/…发表了一个问题。我想发送一个xml正文
— mike vorisis，2016年
5

我已经完成了从字符串数组。调整此解决方案以适应琴弦。

来自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!
    }
}

然后通过以下方式提出您的请求：

Alamofire.request("your url string", method: .post, parameters: [:], encoding: JSONStringArrayEncoding.init(string: "My string for body"), headers: [:])
— 伊莉亚·克里特（Illya Krit）
source
4

我已经使用@afrodev的答案作为参考。就我而言，我将函数参数作为必须在请求中发布的字符串。所以，这是代码：

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)
    }
}
— GeoSD
source
你到底得到了什么？
— GeoSD '18
3

基于Illya Krit的答案

细节

  • Xcode版本10.2.1（10E1001）
  • 迅捷5
  • Alamofire 4.8.2

解

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

用法

Alamofire.request(url, method: .post, parameters: nil, encoding: BodyStringEncoding(body: text), headers: headers).responseJSON { response in
     print(response)
}
— 瓦西里·博德纳丘克（Vasily Bodnarchuk）
source
Спасибовамбольшое！
— ИсмаилХасбулатов
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)
— 安德鲁
source
什么是Mapper？
— Ahmadreza
2

我的案例，发布的Alamofire的内容类型为：“ Content-Type”：“ application / x-www-form-urlencoded”，我不得不更改alampfire发布请求的编码

从：JSONENCODING.DEFAULT到：URLEncoding.httpBody

这里：

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
— IsPha
source
0 
let parameters = ["foo": "bar"]
              
    // All three of these calls are equivalent
    AF.request("https://httpbin.org/post", method: .post, parameters: parameters)
    AF.request("https://httpbin.org/post", method: .post, parameters: parameters, encoder: URLEncodedFormParameterEncoder.default)
    AF.request("https://httpbin.org/post", method: .post, parameters: parameters, encoder: URLEncodedFormParameterEncoder(destination: .httpBody))
— 阿卜杜拉·泽克
source
-3

Xcode 8.X，Swift 3.X

易于使用；

 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)

            }
— Swift开发者
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.