java的HttpClient如何去支持无证书访问https

最新推荐文章于 2023-10-24 01:00:56 发布

转载最新推荐文章于 2023-10-24 01:00:56 发布 · 109 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：https://my.oschina.net/qiaojj/blog/1926315

文章标签：

#java

本文介绍了一种在没有证书的情况下调用HTTPS接口的方法。通过自定义类实现了一个不验证服务器证书的HTTPS连接，适用于一些特定场景下的需求。具体包括创建自定义的SSLContext和SocketFactory，以及如何在HttpClient中使用。

为什么80%的码农都做不了架构师？>>>

之前做调用华为认证接口时，没有证书，使用此方法，实测可用；

调用自定义类：

        if (url.startsWith("https")) {
			Protocol myhttps = new Protocol("https",new MySecureProtocolSocketFactory(), 8445);
			Protocol.registerProtocol("https", myhttps);
		}
		String responseMsg = "";
		// 构造HttpClient的实例
		HttpClient httpClient = new HttpClient();
		httpClient.getParams().setContentCharset("GBK");
		// 构造PostMethod的实例
		PostMethod postMethod = new PostMethod(url);

自定义类：


import java.io.IOException;    
import java.net.InetAddress;    
import java.net.InetSocketAddress;    
import java.net.Socket;    
import java.net.SocketAddress;    
import java.net.UnknownHostException;    
import java.security.KeyManagementException;    
import java.security.NoSuchAlgorithmException;    
import java.security.cert.CertificateException;    
import java.security.cert.X509Certificate;    
    
import javax.net.SocketFactory;    
import javax.net.ssl.SSLContext;    
import javax.net.ssl.TrustManager;    
import javax.net.ssl.X509TrustManager;    
    
import org.apache.commons.httpclient.ConnectTimeoutException;    
import org.apache.commons.httpclient.params.HttpConnectionParams;    
import org.apache.commons.httpclient.protocol.SecureProtocolSocketFactory;    
    
public class MySecureProtocolSocketFactory implements SecureProtocolSocketFactory {    
    private SSLContext sslcontext = null;    
        
    private SSLContext createSSLContext() {    
        SSLContext sslcontext=null;    
        try {    
            sslcontext = SSLContext.getInstance("SSL");    
            sslcontext.init(null, new TrustManager[]{new TrustAnyTrustManager()}, new java.security.SecureRandom());    
        } catch (NoSuchAlgorithmException e) {    
            e.printStackTrace();    
        } catch (KeyManagementException e) {    
            e.printStackTrace();    
        }    
        return sslcontext;    
    }    
        
    private SSLContext getSSLContext() {    
        if (this.sslcontext == null) {    
            this.sslcontext = createSSLContext();    
        }    
        return this.sslcontext;    
    }    
        
    public Socket createSocket(Socket socket, String host, int port, boolean autoClose)    
            throws IOException, UnknownHostException {    
        return getSSLContext().getSocketFactory().createSocket(    
                socket,    
                host,    
                port,    
                autoClose    
            );    
    }    
    
    public Socket createSocket(String host, int port) throws IOException,    
            UnknownHostException {    
        return getSSLContext().getSocketFactory().createSocket(    
                host,    
                port    
            );    
    }    
        
        
    public Socket createSocket(String host, int port, InetAddress clientHost, int clientPort)    
            throws IOException, UnknownHostException {    
        return getSSLContext().getSocketFactory().createSocket(host, port, clientHost, clientPort);    
    }    
    
    public Socket createSocket(String host, int port, InetAddress localAddress,    
            int localPort, HttpConnectionParams params) throws IOException,    
            UnknownHostException, ConnectTimeoutException {    
        if (params == null) {    
            throw new IllegalArgumentException("Parameters may not be null");    
        }    
        int timeout = params.getConnectionTimeout();    
        SocketFactory socketfactory = getSSLContext().getSocketFactory();    
        if (timeout == 0) {    
            return socketfactory.createSocket(host, port, localAddress, localPort);    
        } else {    
            Socket socket = socketfactory.createSocket();    
            SocketAddress localaddr = new InetSocketAddress(localAddress, localPort);    
            SocketAddress remoteaddr = new InetSocketAddress(host, port);    
            socket.bind(localaddr);    
            socket.connect(remoteaddr, timeout);    
            return socket;    
        }    
    }    
        
    //自定义私有类    
    private static class TrustAnyTrustManager implements X509TrustManager {    
           
        public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {    
        }    
       
        public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {    
        }    
       
        public X509Certificate[] getAcceptedIssuers() {    
            return new X509Certificate[]{};    
        }    
    }    
        
    
}

转载于:https://my.oschina.net/qiaojj/blog/1926315