HTTPS przy użyciu klienta sieci Jersey

Question

Jak wysłać żądania GET za pomocą interfejsu API klienta Jersey na serwerze działającym w protokole HTTPS. Czy jest jakiś przykładowy kod, którego mogę użyć?

Answer 1

Construct klienta jako takiego

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

zgrane z tym blogu więcej szczegółów: http://blogs.oracle.com/enterprisetechtips/entry/consuming_restful_web_services_with

Więcej informacji na temat konfigurowania certyfikatów, zobacz ten ładnie odpowiedział SO pytanie: Using HTTPS with REST in Java

Answer 2

Budząc tutaj martwe pytanie, ale dostarczone odpowiedzi nie będą działać z jdk 7 (czytałem gdzieś, że błąd jest otwarty dla Inżynierów Oracle, ale jeszcze nie naprawiony). Wraz z linkiem podanym przez @Ryan, będziesz musiał również dodać:

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

(dzięki uprzejmości wielu odpowiedzi StackOverflow połączonych razem wymyślimy)

Kompletny kod będzie wyglądać następująco który pracował dla mnie (bez ustawiania właściwości systemu Client Config nie działa dla mnie):

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

dla Jersey 2 trzeba by zmodyfikować kod:

 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 za pomocą klienta Jersey posiada dwa inną wersję, jeśli używasz Java 6, 7 i 8 następnie

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

przypadku korzystania Java 8 następnie

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

Proszę znaleźć kod roboczy

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

HELPER CLASS

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

klasa Pomocnik

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

Po uruchomieniu działa aplikacja dostanie Błąd certyfikatu, certyfikat pobierania od przeglądarki i dodać do

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

Dodaj do cacerts, otrzymasz szczegółowe informacje w następujących linkach.

Mało przydatny link, aby zrozumieć błąd

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

Przetestowałem następujący kod dla metody get i post z protokołem SSL i podstawowym uwierzytelnianiem, tutaj możesz pominąć certyfikat SSL, możesz bezpośrednio skopiować trzy klasy i dodać jar do projektu java i uruchomić.

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

    } 


} 

Słoiki

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

Jeśli używasz Java 8, krótsza wersja dla Jersey2 niż odpowiedzi udzielonej przez Aleksandra.

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