解决jdk1.7https 请求是TLS1不支持TLS1.2的问题

ssl证书双向认证访问https—解决javax.net.ssl.SSLHandshakeException: Received fatal alert: handshake_failure 替换${java_home}/jre/lib/security/ 下面的local_policy.jar和US_export_policy.jar即可。下载后解压,可以看到local_policy.jar和US_export_policy.jar以及readme.txt,但经过我一步步踩坑,到最终解决问题,我发现问题的原因并不完全和上面描述的一直,下面我一步步讲解我的解决过程。我是第三种,替换可jar文件,就可以运行了,撒花撒花撒花。别灰心,别气馁,继续Google。,那就把TLSv1.0去掉吧。 阅读详情

如果可以升级jdk把jdk升级到1.8就可以解决,今天被这个困扰了一上午,老是抛出异常 connection reset,下面来说一下解决方法

package com.miaodiyun.httpapidemo.common;

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;  
  
/** 
 * Created by hzlizhou on 2016/9/9. 
 */  
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  
        };  
    }  
}

 

package com.miaodiyun.httpapidemo.common;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.HttpURLConnection;
import java.net.URI;
import java.net.URL;
import java.net.URLConnection;

import org.apache.commons.codec.digest.DigestUtils;

import javax.net.ssl.HttpsURLConnection;

/**
 * http请求工具
 */
public class HttpUtil {

    public static HttpURLConnection createConnection(URI uri) throws IOException {
        URL url = uri.toURL();
        URLConnection connection = url.openConnection();
        HttpsURLConnection httpsURLConnection = (HttpsURLConnection) connection;
        httpsURLConnection.setSSLSocketFactory(new TLSSocketConnectionFactory());
        return httpsURLConnection;
    }
    /**
     * post请求
     * 
     * @param url
     *            功能和操作
     * @param body
     *            要post的数据
     * @return
     * @throws IOException
     */
    public static String post(String url, String body) {
        System.out.println("body:" + System.lineSeparator() + body);
        String result = "";
        try {
            OutputStreamWriter out = null;
            BufferedReader in = null;
//            URL realUrl = new URL(url);
//            URLConnection conn = realUrl.openConnection();
            HttpURLConnection conn = HttpUtil.createConnection(new URI(url ));

            // 设置连接参数
            conn.setDoOutput(true);
            conn.setDoInput(true);
            conn.setConnectTimeout(5000);
            conn.setReadTimeout(20000);
            conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
            // 提交数据
            out = new OutputStreamWriter(conn.getOutputStream(), "UTF-8");
            out.write(body);
            out.flush();

            // 读取返回数据
            in = new BufferedReader(new InputStreamReader(conn.getInputStream(), "UTF-8"));
            String line = "";
            boolean firstLine = true; // 读第一行不加换行符
            while ((line = in.readLine()) != null) {
                if (firstLine) {
                    firstLine = false;
                } else {
                    result += System.lineSeparator();
                }
                result += line;
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

}

 

参考:https://ligaosong.iteye.com/blog/2356346

bcprov-ext-jdk15on-1.54.jar 下载地址 链接:https://pan.baidu.com/s/1EThNXYOgyMQf_WtQa7UTUw 
提取码:f1mv 

 

 

 

javax.net.ssl.SSLHandshakeException: Received fatal alert: handshake_failure 阅读详情

相关推荐

javax.net.ssl.SSLException: Received fatal alert: protocol_version问题解决

完整报错如下: com.mysql.jdbc.exceptions.jdbc4.CommunicationsException: Communications link failure The last packet successfully received from the server was 122 milliseconds ago. The last packet sent successfully to the server was 119 milliseconds ago. at s

微电子学与固体电子学-俞驰 1万+

javax.net.ssl.SSLHandshakeException: Received fatal alert: handshake_failure问题解决

最近在生产环境调用Https接口出现这个问题javax.net.ssl.SSLHandshakeException: Received fatal alert: handshake_failure,经查询,见到网上大部分答案是替换%JAVA_HOME%\jre\lib\security路径下的两个jar包,local_policy.jar和US_export_policy.jar,由于自己替换后发...

wms_17512098051的博客 1万+

JDK版本不同引发的https请求证书问题

终于等到你问题解决问题描述问题分析解决过程 问题解决 问题描述 首先,服务器上跑着一个接口工程,环境是jdk8,为https请求(证书认证,但这里绕过了证书);客户端通过https调用接口,环境是jdk7,请求时报如下错: javax.net.ssl.SSLHandshakeException: Received fatal alert: handshake_failure 问题分析 这个问题出...

charmsongo的博客 7656

解决jdk1.7默认https 请求是TLS1不支持TLS1.2的问题

1,You could just add the following property -Dhttps.protocols=TLSv1.1,TLSv1.2 which configures the JVM to specify which TLS protocol version should be used during https connections.2,参考 点击打开链接...

sunzbking的博客 2万+

Httpclient3.1指定tlsv1.2协议访问https

前言 最近因公司某个服务器应用升级以及互联网安全要求,近期将禁用对TLSv1.0、TLSv1.1的访问支持,要求所有访问该服务的客户端项目升级到TLSv1.2,否则到期TLSv1.2生效后,将影响客户端的正常访问,于是安排工作着手对部份老项目进行升级改造。 TLS协议说明 百度百科的描述 安全传输层协议(TLS)用于在两个通信应用程序之间提供保密性和数据完整性。 该协议由两层组成: TLS 记录协议(TLS Record)和 TLS 握手协议(TLS Handshake)。 传输层安全性协

不会飞的小龙人的博客 1万+

java8支持sslv2_JDK版本不同引发的https请求证书问题

问题解决问题描述首先,服务器上跑着一个接口工程,环境是jdk8,为https请求(证书认证,但这里绕过了证书);客户端通过https调用接口,环境是jdk7,请求时报如下错:javax.net.ssl.SSLHandshakeException: Received fatal alert: handshake_failure问题分析这个问题出现的原因是因为开发时,我客户端用的jdk8测试,没有出现...

weixin_39534002的博客 2111

解决jdk1.7 不支持TLS1.2的问题

场景   java程序使用https方式调用nessus接口时,使用jdk1.7返回如下内容: javax.net.ssl.SSLException: Unrecognized SSL message, plaintext connection?  使用jdk1.8返回正常 {"token":"f360654233f65d964ed220914ec10916fe206a3d1b1c1b...

6831

经典损失函数——均方误差(MSE)和交叉熵误差(CEE)的python实现

损失函数(loss function)用来表示当前的神经网络对训练数据不拟合的程度。这个损失函数有很多,但是一般使用均方误差和交叉熵误差等。 1.均方误差(mean squared error) 先来看一下表达式: 用于将的求导结果变成,是神经网络的输出,是训练数据的标签值,k表示数据的维度。 用python实现: def MS...

Answer3664的博客 1万+

JDK1.7是否支持TLS1.2

查找资料后得出是jdk1.7不支持tls1.2、推测应该是线上调用的服务网关配置强制tls1.2及以上了、不再支持tls1.1了。继续搜索、有的说要jdk1.7 u95的更新版才支持、orcale官网最新版彩u80 何来u95、即https请求时 客户端不支持tls1.2协议、关于https的tls协议这里不多讲述、异常栈。查看异常位点、代码是使用的apache-httpClient 请求oa时报的错、报错信息明显。根据查询解决结果、网上大体分两派、一是加jvm运营参数派,增加如下配置。

650

遥感图像小白--2--图像分割

遥感图像分割基础入门

Mary的博客 4238

Vue3项目实战:CKEditor5富文本编辑器从安装到隐藏不需要的功能

本文详细介绍了在Vue3项目中集成并深度定制CKEditor5富文本编辑器的完整流程。通过分析其模块化架构,指导开发者从标准构建出发,移除图片、表格等冗余插件,创建专属轻量构建,从而显著减小打包体积并提升用户体验。文章结合实战代码,涵盖了环境搭建、自定义构建配置、高级优化技巧等关键步骤。

weixin_29016833的博客 288

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

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

刘超军的博客 8112

LVGL v9的lv_scale控件实战:5分钟打造动态仪表盘(附完整代码)

本文详细介绍了LVGL v9中lv_scale控件的实战应用,通过5个关键步骤快速打造动态仪表盘。文章涵盖核心特性解析、代码实现、样式定制及性能优化,适用于工业HMI、智能家居等场景,并附完整代码示例。

gin88的博客 262

JDK1.7不支持Https TLS1.2协议

1前言     jdk1.7 支持协议 :SSLv2Hello 、SSLv3、TLSv1、TLSv1.1、TLSv1.2五种协议,但是默认协议是:TLSv1,因为https 请求是双向认证的也就是jdk的支持协议最低是TLSv1以上的版本,所有jdk1.7不能访问https请求。2解决思路  新建类 TrustAnyHostnameVerifier  implements HostnameVeri...

u011519508的专栏 1万+

10、X射线聚焦与光学元件技术解析

本文深入解析了X射线聚焦与光学元件技术,重点讨论了椭圆镜的聚焦原理及局限性,多层镜的设计优化及其突破性应用,以及X射线波导的基础理论和模式求解方法。文章还总结了这些技术的优势、局限及其在材料科学、生物学和医学等领域的广泛应用前景。通过理论推导与技术改进,这些光学元件为X射线成像技术的发展提供了重要支撑。

pz890123的博客 123

【系统架构设计师】论文模板样例:论软件系统架构风格

本人于年月参与项目,该系统为*,在该项目组中我担任系统架构师岗位,主要负责系统整体架构设计。本文以该车联网项目为例,主要讨论了软件架构风格在该项目中的具体应用。底层架构风格我们采用了虚拟机风格中的解释器,因该公交共有几十种不同的数据协议,使用解释器风格可以满足整车数据协议兼容性需求;中间层关于应用层的数据流转采用了独立构件风格中的隐式调用,以减低系统间耦合度、简化软件架构,提高可修改性方面的架构属性;应用系统层采用了B/S的架构风格,统一解决公交行业性难题“实施推广难、维护难”问题。

数据知道的博客 9931

java 6 tls1.2_解决 JDK1.7 不支持 VCenter 6.7 的问题(涉及到Https TLS1.2协议)

解决 JDK1.7 不支持 VCenter 6.7 的问题问题描述原项目工程是使用JDK 1.7,可以连接 5.X版本和 6.0版本的 VCenter资源池。但是,现在VCenter已经升到 6.7版本,原程序对于高版本的 VCenter 6.7 不再试用。连接VCenter 6.7版本的资源池的时候,一直报 SSLHandshakeException的异常错误。报错信息如下:问题处理1、背景介...

weixin_29759387的博客 457

全国青少年信息素养大赛图形化(Scratch)编程考点总结

全国青少年信息素养大赛图形化(Scratch)编程考点总结

伶俐角少儿编程 383

jdk1.6支持TLS1.2并忽略证书验证和用户验证

import java.io.*; import java.net.InetAddress; import java.net.InetSocketAddress; import java.net.Socket; import java.net.UnknownHostException; import java.security.*; import java.security.cert.*; imp...

没忄没肺的博客 4286

[Dify实战] 项目复盘助手:自动拉数据、生成复盘报告

本文介绍如何利用Dify平台构建自动化项目复盘助手,解决传统人工复盘效率低、易遗漏等问题。系统通过自动拉取Git/Jira等数据源,计算关键指标后,由LLM生成结构化复盘报告。文章详细讲解了数据采集、指标计算、Prompt设计等核心模块的实现,并分享了完整Workflow搭建步骤。实践表明,该系统能将复盘耗时从4小时缩短至10分钟,显著提升数据准确率和执行频率。最后总结了数据一致性、输出质量等常见问题的解决方案,强调Dify+LLM组合可实现复盘流程的自动化流水线。

技术小甜甜:传播可落地技术,帮助个人和企业降低解决真实场景问题的成本 121

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

JDK1.7不支持Https TLS1.2协议 1.8及以上支持

1:前言 jdk1.7支持协议:SSLv2Hello 、SSLv3、TLSv1、TLSv1.1、TLSv1.2五种协议,但是默认协议是:TLSv1,因为https 请求是双向认证的也就是jdk的支持协议最低是TLSv1以上的版本,所有jdk1.7不能访问https请求。 jdk1.7访问https出现握手失败的情况,原因是jdk1.7默认TLS1.1,目标服务器jdk1.8使用TLS1.2 2:解决方式 新建立类: import javax.ne...

run_2005的博客 5351

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

https请求报Connection reset问题

背景: 使用HttpsURLconnection或者HttpURLConnection进行https请求时,有时会报Connection reset异常 原因: 这是因为客户端的TLS版本服务端不支持的原因。 对于JDK1.6,支持SSLv2、SSLv3、TLSv1,默认使用TLSv1 对于JDK1.7,支持SSLv2、SSLv3、TLSv1、TLSv1.1、TLSv1.2,默认使...

m0_37825799的博客 1万+

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

JAVA HTTPS单向认证和双向认证以及JDK低版本请求

有没有童鞋遇到个问题,就是公司项目太老,用的是JDK1.7,JDK1.8以下的,由于需要调用HTTPS相关接口导致SSLException等异常, 解决办法尝试过的童鞋会采用升级JDK1.8以上,了解版本更新的童鞋就会知道,JDK1.8已经默认支持了HTTPS相关支持。 由于项目老,升级JDK导致很多地方出现问题。 JDK1.7 默认是 TSLv1, 但是可以支持 TSLv1.1,TSLv1.2; JDK1.8 默认是 TSLv1.2 由于JDK1.8以下,发送https请求会导致各种SSL异常信息报错 常

BugRoot的博客 1万+

java6不支持tlsv1.2_解决 JDK1.7 不支持 VCenter 6.7 的问题(涉及到Https TLS1.2协议)

解决 JDK1.7 不支持 VCenter 6.7 的问题问题描述原项目工程是使用JDK 1.7,可以连接 5.X版本和 6.0版本的 VCenter资源池。但是,现在VCenter已经升到 6.7版本,原程序对于高版本的 VCenter 6.7 不再试用。连接VCenter 6.7版本的资源池的时候,一直报 SSLHandshakeException的异常错误。报错信息如下: 问题处理1、背景...

weixin_39539807的博客 523
上一篇: mybatis 批量insert和批量update
下一篇: java 调用微信JsApi支付
linanqi_java
博客等级 码龄10年 8粉丝 19原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值