javax.net.ssl.SSLHandshakeException:异常原因及解决方案_Java

报错原因

一般出现这种问题是因为目标服务器的证书问题，证书的 subject alternative names 字段中没有包含客户端所使用的连接地址（这里是 ip 地址）

一般建议不要使用ip地址来进行链接，如果实在是要用ip地址来进行连接的话，有两种处理方案：

方法一：可以将ip地址加入到服务器证书的 subject alternative names 字段中；

方法二：在程序中进行处理，绕过目标服务器的安全验证

下面来介绍的就是方法二：在程序中绕过服务器的安全验证

在程序中绕过服务器的安全验证

以下就是绕过服务器验证的具体实现代码

import java.util.regex.matcher;
import java.util.regex.pattern;
import java.io.bufferedreader;
import java.io.dataoutputstream;
import java.io.inputstreamreader;
import java.net.url;
import java.security.securerandom;

import javax.net.ssl.httpsurlconnection;
import javax.net.ssl.hostnameverifier;
import javax.net.ssl.sslcontext;
import javax.net.ssl.sslsession;
import javax.net.ssl.sslsocketfactory;
import javax.net.ssl.trustmanager;
import javax.net.ssl.x509trustmanager;


/**
 * @author cbcbcb
 *
 */
public class test {

	public static void main(string[] args) {
		// 测试绕过主机验证
		string pathurl ="https://ip:port/api/test";
		string json = "{\"name\":\"ccc\"}";
		stringbuffer sbf = new stringbuffer();
        try {
            // 创建信任所有证书的 trustmanager
            trustmanager[] trustallcerts = new trustmanager[]{
                    new x509trustmanager() {
                        @override
                        public void checkclienttrusted(java.security.cert.x509certificate[] chain, string authtype) {
                        }

                        @override
                        public void checkservertrusted(java.security.cert.x509certificate[] chain, string authtype) {
                        }

                        @override
                        public java.security.cert.x509certificate[] getacceptedissuers() {
                            return new java.security.cert.x509certificate[]{};
                        }
                    }
            };

            // 创建 sslcontext 并初始化
            sslcontext sslcontext = sslcontext.getinstance("ssl");
            sslcontext.init(null, trustallcerts, new securerandom());

            // 获取 sslsocketfactory
            sslsocketfactory ssf = sslcontext.getsocketfactory();

            // 创建绕过主机名验证的 hostnameverifier
            hostnameverifier allhostsvalid = new hostnameverifier() {
                @override
                public boolean verify(string hostname, sslsession session) {
                    return true;
                }
            };

            url urlx = new url(pathurl);
            httpsurlconnection connection = (httpsurlconnection) urlx.openconnection();
            connection.setdoinput(true);
            connection.setdooutput(true);
            connection.setrequestmethod("post");
            connection.setusecaches(false);
            connection.setinstancefollowredirects(true);
            connection.addrequestproperty("content-type", "application/json");
            connection.setrequestproperty("user-agent", "mozilla/4.0 (compatible; msie 5.0; windows nt; digext)");

           

            // 设置 sslsocketfactory 和 hostnameverifier
            connection.setsslsocketfactory(ssf);
            connection.sethostnameverifier(allhostsvalid);

            connection.connect();
            dataoutputstream out = new dataoutputstream(connection.getoutputstream());

            if (!"".equals(json)) {
                out.write(json.getbytes());
            }
            out.flush();
            out.close();

            bufferedreader reader = new bufferedreader(new inputstreamreader(connection.getinputstream()));
            string lines;
            while ((lines = reader.readline()) != null) {
                lines = new string(lines.getbytes(), "utf-8");
                sbf.append(lines);
            }
//             system.out.println("crm返回参数：" + sbf);
            reader.close();
            // 断开连接
            connection.disconnect();
        } catch (exception e) {
            e.printstacktrace();
        }
        system.out.println(decodeunicode(sbf.tostring()));
		
	}

    //下面这个方法是对输出的内容进行编译，有些接口返回的数据在输出台可能会是乱码展示
    //这个时候在什么方法都无用的情况下，可以通过这个方法将乱码重新编译成正确的展示
	    public static string decodeunicode(string str) {
	        pattern pattern = pattern.compile("(\\\\u(\\p{xdigit}{4}))");
	        matcher matcher = pattern.matcher(str);
	        char ch;
	        while (matcher.find()) {
	            ch = (char) integer.parseint(matcher.group(2), 16);
	            str = str.replace(matcher.group(1), ch + "");
	        }
	        return str;
	    }
	

}

注意点

在上面这串代码中，有一些需要注意的一点就是在设置绕过验证的时候一定要注意设置的是对当前实例绕过还是全部都绕过，稍微有点不注意，设置成了全局的话，那么整个项目所有的链接都会收到相应的影响，所以这里一定要注意注意再注意

httpsurlconnection.setdefaulthostnameverifier-----全局设置

//全局设置
hostnameverifier allhostsvalid = new hostnameverifier() {
            @override
            public boolean verify(string hostname, sslsession session) {
                return true;           
            }
        };
        httpsurlconnection.setdefaulthostnameverifier(allhostsvalid);

connection.sethostnameverifier(allhostsvalid);-------设置对当前实例的

// 创建绕过主机名验证的 hostnameverifier
            hostnameverifier allhostsvalid = new hostnameverifier() {
                @override
                public boolean verify(string hostname, sslsession session) {
                    return true;
                }
            };
 connection.sethostnameverifier(allhostsvalid);