Como posso fazer uma solicitação POST multipart / form-data usando Java?


96

Na época da versão 3.x do Apache Commons HttpClient, era possível fazer uma solicitação POST multipart / form-data ( um exemplo de 2004 ). Infelizmente, isso não é mais possível na versão 4.0 do HttpClient .

Para nossa atividade principal "HTTP", multipart está um tanto fora do escopo. Adoraríamos usar código multiparte mantido por algum outro projeto para o qual esteja no escopo, mas não tenho conhecimento de nenhum. Tentamos mover o código multipartes para commons-codec alguns anos atrás, mas não decolei por aí. Oleg mencionou recentemente outro projeto que tem código de análise multipartes e pode estar interessado em nosso código de formatação multipartes. Não sei o status atual disso. ( http://www.nabble.com/multipart-form-data-in-4.0-td14224819.html )

Alguém conhece alguma biblioteca Java que me permita escrever um cliente HTTP que pode fazer uma solicitação POST multipart / form-data?

Histórico: Eu quero usar a API remota do Zoho Writer .


Respostas:


151

Usamos HttpClient 4.x para fazer a postagem de arquivos multipartes.

ATUALIZAÇÃO : a partir do HttpClient 4.3 , algumas classes se tornaram obsoletas. Aqui está o código com a nova API:

CloseableHttpClient httpClient = HttpClients.createDefault();
HttpPost uploadFile = new HttpPost("...");
MultipartEntityBuilder builder = MultipartEntityBuilder.create();
builder.addTextBody("field1", "yes", ContentType.TEXT_PLAIN);

// This attaches the file to the POST:
File f = new File("[/path/to/upload]");
builder.addBinaryBody(
    "file",
    new FileInputStream(f),
    ContentType.APPLICATION_OCTET_STREAM,
    f.getName()
);

HttpEntity multipart = builder.build();
uploadFile.setEntity(multipart);
CloseableHttpResponse response = httpClient.execute(uploadFile);
HttpEntity responseEntity = response.getEntity();

Abaixo está o snippet original do código com a API HttpClient 4.0 obsoleta :

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();

62
Ah, o material multiparte foi movido para org.apache.httpcomponents-httpmime-4.0! Pode ser mencionado em algum lugar: /

Tentei seu código atualizado, que funciona bem com arquivos pequenos, mas não funciona com arquivos grandes. Você pode me ajudar com esta questão
AabinGunz

Olá ZZ, fiz a alteração acima em meu código, no entanto, estou enfrentando um novo problema agora - meu ponto de extremidade REST não está aceitando a solicitação. Ele está esperando os seguintes parâmetros: ~ @ PathVariable final String id, @RequestParam ("imagem") final MultipartFile image, @RequestParam ("l") final String l, @RequestParam ("lo") final String lo, @RequestParam (" bac ") final String bac, @RequestParam (" cac ") final String cac, @RequestParam (" m ") final String m ... Anteriormente, a solicitação estava sendo aceita. Mas agora estou recebendo o erro 500. Alguma ideia de por que isso pode estar acontecendo?
Logan

Editei a resposta para que o exemplo de código não role mais horizontalmente - a rolagem me fez perder um parâmetro final importante quando tentei usá-lo em meu próprio trabalho.
G. Sylvie Davies

Aqui estão as dependências do Maven para a resposta atualizada <dependency> <groupId> org.apache.httpcomponents </groupId> <artifactId> httpclient </artifactId> <version> 4.3.6 </version> </dependency> <! - mvnrepository.com/artifact/org.apache.httpcomponents/httpmime -> <dependency> <groupId> org.apache.httpcomponents </groupId> <artifactId> httpmime </artifactId> <version> 4.3.6 </version> < / dependency>
Wazime

39

Estas são as dependências do Maven que possuo.

Código Java:

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

FileBody uploadFilePart = new FileBody(uploadFile);
MultipartEntity reqEntity = new MultipartEntity();
reqEntity.addPart("upload-file", uploadFilePart);
httpPost.setEntity(reqEntity);

HttpResponse response = httpclient.execute(httpPost);

Dependências Maven em pom.xml:

<dependency>
  <groupId>org.apache.httpcomponents</groupId>
  <artifactId>httpclient</artifactId>
  <version>4.0.1</version>
  <scope>compile</scope>
</dependency>
<dependency>
  <groupId>org.apache.httpcomponents</groupId>
  <artifactId>httpmime</artifactId>
  <version>4.0.1</version>
  <scope>compile</scope>
</dependency>

1
você precisará do httpcore também, pelo menos em 4.2, para a HttpEntityaula
alalonde

19

Se o tamanho dos JARs for importante (por exemplo, no caso de miniaplicativos), também é possível usar diretamente httpmime com java.net.HttpURLConnection em vez de HttpClient.

httpclient-4.2.4:      423KB
httpmime-4.2.4:         26KB
httpcore-4.2.4:        222KB
commons-codec-1.6:     228KB
commons-logging-1.1.1:  60KB
Sum:                   959KB

httpmime-4.2.4:         26KB
httpcore-4.2.4:        222KB
Sum:                   248KB

Código:

HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setDoOutput(true);
connection.setRequestMethod("POST");

FileBody fileBody = new FileBody(new File(fileName));
MultipartEntity multipartEntity = new MultipartEntity(HttpMultipartMode.STRICT);
multipartEntity.addPart("file", fileBody);

connection.setRequestProperty("Content-Type", multipartEntity.getContentType().getValue());
OutputStream out = connection.getOutputStream();
try {
    multipartEntity.writeTo(out);
} finally {
    out.close();
}
int status = connection.getResponseCode();
...

Dependência em pom.xml:

<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpmime</artifactId>
    <version>4.2.4</version>
</dependency>

FileBody de onde veio isso? Existe uma maneira (fácil) de não usar apace.httpcomponents?
Jr.

6

Use este código para fazer upload de imagens ou quaisquer outros arquivos para o servidor usando post em multipart.

import java.io.File;
import java.io.IOException;
import java.io.UnsupportedEncodingException;

import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.ResponseHandler;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.mime.MultipartEntity;
import org.apache.http.entity.mime.content.FileBody;
import org.apache.http.entity.mime.content.StringBody;
import org.apache.http.impl.client.BasicResponseHandler;
import org.apache.http.impl.client.DefaultHttpClient;

public class SimplePostRequestTest {

    public static void main(String[] args) throws UnsupportedEncodingException, IOException {
        HttpClient httpclient = new DefaultHttpClient();
        HttpPost httppost = new HttpPost("http://192.168.0.102/uploadtest/upload_photo");

        try {
            FileBody bin = new FileBody(new File("/home/ubuntu/cd.png"));
            StringBody id = new StringBody("3");
            MultipartEntity reqEntity = new MultipartEntity();
            reqEntity.addPart("upload_image", bin);
            reqEntity.addPart("id", id);
            reqEntity.addPart("image_title", new StringBody("CoolPic"));

            httppost.setEntity(reqEntity);
            System.out.println("Requesting : " + httppost.getRequestLine());
            ResponseHandler<String> responseHandler = new BasicResponseHandler();
            String responseBody = httpclient.execute(httppost, responseHandler);
            System.out.println("responseBody : " + responseBody);

        } catch (ClientProtocolException e) {

        } finally {
            httpclient.getConnectionManager().shutdown();
        }
    }

}

requer os arquivos abaixo para fazer o upload.

bibliotecas são httpclient-4.1.2.jar, httpcore-4.1.2.jar, httpmime-4.1.2.jar, httpclient-cache-4.1.2.jar, commons-codec.jar e commons-logging-1.1.1.jardevem estar no classpath.


4

Você também pode usar REST Assured, que se baseia no cliente HTTP. É muito simples:

given().multiPart(new File("/somedir/file.bin")).when().post("/fileUpload");

Ele assumirá um nome de controle chamado "arquivo". Se você tiver um nome de controle diferente, será necessário especificá-lo: multiPart("controlName", new File("/somedir/file.bin"))consulte github.com/rest-assured/rest-assured/wiki/…
asmaier

REST Assured tem uma ótima API e suporta muitos recursos. Trabalhar com isso é um prazer. Mas para ser justo, vale a pena mencionar que, devido a alguns procedimentos de aquecimento, você pode encontrar um desempenho diminuído na primeira chamada. Você pode encontrar mais informações na Internet, ou seja, aqui sqa.stackexchange.com/questions/39532/…
user1053510

REST Assured é uma biblioteca brilhante, mas foi projetada para testes de API da Web e não acho que seja a ferramenta certa para fazer chamadas HTTP no código de produção, embora, é claro, faça uso das mesmas bibliotecas subjacentes.
Ranil Wijeyratne

3

Aqui está uma solução que não requer nenhuma biblioteca.

Esta rotina transmite todos os arquivos do diretório d:/data/mpf10paraurlToConnect


String boundary = Long.toHexString(System.currentTimeMillis());
URLConnection connection = new URL(urlToConnect).openConnection();
connection.setDoOutput(true);
connection.setRequestProperty("Content-Type", "multipart/form-data; boundary=" + boundary);
PrintWriter writer = null;
try {
    writer = new PrintWriter(new OutputStreamWriter(connection.getOutputStream(), "UTF-8"));
    File dir = new File("d:/data/mpf10");
    for (File file : dir.listFiles()) {
        if (file.isDirectory()) {
            continue;
        }
        writer.println("--" + boundary);
        writer.println("Content-Disposition: form-data; name=\"" + file.getName() + "\"; filename=\"" + file.getName() + "\"");
        writer.println("Content-Type: text/plain; charset=UTF-8");
        writer.println();
        BufferedReader reader = null;
        try {
            reader = new BufferedReader(new InputStreamReader(new FileInputStream(file), "UTF-8"));
            for (String line; (line = reader.readLine()) != null;) {
                writer.println(line);
            }
        } finally {
            if (reader != null) {
                reader.close();
            }
        }
    }
    writer.println("--" + boundary + "--");
} finally {
    if (writer != null) writer.close();
}
// Connection is lazily executed whenever you request any status.
int responseCode = ((HttpURLConnection) connection).getResponseCode();
// Handle response

2

httpcomponents-client-4.0.1trabalhou para mim. No entanto, tive que adicionar o jar externo apache-mime4j-0.6.jar ( org.apache.james.mime4j ), caso contrário reqEntity.addPart("bin", bin);não compilaria. Agora está funcionando como um encanto.


2

Encontrei este exemplo no Guia de início rápido do Apache . É para a versão 4.5:

/**
 * Example how to use multipart/form encoded POST request.
 */
public class ClientMultipartFormPost {

    public static void main(String[] args) throws Exception {
        if (args.length != 1)  {
            System.out.println("File path not given");
            System.exit(1);
        }
        CloseableHttpClient httpclient = HttpClients.createDefault();
        try {
            HttpPost httppost = new HttpPost("http://localhost:8080" +
                    "/servlets-examples/servlet/RequestInfoExample");

            FileBody bin = new FileBody(new File(args[0]));
            StringBody comment = new StringBody("A binary file of some kind", ContentType.TEXT_PLAIN);

            HttpEntity reqEntity = MultipartEntityBuilder.create()
                    .addPart("bin", bin)
                    .addPart("comment", comment)
                    .build();


            httppost.setEntity(reqEntity);

            System.out.println("executing request " + httppost.getRequestLine());
            CloseableHttpResponse response = httpclient.execute(httppost);
            try {
                System.out.println("----------------------------------------");
                System.out.println(response.getStatusLine());
                HttpEntity resEntity = response.getEntity();
                if (resEntity != null) {
                    System.out.println("Response content length: " + resEntity.getContentLength());
                }
                EntityUtils.consume(resEntity);
            } finally {
                response.close();
            }
        } finally {
            httpclient.close();
        }
    }
}

0

Temos uma implementação java pura de envio de formulário multipartes sem usar dependências externas ou bibliotecas fora do jdk. Consulte https://github.com/atulsm/https-multipart-purejava/blob/master/src/main/java/com/atul/MultipartPure.java

private static String body = "{\"key1\":\"val1\", \"key2\":\"val2\"}";
private static String subdata1 = "@@ -2,3 +2,4 @@\r\n";
private static String subdata2 = "<data>subdata2</data>";

public static void main(String[] args) throws Exception{        
    String url = "https://" + ip + ":" + port + "/dataupload";
    String token = "Basic "+ Base64.getEncoder().encodeToString((userName+":"+password).getBytes());

    MultipartBuilder multipart = new MultipartBuilder(url,token);       
    multipart.addFormField("entity", "main", "application/json",body);
    multipart.addFormField("attachment", "subdata1", "application/octet-stream",subdata1);
    multipart.addFormField("attachment", "subdata2", "application/octet-stream",subdata2);        
    List<String> response = multipart.finish();         
    for (String line : response) {
        System.out.println(line);
    }
}

0

Meu código postar multipartFile no servidor.

  public static HttpResponse doPost(
    String host,
    String path,
    String method,
    MultipartFile multipartFile
  ) throws IOException
  {

    HttpClient httpClient = wrapClient(host);
    HttpPost httpPost = new HttpPost(buildUrl(host, path));

    if (multipartFile != null) {

      HttpEntity httpEntity;

      ContentBody contentBody;
      contentBody = new ByteArrayBody(multipartFile.getBytes(), multipartFile.getOriginalFilename());
      httpEntity = MultipartEntityBuilder.create()
                                         .addPart("nameOfMultipartFile", contentBody)
                                         .build();

      httpPost.setEntity(httpEntity);

    }
    return httpClient.execute(httpPost);
  }
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.