प्ले 2.0 WS.url या WS.WSRequest

Question

का उपयोग करके MultipartFormData को पोस्ट करने के लिए कैसे करें जावा एचटीपी अनुरोध में, हम multipart HTTP पोस्ट बनाने के लिए ऐसा कर सकते हैं।

HttpClient httpclient = new DefaultHttpClient(); 
HttpPost httppost = new HttpPost(url); 

FileBody bin = new FileBody(new File(fileName)); 
StringBody comment = new StringBody("Filename: " + fileName); 

MultipartEntity reqEntity = new MultipartEntity(); 
reqEntity.addPart("bin", bin); 
reqEntity.addPart("comment", comment); 
httppost.setEntity(reqEntity); 

HttpResponse response = httpclient.execute(httppost); 
HttpEntity resEntity = response.getEntity(); 

मैं WS.url या WS.WSRequest का उपयोग करके इसे कैसे प्राप्त कर सकता हूं?

WSRequestHolder wsReq = WS.url("http//url");    
wsReq.setHeader("Content-type", "multipart/form-data"); 

Answer 1

यह मैला है, और निश्चित रूप से साफ किया जा सकता है, लेकिन यह है कि मैंने इसे काम करने के लिए क्या किया। इसे इतना बेहतर बनाने के लिए स्वतंत्र महसूस करें।

import java.io.ByteArrayInputStream; 
import java.io.ByteArrayOutputStream; 

import play.libs.WS; 

import com.ning.http.multipart.FilePart; 
import com.ning.http.multipart.MultipartRequestEntity; 
import com.ning.http.multipart.Part; 

ByteArrayOutputStream bos = new ByteArrayOutputStream(); 

// Build up the Multiparts 
List<Part> parts = new ArrayList<>(); 
parts.add(new FilePart("file", new File(filename))); 
Part[] partsA = parts.toArray(new Part[parts.size()]); 

// Add it to the MultipartRequestEntity 
MultipartRequestEntity reqE = new MultipartRequestEntity(partsA, null); 
reqE.writeRequest(bos); 
InputStream reqIS = new ByteArrayInputStream(bos.toByteArray()); 
WS.WSRequestHolder req = WS.url(InterchangeConfig.conflateUrl+"dataset") 
    .setContentType(reqE.getContentType()); 
req.post(reqIS).map(...); 
// or req.post(reqIS).get(); 

यह सब प्ले 2.0 ढांचे में पहले से ही टुकड़ों का उपयोग कर रहा है।

Answer 2

ऐसा लगता है कि प्ले एपीआई दस्तावेज के आधार पर, मल्टीपार्ट पोस्ट निकायों के लिए कोई अंतर्निहित नहीं है।

हालांकि, यह अपनी पसंद का एक प्रकार टी के साथ विधि

post[T](body: T)(implicit wrt: Writeable[T], ct: ContentTypeOf[T]): Future[Response] 

उपयोग कर अपने खुद बहुखण्डीय शरीर बनाने के लिए संभव हो सकता है, और भी इसी लेखनीय और ContentTypeOf प्रकार के।

लेकिन यह यह बताएगा कि मल्टीपार्ट निकायों HTTP के साथ कैसे काम करते हैं।

Answer 3

बाह्य पुस्तकालयों पर भरोसा किए बिना, अब के लिए एकमात्र समाधान मैन्युअल रूप से मल्टीपार्ट फॉर्म डेटा अनुरोध बना रहा है। यह एक उदाहरण है कि यह कैसे, किया जा सकता है play.libs.WS.url का उपयोग कर:

WSRequestHolder wsRequestHolder = WS.url(URL); 

String boundary = "--XYZ123--"; 

String body = ""; 
for (String key : data.keySet()) { 
    body += "--" + boundary + "\r\n" 
     + "Content-Disposition: form-data; name=\"" 
     + key + "\"\r\n\r\n" 
     + data.get(key) + "\r\n"; 
} 
body += "--" + boundary + "--"; 

wsRequestHolder.setHeader("Content-Type", "multipart/form-data; boundary=" + boundary); 
wsRequestHolder.setHeader("Content-length", String.valueOf(body.length())); 

wsRequestHolder.post(body); 

data एक java.util.Map<String, String> सभी नाम/मान युग्म आप फार्म पैरामीटर के रूप में पारित करने के लिए चाहते हैं होगा। अनुरोध से अनुरोध में सीमा बदलने के लिए randomString एक यादृच्छिक मान है। बाइनरी डेटा जोड़ना वैसे ही काम करेगा।

यह http://www.htmlcodetutorial.com/forms/form_enctype.html चश्मा को समझने के लिए संदर्भित करने के लिए एक अच्छी जगह है।

Answer 4

जैसा कि रोमैन सर्टेलन ने सुझाव दिया था, आप इस मामले को संभालने के लिए एक लिखने योग्य लिख सकते हैं। यहाँ एक है मैं ने लिखा है:

package utilities 

import java.io.{ByteArrayOutputStream, File} 

import com.ning.http.client.FluentCaseInsensitiveStringsMap 
import com.ning.http.multipart.{MultipartRequestEntity, FilePart, StringPart} 
import play.api.http.HeaderNames._ 
import play.api.http.{ContentTypeOf, Writeable} 
import play.api.mvc.{Codec, MultipartFormData} 

object MultipartFormDataWriteable { 

    implicit def contentTypeOf_MultipartFormData[A](implicit codec: Codec): ContentTypeOf[MultipartFormData[A]] = { 
     ContentTypeOf[MultipartFormData[A]](Some("multipart/form-data; boundary=__X_PROCESS_STREET_BOUNDARY__")) 
    } 

    implicit def writeableOf_MultipartFormData(implicit contentType: ContentTypeOf[MultipartFormData[File]]): Writeable[MultipartFormData[File]] = { 
     Writeable[MultipartFormData[File]]((formData: MultipartFormData[File]) => { 

      val stringParts = formData.dataParts flatMap { 
       case (key, values) => values map (new StringPart(key, _)) 
      } 

      val fileParts = formData.files map { filePart => 
       new FilePart(filePart.key, filePart.ref, filePart.contentType getOrElse "application/octet-stream", null) 
      } 

      val parts = stringParts ++ fileParts 

      val headers = new FluentCaseInsensitiveStringsMap().add(CONTENT_TYPE, contentType.mimeType.get) 
      val entity = new MultipartRequestEntity(parts.toArray, headers) 
      val outputStream = new ByteArrayOutputStream 
      entity.writeRequest(outputStream) 

      outputStream.toByteArray 

     })(contentType) 
    } 

} 

इसका इस्तेमाल करने के तरीके:

import utilities.MultipartFormDataWriteable._ 

... 

val url = "https://example.com" 

val dataParts = Map(
    "foo" -> Seq("bar"), 
    "alice" -> Seq("bob") 
) 

val file = new jave.io.File(... path to a jpg ...) 
val fileParts = Seq(new FilePart("attachment", "foo.jpg", Some("image/jpeg"), file) 

val multipartFormData = MultipartFormData(dataParts, fileParts, Seq(), Seq()) 

WS.url(url).post(multipartFormData) 

Answer 5

कार्य उदाहरण खेलने 2.3 के लिए दृष्टिकोण से ऊपर का उपयोग कर, यह भी contentType फ़ाइल अपलोड करते समय जोड़ा।

public Promise<WSResponse> upload(Http.MultipartFormData.FilePart policyFilePart, String contentType) { 
    ByteArrayOutputStream bos = new ByteArrayOutputStream(); 
    List<Part> parts = new ArrayList<>(); 
    try { 
     parts.add(new FilePart("file", policyFilePart.getFile(), contentType, null)); 
     parts.add(new StringPart("param1", "value1")); 
     parts.add(new StringPart("param2", "value2")); 
     Part[] partsA = parts.toArray(new Part[parts.size()]); 

     // Add it to the multipart request entity 
     MultipartRequestEntity requestEntity = new MultipartRequestEntity(partsA, new FluentCaseInsensitiveStringsMap()); 
     requestEntity.writeRequest(bos); 
     InputStream reqIS = new ByteArrayInputStream(bos.toByteArray()); 
     return WS.url(baseUrl + "upload") 
       .setContentType(requestEntity.getContentType()) 
       .post(reqIS).map(new Function<WSResponse, WSResponse>() { 
        @Override 
        public WSResponse apply(WSResponse wsResponse) throws Throwable { 
          return wsResponse; 
        } 
       }); 
    } catch (IOException e) { 
     e.printStackTrace(); 
     return null; 
    } 
}