精华内容
下载资源
问答
  • 使用java代码模拟https实现。具体来源详见:https://my.oschina.net/ydsakyclguozi/blog/612886。 欢迎大家去看,我不敢将功劳据为己有。 包括如下6个类: DesCoder Des对称加密和解密工具类 HttpsMockBase https...
  • Java实现https请求

    千次阅读 2019-01-23 19:06:08
    /** * @author XuJD * @create 2019-01-21 17:21 **/ public class HttpsUtil { private static Logger logger = LoggerFactory.getLogger(HttpsUtil.class);... public static JSONObject httpsRequest(St...
    /**
     * @author XuJD
     * @create 2019-01-21 17:21
     **/
    public class HttpsUtil {
        private static Logger logger = LoggerFactory.getLogger(HttpsUtil.class);
    
        public static JSONObject httpsRequest(String requestUrl, String requestMethod, String outputStr) {
            logger.info("send https requestUrl:"+requestUrl);
            logger.info("send https requestMethod:"+requestMethod);
            logger.info("send https param:"+outputStr);
            JSONObject jsonObject = new JSONObject();
            StringBuffer buffer = new StringBuffer();
            InputStream inputStream = null;
            InputStreamReader inputStreamReader = null;
            BufferedReader bufferedReader = null;
            try {
                // 创建SSLContext对象,并使用我们指定的信任管理器初始化
                TrustManager[] tm = {new MyX509TrustManager()};
                SSLContext sslContext = SSLContext.getInstance("SSL", "SunJSSE");
                sslContext.init(null, tm, new java.security.SecureRandom());
                // 从上述SSLContext对象中得到SSLSocketFactory对象
                SSLSocketFactory ssf = sslContext.getSocketFactory();
    
                URL url = new URL(requestUrl);
                HttpsURLConnection httpUrlConn = (HttpsURLConnection) url.openConnection();
                httpUrlConn.setSSLSocketFactory(ssf);
                /*允许输出*/
                httpUrlConn.setDoOutput(true);
                /*允许输入*/
                httpUrlConn.setDoInput(true);
                /*不允许缓存*/
                httpUrlConn.setUseCaches(false);
                // 设置请求方式(GET/POST)
                httpUrlConn.setRequestMethod(requestMethod);
                /*如果是get请求,明文连接*/
                if (HttpMethod.GET.toString().equalsIgnoreCase(requestMethod)) {
                    httpUrlConn.connect();
                }
                // 当有数据需要提交时
                if (!StringUtils.isEmpty(outputStr)) {
                    OutputStream outputStream = httpUrlConn.getOutputStream();
                    // 注意编码格式,防止中文乱码
                    outputStream.write(outputStr.getBytes("UTF-8"));
                    outputStream.close();
                }
                // 将请求返回的输入流转换成字json对象
                inputStream = httpUrlConn.getInputStream();
                inputStreamReader = new InputStreamReader(inputStream, "UTF-8");
                bufferedReader = new BufferedReader(inputStreamReader);
                String str = null;
                while ((str = bufferedReader.readLine()) != null) {
                    buffer.append(str);
                }
                httpUrlConn.disconnect();
                jsonObject = (JSONObject) JSONObject.parse(buffer.toString());
                logger.info("response code:"+httpUrlConn.getResponseCode());
                logger.info("response jsonObject:"+jsonObject);
            } catch (ConnectException ce) {
                logger.info("Weixin server connection timed out.");
                throw new BusinessException("Weixin server connection timed out.");
            } catch (Exception e) {
                logger.info("https request error:" + e);
                throw new BusinessException("https request error:" + e);
            } finally {
                try {
                    // 释放资源
                    bufferedReader.close();
                    inputStreamReader.close();
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return jsonObject;
        }
    }
    
    

    自定义信任管理器

    /**
     * @author XuJD
     * @create 2019-01-21 17:24
     **/
    public class MyX509TrustManager implements X509TrustManager{
        @Override
        public void checkClientTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
    
        }
    
        @Override
        public void checkServerTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
    
        }
    
        @Override
        public X509Certificate[] getAcceptedIssuers() {
            return null;
        }
    }
    
    
    展开全文
  • java实现https请求

    万次阅读 2018-08-07 21:25:45
    ...import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net....

    package com.demo.test;

    import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.URL;
    import java.security.KeyManagementException;
    import java.security.NoSuchAlgorithmException;
    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.KeyManager;
    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;

    public class HttpsUtil {

        private static final class DefaultTrustManager implements X509TrustManager {
            @Override
            public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
            }

            @Override
            public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
            }

            @Override
            public X509Certificate[] getAcceptedIssuers() {
                return null;
            }
        }

        private static HttpsURLConnection getHttpsURLConnection(String uri, String method) throws IOException {
            SSLContext ctx = null;
            try {
                ctx = SSLContext.getInstance("TLS");
                ctx.init(new KeyManager[0], new TrustManager[] { new DefaultTrustManager() }, new SecureRandom());
            } catch (KeyManagementException e) {
                e.printStackTrace();
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            }
            SSLSocketFactory ssf = ctx.getSocketFactory();

            URL url = new URL(uri);
            HttpsURLConnection httpsConn = (HttpsURLConnection) url.openConnection();
            httpsConn.setSSLSocketFactory(ssf);
            httpsConn.setHostnameVerifier(new HostnameVerifier() {
                @Override
                public boolean verify(String arg0, SSLSession arg1) {
                    return true;
                }
            });
            httpsConn.setRequestMethod(method);
            httpsConn.setDoInput(true);
            httpsConn.setDoOutput(true);
            return httpsConn;
        }

        private static byte[] getBytesFromStream(InputStream is) throws IOException {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            byte[] kb = new byte[1024];
            int len;
            while ((len = is.read(kb)) != -1) {
                baos.write(kb, 0, len);
            }
            byte[] bytes = baos.toByteArray();
            baos.close();
            is.close();
            return bytes;
        }

        private static void setBytesToStream(OutputStream os, byte[] bytes) throws IOException {
            ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
            byte[] kb = new byte[1024];
            int len;
            while ((len = bais.read(kb)) != -1) {
                os.write(kb, 0, len);
            }
            os.flush();
            os.close();
            bais.close();
        }

        public static byte[] doGet(String uri) throws IOException {
            HttpsURLConnection httpsConn = getHttpsURLConnection(uri, "GET");
            return getBytesFromStream(httpsConn.getInputStream());
        }

        public static byte[] doPost(String uri, String data) throws IOException {
            HttpsURLConnection httpsConn = getHttpsURLConnection(uri, "POST");
            setBytesToStream(httpsConn.getOutputStream(), data.getBytes());
            return getBytesFromStream(httpsConn.getInputStream());
        }
    }
     

    package com.demo.test;

    import java.io.FileOutputStream;
    import java.io.IOException;

    public class test {
        public static void main(String[] args) throws IOException {
            String uri = "https://www.baidu.com";
            byte[] bytes = HttpsUtil.doGet(uri);
            System.out.println(new String (bytes,"utf-8"));
            FileOutputStream fos = new FileOutputStream("D:/bing.txt");
            fos.write(bytes);
            fos.close();
            System.out.println("done!");
            byte[] bytes1 = "hello world".getBytes();        //Verify original content
            System.out.println( new String(bytes1,"utf-8") );
        }

    }
     

    HTTP与HTTPS的区别

      超文本传输协议HTTP协议被用于在Web浏览器和网站服务器之间传递信息,HTTP协议以明文方式发送内容,不提供任何方式的数据加密,如果攻击者截取了Web浏览器和网站服务器之间的传输报文,就可以直接读懂其中的信息,因此,HTTP协议不适合传输一些敏感信息,比如:信用卡号、密码等支付信息。

      为了解决HTTP协议的这一缺陷,需要使用另一种协议:安全套接字层超文本传输协议HTTPS,为了数据传输的安全,HTTPS在HTTP的基础上加入了SSL协议,SSL依靠证书来验证服务器的身份,并为浏览器和服务器之间的通信加密。

    一、HTTP和HTTPS的基本概念

      HTTP:是互联网上应用最为广泛的一种网络协议,是一个客户端和服务器端请求和应答的标准(TCP),用于从WWW服务器传输超文本到本地浏览器的传输协议,它可以使浏览器更加高效,使网络传输减少。

      HTTPS:是以安全为目标的HTTP通道,简单讲是HTTP的安全版,即HTTP下加入SSL层,HTTPS的安全基础是SSL,因此加密的详细内容就需要SSL。

      HTTPS协议的主要作用可以分为两种:一种是建立一个信息安全通道,来保证数据传输的安全;另一种就是确认网站的真实性。

    二、HTTP与HTTPS有什么区别?

      HTTP协议传输的数据都是未加密的,也就是明文的,因此使用HTTP协议传输隐私信息非常不安全,为了保证这些隐私数据能加密传输,于是网景公司设计了SSL(Secure Sockets Layer)协议用于对HTTP协议传输的数据进行加密,从而就诞生了HTTPS。简单来说,HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、身份认证的网络协议,要比http协议安全。

      HTTPS和HTTP的区别主要如下:

      1、https协议需要到ca申请证书,一般免费证书较少,因而需要一定费用。

      2、http是超文本传输协议,信息是明文传输,https则是具有安全性的ssl加密传输协议。

      3、http和https使用的是完全不同的连接方式,用的端口也不一样,前者是80,后者是443。

      4、http的连接很简单,是无状态的;HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、身份认证的网络协议,比http协议安全。

    三、HTTPS的工作原理

      我们都知道HTTPS能够加密信息,以免敏感信息被第三方获取,所以很多银行网站或电子邮箱等等安全级别较高的服务都会采用HTTPS协议。

    HTTP与HTTPS的区别-马海祥博客

     客户端在使用HTTPS方式与Web服务器通信时有以下几个步骤,如图所示。

      (1)客户使用https的URL访问Web服务器,要求与Web服务器建立SSL连接。

      (2)Web服务器收到客户端请求后,会将网站的证书信息(证书中包含公钥)传送一份给客户端。

      (3)客户端的浏览器与Web服务器开始协商SSL连接的安全等级,也就是信息加密的等级。

      (4)客户端的浏览器根据双方同意的安全等级,建立会话密钥,然后利用网站的公钥将会话密钥加密,并传送给网站。

      (5)Web服务器利用自己的私钥解密出会话密钥。

      (6)Web服务器利用会话密钥加密与客户端之间的通信。

      

    四、HTTPS的优点

      尽管HTTPS并非绝对安全,掌握根证书的机构、掌握加密算法的组织同样可以进行中间人形式的攻击,但HTTPS仍是现行架构下最安全的解决方案,主要有以下几个好处:

      (1)使用HTTPS协议可认证用户和服务器,确保数据发送到正确的客户机和服务器;

      (2)HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、身份认证的网络协议,要比http协议安全,可防止数据在传输过程中不被窃取、改变,确保数据的完整性。

      (3)HTTPS是现行架构下最安全的解决方案,虽然不是绝对安全,但它大幅增加了中间人攻击的成本。

      (4)谷歌曾在2014年8月份调整搜索引擎算法,并称“比起同等HTTP网站,采用HTTPS加密的网站在搜索结果中的排名将会更高”。

    五、HTTPS的缺点

      虽然说HTTPS有很大的优势,但其相对来说,还是存在不足之处的:

      (1)HTTPS协议握手阶段比较费时,会使页面的加载时间延长近50%,增加10%到20%的耗电;

      (2)HTTPS连接缓存不如HTTP高效,会增加数据开销和功耗,甚至已有的安全措施也会因此而受到影响;

      (3)SSL证书需要钱,功能越强大的证书费用越高,个人网站、小网站没有必要一般不会用。

        (4)SSL证书通常需要绑定IP,不能在同一IP上绑定多个域名,IPv4资源不可能支撑这个消耗。

      (5)HTTPS协议的加密范围也比较有限,在黑客攻击、拒绝服务攻击、服务器劫持等方面几乎起不到什么作用。最关键的,SSL证书的信用链体系并不安全,特别是在某些国家可以控制CA根证书的情况下,中间人攻击一样可行。

    六、http切换到HTTPS

      如果需要将网站从http切换到https到底该如何实现呢?

         这里需要将页面中所有的链接,例如js,css,图片等等链接都由http改为https。例如:http://www.baidu.com改为https://www.baidu.com

      BTW,这里虽然将http切换为了https,还是建议保留http。所以我们在切换的时候可以做http和https的兼容,具体实现方式是,去掉页面链接中的http头部,这样可以自动匹配http头和https头。例如:将http://www.baidu.com改为//www.baidu.com。然后当用户从http的入口进入访问页面时,页面就是http,如果用户是从https的入口进入访问页面,页面即使https的。

     

    展开全文
  • JAVA实现HTTPS接口(POST方式)

    万次阅读 2017-12-22 14:24:04
    前言:最近开发一个项目,需要回调其他公司的HTTPS...1.实现X509证书信任管理器类(避免导证书) import java.security.cert.CertificateException; import java.security.cert.X509Certificate; import java

    前言:最近开发一个项目,需要回调其他公司的HTTPS远程接口,由于开发过程中遇到些困难,但最终还是解决,写这篇博客,记录一下过程。

    1.实现X509证书信任管理器类(避免导证书)

    import java.security.cert.CertificateException;
    import java.security.cert.X509Certificate;


    import javax.net.ssl.X509TrustManager;


    public class MyX509TrustManager implements X509TrustManager{

    @Override  
    public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {  
       
    }  
     
    @Override  
    public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {  
                       
    }  
     
    @Override  
    public X509Certificate[] getAcceptedIssuers() {    
        return null;  
    }  
    }

    2.写一个发送POST请求的类

    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.PrintWriter;
    import java.net.URL;

    import javax.net.ssl.HttpsURLConnection;
    import javax.net.ssl.SSLContext;
    import javax.net.ssl.SSLSocketFactory;
    import javax.net.ssl.TrustManager;

    public class HttpRequest {

        /**
         * 向指定 URL 发送POST方法的请求
         * 
         * @param url
         *            发送请求的 URL
         * @param param
         *            请求参数,请求参数应该是 name1=value1&name2=value2 的形式。
         * @return 所代表远程资源的响应结果
         */
        public static String sendPost(String url, String param) {
            PrintWriter out = null;
            BufferedReader in = null;
            String result = "";
            try {
           
            // 创建SSLContext对象,并使用我们指定的信任管理器初始化     
                TrustManager[] tm = { new MyX509TrustManager() };    
                SSLContext sslContext = SSLContext.getInstance("SSL");             
                sslContext.init(null, tm, new java.security.SecureRandom());    
                  
                // 从上述SSLContext对象中得到SSLSocketFactory对象     
                SSLSocketFactory ssf = sslContext.getSocketFactory(); 
                
                // 打开和URL之间的连接
                URL realUrl = new URL(url);
                HttpsURLConnection conn = (HttpsURLConnection) realUrl.openConnection();
                conn.setSSLSocketFactory(ssf); 
                
                // 设置通用的请求属性
                conn.setRequestProperty("accept", "*/*");
                conn.setRequestProperty("connection", "Keep-Alive");
                conn.setRequestProperty("content-Type", "application/json");
                conn.setRequestProperty("user-agent",
                        "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
                // 发送POST请求必须设置如下两行
                conn.setDoOutput(true);
                conn.setDoInput(true);
                // 获取URLConnection对象对应的输出流
                out = new PrintWriter(conn.getOutputStream());
                // 发送请求参数
                         
                out.print(param);
                // flush输出流的缓冲
                out.flush();
                // 定义BufferedReader输入流来读取URL的响应
                in = new BufferedReader(
                        new InputStreamReader(conn.getInputStream()));
                String line;
                while ((line = in.readLine()) != null) {
                    result += line;
                }
                System.out.println("-----result-----"+result);
            } catch (Exception e) {
                System.out.println("发送 POST 请求出现异常!"+e);
                e.printStackTrace();
            }
            //使用finally块来关闭输出流、输入流
            finally{
                try{
                    if(out!=null){
                        out.close();
                    }
                    if(in!=null){
                        in.close();
                    }
                }
                catch(IOException ex){
                    ex.printStackTrace();
                }
            }
            return result;
        }   
     
    }

    3.调用POST请求测试代码

    import java.util.HashMap;
    import java.util.Map;


    import com.alibaba.druid.support.json.JSONUtils;


    public class Test {

    private static String url = "https://192.168.1.101/"; 

    public static void main(String[] args) throws Exception {

    Map<String,Object> param = new HashMap<String,Object>();

    //封装请求数据
    param.put("service", "service");
       param.put("api", "api");    
       param.put("method", "method");  


       String message = JSONUtils.toJSONString(param);
       
       HttpRequest.sendPost(url, message);
    }
    }

    这种方式的好处是绕过了证书认证,避免导证书,比较方便、简洁。

    展开全文
  • JAVA实现HTTPS协议POST请求JSON报文

    万次阅读 2017-12-11 16:48:08
    HTTPS和HTTP的区别 超文本传输协议HTTP协议被用于在Web浏览器和网站服务器之间传递信息。HTTP协议以明文方式发送内容,不提供任何方式的数据加密,如果攻击者截取了Web浏览器和网站服务器之间的传输报文,就可以...
     
    
    HTTPS和HTTP的区别
    超文本传输协议HTTP协议被用于在Web浏览器和网站服务器之间传递信息。HTTP协议以明文方式发送内容,不提供任何方式的数据加密,如果攻击者截取了Web浏览器和网站服务器之间的传输报文,就可以直接读懂其中的信息,因此HTTP协议不适合传输一些敏感信息,比如信用卡号、密码等。
    为了解决HTTP协议的这一缺陷,需要使用另一种协议:安全套接字层超文本传输协议HTTPS。为了数据传输的安全,HTTPS在HTTP的基础上加入了SSL协议,SSL依靠证书来验证服务器的身份,并为浏览器和服务器之间的通信加密。
    HTTPS和HTTP的区别主要为以下四点:
    一、https协议需要到ca申请证书,一般免费证书很少,需要交费。
    二、http是 超文本传输协议,信息是明文传输,https 则是具有 安全性ssl加密传输协议。
    三、http和https使用的是完全不同的连接方式,用的端口也不一样,前者是80,后者是443。
    四、http的连接很简单,是无状态的;HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、身份认证的 网络协议,比http协议安全。
    package https;
    import java.io.ByteArrayOutputStream;  
    import java.io.DataOutputStream;  
    import java.io.IOException;  
    import java.io.InputStream;  
    import java.net.URL;  
    import java.security.KeyManagementException;  
    import java.security.NoSuchAlgorithmException;  
    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 net.sf.json.JSONArray;
    import net.sf.json.JSONObject;
      
    public class PostJson {  
      
        private static class TrustAnyTrustManager implements X509TrustManager {  
        //该方法检查客户端的证书,若不信任该证书则抛出异常。由于我们不需要对客户端进行认证,因此我们只需要执行默认的信任管理器的这个方法。
        //JSSE中,默认的信任管理器类为TrustManager。
            public void checkClientTrusted(X509Certificate[] chain, String authType)  
                    throws CertificateException {  
            }  
            //该方法检查服务器的证书,若不信任该证书同样抛出异常。通过自己实现该方法,可以使之信任我们指定的任何证书。在实现该方法时,也可以简单的不做任何处理,即一个空的函数体,由于不会抛出异常,它就会信任任何证书。
            public void checkServerTrusted(X509Certificate[] chain, String authType)  
                    throws CertificateException {  
            }  
            //返回受信任的X509证书数组。
            public X509Certificate[] getAcceptedIssuers() {  
                return new X509Certificate[] {};  
            }  
        }  
      
        private static class TrustAnyHostnameVerifier implements HostnameVerifier {  
            public boolean verify(String hostname, SSLSession session) {  
                return true;  
            }  
        }  
      
        /** 
         * post方式请求服务器(https协议) 
         *  
         * @param url 
         *            请求地址 
         * @param content 
         *            参数 
         * @param charset 
         *            编码 
         * @return 
         * @throws NoSuchAlgorithmException 
         * @throws KeyManagementException 
         * @throws IOException 
         */  
        public static byte[] post(String url, String content, String charset)  
                throws NoSuchAlgorithmException, KeyManagementException,  
                IOException {  
        /*类HttpsURLConnection似乎并没有提供方法设置信任管理器。其实,HttpsURLConnection通过SSLSocket来建立与HTTPS的安全连接,SSLSocket对象是由SSLSocketFactory生成的。
        * HttpsURLConnection提供了方法setSSLSocketFactory(SSLSocketFactory)设置它使用的SSLSocketFactory对象。
        * SSLSocketFactory通过SSLContext对象来获得,在初始化SSLContext对象时,可指定信任管理器对象。
        * */
            SSLContext sc = SSLContext.getInstance("SSL");  
            sc.init(null, new TrustManager[] { new TrustAnyTrustManager() },  
                    new java.security.SecureRandom());  
      
            URL console = new URL(url);  
            HttpsURLConnection conn = (HttpsURLConnection) console.openConnection();  
            conn.setSSLSocketFactory(sc.getSocketFactory());  
            conn.setHostnameVerifier(new TrustAnyHostnameVerifier());  
            conn.setDoOutput(true); 
            //设置请求头
            conn.setRequestProperty("Content-Type", "application/json;charset=utf-8");
            conn.connect();  
            DataOutputStream out = new DataOutputStream(conn.getOutputStream());  
            out.write(content.getBytes(charset));  
            // 刷新、关闭  
            out.flush();  
            out.close();  
            InputStream is = conn.getInputStream();  
            if (is != null) {  
                ByteArrayOutputStream outStream = new ByteArrayOutputStream();  
                byte[] buffer = new byte[1024];  
                int len = 0;  
                while ((len = is.read(buffer)) != -1) {  
                    outStream.write(buffer, 0, len);  
                }  
                is.close();  
                return outStream.toByteArray();  
            }  
            return null;  
        } 
        public static void main(String[] args) throws KeyManagementException, NoSuchAlgorithmException, IOException{
        String url = "https://xxx.xxx.xxx/path/to/dir/${action}";
        PostJson pj = new PostJson();
        String content=pj.getbaowen();
        String charset="UTF-8";
       
        byte[] a = pj.post(url, content, charset);
        String b = new String(a);
        System.out.println(b);
       
        }
        //构造嵌套的JSON报文方式,即在new一个JSONObject,并返回报文字符串
        public  String getbaowen(){
        JSONObject test= new JSONObject();
        test.put("xxxx", "");
        String resp= null;
            JSONObject obj = new JSONObject();
            obj.put("xxxxxx", "");   
            obj.put("test", test);
            
            
            
           


            String query = obj.toString();
            return query;
        }
      
    }  

     



    展开全文
  • java实现https双向认证

    千次阅读 2017-11-14 00:39:05
    了解了一些https的工作原理,但是还是理解的不透彻,参考其他实现,写了一段代码练手。 参考文章: 1.讲https的工作原理的:Java 和 HTTP 的那些事(四) HTTPS 和 证书 2.keytool相关命令:使用keytool 生成证书 ...
  • java 实现https请求的基本原理与介绍

    万次阅读 2016-09-05 17:38:09
    摘 要 JSSE是一个SSL和TLS的纯Java实现,通过JSSE可以很容易地编程实现对HTTPS站点的访问。但是,如果该站点的证书未经权威机构的验证,JSSE将拒绝信任该证书从而不能访问HTTPS站点。本文在简要介绍JSSE的基础上...
  • Java项目需要作为客户端发起HTTPS请求访问服务端,并且需要携带证书进行SSL双向认证,当前提供的证书相关文件有:ca.crt、ca.key、client.crt、client.key、server.crt、server.key 二、实现步骤 1、对客户端证书和...
  • java发送https请求的例子

    热门讨论 2013-10-31 16:18:51
    java发送https请求的例子
  • java实现读取证书访问https接口

    热门讨论 2017-07-26 17:50:21
    java实现读取证书访问https接口并获取返回数据.证书格式cer,der,crt等。
  • java实现https请求绕过证书检测

    万次阅读 2019-01-23 10:24:59
    import org.apache.http.HttpEntity; import org.apache.http.client.config.RequestConfig; import org.apache.http.client.methods.CloseableHttpResponse; import org.apache.... imp...
  • java实现http/https抓包拦截

    千次阅读 热门讨论 2019-10-20 15:29:13
    但每次打开fiddler去查看对应的接口并找到对应的参数感觉还是有点复杂,正好今天是周末,打算自己来研究下它的原理并自己通过java来写一个(之所以知道java可以实现这个功能是因为著名的web安全检测工具 burpsuite...
  • HTTPS客户端java实现

    千次阅读 2017-11-28 16:30:40
    https是http加入ssl安全协议后的数据传输协议,提供身份验证与加密通讯,默认端口为443,关于握手协议参考这里写链接内容SSL是在安全套接层、传输层保障数据安全性的协议,安全认证过程: 1)客户端向服务器发送一...
  • Java实现Http/Https请求的方式

    千次阅读 2018-04-17 16:57:14
    作为用Java为开发语言的后端开发,实现Http请求的方式有原始Socket、URLConnection、HttpURLConnection、第三方工具HttpClient等。网络上已经有很多前人做了归纳,这里做个笔记: 1. java.ne...
  • 前言平时测试的时候可能会遇到使用Java发送http或者https请求的需求.网上找了一圈暂时没有发现比较称心方便...主要实现http/https的get和post请求,并支持设置代理抓包.只需要一个Java文件就搞定,不需要第三方库支持.
  • Java发送HTTPS请求

    万次阅读 多人点赞 2019-03-19 15:56:03
    上篇文章介绍了 java 发送 http 请求,大家都知道发送http是不安全的。我也是由于对接了其他企业后总结了一套发送 https的工具。大家网上找方法很多的,但是可不是你粘过来就能用啊,我也是踩过坑的,所以我这个工具...
  • Java实现免证书访问Https请求

    千次阅读 2019-01-29 10:51:16
    创建证书管理器类 import java.security.cert.CertificateException; import java.security.cert.X509Certificate; import javax.net.ssl.... * 证书信任管理器(用于https请求) * */ public class MyX509Tr...
  • JAVA实现https单向认证

    万次阅读 2014-09-04 09:09:55
    Scheme sch = new Scheme("https", socketFactory, 443); httpClient.getConnectionManager().getSchemeRegistry().register(sch); } catch (Exception e) { e.printStackTrace(); } //下面这段是调用...
  • Java实现的FTP连接与数据浏览程序 1个目标文件 摘要:Java源码,网络相关,FTP Java实现的FTP连接与数据浏览程序,实现实例化可操作的窗口。 部分源代码摘录: ftpClient = new FtpClient(); //实例化FtpClient对象 ...
  • JAVA根据HTTPS URL下载文件

    万次阅读 2017-12-29 15:02:30
    sslcontext.init(null, new TrustManager[] { new X509TrustUtiil() }, new java.security.SecureRandom()); URL url = new URL(fileUrl); HostnameVerifier ignoreHostnameVerifier = new HostnameVerifier() { ...
  • https与SSL协议详解及Java实现免证书访问https服务代码 tomcat提供https服务接口方法
  • Java知识体系最强总结(2021版)

    万次阅读 多人点赞 2019-12-18 10:09:56
    本人从事Java开发已多年,平时有记录问题解决方案和总结知识点的习惯,整理了一些有关Java的知识体系,这不是最终版,会不定期的更新。也算是记录自己在从事编程工作的成长足迹,通过博客可以促进博主与阅读者的共同...
  • 1、开发需求 需要实现在服务端发起HTTP/HTTPS请求,访问其他程序资源。 2、URLConnection和HTTPClient的比较 HttpClient是个很不错的开源框架,封装了访问http的请求头,参数,内容体,响应等等, ...
  • javahttps请求忽略证书

    千次阅读 2019-11-12 14:22:10
    java在发送https请求的时候会报缺少ssl证书错误。错误如下: org.springframework.web.client.ResourceAccessException: I/O error on POST request for ...
  • Java基础知识面试题(2020最新版)

    万次阅读 多人点赞 2020-02-19 12:11:27
    文章目录Java概述何为编程什么是Javajdk1.5之后的三大版本JVM、JRE和JDK的关系什么是跨平台性?原理是什么Java语言有哪些特点什么是字节码?采用字节码的最大好处是什么什么是Java程序的主类?应用程序和小程序的...
  • Java实现SSL双向认证的方法

    万次阅读 2018-09-25 11:07:25
    本文实例讲述了Java实现SSL双向认证的方法。分享给大家供大家参考,具体如下: 我们常见的SSL验证较多的只是验证我们的服务器是否是真实正确的,当然如果你访问的URL压根就错了,那谁也没有办法。这个就是所谓的SSL...
  • 自己用java写一个http和https代理服务器

    千次阅读 热门讨论 2019-05-13 16:21:37
    本文是基于socket实现的http,https代理服务器,资源利用率上肯定也是没有nio实现的效率要好。但是,秉持学习的态度,我还是来来实践一下。当然,如果这个实现的代理器只是你自己用的话或者少数几个人用的话,我觉得...
  • 使用Java实现串口通信demo下载

    热门讨论 2017-10-11 14:10:36
    博客地址:http://blog.csdn.net/kong_gu_you_lan/article/details/52302075 GitHub地址:https://github.com/alidili/SerialPortDemo
  • Java后端HTTP转HTTPS实现

    千次阅读 2020-04-01 21:24:37
    HTTPS是HTTP的加密实现,其中引入了公钥,私钥,数字证书等概念,以实现数据收发双方的身份认证和数据加密。 1. 原理 数字证书在用户公钥后附加了用户信息及CA的签名。公钥是密钥对的一部分,另一部分是私钥。公钥...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,214,756
精华内容 485,902
关键字:

java实现https

java 订阅