HTTPS con client Jersey

Question

Come inviare richieste GET utilizzando l'API client Jersey a un server che viene eseguito sul protocollo HTTPS. C'è qualche codice di esempio che posso usare?

Answer 1

costruire il vostro cliente in quanto tale

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

strappato da questo post del blog con più dettagli: http://blogs.oracle.com/enterprisetechtips/entry/consuming_restful_web_services_with

Per informazioni su come impostare i tuoi certs, vedere questo ben risposto SO domanda: Using HTTPS with REST in Java

Answer 2

Svegliando una domanda morta qui, ma le risposte fornite non funzioneranno con jdk 7 (ho letto da qualche parte che un bug è aperto per questo per gli ingegneri Oracle ma non è stato ancora risolto). Insieme al link fornito da @Ryan, è necessario aggiungere anche:

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

(Per gentile concessione di molte risposte StackOverflow combinate insieme per capirlo)

Il codice completo sarà il seguente, che ha lavorato per me (senza impostare la proprietà di sistema la configurazione client non ha funzionato per me):

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

per Jersey 2 avresti bisogno di modificare il codice:

 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 utilizzando il client Jersey ha due versione diversa se si utilizza Java 6, 7 e 8 poi

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

Se si utilizza Java 8 poi

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

Si prega di trovare il codice di lavoro

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 CLASS

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

classe helper

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 Helper

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]; 
    } 
} 

volta che si avvia in esecuzione l'applicazione otterrà errore certificato, certificato di download dal browser e aggiungere nel

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

Aggiungi in cacerts, otterrete i dettagli nei seguenti collegamenti.

Pochi link utile per capire l'errore

• 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"

Ho testato il seguente codice per ottenere e pubblicare il metodo con SSL e l'autenticazione di base qui è possibile saltare il certificato SSL, è possibile copiare direttamente tre classi e aggiungere jar nel progetto java ed eseguire.

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

    } 


} 

Vasi

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

Se si utilizza Java 8, una versione più breve per Jersey2 rispetto alla risposta fornita da 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 { 
     } 
    } 
    }; 
}