代码之家  ›  专栏  ›  技术社区  ›  Stormshadow

使用Jersey客户端的HTTPS

  •  39
  • Stormshadow  · 技术社区  · 16 年前

    如何使用Jersey客户端API向运行HTTPS协议的服务器发送GET请求。有没有我可以使用的示例代码?

    5 回复  |  直到 16 年前
        1
  •  35
  •   Community Mohan Dere    9 年前

    把你的客户塑造成这样

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

    http://blogs.oracle.com/enterprisetechtips/entry/consuming_restful_web_services_with

    有关设置证书的信息,请参见以下问题: Using HTTPS with REST in Java

        2
  •  23
  •   Community Mohan Dere    9 年前

    如果您使用的是Java6、7和8,那么使用Jersey客户端的HTTPS有两个不同的版本 然后

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

    如果使用Java8,那么

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

    请查找工作代码

    聚甲醛

    <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类

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

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

    助手类

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

    一旦开始运行应用程序,就会出现证书错误,请从浏览器下载证书并添加到

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

    添加到cacerts中,您将在以下链接中获得详细信息。

    我已经用SSL和基本身份验证测试了以下get和post方法的代码,在这里您可以跳过SSL证书,您可以直接复制三个类并将jar添加到java项目中并运行。

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

    罐

    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"
    
        3
  •  14
  •   Aleksandr Panzin    11 年前

            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

        4
  •  10
  •   Wolfgang Fahl    10 年前

    在这里唤醒一个死板的问题,但提供的答案对jdk 7不起作用(我在某个地方读到,对于Oracle工程师来说,存在一个漏洞,但尚未修复)。除了@Ryan提供的链接外,您还必须添加:

    System.setProperty(“jsse.enableSNIExtension”、“false”);

    (礼貌地将多个答案组合在一起以解决此问题)

    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());
        }
    
        5
  •  8
  •   Neo    9 年前

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