Qual é a melhor biblioteca Java para usar para HTTP POST, GET etc.? [fechadas]

Qual é a melhor biblioteca Java para usar para HTTP POST, GET etc. em termos de desempenho, estabilidade, maturidade etc.? Existe uma biblioteca específica que é mais usada do que outras?

Meus requisitos são enviar solicitações HTTPS POST a um servidor remoto. Eu usei o pacote java.net. * No passado, bem como o pacote org.apache.commons.httpclient. *. Ambos fizeram o trabalho, mas gostaria de algumas de suas opiniões / recomendações.

imho: Cliente Apache HTTP

exemplo de uso:

import org.apache.commons.httpclient.*;
import org.apache.commons.httpclient.methods.*;
import org.apache.commons.httpclient.params.HttpMethodParams;

import java.io.*;

public class HttpClientTutorial {

  private static String url = "http://www.apache.org/";

  public static void main(String[] args) {
    // Create an instance of HttpClient.
    HttpClient client = new HttpClient();

    // Create a method instance.
    GetMethod method = new GetMethod(url);

    // Provide custom retry handler is necessary
    method.getParams().setParameter(HttpMethodParams.RETRY_HANDLER, 
            new DefaultHttpMethodRetryHandler(3, false));

    try {
      // Execute the method.
      int statusCode = client.executeMethod(method);

      if (statusCode != HttpStatus.SC_OK) {
        System.err.println("Method failed: " + method.getStatusLine());
      }

      // Read the response body.
      byte[] responseBody = method.getResponseBody();

      // Deal with the response.
      // Use caution: ensure correct character encoding and is not binary data
      System.out.println(new String(responseBody));

    } catch (HttpException e) {
      System.err.println("Fatal protocol violation: " + e.getMessage());
      e.printStackTrace();
    } catch (IOException e) {
      System.err.println("Fatal transport error: " + e.getMessage());
      e.printStackTrace();
    } finally {
      // Release the connection.
      method.releaseConnection();
    }  
  }
}

alguns recursos de destaque:

• Baseada em padrões, Java puro, implementação de HTTP versões 1.0 e 1.1
  • Implementação completa de todos os métodos HTTP (GET, POST, PUT, DELETE, HEAD, OPTIONS e TRACE) em uma estrutura OO extensível.
  • Suporta criptografia com protocolo HTTPS (HTTP sobre SSL).
  • Configuração e rastreamento granulares fora dos padrões.
  • Conexões transparentes por meio de proxies HTTP.
  • Conexões HTTPS em túnel por meio de proxies HTTP, por meio do método CONNECT.
  • Conexões transparentes por meio de proxies SOCKS (versão 4 e 5) usando suporte de soquete Java nativo.
  • Autenticação usando os métodos Basic, Digest e de criptografia NTLM (NT Lan Manager).
  • Mecanismo de plug-in para métodos de autenticação customizados.
  • POST com várias partes para o upload de arquivos grandes.
  • Implementações de soquetes seguros plugáveis, tornando mais fácil usar soluções de terceiros
  • Suporte ao gerenciamento de conexão para uso em aplicativos multithread. Suporta a configuração do total máximo de conexões, bem como o máximo de conexões por host. Detecta e fecha conexões obsoletas.
  • Manipulação automática de cookies para ler Set-Cookie: cabeçalhos do servidor e enviá-los de volta em um Cookie: cabeçalho quando apropriado.
  • Mecanismo de plug-in para políticas de cookies customizadas.
  • Solicite fluxos de saída para evitar o armazenamento em buffer de qualquer corpo de conteúdo, transmitindo diretamente para o soquete do servidor.
  • Fluxos de entrada de resposta para ler com eficiência o corpo da resposta, transmitindo diretamente do soquete para o servidor.
  • Conexões persistentes usando KeepAlive em HTTP / 1.0 e persistência em HTTP / 1.1
  • Acesso direto ao código de resposta e cabeçalhos enviados pelo servidor.
  • A capacidade de definir tempos limite de conexão.
  • HttpMethods implementam o Padrão de Comando para permitir solicitações paralelas e reutilização eficiente de conexões.
  • O código-fonte está disponível gratuitamente sob a licença de software Apache.

Eu recomendaria Apache HttpComponents HttpClient , um sucessor do Commons HttpClient

Eu também recomendaria dar uma olhada no HtmlUnit. HtmlUnit é um "navegador sem interface gráfica para programas Java". http://htmlunit.sourceforge.net/

Tenho uma certa preferência por Jersey . Usamos 1.10 em todos os nossos projetos e não encontramos nenhum problema que não pudéssemos resolver com ele.

Alguns motivos pelos quais gosto:

• Provedores - criaram provedores soap 1.1 / 1.2 em Jersey e eliminaram a necessidade de usar o AXIS volumoso para nossas chamadas JAX-WS
• Filtros - filtros de registro de banco de dados criados para registrar toda a solicitação (incluindo os cabeçalhos de solicitação / resposta) enquanto evita o registro de informações confidenciais.
• JAXB - suporta empacotamento de / para objetos diretamente da solicitação / resposta
• API é fácil de usar

Na verdade, HTTPClient e Jersey são muito semelhantes em implementação e API. Há também uma extensão para Jersey que permite oferecer suporte a HTTPClient.

Alguns exemplos de código com Jersey 1.x: https://blogs.oracle.com/enterprisetechtips/entry/consuming_restful_web_services_with

http://www.mkyong.com/webservices/jax-rs/restful-java-client-with-jersey-client/

HTTPClient com Jersey Client: https://blogs.oracle.com/PavelBucek/entry/jersey_client_apache_http_client

Eu concordo que httpclient é uma espécie de padrão - mas acho que você está procurando opções, então ...

Restlet fornece um cliente http especialmente projetado para interagir com os serviços da Web Restful.

Código de exemplo:

    Client client = new Client(Protocol.HTTP);
    Request r = new Request();
    r.setResourceRef("http://127.0.0.1:8182/sample");
    r.setMethod(Method.GET);
    r.getClientInfo().getAcceptedMediaTypes().add(new Preference<MediaType>(MediaType.TEXT_XML));
    client.handle(r).getEntity().write(System.out);

Veja http://www.restlet.org/ para mais detalhes

Posso recomendar-lhe corn-httpclient . É simples, rápido e suficiente para a maioria dos casos.

HttpForm form = new HttpForm(new URI("http://localhost:8080/test/formtest.jsp"));
//Authentication form.setCredentials("user1", "password");
form.putFieldValue("input1", "your value");
HttpResponse response = form.doPost();
assertFalse(response.hasError());
assertNotNull(response.getData());
assertTrue(response.getData().contains("received " + val));

dependência maven

<dependency>
    <groupId>net.sf.corn</groupId>
    <artifactId>corn-httpclient</artifactId>
    <version>1.0.0</version>
</dependency>

O cliente Google HTTP Java parece bom para mim porque pode ser executado no Android e no App Engine também.

Quero mencionar a biblioteca de cliente Http Ning Async . Eu nunca usei, mas meu colega elogia isso em comparação com o cliente Apache Http, que sempre usei no passado. Fiquei particularmente interessado em saber que é baseado no Netty , a estrutura de E / S assíncrona de alto desempenho, com a qual estou mais familiarizado e tenho grande estima.