web-dev-qa-db-fra.com

Quelle est la meilleure Java à utiliser pour HTTP POST, GET, etc.)?

Quelle est la meilleure Java à utiliser pour HTTP POST, GET, etc. en termes de performances, de stabilité, de maturité, etc.)? Existe-t-il une bibliothèque particulière plus utilisée que d’autres?

Mes exigences sont de soumettre des demandes HTTPS POST à un serveur distant. J'ai déjà utilisé le package Java.net. * Ainsi que le package org.Apache.commons.httpclient. *. fait le travail, mais j'aimerais avoir vos opinions/recommandations.

javahttp
82
rmcc

imho: Client HTTP Apache

exemple d'utilisation:

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

quelques points forts:

  • Implémentation des versions HTTP 1.0 et 1.1 basées sur des normes, en Java pur
    • Implémentation complète de toutes les méthodes HTTP (GET, POST, PUT, DELETE, HEAD, OPTIONS et TRACE) dans un cadre extensible OO.
    • Prend en charge le cryptage avec le protocole HTTPS (HTTP sur SSL).
    • Configuration et suivi granulaires non conformes aux normes.
    • Connexions transparentes via des serveurs proxy HTTP.
    • Connexions HTTPS en tunnel via des proxies HTTP, via la méthode CONNECT.
    • Connexions transparentes via des serveurs proxy SOCKS (versions 4 et 5) à l'aide du support de socket natif Java).
    • Authentification à l'aide des méthodes Basic, Digest et cryptage NTLM (NT Lan Manager).
    • Mécanisme de plug-in pour les méthodes d'authentification personnalisées.
    • Formulaire multi-parties POST pour le téléchargement de fichiers volumineux.
    • Implémentations de sockets sécurisés enfichables, facilitant l'utilisation de solutions tierces
    • Prise en charge de la gestion des connexions pour une utilisation dans des applications multithreads. Prend en charge la définition du nombre total maximal de connexions ainsi que du nombre maximal de connexions par hôte. Détecte et ferme les connexions obsolètes.
    • Gestion automatique des cookies pour lire les en-têtes Set-Cookie: du serveur et les renvoyer dans un en-tête Cookie: le cas échéant.
    • Mécanisme de plug-in pour les stratégies de cookies personnalisées.
    • Demandez des flux de sortie pour éviter de mettre en mémoire tampon le corps du contenu en le diffusant directement sur le socket vers le serveur.
    • Les flux d'entrée de réponse permettent de lire efficacement le corps de la réponse en le transmettant directement du socket au serveur.
    • Connexions persistantes utilisant KeepAlive dans HTTP/1.0 et persistance dans HTTP/1.1
    • Accès direct au code de réponse et aux en-têtes envoyés par le serveur.
    • La possibilité de définir des délais de connexion.
    • HttpMethods implémente le modèle de commande pour permettre les demandes parallèles et la réutilisation efficace des connexions.
    • Le code source est disponible gratuitement sous licence de logiciel Apache.
96
Chris

Je recommanderais Apache HttpComponents HttpClient , un successeur de Commons HttpClient

Je recommanderais également de jeter un coup d'oeil à HtmlUnit. HtmlUnit est un "navigateur sans interface graphique pour Java") ". http://htmlunit.sourceforge.net/

21
Adil

Je suis un peu partial à Jersey . Nous utilisons 1.10 dans tous nos projets et n'avons rencontré aucun problème que nous ne pourrions pas résoudre avec.

Quelques raisons pour lesquelles j'aime ça:

  • Fournisseurs - ont créé des fournisseurs de savon 1.1/1.2 à Jersey et ont éliminé la nécessité d’utiliser le serveur AXIS volumineux pour nos appels JAX-WS
  • Filtres - filtres de journalisation de base de données créés pour consigner l'intégralité de la demande (y compris les en-têtes de requête/réponse) tout en empêchant la journalisation d'informations sensibles.
  • JAXB - prend en charge le marshaling vers/depuis les objets directement à partir de la demande/réponse
  • API est facile à utiliser

En réalité, HTTPClient et Jersey sont très similaires en termes de mise en œuvre et d’API. Il existe également une extension pour Jersey qui lui permet de prendre en charge HTTPClient.

Quelques exemples de code avec 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 avec le client Jersey: https://blogs.Oracle.com/PavelBucek/entry/jersey_client_Apache_http_client

16
ElMattIO

Je conviens que httpclient est en quelque sorte un standard - mais je suppose que vous recherchez des options alors ...

Restlet fournit un client HTTP spécialement conçu pour interagir avec les services Web Restful.

Exemple de code:

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

Voir http://www.restlet.org/ pour plus de détails

10
Pablojim

Puis-je vous recommander corn-httpclient . C'est simple, rapide et suffisant pour la plupart des cas.

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

dépendance maven

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

Google HTTP Java Client me convient bien car il peut s'exécuter sur Android et le moteur d'application également.].

4
Umair A.

Je veux mentionner le Ning Async Client Http Library . Je ne l'ai jamais utilisé, mais mon collègue en raffole par rapport au client Apache Http, que j'ai toujours utilisé par le passé. J'étais particulièrement intéressé d'apprendre qu'il est basé sur Netty , le framework d'entrées/sorties asynchrones hautes performances, avec lequel je suis plus familier et que j'ai une grande estime.

4
Josh