jdk1.7访问https请求，jdk1.8访问https请求

刺骨的言语ヽ痛彻心扉 2022-01-23 01:19 625阅读 0赞

##          之前用jdk1.7去访问https，怎么都不成功，要么成功后就是返回html代码，而不是json数据，但是用jdk1.8访问就是成功的，返回的也是json数据，由于项目搭建是jdk1.7，不能够因为https问题去升级jdk，因为会很麻烦，主要因为jdk1.7默认https 请求是TLS1不支持TLS1.2，而jdk1.8是访问没问题的，下面的jdk1.7代码做了改进之后就可以访问了。 ##

##               以下jdk1.7和1.8的两种版本代码都会写上。 ##

# **jdk1.7** #

需要加入一个jar包：

pom地址或者url地址下载

可惜下载频道上传不了资源了，也不知道为啥违反csdn规则了，暂时直接用pom下吧，如果有需要下载不到包，直接留邮箱账号就行。

<dependency>
    		    <groupId>org.bouncycastle</groupId>
    		    <artifactId>bcprov-jdk15on</artifactId>
    		    <version>1.57</version>
    		</dependency>

import java.io.ByteArrayInputStream;  
    import java.io.ByteArrayOutputStream;  
    import java.io.DataOutputStream;  
    import java.io.FileInputStream;  
    import java.io.IOException;  
    import java.io.InputStream;  
    import java.io.OutputStream;  
    import java.net.InetAddress;  
    import java.net.InetSocketAddress;  
    import java.net.Socket;  
    import java.net.UnknownHostException;  
    import java.security.KeyStore;  
    import java.security.Principal;  
    import java.security.SecureRandom;  
    import java.security.Security;  
    import java.security.cert.CertificateExpiredException;  
    import java.security.cert.CertificateFactory;  
    import java.util.Hashtable;  
    import java.util.LinkedList;  
    import java.util.List;  
      
    import javax.net.ssl.HandshakeCompletedListener;  
    import javax.net.ssl.SSLPeerUnverifiedException;  
    import javax.net.ssl.SSLSession;  
    import javax.net.ssl.SSLSessionContext;  
    import javax.net.ssl.SSLSocket;  
    import javax.net.ssl.SSLSocketFactory;  
    import javax.security.cert.X509Certificate;  
      
    import org.bouncycastle.crypto.tls.*;  
    import org.bouncycastle.crypto.tls.Certificate;  
    import org.bouncycastle.jce.provider.BouncyCastleProvider;  
      
     
    public class TLSSocketConnectionFactory extends SSLSocketFactory {  
      
        static {  
            if (Security.getProvider(BouncyCastleProvider.PROVIDER_NAME) == null) {  
                Security.addProvider(new BouncyCastleProvider());  
            }  
        }  
      
        @Override  
        public Socket createSocket(Socket socket, final String host, int port,  
                                   boolean arg3) throws IOException {  
            if (socket == null) {  
                socket = new Socket();  
            }  
            if (!socket.isConnected()) {  
                socket.connect(new InetSocketAddress(host, port));  
            }  
      
            final TlsClientProtocol tlsClientProtocol = new TlsClientProtocol(socket.getInputStream(), socket.getOutputStream(), new SecureRandom());  
      
            return _createSSLSocket(host, tlsClientProtocol);  
        }  
      
        @Override  
        public String[] getDefaultCipherSuites() {  
            return null;  
        }  
      
        @Override  
        public String[] getSupportedCipherSuites() {  
            return null;  
        }  
      
        @Override  
        public Socket createSocket(String host, int port) throws IOException, UnknownHostException {  
            throw new UnsupportedOperationException();  
        }  
      
        @Override  
        public Socket createSocket(InetAddress host, int port) throws IOException {  
            throw new UnsupportedOperationException();  
        }  
      
        @Override  
        public Socket createSocket(String host, int port, InetAddress localHost, int localPort) throws IOException, UnknownHostException {  
            return null;  
        }  
      
        @Override  
        public Socket createSocket(InetAddress address, int port, InetAddress localAddress, int localPort) throws IOException {  
            throw new UnsupportedOperationException();  
        }  
      
        private SSLSocket _createSSLSocket(final String host, final TlsClientProtocol tlsClientProtocol) {  
            return new SSLSocket() {  
                private java.security.cert.Certificate[] peertCerts;  
      
                @Override  
                public InputStream getInputStream() throws IOException {  
                    return tlsClientProtocol.getInputStream();  
                }  
      
                @Override  
                public OutputStream getOutputStream() throws IOException {  
                    return tlsClientProtocol.getOutputStream();  
                }  
      
                @Override  
                public synchronized void close() throws IOException {  
                    tlsClientProtocol.close();  
                }  
      
                @Override  
                public void addHandshakeCompletedListener(HandshakeCompletedListener arg0) {  
                }  
      
                @Override  
                public boolean getEnableSessionCreation() {  
                    return false;  
                }  
      
                @Override  
                public String[] getEnabledCipherSuites() {  
                    return null;  
                }  
      
                @Override  
                public String[] getEnabledProtocols() {  
                    return null;  
                }  
      
                @Override  
                public boolean getNeedClientAuth() {  
                    return false;  
                }  
      
                @Override  
                public SSLSession getSession() {  
                    return new SSLSession() {  
      
                        @Override  
                        public int getApplicationBufferSize() {  
                            return 0;  
                        }  
      
                        @Override  
                        public String getCipherSuite() {  
                            throw new UnsupportedOperationException();  
                        }  
      
                        @Override  
                        public long getCreationTime() {  
                            throw new UnsupportedOperationException();  
                        }  
      
                        @Override  
                        public byte[] getId() {  
                            throw new UnsupportedOperationException();  
                        }  
      
                        @Override  
                        public long getLastAccessedTime() {  
                            throw new UnsupportedOperationException();  
                        }  
      
                        @Override  
                        public java.security.cert.Certificate[] getLocalCertificates() {  
                            throw new UnsupportedOperationException();  
                        }  
      
                        @Override  
                        public Principal getLocalPrincipal() {  
                            throw new UnsupportedOperationException();  
                        }  
      
                        @Override  
                        public int getPacketBufferSize() {  
                            throw new UnsupportedOperationException();  
                        }  
      
                        @Override  
                        public X509Certificate[] getPeerCertificateChain() throws SSLPeerUnverifiedException {  
                            return null;  
                        }  
      
                        @Override  
                        public java.security.cert.Certificate[] getPeerCertificates() throws SSLPeerUnverifiedException {  
                            return peertCerts;  
                        }  
      
                        @Override  
                        public String getPeerHost() {  
                            throw new UnsupportedOperationException();  
                        }  
      
                        @Override  
                        public int getPeerPort() {  
                            return 0;  
                        }  
      
                        @Override  
                        public Principal getPeerPrincipal() throws SSLPeerUnverifiedException {  
                            return null;  
                        }  
      
                        @Override  
                        public String getProtocol() {  
                            throw new UnsupportedOperationException();  
                        }  
      
                        @Override  
                        public SSLSessionContext getSessionContext() {  
                            throw new UnsupportedOperationException();  
                        }  
      
                        @Override  
                        public Object getValue(String arg0) {  
                            throw new UnsupportedOperationException();  
                        }  
      
                        @Override  
                        public String[] getValueNames() {  
                            throw new UnsupportedOperationException();  
                        }  
      
                        @Override  
                        public void invalidate() {  
                            throw new UnsupportedOperationException();  
                        }  
      
                        @Override  
                        public boolean isValid() {  
                            throw new UnsupportedOperationException();  
                        }  
      
                        @Override  
                        public void putValue(String arg0, Object arg1) {  
                            throw new UnsupportedOperationException();  
                        }  
      
                        @Override  
                        public void removeValue(String arg0) {  
                            throw new UnsupportedOperationException();  
                        }  
                    };  
                }  
      
                @Override  
                public String[] getSupportedProtocols() {  
                    return null;  
                }  
      
                @Override  
                public boolean getUseClientMode() {  
                    return false;  
                }  
      
                @Override  
                public boolean getWantClientAuth() {  
                    return false;  
                }  
      
                @Override  
                public void removeHandshakeCompletedListener(HandshakeCompletedListener arg0) {  
                }  
      
                @Override  
                public void setEnableSessionCreation(boolean arg0) {  
                }  
      
                @Override  
                public void setEnabledCipherSuites(String[] arg0) {  
                }  
      
                @Override  
                public void setEnabledProtocols(String[] arg0) {  
                }  
      
                @Override  
                public void setNeedClientAuth(boolean arg0) {  
                }  
      
                @Override  
                public void setUseClientMode(boolean arg0) {  
                }  
      
                @Override  
                public void setWantClientAuth(boolean arg0) {  
                }  
      
                @Override  
                public String[] getSupportedCipherSuites() {  
                    return null;  
                }  
      
                @Override  
                public void startHandshake() throws IOException {  
                    tlsClientProtocol.connect(new DefaultTlsClient() {  
      
                        @SuppressWarnings("unchecked")  
                        @Override  
                        public Hashtable<Integer, byte[]> getClientExtensions() throws IOException {  
                            Hashtable<Integer, byte[]> clientExtensions = super.getClientExtensions();  
                            if (clientExtensions == null) {  
                                clientExtensions = new Hashtable<Integer, byte[]>();  
                            }  
      
                            //Add host_name  
                            byte[] host_name = host.getBytes();  
      
                            final ByteArrayOutputStream baos = new ByteArrayOutputStream();  
                            final DataOutputStream dos = new DataOutputStream(baos);  
                            dos.writeShort(host_name.length + 3);  
                            dos.writeByte(0);  
                            dos.writeShort(host_name.length);  
                            dos.write(host_name);  
                            dos.close();  
                            clientExtensions.put(ExtensionType.server_name, baos.toByteArray());  
                            return clientExtensions;  
                        }  
      
                        @Override  
                        public TlsAuthentication getAuthentication() throws IOException {  
                            return new TlsAuthentication() {  
                                @Override  
                                public void notifyServerCertificate(Certificate serverCertificate) throws IOException {  
                                    try {  
                                        KeyStore ks = _loadKeyStore();  
      
                                        CertificateFactory cf = CertificateFactory.getInstance("X.509");  
                                        List<java.security.cert.Certificate> certs = new LinkedList<java.security.cert.Certificate>();  
                                        boolean trustedCertificate = false;  
                                        for (org.bouncycastle.asn1.x509.Certificate c : ((org.bouncycastle.crypto.tls.Certificate) serverCertificate).getCertificateList()) {  
                                            java.security.cert.Certificate cert = cf.generateCertificate(new ByteArrayInputStream(c.getEncoded()));  
                                            certs.add(cert);  
      
                                            String alias = ks.getCertificateAlias(cert);  
                                            if (alias != null) {  
                                                if (cert instanceof java.security.cert.X509Certificate) {  
                                                    try {  
                                                        ((java.security.cert.X509Certificate) cert).checkValidity();  
                                                        trustedCertificate = true;  
                                                    } catch (CertificateExpiredException cee) {  
                                                        // Accept all the certs!  
                                                    }  
                                                }  
                                            } else {  
                                                // Accept all the certs!  
                                            }  
      
                                        }  
                                        if (!trustedCertificate) {  
                                            // Accept all the certs!  
                                        }  
                                        peertCerts = certs.toArray(new java.security.cert.Certificate[0]);  
                                    } catch (Exception ex) {  
                                        ex.printStackTrace();  
                                        throw new IOException(ex);  
                                    }  
                                }  
      
                                @Override  
                                public TlsCredentials getClientCredentials(CertificateRequest certificateRequest) throws IOException {  
                                    return null;  
                                }  
      
                                private KeyStore _loadKeyStore() throws Exception {  
                                    FileInputStream trustStoreFis = null;  
                                    try {  
                                        KeyStore localKeyStore = null;  
      
                                        String trustStoreType = System.getProperty("javax.net.ssl.trustStoreType") != null ? System.getProperty("javax.net.ssl.trustStoreType") : KeyStore.getDefaultType();  
                                        String trustStoreProvider = System.getProperty("javax.net.ssl.trustStoreProvider") != null ? System.getProperty("javax.net.ssl.trustStoreProvider") : "";  
      
                                        if (trustStoreType.length() != 0) {  
                                            if (trustStoreProvider.length() == 0) {  
                                                localKeyStore = KeyStore.getInstance(trustStoreType);  
                                            } else {  
                                                localKeyStore = KeyStore.getInstance(trustStoreType, trustStoreProvider);  
                                            }  
      
                                            char[] keyStorePass = null;  
                                            String str5 = System.getProperty("javax.net.ssl.trustStorePassword") != null ? System.getProperty("javax.net.ssl.trustStorePassword") : "";  
      
                                            if (str5.length() != 0) {  
                                                keyStorePass = str5.toCharArray();  
                                            }  
      
                                            localKeyStore.load(trustStoreFis, keyStorePass);  
      
                                            if (keyStorePass != null) {  
                                                for (int i = 0; i < keyStorePass.length; i++) {  
                                                    keyStorePass[i] = 0;  
                                                }  
                                            }  
                                        }  
                                        return localKeyStore;  
                                    } finally {  
                                        if (trustStoreFis != null) {  
                                            trustStoreFis.close();  
                                        }  
                                    }  
                                }  
      
                            };  
                        }  
      
                    });  
                } // startHandshake  
            };  
        }  
    }

import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStreamWriter;
    import java.net.HttpURLConnection;
    import java.net.URI;
    import java.net.URISyntaxException;
    import java.net.URL;
    import java.net.URLConnection;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    import javax.net.ssl.HttpsURLConnection;
    
    import org.apache.commons.lang.StringUtils;
    
    public class HttpClientUtil {
    	public HttpURLConnection createConnection(URI uri) throws IOException {
    		URL url = uri.toURL();
    		URLConnection connection = url.openConnection();
    		HttpsURLConnection httpsURLConnection = (HttpsURLConnection) connection;
    		httpsURLConnection
    				.setSSLSocketFactory(new TLSSocketConnectionFactory());
    		return httpsURLConnection;
    	}
    
    	public static String get(String url, Map<String, String> paramMap) {
    		List<String> list = new ArrayList<String>();
    		if (null != paramMap && paramMap.size() > 0) {
    			for (String key : paramMap.keySet()) {
    				list.add(key + "=" + paramMap.get(key));
    			}
    		}
    		String param = "";
    		if (null != list && list.size() > 0) {
    			param = StringUtils.join(list, "&");
    		}
    		HttpClientUtil httpsUrlConnectionMessageSender = new HttpClientUtil();
    		HttpURLConnection connection;
    		try {
    			connection = httpsUrlConnectionMessageSender
    					.createConnection(new URI(url));
    			connection.setDoOutput(true);
    			connection.setDoInput(true);
    			connection.setRequestMethod("GET");
    			connection.setUseCaches(false);
    			connection.setInstanceFollowRedirects(true);
    			connection.setRequestProperty("Content-Type",
    					"application/x-www-form-urlencoded");
    
    			connection.connect();
    			// POST请求
    			OutputStreamWriter os = null;
    			String json = "";
    			os = new OutputStreamWriter(connection.getOutputStream());
    			os.write(param);
    			os.flush();
    			json = getResponse(connection);
    			if (connection != null) {
    				connection.disconnect();
    			}
    			return json;
    		} catch (IOException e) {
    			e.printStackTrace();
    		} catch (URISyntaxException e) {
    			e.printStackTrace();
    		}
    		return "失败";
    
    	}
    	
    	public static String get(String url, String param) {
    		HttpClientUtil httpsUrlConnectionMessageSender = new HttpClientUtil();
    		HttpURLConnection connection;
    		try {
    			connection = httpsUrlConnectionMessageSender
    					.createConnection(new URI(url));
    			connection.setDoOutput(true);
    			connection.setDoInput(true);
    			connection.setRequestMethod("GET");
    			connection.setUseCaches(false);
    			connection.setInstanceFollowRedirects(true);
    			connection.setRequestProperty("Content-Type",
    					"application/x-www-form-urlencoded");
    
    			connection.connect();
    			// POST请求
    			OutputStreamWriter os = null;
    			String json = "";
    			os = new OutputStreamWriter(connection.getOutputStream());
    			os.write(param);
    			os.flush();
    			json = getResponse(connection);
    			if (connection != null) {
    				connection.disconnect();
    			}
    			return json;
    		} catch (IOException e) {
    			e.printStackTrace();
    		} catch (URISyntaxException e) {
    			e.printStackTrace();
    		}
    		return "失败";
    
    	}
    
    	public static void main(String[] args) {
    		String url = "https://crm.zoho.com.cn/crm/private/json/Potentials/searchRecords";
    		Map<String, String> paramMap = new HashMap<String, String>();
    		paramMap.put("参数名", "值");
    		System.out.println(get(url, paramMap));
    		
    		String param = "&参数名=值&参数名=值";
    		System.out.println(get(url, param));
    	}
    
    	public static String getResponse(HttpURLConnection Conn) throws IOException {
    		InputStream is;
    		if (Conn.getResponseCode() >= 400) {
    			is = Conn.getErrorStream();
    		} else {
    			is = Conn.getInputStream();
    		}
    		String response = streamToString(is, "utf-8");
    		/*
    		 * String response = ""; byte buff[] = new byte[2048]; int b = 0; while
    		 * ((b = is.read(buff, 0, buff.length)) != -1) { response += new
    		 * String(buff, 0, b);
    		 * 
    		 * }
    		 */
    		is.close();
    		return response;
    	}
    
    	public static String streamToString(InputStream in, String encoding) {
    		ByteArrayOutputStream bos = null;
    		try {
    			bos = new ByteArrayOutputStream();
    			byte[] arr = new byte[1024];
    			int len;
    			while (-1 != (len = in.read(arr))) {
    				bos.write(arr, 0, len);
    			}
    			return bos.toString(encoding);
    		} catch (IOException e) {
    			e.printStackTrace();
    			throw new RuntimeException("提取 requestBody 异常", e);
    		} finally {
    			if (null != bos) {
    				try {
    					bos.close();
    				} catch (IOException e) {
    					e.printStackTrace();
    				}
    			}
    		}
    	}
    }

# jdk1.8 #

import org.apache.commons.lang.StringUtils;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.net.HttpURLConnection;
    import java.net.URL;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    public class HttpUtils {
    	public static String httpPost(String urlAddress,Map<String, String> paramMap){ 
            if(paramMap==null){ 
                paramMap = new HashMap<String, String>(); 
            } 
            String [] params = new String[paramMap.size()]; 
            int i = 0; 
            for(String paramKey:paramMap.keySet()){ 
                String param = paramKey+"="+paramMap.get(paramKey); 
                params[i] = param; 
                i++; 
            } 
            return http(urlAddress, params, "POST"); 
        } 
    	public static String httpGet(String urlAddress,Map<String, String> paramMap){ 
            if(paramMap==null){ 
                paramMap = new HashMap<String, String>(); 
            } 
            String [] params = new String[paramMap.size()]; 
            int i = 0; 
            for(String paramKey:paramMap.keySet()){ 
                String param = paramKey+"="+paramMap.get(paramKey); 
                params[i] = param; 
                i++; 
            } 
            return http(urlAddress, params, "GET"); 
        } 
    	
        public static String httpPost(String urlAddress,List<String> paramList){ 
            if(paramList==null){ 
                paramList = new ArrayList<String>(); 
            } 
            return http(urlAddress, paramList.toArray(new String[0]), "POST"); 
        } 
        
    	public static String httpGet(String urlAddress,List<String> paramList) {
            return http(urlAddress, paramList.toArray(new String[0]), "GET"); 
    	}
        
        public static String http(String urlAddress,String []params, String requestType){ 
            URL url = null; 
            HttpURLConnection con  =null; 
            BufferedReader in = null; 
            StringBuffer result = new StringBuffer(); 
            try { 
                url = new URL(urlAddress); 
                con  = (HttpURLConnection) url.openConnection(); 
                con.setUseCaches(false); 
                con.setDoOutput(true); 
                con.setRequestMethod(requestType); 
                String paramsTemp = ""; 
                for(String param:params){ 
                    if(StringUtils.isNotEmpty(param)){ 
                        paramsTemp+="&"+param; 
                    } 
                } 
                byte[] b = paramsTemp.getBytes(); 
                con.getOutputStream().write(b, 0, b.length); 
                con.getOutputStream().flush(); 
                con.getOutputStream().close(); 
                in = new BufferedReader(new InputStreamReader(con.getInputStream())); 
                while (true) { 
                  String line = in.readLine(); 
                  if (line == null) { 
                    break; 
                  } 
                  else { 
                      result.append(line); 
                  } 
                } 
            } catch (IOException e) { 
                e.printStackTrace(); 
            }finally{ 
                try { 
                    if(in!=null){ 
                        in.close(); 
                    } 
                    if(con!=null){ 
                        con.disconnect(); 
                    } 
                } catch (IOException e) { 
                    e.printStackTrace(); 
                } 
            } 
            return result.toString(); 
        }
    
        public static void main(String[] args) {
            Map<String,String> objectMap = new HashMap<>();
            objectMap.put("参数","值");
     
            HttpUtils.httpGet("url",objectMap);
        }
        
    }

##    二种方式都可以访问成功，亲测的 ##

最后：在项目中遇到的几个问题也提一下，

1.有些https跨域访问，url中文需要编码的，不然也会报错，具体查看报错详情核对原因

2.中间流读取中文本来有乱码，半个文字字节读取那样的，后面屏蔽那段方法加上下面的byte流的读取方式，就没有不读取完整的问题了

任何事情，遇到困难，保持头脑清晰，谁都有麻烦事，不要遇到问题就退缩。