http和https 访问资源

最新推荐文章于 2023-08-01 09:20:45 发布
最新推荐文章于 2023-08-01 09:20:45 发布
阅读量7.1k 收藏
点赞数 1
分类专栏： http
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sunRest/article/details/82587385
版权 
package com.dmzone.snow.core.untils;


import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.config.AuthSchemes;
import org.apache.http.client.config.CookieSpecs;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpDelete;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpPut;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.entity.ByteArrayEntity;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;

import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;

/**
 * http请求工具类
 * @author zhuzhe
 * @date 2018/5/3 11:46
 */
public class HttpUtils {

    /**
     * get
     *
     * @param host
     * @param path
     *
     * @param headers
     * @param querys
     * @return
     * @throws Exception
     */
    public static HttpResponse doGet(String host, String path,
                                     Map<String, String> headers,
                                     Map<String, String> querys)
            throws Exception {
        HttpClient httpClient = wrapClient(host,path);
        HttpGet request = new HttpGet(buildUrl(host, path, querys));
        for (Map.Entry<String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }
        request.setConfig(setTimeOutConfig(request.getConfig()));
        return httpClient.execute(request);
    }

    /**
     * post form
     *
     * @param host
     * @param path
     *
     * @param headers
     * @param querys
     * @param bodys
     * @return
     * @throws Exception
     */
    public static HttpResponse doPost(String host, String path,
                                      Map<String, String> headers,
                                      Map<String, String> querys,
                                      Map<String, String> bodys)
            throws Exception {
        HttpClient httpClient = wrapClient(host,path);
        HttpPost request = new HttpPost(buildUrl(host, path, querys));
        for (Map.Entry<String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }
        request.setConfig(setTimeOutConfig(request.getConfig()));
        if (bodys != null) {
            List<NameValuePair> nameValuePairList = new ArrayList<NameValuePair>();

            for (String key : bodys.keySet()) {
                nameValuePairList.add(new BasicNameValuePair(key, bodys.get(key)));
            }
            UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(nameValuePairList, "utf-8");
            formEntity.setContentType("application/x-www-form-urlencoded; charset=UTF-8");
            request.setEntity(formEntity);
        }
        return httpClient.execute(request);
    }

    /**
     * Post String
     *
     * @param host
     * @param path
     *
     * @param headers
     * @param querys
     * @param body
     * @return
     * @throws Exception
     */
    public static HttpResponse doPost(String host, String path,
                                      Map<String, String> headers,
                                      Map<String, String> querys,
                                      String body)
            throws Exception {
        HttpClient httpClient = wrapClient(host,path);
        HttpPost request = new HttpPost(buildUrl(host, path, querys));
        for (Map.Entry<String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }
        if (StringUtils.isNotBlank(body)) {
            request.setEntity(new StringEntity(body, "utf-8"));
        }
        request.setConfig(setTimeOutConfig(request.getConfig()));
        return httpClient.execute(request);
    }

    /**
     * Post stream
     *
     * @param host
     * @param path
     *
     * @param headers
     * @param querys
     * @param body
     * @return
     * @throws Exception
     */
    public static HttpResponse doPost(String host, String path,
                                      Map<String, String> headers,
                                      Map<String, String> querys,
                                      byte[] body)
            throws Exception {
        HttpClient httpClient = wrapClient(host,path);
        HttpPost request = new HttpPost(buildUrl(host, path, querys));
        for (Map.Entry<String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }
        if (body != null) {
            request.setEntity(new ByteArrayEntity(body));
        }
        request.setConfig(setTimeOutConfig(request.getConfig()));
        return httpClient.execute(request);
    }

    /**
     * Put String
     * @param host
     * @param path
     *
     * @param headers
     * @param querys
     * @param body
     * @return
     * @throws Exception
     */
    public static HttpResponse doPut(String host, String path,
                                     Map<String, String> headers,
                                     Map<String, String> querys,
                                     String body)
            throws Exception {
        HttpClient httpClient = wrapClient(host,path);
        HttpPut request = new HttpPut(buildUrl(host, path, querys));
        for (Map.Entry<String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }
        if (StringUtils.isNotBlank(body)) {
            request.setEntity(new StringEntity(body, "utf-8"));
        }
        request.setConfig(setTimeOutConfig(request.getConfig()));
        return httpClient.execute(request);
    }

    /**
     * Put stream
     * @param host
     * @param path
     *
     * @param headers
     * @param querys
     * @param body
     * @return
     * @throws Exception
     */
    public static HttpResponse doPut(String host, String path,
                                     Map<String, String> headers,
                                     Map<String, String> querys,
                                     byte[] body)
            throws Exception {
        HttpClient httpClient = wrapClient(host,path);
        HttpPut request = new HttpPut(buildUrl(host, path, querys));
        for (Map.Entry<String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }
        if (body != null) {
            request.setEntity(new ByteArrayEntity(body));
        }
        request.setConfig(setTimeOutConfig(request.getConfig()));
        return httpClient.execute(request);
    }

    /**
     * Delete
     *
     * @param host
     * @param path
     *
     * @param headers
     * @param querys
     * @return
     * @throws Exception
     */
    public static HttpResponse doDelete(String host, String path,
                                        Map<String, String> headers,
                                        Map<String, String> querys)
            throws Exception {
        HttpClient httpClient = wrapClient(host,path);
        HttpDelete request = new HttpDelete(buildUrl(host, path, querys));
        for (Map.Entry<String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }
        request.setConfig(setTimeOutConfig(request.getConfig()));
        return httpClient.execute(request);
    }

    /**
     * 构建请求的 url
     * @param host
     * @param path
     * @param querys
     * @return
     * @throws UnsupportedEncodingException
     */
    private static String buildUrl(String host, String path, Map<String, String> querys) throws UnsupportedEncodingException {
        StringBuilder sbUrl = new StringBuilder();
        if (!StringUtils.isBlank(host)) {
            sbUrl.append(host);
        }
        if (!StringUtils.isBlank(path)) {
            sbUrl.append(path);
        }
        if (null != querys) {
            StringBuilder sbQuery = new StringBuilder();
            for (Map.Entry<String, String> query : querys.entrySet()) {
                if (0 < sbQuery.length()) {
                    sbQuery.append("&");
                }
                if (StringUtils.isBlank(query.getKey()) && !StringUtils.isBlank(query.getValue())) {
                    sbQuery.append(query.getValue());
                }
                if (!StringUtils.isBlank(query.getKey())) {
                    sbQuery.append(query.getKey());
                    if (!StringUtils.isBlank(query.getValue())) {
                        sbQuery.append("=");
                        sbQuery.append(URLEncoder.encode(query.getValue(), "utf-8"));
                    }
                }
            }
            if (0 < sbQuery.length()) {
                sbUrl.append("?").append(sbQuery);
            }
        }
        return sbUrl.toString();
    }

    /**
     * 获取 HttpClient
     * @param host
     * @param path
     * @return
     */
    private static HttpClient wrapClient(String host,String path) {
        HttpClient httpClient = HttpClientBuilder.create().build();
        if (host != null && host.startsWith("https://")) {
            return sslClient();
        }else if (StringUtils.isBlank(host) && path != null && path.startsWith("https://")) {
            return sslClient();
        }
        return httpClient;
    }

    /**
     * 在调用SSL之前需要重写验证方法，取消检测SSL
     * 创建ConnectionManager，添加Connection配置信息
     * @return HttpClient 支持https
     */
    private static HttpClient sslClient() {
        try {
            // 在调用SSL之前需要重写验证方法，取消检测SSL
            X509TrustManager trustManager = new X509TrustManager() {
                @Override public X509Certificate[] getAcceptedIssuers() {
                    return null;
                }
                @Override public void checkClientTrusted(X509Certificate[] xcs, String str) {}
                @Override public void checkServerTrusted(X509Certificate[] xcs, String str) {}
            };
            SSLContext ctx = SSLContext.getInstance(SSLConnectionSocketFactory.TLS);
            ctx.init(null, new TrustManager[] { trustManager }, null);
            SSLConnectionSocketFactory socketFactory = new SSLConnectionSocketFactory(ctx, NoopHostnameVerifier.INSTANCE);
            // 创建Registry
            RequestConfig requestConfig = RequestConfig.custom().setCookieSpec(CookieSpecs.STANDARD_STRICT)
                    .setExpectContinueEnabled(Boolean.TRUE).setTargetPreferredAuthSchemes(Arrays.asList(AuthSchemes.NTLM,AuthSchemes.DIGEST))
                    .setProxyPreferredAuthSchemes(Arrays.asList(AuthSchemes.BASIC)).build();
            Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
                    .register("http", PlainConnectionSocketFactory.INSTANCE)
                    .register("https",socketFactory).build();
            // 创建ConnectionManager，添加Connection配置信息
            PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
            CloseableHttpClient closeableHttpClient = HttpClients.custom().setConnectionManager(connectionManager)
                    .setDefaultRequestConfig(requestConfig).build();
            return closeableHttpClient;
        } catch (KeyManagementException ex) {
            throw new RuntimeException(ex);
        } catch (NoSuchAlgorithmException ex) {
            throw new RuntimeException(ex);
        }
    }

    /**
     * 设置 连接超时、 请求超时 、 读取超时  毫秒
     * @param requestConfig
     * @return
     */
    private static RequestConfig setTimeOutConfig(RequestConfig requestConfig){
        if (null == requestConfig) {
            return RequestConfig.custom()
                    .setConnectionRequestTimeout(60000)
                    .setConnectTimeout(60000)
                    .setSocketTimeout(10000)
                    .build();
        }
        return RequestConfig.copy(requestConfig)
                .setConnectionRequestTimeout(60000)
                .setConnectTimeout(60000)
                .setSocketTimeout(10000)
                .build();
    }

    /**
     * 将结果转换成JSONObject
     * @param httpResponse
     * @return
     * @throws IOException
     */
    public static JSONObject getJson(HttpResponse httpResponse) throws IOException {
        System.out.println("pppppppp+"+JSON.toJSON(httpResponse));
        HttpEntity entity = httpResponse.getEntity();
        String resp = EntityUtils.toString(entity, "UTF-8");
        System.out.println("zhanghui qingqiu jie guo ==========:" + resp);
        return JSON.parseObject(resp);
    }
}
sunRest
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
Nginx配置http转https以及https访问http静态资源.docx
08-25
Nginx配置http转https以及https访问http静态资源.docx
http和https的请求与响应
qq_70761095的博客
02-08 4829
HTTP协议（HyperText Transfer Protocol，超文本传输协议）：是一种发布和接收 HTML页面的方法。HTTPS（Hypertext Transfer Protocol over Secure Socket Layer）简单讲是HTTP的安全版，在HTTP下加入SSL层。SSL（Secure Sockets Layer 安全套接层）主要用于Web的安全传输协议，在传输层对网络连接进行加密，保障在Internet上数据传输的安全。HTTP的端口号为80HTTPS的端口号为443。
gbox推荐源_GBox
weixin_28706541的博客
02-23 2万+
2.16????????企业GBox已经发布，只要安装它，你就可以免费获得证书https://gbox.run-免企业证书第三方应用来源复制以下内容，GBox官方游戏源：http://game.gbox.plus/Public/Source.json萝卜网官方软件源：https://www.margua.top/Public/Source.jsonAn南拥夏栀官方软件源：https://nyxz166.cn/...
最新天龙八部环境-GS环境教程-【长期稳定版本】+ 视频教程
雨林之后博客
11-29 1万+
GS环境教程，最新天龙八部环境支持当下主流最新的所有Linux系统，一键运行安装环境，全程开源，无后门无套路无任何费用，免费使用。有问题可以反馈并且持续更新升级
http网页是否能引用https资源/调用https接口？https网页是否能引用http资源/调用http接口？
細水、長流√的专栏
12-23 6356
总结：http可以调用https , https不能调用http (浏览器认为不安全) http网页引用https资源 -> 可以 http网页调用https接口 -> 可以 https网页引用http资源 -> 不行（浏览器认为不安全） 推荐解决方法，不指定具体协议，使用资源协议自适配，比如，当前为https页面，那么就是https资源，如果是http页面，那么就是http资源。具体方法超简单：<script src='//www.aa...
HTTP环境下添加HTTPS的实际解决方案
xiaogangpi的专栏
01-22 6145
背景：项目如果遇到外网公开访问，或者是外围系统对接使用的是HTTPS，亦或者增加兼容http，都需要添加HTTPS渠道。 HTTPS 简介 Http超⽂本传输协议，明⽂传输 ，传输不安全，https在传输数据的时候会对数据进⾏加密；ssl协议、TLS(transport layer security)协 HTTPS和HTTP的主要区别 HTTPS协议使⽤时需要到电⼦商务认证授权机构（CA）申请SSL证书 HTTP默认使⽤8080端⼝，HTTPS默认使⽤8443端⼝ HTTPS则是具有SSL加密的安
springboot 微信小程序 对接微信支付功能(完整版)
Majker的专栏
03-10 3万+
微信小程序对接微信支付功能业务流程时序图JAVA版1. 项目架构2. pom.xml配置文件3. 小程序账号参数配置类4.JAVA 通用代码4.1 工具类4.1.1 IdGen （id生成类）4.1.2 Render(响应结果类)4.1.3 ResultCode 响应码4.2 SDK类4.2.1 HttpKit4.2.2 IOUtils4.2.3 PaymentApi4.2.4 Payment...
tomcat同时使用http和https访问的配置方法
01-10
针对一个tomcat中有的项目需要使用ssl加密有些可以直接访问的情况，可通过修改tomcat/conf下的server.xml来实现。具体配置可参考下面这段代码，注意”Catalina1″>这个标签中的配置。 <?xml version='1.0' ...
C++ socket访问HTTP，OpenSSL访问HTTPS
03-10
原生socket POST访问HTTP站点。可成功登陆某站点； 2> 集成OpenSSL POST访问HTTPS站点。可成功登陆小米官网。 文件包内含有完整的，编译好的OpenSSL开发需要的头文件以及库文件等，可以方便的使用在您的项目中。
详解NGINX访问https跳转到http的解决方法
09-30
主要介绍了详解NGINX访问https跳转到http的解决方法,非常具有实用价值，需要的朋友可以参考下
用CWinInet访问HTTP/HTTPS资源
01-14
windows下用C++MFC中的CWinInet访问HTTP、HTTPS协议的网页 包含GET POST等
访问HTTP资源
chengyangyy的专栏
06-20 657
提交HTTP GET 和HTTP POST请求 本节将介绍Android SDK集成的Apache HttpClient模块，要注意的是，这里的Apache HttpClient模块是 HttpClient 4.0( org.apache.http.* ), 而不是Jakarata Commons HttpClient 3.x ( org.apache.commons.httpclient.* )。
浏览器访问本地静态资源
H30919的博客
08-01 575
浏览器直接访问本地静态资源
HTTP请求详解及HTTPS协议
weixin_51235620的博客
11-02 1034
HTTP 关于HTTP 超文本传输协议(HyperText Transfer Protocol) 一种无状态的，以请求/应答方式运行的协议，它使用可扩展的语义和自描述消息格式，与基于网络的超文本信息系统灵活的互动 HTTP报文格式 HTTP协议的请求报文和响应报文的结构基本相同，有三大部分组成： 起始行(start line)：描述请求或响应的基本信息，例如：GET/index.html/HTTP/1.1 HTTP/1.1 200 OK,其中，GET表示为请求方式(此处为读取数据，index.html为
Http 四种请求访问代码 HttpGet HttpPost HttpPut HttpDelete
飘过的春风
01-24 3183
String url = "http://www.baidu.com"; //将要访问的url字符串放入HttpPost中 HttpPost httpPost = new HttpPost(url); //请求头 放置一些修改http请求头和cookie httpPost.setHeader("Accept", "application/json"); ......
HttpClient4.5实现http与https请求，解决之前方法过时问题
朱哲的博客
05-30 2万+
前言最近项目正在筹备上线，发现 HttpClient 中的很多类和方法都已经过时了，虽然并不影响功能的实现，但是看着确实让人捉急，所以，索性抽了点时间把它给改了。今天就来分享一下。。。之前的代码先看看之前的代码吧：以下是之前的过时代码（部分，完整代码在文章末会贴出git地址）private static void sslClient(HttpClient httpClient) { ...
C#(.NET) Webservice返回json设置
Jaylon Wang的专栏
07-14 3万+
一 、服务器端设置    1.修改web.config 在web.config里面的的system.Web节点添加                                                                                 2.修改XX.asmx.cs  [WebService(Namespace = "ht
Http请求
Weigeli的博客
07-27 65
【代码】Http请求。
URL原理、URL编码、URL特殊字符、输入URL到页面显示
热门推荐
freeking101的博客
03-31 5万+
通常如果一样东西需要编码，说明这样东西并不适合传输。原因多种多样，如Size过大，包含隐私数据，对于Url来说，之所以要进行编码，是因为Url中有些字符会引起歧义。 例如，Url参数字符串中使用key=value键值对这样的形式来传参，键值对之间以&符号分隔，如/s?q=abc&ie=utf-8。如果你的value字符串中包含了=或者&，那么势必会造成接收Url的服务器解析错误，因此必须将引起歧义的&和=符号进行转义，也就是对其进行编码。
https 访问http资源
最新发布
08-04
虽然用HTTPS访问http资源提供了更高的安全性，但这并不代表所有网站和资源都需要使用HTTPS。对于非敏感信息和公开资源，使用http仍然足够。然而，随着网络安全问题的加剧，越来越多的网站都在选择使用HTTPS来保障...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值