HTTPS utilisant Jersey Client

Question

Comment envoyer des requêtes GET en utilisant l'API Jersey Client à un serveur qui s'exécute sur le protocole HTTPS. Existe-t-il un exemple de code que je peux utiliser?

Answer 1

Bâtissez votre client en tant que tels

HostnameVerifier hostnameVerifier = HttpsURLConnection.getDefaultHostnameVerifier(); 
ClientConfig config = new DefaultClientConfig(); 
SSLContext ctx = SSLContext.getInstance("SSL"); 
ctx.init(null, myTrustManager, null); 
config.getProperties().put(HTTPSProperties.PROPERTY_HTTPS_PROPERTIES, new HTTPSProperties(hostnameVerifier, ctx)); 
Client client = Client.create(config); 

Ripped de ce billet de blog avec plus de détails: http://blogs.oracle.com/enterprisetechtips/entry/consuming_restful_web_services_with

Pour plus d'informations sur la configuration de certs, voir ce bien répondu SO question: Using HTTPS with REST in Java

Answer 2

Réveiller une question morte ici mais les réponses fournies ne fonctionneront pas avec jdk 7 (j'ai lu quelque part qu'un bug est ouvert pour cela pour Oracle Engineers mais pas encore résolu). Avec le lien fourni par @Ryan, vous devrez également ajouter:

System.setProperty ("jsse.enableSNIExtension", "false");

(Avec l'aimable autorisation à de nombreuses réponses stackoverflow combinés ensemble pour comprendre cela)

Le code complet regardera comme suit qui a fonctionné pour moi (sans définir la propriété du système du client Config ne fonctionne pas pour moi):

import java.security.SecureRandom; 
import java.security.cert.CertificateException; 
import java.security.cert.X509Certificate; 

import javax.net.ssl.HostnameVerifier; 
import javax.net.ssl.HttpsURLConnection; 
import javax.net.ssl.SSLContext; 
import javax.net.ssl.SSLSession; 
import javax.net.ssl.TrustManager; 
import javax.net.ssl.X509TrustManager; 

import com.sun.jersey.api.client.Client; 
import com.sun.jersey.api.client.config.ClientConfig; 
import com.sun.jersey.api.client.config.DefaultClientConfig; 
import com.sun.jersey.client.urlconnection.HTTPSProperties; 
public class ClientHelper 
{ 
    public static ClientConfig configureClient() 
    { 
     System.setProperty("jsse.enableSNIExtension", "false"); 
     TrustManager[] certs = new TrustManager[] 
     { 
      new X509TrustManager() 
      { 
       @Override 
       public X509Certificate[] getAcceptedIssuers() 
       { 
        return null; 
       } 

       @Override 
       public void checkServerTrusted(X509Certificate[] chain, String authType) 
         throws CertificateException 
       { 
       } 

       @Override 
       public void checkClientTrusted(X509Certificate[] chain, String authType) 
         throws CertificateException 
       { 
       } 
      } 
     }; 
     SSLContext ctx = null; 
     try 
     { 
      ctx = SSLContext.getInstance("SSL"); 
      ctx.init(null, certs, new SecureRandom()); 
     } 
     catch (java.security.GeneralSecurityException ex) 
     { 
     } 
     HttpsURLConnection.setDefaultSSLSocketFactory(ctx.getSocketFactory()); 
     ClientConfig config = new DefaultClientConfig(); 
     try 
     { 
      config.getProperties().put(HTTPSProperties.PROPERTY_HTTPS_PROPERTIES, new HTTPSProperties(
        new HostnameVerifier() 
      { 
       @Override 
       public boolean verify(String hostname, SSLSession session) 
       { 
        return true; 
       } 
      }, 
        ctx)); 
     } 
     catch (Exception e) 
     { 
     } 
     return config; 
    } 

    public static Client createClient() 
    { 
     return Client.create(ClientHelper.configureClient()); 
    } 

Answer 3

pour Jersey 2, vous aurez besoin de modifier le code:

 return ClientBuilder.newBuilder() 
      .withConfig(config) 
      .hostnameVerifier(new TrustAllHostNameVerifier()) 
      .sslContext(ctx) 
      .build(); 

https://gist.github.com/JAlexoid/b15dba31e5919586ae51 http://www.panz.in/2015/06/jersey2https.html

Answer 4

HTTPS à l'aide client Jersey a deux versions différentes si vous utilisez Java 6, 7 et 8 puis

SSLContext sc = SSLContext.getInstance("SSL"); 

Si vous utilisez java 8 puis

SSLContext sc = SSLContext.getInstance("TLSv1"); 
System.setProperty("https.protocols", "TLSv1"); 

S'il vous plaît trouver le code de travail

POM

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> 
    <modelVersion>4.0.0</modelVersion> 
    <groupId>WebserviceJersey2Spring</groupId> 
    <artifactId>WebserviceJersey2Spring</artifactId> 
    <version>0.0.1-SNAPSHOT</version> 
    <packaging>war</packaging> 
    <properties> 
     <jersey.version>2.16</jersey.version> 
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> 
    </properties> 
    <repositories> 
     <repository> 
      <id>maven2-repository.java.net</id> 
      <name>Java.net Repository for Maven</name> 
      <url>http://download.java.net/maven/2/</url> 
     </repository> 
    </repositories> 

    <dependencyManagement> 

     <dependencies> 
      <dependency> 
       <groupId>org.glassfish.jersey</groupId> 
       <artifactId>jersey-bom</artifactId> 
       <version>${jersey.version}</version> 
       <type>pom</type> 
       <scope>import</scope> 
      </dependency> 
     </dependencies> 
    </dependencyManagement> 

    <dependencies> 

     <!-- Jersey --> 
     <dependency> 
      <groupId>org.glassfish.jersey.containers</groupId> 
      <artifactId>jersey-container-servlet-core</artifactId> 

     </dependency> 
     <dependency> 
      <groupId>org.glassfish.jersey.media</groupId> 
      <artifactId>jersey-media-moxy</artifactId> 

     </dependency> 

     <!-- Spring 3 dependencies --> 
     <dependency> 
      <groupId>org.springframework</groupId> 
      <artifactId>spring-core</artifactId> 
      <version>3.0.5.RELEASE</version> 
     </dependency> 

     <dependency> 
      <groupId>org.springframework</groupId> 
      <artifactId>spring-context</artifactId> 
      <version>3.0.5.RELEASE</version> 
     </dependency> 

     <dependency> 
      <groupId>org.springframework</groupId> 
      <artifactId>spring-web</artifactId> 
      <version>3.0.5.RELEASE</version> 
     </dependency> 
     <dependency> 
      <groupId>org.glassfish.jersey.core</groupId> 
      <artifactId>jersey-client</artifactId> 
      </dependency> 



     <!-- Jersey + Spring --> 
     <dependency> 
      <groupId>org.glassfish.jersey.ext</groupId> 
      <artifactId>jersey-spring3</artifactId> 
      <exclusions> 
       <exclusion> 
        <artifactId>spring-context</artifactId> 
        <groupId>org.springframework</groupId> 
       </exclusion> 
       <exclusion> 
        <artifactId>spring-beans</artifactId> 
        <groupId>org.springframework</groupId> 
       </exclusion> 
       <exclusion> 
        <artifactId>spring-core</artifactId> 
        <groupId>org.springframework</groupId> 
       </exclusion> 
       <exclusion> 
        <artifactId>spring-web</artifactId> 
        <groupId>org.springframework</groupId> 
       </exclusion> 
       <exclusion> 
        <artifactId>jersey-server</artifactId> 
        <groupId>org.glassfish.jersey.core</groupId> 
       </exclusion> 
       <exclusion> 
        <artifactId> 
        jersey-container-servlet-core 
       </artifactId> 
        <groupId>org.glassfish.jersey.containers</groupId> 
       </exclusion> 
       <exclusion> 
        <artifactId>hk2</artifactId> 
        <groupId>org.glassfish.hk2</groupId> 
       </exclusion> 
      </exclusions> 
     </dependency> 

    </dependencies> 
    <build> 
     <sourceDirectory>src</sourceDirectory> 
     <plugins> 
      <plugin> 
       <artifactId>maven-compiler-plugin</artifactId> 
       <version>3.1</version> 
       <configuration> 
        <source>1.7</source> 
        <target>1.7</target> 
       </configuration> 
      </plugin> 
      <plugin> 
       <artifactId>maven-war-plugin</artifactId> 
       <version>2.3</version> 
       <configuration> 
        <warSourceDirectory>WebContent</warSourceDirectory> 
        <failOnMissingWebXml>false</failOnMissingWebXml> 
       </configuration> 
      </plugin> 
     </plugins> 
    </build> 
</project> 

JAVA CLASSE

package com.example.client; 




import org.glassfish.jersey.client.authentication.HttpAuthenticationFeature; 
import org.springframework.http.HttpStatus; 
import javax.net.ssl.HostnameVerifier; 
import javax.net.ssl.SSLContext; 
import javax.net.ssl.TrustManager; 
import javax.ws.rs.core.MediaType; 
import javax.ws.rs.client.Client; 
import javax.ws.rs.client.ClientBuilder; 
import javax.ws.rs.client.Entity; 
import javax.ws.rs.core.Response; 

public class JerseyClientGet { 
    public static void main(String[] args) { 
     String username = "username"; 
      String password = "p@ssword"; 
     String input = "{\"userId\":\"12345\",\"name \":\"Viquar\",\"surname\":\"Khan\",\"Email\":\"Vaquar.khan@gmail.com\"}"; 
     try { 
     //SSLContext sc = SSLContext.getInstance("SSL");//Java 6 
     SSLContext sc = SSLContext.getInstance("TLSv1");//Java 8 
     System.setProperty("https.protocols", "TLSv1");//Java 8 


     TrustManager[] trustAllCerts = { new InsecureTrustManager() }; 
     sc.init(null, trustAllCerts, new java.security.SecureRandom()); 
     HostnameVerifier allHostsValid = new InsecureHostnameVerifier(); 

     Client client = ClientBuilder.newBuilder().sslContext(sc).hostnameVerifier(allHostsValid).build(); 

     HttpAuthenticationFeature feature = HttpAuthenticationFeature.universalBuilder() 
        .credentialsForBasic(username, password).credentials(username, password).build(); 


      client.register(feature); 
        //PUT request, if need uncomment it 
        //final Response response = client 
        //.target("https://localhost:7002/VaquarKhanWeb/employee/api/v1/informations") 
        //.request().put(Entity.entity(input, MediaType.APPLICATION_JSON), Response.class); 
      //GET Request 
      final Response response = client 
        .target("https://localhost:7002/VaquarKhanWeb/employee/api/v1/informations") 
        .request().get(); 




      if (response.getStatus() != HttpStatus.OK.value()) { throw new RuntimeException("Failed : HTTP error code : " 
        + response.getStatus()); } 
      String output = response.readEntity(String.class); 
      System.out.println("Output from Server .... \n"); 
      System.out.println(output); 
      client.close(); 
     } catch (Exception e) { 
      e.printStackTrace(); 
     } 
    } 
} 

HELPER CLASSE

package com.example.client; 

import javax.net.ssl.HostnameVerifier; 
import javax.net.ssl.SSLSession; 

public class InsecureHostnameVerifier implements HostnameVerifier { 
    @Override 
    public boolean verify(String hostname, SSLSession session) { 
     return true; 
    } 
} 

Classe d'assistance

package com.example.client; 

import java.security.cert.CertificateException; 
import java.security.cert.X509Certificate; 
import javax.net.ssl.X509TrustManager; 

public class InsecureTrustManager implements X509TrustManager { 
    /** 
    * {@inheritDoc} 
    */ 
    @Override 
    public void checkClientTrusted(final X509Certificate[] chain, final String authType) throws CertificateException { 
     // Everyone is trusted! 
    } 

    /** 
    * {@inheritDoc} 
    */ 
    @Override 
    public void checkServerTrusted(final X509Certificate[] chain, final String authType) throws CertificateException { 
     // Everyone is trusted! 
    } 

    /** 
    * {@inheritDoc} 
    */ 
    @Override 
    public X509Certificate[] getAcceptedIssuers() { 
     return new X509Certificate[0]; 
    } 
} 

Une fois que vous commencez à l'application en cours d'exécution sera obtenir erreur de certificat, un certificat de téléchargement du navigateur et ajouter dans

C:\java-8\jdk1_8_0\jre\lib\security 

Ajoutez dans cacerts, vous obtiendrez des détails dans les liens suivants.

Peu liens utiles pour comprendre l'erreur

• http://www.9threes.com/2015/01/restful-java-client-with-jersey-client.html

  Java: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target

  http://magicmonster.com/kb/prg/java/ssl/pkix_path_building_failed.html

  Java Keytool error after importing certificate , "keytool error: java.io.FileNotFoundException & Access Denied"

J'ai testé le code suivant pour get et post méthode avec SSL et l'authentification de base ici vous pouvez passer le certificat SSL, vous pouvez directement copier trois classes et ajouter jar dans le projet java et exécuter.

package com.rest.client; 
import java.io.IOException; 
import java.net.*; 
import java.security.KeyManagementException; 
import java.security.NoSuchAlgorithmException; 
import javax.net.ssl.HostnameVerifier; 
import javax.net.ssl.SSLContext; 
import javax.net.ssl.TrustManager; 
import javax.ws.rs.client.Client; 
import javax.ws.rs.client.ClientBuilder; 
import javax.ws.rs.client.Entity; 
import javax.ws.rs.client.WebTarget; 
import javax.ws.rs.core.Response; 
import org.glassfish.jersey.client.authentication.HttpAuthenticationFeature; 
import org.glassfish.jersey.filter.LoggingFilter; 
import com.rest.dto.EarUnearmarkCollateralInput; 

public class RestClientTest { 
    /** 
    * @param args 
    */ 
    public static void main(String[] args) { 
     try { 
      // 
      sslRestClientGETReport(); 
      // 
      sslRestClientPostEarmark(); 
      // 
      sslRestClientGETRankColl(); 
      // 
     } catch (KeyManagementException e1) { 
      // TODO Auto-generated catch block 
      e1.printStackTrace(); 
     } catch (NoSuchAlgorithmException e1) { 
      // TODO Auto-generated catch block 
      e1.printStackTrace(); 
     } catch (IOException e1) { 
      // TODO Auto-generated catch block 
      e1.printStackTrace(); 
     } 
    } 

    // 
    private static WebTarget target  = null; 
    private static String  userName = "username"; 
    private static String  passWord = "password"; 

    // 
    public static void sslRestClientGETReport() throws KeyManagementException, IOException, NoSuchAlgorithmException { 
     // 
     // 
     SSLContext sc = SSLContext.getInstance("SSL"); 
     TrustManager[] trustAllCerts = { new InsecureTrustManager() }; 
     sc.init(null, trustAllCerts, new java.security.SecureRandom()); 
     HostnameVerifier allHostsValid = new InsecureHostnameVerifier(); 
     // 
     Client c = ClientBuilder.newBuilder().sslContext(sc).hostnameVerifier(allHostsValid).build(); 
     // 
     String baseUrl = "https://localhost:7002/VaquarKhanWeb/employee/api/v1/informations/report"; 
     c.register(HttpAuthenticationFeature.basic(userName, passWord)); 
     target = c.target(baseUrl); 
     target.register(new LoggingFilter()); 
     String responseMsg = target.request().get(String.class); 
     System.out.println("-------------------------------------------------------"); 
     System.out.println(responseMsg); 
     System.out.println("-------------------------------------------------------"); 
     // 

    } 

    public static void sslRestClientGET() throws KeyManagementException, IOException, NoSuchAlgorithmException { 
     //Query param Search={JSON} 
     // 
     SSLContext sc = SSLContext.getInstance("SSL"); 
     TrustManager[] trustAllCerts = { new InsecureTrustManager() }; 
     sc.init(null, trustAllCerts, new java.security.SecureRandom()); 
     HostnameVerifier allHostsValid = new InsecureHostnameVerifier(); 
     // 
     Client c = ClientBuilder.newBuilder().sslContext(sc).hostnameVerifier(allHostsValid).build(); 
     // 
     String baseUrl = "https://localhost:7002/VaquarKhanWeb"; 

     // 
     c.register(HttpAuthenticationFeature.basic(userName, passWord)); 
     target = c.target(baseUrl); 
     target = target.path("employee/api/v1/informations/employee/data").queryParam("search","%7B\"name\":\"vaquar\",\"surname\":\"khan\",\"age\":\"30\",\"type\":\"admin\""%7D"); 

     target.register(new LoggingFilter()); 
     String responseMsg = target.request().get(String.class); 
     System.out.println("-------------------------------------------------------"); 
     System.out.println(responseMsg); 
     System.out.println("-------------------------------------------------------"); 
     // 

    } 
    //TOD need to fix 
    public static void sslRestClientPost() throws KeyManagementException, IOException, NoSuchAlgorithmException { 
     // 
     // 
     Employee employee = new Employee("vaquar", "khan", "30", "E"); 
     // 
     SSLContext sc = SSLContext.getInstance("SSL"); 
     TrustManager[] trustAllCerts = { new InsecureTrustManager() }; 
     sc.init(null, trustAllCerts, new java.security.SecureRandom()); 
     HostnameVerifier allHostsValid = new InsecureHostnameVerifier(); 
     // 
     Client c = ClientBuilder.newBuilder().sslContext(sc).hostnameVerifier(allHostsValid).build(); 
     // 
     String baseUrl = "https://localhost:7002/VaquarKhanWeb/employee/api/v1/informations/employee"; 
     c.register(HttpAuthenticationFeature.basic(userName, passWord)); 
     target = c.target(baseUrl); 
     target.register(new LoggingFilter()); 
     // 
     Response response = target.request().put(Entity.json(employee)); 
     String output = response.readEntity(String.class); 
     // 
     System.out.println("-------------------------------------------------------"); 
     System.out.println(output); 
     System.out.println("-------------------------------------------------------"); 

    } 


} 

Jars

repository/javax/ws/rs/javax.ws.rs-api/2.0/javax.ws.rs-api-2.0.jar" 
    repository/org/glassfish/jersey/core/jersey-client/2.6/jersey-client-2.6.jar" 
    repository/org/glassfish/jersey/core/jersey-common/2.6/jersey-common-2.6.jar" 
    repository/org/glassfish/hk2/hk2-api/2.2.0/hk2-api-2.2.0.jar" 
    repository/org/glassfish/jersey/bundles/repackaged/jersey-guava/2.6/jersey-guava-2.6.jar" 
    repository/org/glassfish/hk2/hk2-locator/2.2.0/hk2-locator-2.2.0.jar" 
    repository/org/glassfish/hk2/hk2-utils/2.2.0/hk2-utils-2.2.0.jar" 
    repository/org/javassist/javassist/3.15.0-GA/javassist-3.15.0-GA.jar" 
    repository/org/glassfish/hk2/external/javax.inject/2.2.0/javax.inject-2.2.0.jar" 
    repository/javax/annotation/javax.annotation-api/1.2/javax.annotation-api-1.2.jar" 
    genson-1.3.jar" 

Answer 5

Si vous utilisez Java 8, une version plus courte pour Jersey2 que la réponse fournie par Aleksandr.

SSLContext sslContext = null; 
try { 
    sslContext = SSLContext.getInstance("SSL"); 
    // Create a new X509TrustManager 
    sslContext.init(null, getTrustManager(), null); 
} catch (NoSuchAlgorithmException | KeyManagementException e) { 
    throw e; 
} 
final Client client = ClientBuilder.newBuilder().hostnameVerifier((s, session) -> true) 
    .sslContext(sslContext).build(); 
return client; 

private TrustManager[] getTrustManager() { 
    return new TrustManager[] { 
    new X509TrustManager() { 
     @Override 
     public X509Certificate[] getAcceptedIssuers() { 
     return null; 
     } 
     @Override 
     public void checkServerTrusted(X509Certificate[] chain, String authType) 
     throws CertificateException { 
     } 
     @Override 
     public void checkClientTrusted(X509Certificate[] chain, String authType) 
     throws CertificateException { 
     } 
    } 
    }; 
}