it-swarm.com.de

Java-HTTP-Client zum Hochladen der Datei POST

Ich entwickle einen J2ME-Client, der eine Datei über HTTP in ein Servlet hochladen muss.

Der Servlet-Teil wird mit Apache Commons FileUpload abgedeckt

protected void doPost(HttpServletRequest request, HttpServletResponse response) 
{       

    ServletFileUpload upload = new ServletFileUpload();
    upload.setSizeMax(1000000);

    File fileItems = upload.parseRequest(request);

    // Process the uploaded items
    Iterator iter = fileItems.iterator();
    while (iter.hasNext()) {
        FileItem item = (FileItem) iter.next();
        File file = new File("\files\\"+item.getName());
        item.write(file);
    }
}

Commons Upload scheint in der Lage zu sein, nur mehrteilige Dateien hochzuladen, jedoch keine Anwendung/Octect-Stream.

Auf der Clientseite gibt es jedoch keine Multipart-Klassen. In diesem Fall können auch keine HttpClient-Bibliotheken verwendet werden.

Eine andere Option könnte die Verwendung von HTTP-Chunk-Upload sein, aber ich habe kein klares Beispiel dafür gefunden, wie dies implementiert werden könnte, insbesondere auf der Servlet-Seite.

Meine Auswahlmöglichkeiten sind: - Implementieren Sie ein Servlet für das Hochladen von HTTP-Blöcken - Implementieren Sie einen Raw-Client für die http-mehrteilige Erstellung

Ich weiß nicht, wie ich keine der oben genannten Optionen implementieren soll.

12
Clark Ku

Der Versand von Dateien über HTTP soll mit der multipart/form-data-Codierung erfolgen. Ihr Servlet-Teil ist in Ordnung, da er bereits Apache Commons FileUpload verwendet, um eine multipart/form-data-Anforderung zu analysieren.

Ihr Client-Teil ist jedoch anscheinend nicht in Ordnung, da Sie scheinbar den Dateiinhalt in den Anfragetext schreiben. Sie müssen sicherstellen, dass Ihr Client eine korrekte multipart/form-data-Anforderung sendet. Wie genau dies zu tun ist, hängt von der API ab, mit der Sie die HTTP-Anforderung senden. Wenn es sich um Vanilla Java.net.URLConnection handelt, können Sie ein konkretes Beispiel in der Nähe von dieser Antwort finden. Wenn Sie Apache HttpComponents Client verwenden, ist hier ein konkretes Beispiel:

HttpClient client = new DefaultHttpClient();
HttpPost post = new HttpPost(url);

MultipartEntity entity = new MultipartEntity();
entity.addPart("file", new FileBody(file));
post.setEntity(entity);

HttpResponse response = client.execute(post);
// ...

Nicht mit dem konkreten Problem verwandt, enthält der serverseitige Code einen Fehler:

File file = new File("\files\\"+item.getName());
item.write(file);

Dadurch wird möglicherweise eine zuvor hochgeladene Datei mit demselben Namen überschrieben. Ich würde vorschlagen, stattdessen File#createTempFile() zu verwenden.

String name = FilenameUtils.getBaseName(item.getName());
String ext = FilenameUtils.getExtension(item.getName());
File file = File.createTempFile(name + "_", "." + ext, new File("/files"));
item.write(file);
28
BalusC

Der folgende Code kann zum Hochladen einer Datei mit HTTP-Client 4.x verwendet werden (die Antwort oben verwendet MultipartEntity, das jetzt veraltet ist)

import org.Apache.http.HttpResponse;
import org.Apache.http.client.methods.HttpPost;
import org.Apache.http.entity.mime.MultipartEntityBuilder;
import org.Apache.http.entity.mime.content.FileBody;
import org.Apache.http.impl.client.CloseableHttpClient;
import org.Apache.http.impl.client.HttpClients;
import org.Apache.http.util.EntityUtils;

String uploadFile(String url, File file) throws IOException
{
    HttpPost post = new HttpPost(url);
    post.setHeader("Accept", "application/json");
    _addAuthHeader(post);
    MultipartEntityBuilder builder = MultipartEntityBuilder.create();
    // fileParamName should be replaced with parameter name your REST API expect.
    builder.addPart("fileParamName", new FileBody(file));
    //builder.addPart("optionalParam", new StringBody("true", ContentType.create("text/plain", Consts.ASCII)));
    post.setEntity(builder.build());
    HttpResponse response = getClient().execute(post);;
    int httpStatus = response.getStatusLine().getStatusCode();
    String responseMsg = EntityUtils.toString(response.getEntity(), "UTF-8");

    // If the returned HTTP response code is not in 200 series then
    // throw the error
    if (httpStatus < 200 || httpStatus > 300) {
        throw new IOException("HTTP " + httpStatus + " - Error during upload of file: " + responseMsg);
    }

    return responseMsg;
}

Sie benötigen aktuelle Versionen der folgenden Apache-Bibliotheken: httpclient, httpcore, httpmime.

getClient() kann durch HttpClients.createDefault() ersetzt werden.

5
Hemant

Das Arbeitsbeispiel für die Funktion zum Hochladen von Dateien mit HttpClient in Java finden Sie hier.

package test;

import Java.io.File;
import Java.io.IOException;
import Java.io.UnsupportedEncodingException;

import org.Apache.http.HttpResponse;
import org.Apache.http.client.ClientProtocolException;
import org.Apache.http.client.HttpClient;
import org.Apache.http.client.methods.HttpPost;
import org.Apache.http.entity.FileEntity;
import org.Apache.http.impl.client.DefaultHttpClient;

public class fileUpload {
private static void executeRequest(HttpPost httpPost) {
    try {
        HttpClient client = new DefaultHttpClient();
        HttpResponse response = client.execute(httpPost);
        System.out.println("Response Code:  " + response.getStatusLine().getStatusCode());
    } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
    } catch (ClientProtocolException e) {
        e.printStackTrace();
    } catch (IllegalStateException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

public void executeMultiPartRequest(String urlString, File file) throws IOException {
    HttpPost postRequest = new HttpPost(urlString);
    postRequest = addHeader(postRequest, "Access Token");
    try {
        postRequest.setEntity(new FileEntity(file));
    } catch (Exception ex) {
        ex.printStackTrace();
    }
    executeRequest(postRequest);
}

private static HttpPost addHeader(HttpPost httpPost, String accessToken) {
    httpPost.addHeader("Accept", "application/json;odata=verbose");
    httpPost.setHeader("Authorization", "Bearer " + accessToken);
    return httpPost;
}

public static void main(String args[]) throws IOException {
    fileUpload fileUpload = new fileUpload();
    File file = new File("C:\\users\\bgulati\\Desktop\\test.docx");
    fileUpload.executeMultiPartRequest(
            "Here Goes the URL", file);

}
}
0
Bharti Gulati

Danke für all den Code, den ich geschrieben habe ... Hier sind einige zurück.

Gradle

compile "org.Apache.httpcomponents:httpclient:4.4"  
compile "org.Apache.httpcomponents:httpmime:4.4"



import Java.io.File;
import Java.io.IOException;
import Java.io.InputStream;
import Java.io.StringWriter;
import Java.util.Map;

import org.Apache.commons.io.IOUtils;
import org.Apache.http.HttpEntity;
import org.Apache.http.client.ClientProtocolException;
import org.Apache.http.client.methods.CloseableHttpResponse;
import org.Apache.http.client.methods.HttpGet;
import org.Apache.http.client.methods.HttpPost;
import org.Apache.http.entity.ContentType;
import org.Apache.http.entity.mime.MultipartEntityBuilder;
import org.Apache.http.entity.mime.content.FileBody;
import org.Apache.http.entity.mime.content.StringBody;
import org.Apache.http.impl.client.CloseableHttpClient;
import org.Apache.http.impl.client.HttpClients;


public class HttpClientUtils {

    public static String post(String postUrl, Map<String, String> params,
            Map<String, String> files) throws ClientProtocolException,
            IOException {
        CloseableHttpResponse response = null;
        InputStream is = null;
        String results = null;
        CloseableHttpClient httpclient = HttpClients.createDefault();

        try {

            HttpPost httppost = new HttpPost(postUrl);

            MultipartEntityBuilder builder = MultipartEntityBuilder.create();

            if (params != null) {
                for (String key : params.keySet()) {
                    StringBody value = new StringBody(params.get(key),
                            ContentType.TEXT_PLAIN);
                    builder.addPart(key, value);
                }
            }

            if (files != null && files.size() > 0) {
                for (String key : files.keySet()) {
                    String value = files.get(key);
                    FileBody body = new FileBody(new File(value));
                    builder.addPart(key, body);
                }
            }

            HttpEntity reqEntity = builder.build();
            httppost.setEntity(reqEntity);

            response = httpclient.execute(httppost);
            // assertEquals(200, response.getStatusLine().getStatusCode());

            HttpEntity entity = response.getEntity();
            if (entity != null) {
                is = entity.getContent();
                StringWriter writer = new StringWriter();
                IOUtils.copy(is, writer, "UTF-8");
                results = writer.toString();
            }

        } finally {
            try {
                if (is != null) {
                    is.close();
                }
            } catch (Throwable t) {
                // No-op
            }

            try {
                if (response != null) {
                    response.close();
                }
            } catch (Throwable t) {
                // No-op
            }

            httpclient.close();
        }

        return results;
    }

    public static String get(String getStr) throws IOException,
            ClientProtocolException {
        CloseableHttpResponse response = null;
        InputStream is = null;
        String results = null;
        CloseableHttpClient httpclient = HttpClients.createDefault();

        try {
            HttpGet httpGet = new HttpGet(getStr);
            response = httpclient.execute(httpGet);

            assertEquals(200, response.getStatusLine().getStatusCode());

            HttpEntity entity = response.getEntity();
            if (entity != null) {
                is = entity.getContent();
                StringWriter writer = new StringWriter();
                IOUtils.copy(is, writer, "UTF-8");
                results = writer.toString();
            }

        } finally {

            try {
                if (is != null) {
                    is.close();
                }
            } catch (Throwable t) {
                // No-op
            }

            try {
                if (response != null) {
                    response.close();
                }
            } catch (Throwable t) {
                // No-op
            }

            httpclient.close();
        }

        return results;
    }

}
0
Peter