मेरे 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")
जवाबों:
आपके उदाहरण में Alamofire.request(.POST, "http://mywebsite.com/post-request", parameters: ["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, स्विफ्ट 3.0):
Alamofire में 4.0 एपीआई बदल गया है। तो कस्टम एन्कोडिंग के लिए हमें मूल्य / वस्तु की आवश्यकता होती है जो 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: [:])
तुम यह केर सकते हो:
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)
}
यदि आप Alamofire का उपयोग करते हैं, तो यह "URLEncoding.httpBody" टाइप करने के लिए एन्कोडिंग के लिए पर्याप्त है
इसके साथ, आप अपने डेटा को httpbody में एक स्ट्रिंग के रूप में भेज सकते हैं हालांकि आपने इसे अपने कोड में json परिभाषित किया था।
इसने मेरे लिए काम किया ।।
के लिए अद्यतन
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"]!)
}
})
double quotes stringsऔर त्रुटि कोड प्राप्त करता हूं 400। मैं इसे कैसे हल करूंगा?
मैंने Alamofire के प्रबंधक का विस्तार करने के लिए @ Silmaril के उत्तर को संशोधित किया। यह समाधान सीधे किसी वस्तु को क्रमबद्ध करने के लिए 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)
यदि आप अनुरोध में कच्चे शरीर के रूप में स्ट्रिंग पोस्ट करना चाहते हैं
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)
}))
मैंने इसे स्ट्रिंग्स से सरणी के लिए किया है। यह समाधान शरीर में स्ट्रिंग के लिए समायोजित किया गया है।
अल्मोफायर 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: [:])
मैंने संदर्भ के रूप में @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)
}
}
इलिया क्रिट के जवाब के आधार पर
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)
}
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)
मेरा मामला, सामग्री-प्रकार के साथ अलमोफ़ायर पोस्ट करना: "सामग्री-प्रकार": "आवेदन / x-www-form-urlencoded", मुझे एलामफ़ायर पोस्ट अनुरोध के एन्कोडिंग को बदलना पड़ा
से: JSONENCODING.DEFAULT to: 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
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))
Xcode 8.X, स्विफ्ट 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)
}