http请求工具类 支持https

最新推荐文章于 2023-11-11 11:29:49 发布
最新推荐文章于 2023-11-11 11:29:49 发布
阅读量556 收藏
点赞数
分类专栏： Java 文章标签： http
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ljm15832631631/article/details/82843388
版权

package com.lbonline.tms.util;

import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.Consts;
import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpRequestBase;
import org.apache.http.client.protocol.HttpClientContext;
import org.apache.http.client.utils.URIBuilder;
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.LayeredConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLContextBuilder;
import org.apache.http.conn.ssl.TrustStrategy;
import org.apache.http.conn.ssl.X509HostnameVerifier;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;

import org.apache.http.entity.mime.HttpMultipartMode;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.entity.mime.content.FileBody;
import org.apache.http.entity.mime.content.StringBody;
import org.apache.http.impl.client.BasicCookieStore;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.impl.cookie.BasicClientCookie;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.BasicHttpContext;
import org.apache.http.protocol.HttpContext;
import org.apache.http.util.CharsetUtils;
import org.apache.http.util.EntityUtils;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLException;
import javax.net.ssl.SSLSession;
import javax.net.ssl.SSLSocket;
import java.io.File;
import java.io.IOException;
import java.net.URISyntaxException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**

  • http请求工具类 支持https
    */
    public class HttpClientUtils {

    private static String EMPTY_STR = “”;
    private static String UTF_8 = “UTF-8”;
    private static RequestConfig requestConfig;
    private static final int CONN_TIME_OUT = 8000; //连接超时时间 8s
    private static final int CONN_REQUEST_TIME_OUT = 10000;//请求超时时间 10s
    private static final int SOCKET_TIME_OUT = 60000;//数据处理超时时间60s
    private static final int MAX_TOTAL_CONNECTION = 200;//连接池的最大连接数
    private static final int MAX_CONNECTION_PER_ROUTE = 100;//每个路由的最大连接数
    private static final String HTTP_PREFIX = “HTTP”;
    private static final String HTTP_HEADER = “HTTP:”;
    private static final String JSONP_CALLBACK = “callback”;
    private static CloseableHttpClient closeableHttpClient;
    private static final String HTTP_SPLIT= “//”;

    private static final Logger logger = LoggerFactory.getLogger(HttpClientUtils.class);

    static {

     //定义 http连接的 策略  可以允许 http和 https
 ConnectionSocketFactory plainsf = PlainConnectionSocketFactory.getSocketFactory();
 LayeredConnectionSocketFactory sslsf = createSSLConnSocketFactory();
 Registry<ConnectionSocketFactory> registry = RegistryBuilder
         .<ConnectionSocketFactory> create().register("http", plainsf)
         .register("https", sslsf).build();

 //初始化http请求池
 PoolingHttpClientConnectionManager cm;
 cm = new PoolingHttpClientConnectionManager(registry);
 cm.setMaxTotal(MAX_TOTAL_CONNECTION);//整个连接池最大连接数
 cm.setDefaultMaxPerRoute(MAX_CONNECTION_PER_ROUTE);//每路由最大连接数，默认值是2
 closeableHttpClient = HttpClients
         .custom()
         .setConnectionManager(cm)
         .build();

 //初始化请求参数
 requestConfig = RequestConfig.custom()
         .setConnectTimeout(CONN_TIME_OUT)//设置连接超时时间，单位毫秒
         .setConnectionRequestTimeout(CONN_REQUEST_TIME_OUT)//设置从connect Manager获取Connection 超时时间，单位毫秒
         .setSocketTimeout(SOCKET_TIME_OUT).build();//请求获取数据的超时时间，单位毫秒。 如果访问一个接口，多少时间内无法返回数据

    }

    /**

    • 通过连接池获取HttpClient
    • @return
      */
      private static CloseableHttpClient getHttpClient() {
      return closeableHttpClient;
      }

    public static String httpGetRequest(String url) throws IOException {
    return httpGetRequest(url, UTF_8);
    }

    public static String httpGetRequest(String url, String charSet) throws IOException {
    HttpGet httpGet = buildHttpGet(url);
    return getResult(httpGet, charSet);
    }

    public static String httpGetRequest(String url, Map<String, Object> params) throws URISyntaxException, IOException {
    return httpGetRequest(url, params, UTF_8);
    }

    public static String httpGetRequest(String url, Map<String, Object> params,List cookieList) throws URISyntaxException, IOException {
    return httpGetRequest(url, params, UTF_8,cookieList);
    }

    public static String httpGetRequest(String url, Map<String, Object> params, String charSet) throws URISyntaxException, IOException {
    return httpGetRequest(url, params, charSet, null);
    }

    public static String httpGetRequest(String url, Map<String, Object> params, String charSet, List cookieList) throws URISyntaxException, IOException {
    URIBuilder ub = new URIBuilder();
    ub.setPath(processURL(url));

     ArrayList<NameValuePair> pairs = covertParams2NVPS(params);
 ub.setParameters(pairs);

 HttpGet httpGet = new HttpGet(ub.build());

 //处理cookie
 HttpContext httpContext = processCookie(cookieList);

 return getResult(httpGet, charSet, httpContext);

    }

    public static String httpGetRequest(String url, Map<String, Object> headers, Map<String, Object> params) throws URISyntaxException, IOException {
    return httpGetRequest(url, headers, params, UTF_8);
    }
    public static String httpJsonpGetRequest(String url, Map<String, Object> headers, Map<String, Object> params) throws URISyntaxException, IOException {
    params.put(JSONP_CALLBACK,JSONP_CALLBACK);
    String result = httpGetRequest(url, headers, params, UTF_8);
    return getJsonString(result,JSONP_CALLBACK);
    }

    public static String httpGetRequest(String url, Map<String, Object> headers, Map<String, Object> params, String charSet,List cookieList) throws URISyntaxException, IOException {
    URIBuilder ub = new URIBuilder();
    ub.setPath(processURL(url));

     ArrayList<NameValuePair> pairs = covertParams2NVPS(params);
 ub.setParameters(pairs);

 HttpGet httpGet = new HttpGet(ub.build());
 for (Map.Entry<String, Object> param : headers.entrySet()) {
     httpGet.addHeader(param.getKey(), String.valueOf(param.getValue()));
 }

 //处理cookie
 HttpContext httpContext = processCookie(cookieList);

 return getResult(httpGet, charSet,httpContext);

    }

    public static String httpGetRequest(String url, Map<String, Object> headers, Map<String, Object> params, String charSet) throws URISyntaxException, IOException {
    URIBuilder ub = new URIBuilder();
    ub.setPath(processURL(url));

     ArrayList<NameValuePair> pairs = covertParams2NVPS(params);
 ub.setParameters(pairs);

 HttpGet httpGet = new HttpGet(ub.build());
 for (Map.Entry<String, Object> param : headers.entrySet()) {
     httpGet.addHeader(param.getKey(), String.valueOf(param.getValue()));
 }
 return getResult(httpGet, charSet);

    }

    public static String httpGetRequestSSL(String url, Map<String, Object> headers, Map<String, Object> params) throws Exception {
    return httpGetRequestSSL(url, headers, params, UTF_8);
    }

    public static String httpGetRequestSSL(String url, Map<String, Object> headers, Map<String, Object> params, String charSet) throws Exception {
    URIBuilder ub = new URIBuilder();
    ub.setPath(processURL(url));

     ArrayList<NameValuePair> pairs = covertParams2NVPS(params);
 ub.setParameters(pairs);

 HttpGet httpGet = new HttpGet(ub.build());
 for (Map.Entry<String, Object> param : headers.entrySet()) {
     httpGet.addHeader(param.getKey(), String.valueOf(param.getValue()));
 }

 return getSSLResult(httpGet, charSet);

    }

    public static String httpPostRequest(String url) throws IOException {
    HttpPost httpPost = buildHttpPost(url);
    return getResult(httpPost, UTF_8);
    }

    public static String httpPostRequest(String url, Map<String, Object> params) throws IOException {
    return httpPostRequest(url, params, UTF_8);
    }

    public static String httpPostRequest(String url, Map<String, Object> params, String charSet) throws IOException {
    HttpPost httpPost = buildHttpPost(url);
    ArrayList pairs = covertParams2NVPS(params);

     httpPost.setEntity(new UrlEncodedFormEntity(pairs, UTF_8));
 return getResult(httpPost, charSet);

    }

    public static String httpPostRequest(String url, String data, String contentType) throws IOException {
    return httpPostRequest(url, data, contentType, UTF_8);
    }

    public static String httpPostRequest(String url, String data, String contentType, String charSet) throws IOException {
    HttpPost httpPost = buildHttpPost(url);
    StringEntity stringEntity = new StringEntity(data, ContentType.create(contentType, Consts.UTF_8));
    httpPost.setEntity(stringEntity);
    return getResult(httpPost, charSet);
    }

    public static String httpPostRequest(String url, String data, String contentType, String charSet ,RequestConfig requestConfig) throws IOException {
    HttpPost httpPost = buildHttpPost(url);
    StringEntity stringEntity = new StringEntity(data, ContentType.create(contentType, Consts.UTF_8));
    httpPost.setEntity(stringEntity);
    return getResult(httpPost, charSet,requestConfig);
    }

    public static String httpPostRequest(String url, Map<String, Object> headers, Map<String, Object> params) throws IOException {
    return httpPostRequest(url, headers, params, UTF_8);
    }

    public static String httpJsonpPostRequest(String url, Map<String, Object> headers,Map<String, Object> params) throws IOException {
    params.put(JSONP_CALLBACK,JSONP_CALLBACK);
    String result = httpPostRequest(url, headers, params, UTF_8);
    return getJsonString(result,JSONP_CALLBACK);
    }

    public static String httpPostRequest(String url, Map<String, Object> headers, Map<String, Object> params, List cookieList) throws IOException {
    return httpPostRequest(url, headers, params, UTF_8, cookieList);
    }

    public static String httpPostRequest(String url, Map<String, Object> headers, Map<String, Object> params, String charSet) throws IOException {
    return httpPostRequest(url, headers, params, charSet, null);
    }

    public static String httpPostRequest(String url, Map<String, Object> headers, Map<String, Object> params, String charSet, List cookieList) throws IOException {
    HttpPost httpPost = buildHttpPost(url);

     for (Map.Entry<String, Object> param : headers.entrySet()) {
     httpPost.addHeader(param.getKey(), String.valueOf(param.getValue()));
 }

 ArrayList<NameValuePair> pairs = covertParams2NVPS(params);
 httpPost.setEntity(new UrlEncodedFormEntity(pairs, UTF_8));

 //处理cookie
 HttpContext httpContext = processCookie(cookieList);

 return getResult(httpPost, charSet, httpContext);

    }

    public static String httpPostRequestSSL(String url, Map<String, Object> headers, Map<String, Object> params) throws Exception {
    return httpPostRequestSSL(url, headers, params, UTF_8);
    }

    public static String httpPostRequestSSL(String url, Map<String, Object> headers, Map<String, Object> params, String charSet) throws Exception {
    HttpPost httpPost = buildHttpPost(url);

     for (Map.Entry<String, Object> param : headers.entrySet()) {
     httpPost.addHeader(param.getKey(), String.valueOf(param.getValue()));
 }

 ArrayList<NameValuePair> pairs = covertParams2NVPS(params);
 httpPost.setEntity(new UrlEncodedFormEntity(pairs, UTF_8));

 return getSSLResult(httpPost, charSet);

    }

    private static ArrayList covertParams2NVPS(Map<String, Object> params) {
    ArrayList pairs = new ArrayList();
    for (Map.Entry<String, Object> param : params.entrySet()) {
    pairs.add(new BasicNameValuePair(param.getKey(), String.valueOf(param.getValue())));
    }

     return pairs;

    }

    public static String httpPostRequest(String url, Map<String, Object> params, String charSet,boolean isNullToString) throws IOException {
    HttpPost httpPost = buildHttpPost(url);
    ArrayList pairs = covertParams2NVPS(params,isNullToString);

     httpPost.setEntity(new UrlEncodedFormEntity(pairs, UTF_8));
 return getResult(httpPost, charSet);

    }

    private static ArrayList covertParams2NVPS(Map<String, Object> params,boolean isNullToString) {
    ArrayList pairs = new ArrayList();
    for (Map.Entry<String, Object> param : params.entrySet()) {
    Object object = param.getValue();
    if (object == null && !isNullToString) {
    pairs.add(new BasicNameValuePair(param.getKey(), null));
    } else {
    pairs.add(new BasicNameValuePair(param.getKey(), String.valueOf(param.getValue())));
    }
    }

     return pairs;

    }

    /**

    • 创建SSL安全连接

    • @return
      */
      private static SSLConnectionSocketFactory createSSLConnSocketFactory(){
      SSLConnectionSocketFactory sslsf = null;
      try {
      SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() {
      public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException {
      return true;
      }
      }).build();
      sslsf = new SSLConnectionSocketFactory(sslContext, new X509HostnameVerifier() {
      @Override
      public boolean verify(String arg0, SSLSession arg1) {
      return true;
      }

           @Override
     public void verify(String host, SSLSocket ssl) throws IOException {
     }

     @Override
     public void verify(String host, X509Certificate cert) throws SSLException {
     }

     @Override
     public void verify(String host, String[] cns, String[] subjectAlts) throws SSLException {
     }
 });

      } catch (Exception e){
      logger.error(“异常”, e);
      }
      return sslsf;
      }

    /**

    • 处理Http请求
    • @param request
    • @return
      */
      private static String getResult(HttpRequestBase request, String charSet) throws IOException {
      return getResult(request, charSet, null, requestConfig);
      }

    /**

    • 处理Http请求
    • @param request
    • @return
      */
      private static String getResult(HttpRequestBase request, String charSet,HttpContext httpContext) throws IOException {
      return getResult(request,charSet,httpContext,requestConfig);
      }

    /**

    • 处理Http请求
    • @param request
    • @return
      */
      private static String getResult(HttpRequestBase request, String charSet, RequestConfig requestConfig) throws IOException {
      return getResult(request, charSet, null, requestConfig);
      }

    /**

    • 处理Http请求

    • @param request

    • @return
      */
      private static String getResult(HttpRequestBase request, String charSet,HttpContext httpContext,RequestConfig requestConfig) throws IOException {
      request.setConfig(requestConfig);

      CloseableHttpClient httpClient = getHttpClient();
      CloseableHttpResponse response = httpClient.execute(request,httpContext);
      HttpEntity entity = response.getEntity();
      if (entity != null) {
      String result = EntityUtils.toString(entity, charSet);
      response.close();
      return result;
      }
      return EMPTY_STR;
      }

    /**

    • 处理Http请求

    • @param request

    • @return
      */
      private static String getSSLResult(HttpRequestBase request, String charSet) throws Exception {

      return getResult(request,charSet,null,requestConfig);

// request.setConfig(requestConfig);
// CloseableHttpClient httpClient = HttpClients.custom()
// .setSSLSocketFactory(createSSLConnSocketFactory())
// .setDefaultRequestConfig(requestConfig)
// .build();
// CloseableHttpResponse response = httpClient.execute(request);
// HttpEntity entity = response.getEntity();
// if (entity != null) {
// String result = EntityUtils.toString(entity, charSet);
// response.close();
// return result;
// }
// return EMPTY_STR;
}

private static HttpPost buildHttpPost(String url) {
    return new HttpPost(processURL(url));
}

private static HttpGet buildHttpGet(String url) {
    return new HttpGet(processURL(url));
}

private static String processURL(String url) {
    if (StringUtils.isBlank(url)) {
        return url;
    }
    String upperUrl = url.toUpperCase();
    if (upperUrl.startsWith(HTTP_PREFIX)) {
        return url;
    } else if (upperUrl.startsWith(HTTP_SPLIT)) {
        return HTTP_HEADER + url;
    } else {
        return HTTP_HEADER + HTTP_SPLIT + url;
    }
}

private static HttpContext processCookie(List<BasicClientCookie> cookieList) {
    HttpContext httpContext = null;
    if (CollectionUtils.isNotEmpty(cookieList)) {
        httpContext = new BasicHttpContext();
        BasicCookieStore cookieStore = new BasicCookieStore();
        BasicClientCookie[] array = new BasicClientCookie[cookieList.size()];
        cookieStore.addCookies(cookieList.toArray(array));
        httpContext.setAttribute(HttpClientContext.COOKIE_STORE, cookieStore);
    }
    return httpContext;
}




/**
 * 发送 post请求（带文件）
 * @create by zoran.huang
 * @param url 地址
 * @param fileParams 附件
 *
 */
public static String httpPostFileRequest(String url, Map<String,File> fileParams) throws Exception{
    return httpPostFileRequest(url,null,null,fileParams);
}
/**
 * 发送 post请求（带文件）
 * @create by zoran.huang
 * @param url 地址
 * @param maps 参数
 * @param fileParams 附件
 *
 */
public static  String httpPostFileRequest(String url, Map<String, Object> maps, Map<String,File> fileParams) throws Exception{
    return httpPostFileRequest(url,null,maps,fileParams);
}
/**
 * 发送 post请求（带文件）
 * @create by zoran.huang
 * @param url 地址
 * @param maps 参数
 * @param headers 头信息
 * @param fileParams 附件
 *
 */
public static String httpPostFileRequest(String url,Map<String, Object> headers, Map<String, Object> maps, Map<String,File> fileParams) throws Exception{
    HttpPost httpPost = new HttpPost(url);// 创建httpPost
    MultipartEntityBuilder meBuilder = MultipartEntityBuilder.create();
    meBuilder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);
    meBuilder.setCharset(CharsetUtils.get("UTF-8"));
    if(maps != null ){
        for (String key : maps.keySet()) {
            meBuilder.addPart(key, new StringBody(String.valueOf(maps.get(key)), ContentType.TEXT_PLAIN));
        }
    }
    if (headers != null ){
        for (Map.Entry<String, Object> param : headers.entrySet()) {
            httpPost.addHeader(param.getKey(), String.valueOf(param.getValue()));
        }
    }

    if (fileParams != null ){
        for(Map.Entry<String, File>  file : fileParams.entrySet()) {
            FileBody fileBody = new FileBody(file.getValue());
            meBuilder.addPart(file.getKey(), fileBody);
        }
    }
    HttpEntity reqEntity = meBuilder.build();
    httpPost.setEntity(reqEntity);
    return getResult(httpPost,UTF_8);
}


public static HttpPost getPost(String url,Map<String,Object> params) throws Exception{
    HttpPost httpPost = buildHttpPost(url);// 创建httpPost
    ArrayList<NameValuePair> pairs = covertParams2NVPS(params);
    httpPost.setEntity(new UrlEncodedFormEntity(pairs, UTF_8));

    return httpPost;

}

private static String getJsonString(String resultStr,String callback) {
    if(StringUtils.isNotEmpty(resultStr) && StringUtils.isNotEmpty(callback)){
        int index = callback.indexOf(callback);
        if(index>-1 && resultStr.length()>callback.length()){
            resultStr = resultStr.substring(callback.length()+1,resultStr.length()-1);
        }
    }
    return resultStr;
}

}

fddxb110
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Mixed Content: The page at ‘xxx‘ was loaded over HTTPS, but requested an insecure resource ‘xxx‘.
猿小白的博客
06-11 1万+
今天使用nginx+tomcat+ssl完成了web项目的部署，本以为没有什么问题，但是在页面测试的时候又蹦出了这么一个问题，大致是说由于配置了HTTPS,但是之前的请求是通过HTTP请求的，所以现在被拦截，由于缺少某些权限信息，被禁止转发请求和访问。 经过一系列的排错与总结，整理了些有用的解决方法。 解决方法：在html页面的head中加入： <meta http-equiv="C...
通过一个诡异的问题深看字符集编码及HttpClient发送Post请求时StringEntity的编码
ystyaoshengting的专栏
12-03 2153
StringEntity 类的构造方法有两个参数，一个是String类型的具体的要传输的内容，另一个是ContentType（有三个多态形式charset，Charset，ContentType） 如果在构造方法里不显示指定ContentType，那么默认的ContentType是ContentType TEXT_PLAIN = create("text/plain", Consts.ISO_8859_1); 即mimeType是text/plan,charset是“ISO-8859-1” p
StringEntity格式编码问题
至愚则明
02-21 2万+
最近使用Apache的httpclient发起httpPost请求，后端一直提示编码格式错误。代码和环境都是在UTF-8写处理的，后端接受的编码也是UTF-8，但是后端依然报错。在跟踪代码的时候，发现主要是客户端StringEntity的处理问题。StringEntity设置编码格式主要有以下两种方式 //第一种方式：后端无法解码 StringEntity stringEntity ...
httpclient简单发送http request
Georgee1992的博客
06-13 2743
stub
java实现http及https请求(get及post方式)
LazyCancerPatiens的博客
06-18 1405
java实现http请求 import org.apache.http.Consts; import org.apache.http.HttpEntity; import org.apache.http.NameValuePair; import org.apache.http.client.entity.UrlEncodedFormEntity; import org.apache.http.client.methods.CloseableHttpResponse; import org.apache.h
HTTP兼容HTTPS请求工具类
04-09
Java Http 工具类，和Https工具类，自动识别Https走SSL协议
Java实现的Https请求工具类
04-09
综上所述，Java实现的HTTPS请求工具类通常会封装以上步骤，提供简洁的API供其他模块调用。通过这个工具类，开发者可以轻松地发起HTTPS请求，获取服务器响应，并进行数据交互，同时确保通信过程的安全性。在实际项目...
Java发 Https请求工具类 支持SSL
04-09
在Java编程中，HTTPS（Hypertext Transfer Protocol Secure）是一种基于HTTP的安全协议，它通过SSL/TLS（Secure Sockets ...通过阅读提供的"Java发 Https请求工具类 支持SSL.pdf"文档，可以深入理解其具体实现和用法。
HttpClientUtil工具类发送get和post请求，支持http和https，支持发送文件
04-07
3. 支持http和https：HttpClientUtil需要能够处理HTTP和HTTPS协议。HTTP协议不涉及数据加密，而HTTPS协议在HTTP的基础上加入了SSL/TLS层，提供数据加密和服务器身份验证，确保通信安全。HttpClient支持SSL/TLS，只需...
HttpUtils 发送http请求工具类(实例讲解)
08-30
HttpUtils 发送 HTTP 请求工具类详解 HTTP 请求工具类是 Java 语言中一个常用的工具类，用于发送 HTTP 请求并处理响应结果。本文将对 HttpUtils 发送 HTTP 请求工具类进行详细的讲解，包括其实现原理、关键代码分析...
HttpClient中GET、POST方法示例，支持 https
rimac的博客
02-06 516
HttpClient中GET、POST方法示例，支持 HTTPS import java.io.IOException; import java.security.GeneralSecurityException; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import o
JAVA http请求工具类
热门推荐
拾一二的博客
01-25 2万+
指定请求头自定义Cookie（cookie方法）指定是否keepAlive（keepAlive方法）指定表单内容（form方法）指定请求内容，比如rest请求指定JSON请求体（body方法）超时设置（timeout方法）指定代理（setProxy方法）指定SSL协议（setSSLProtocol）简单验证（basicAuth方法）很多时间受限于项目，开发环境，还是必须自己封装http,下边就这几贴代码了/**
HTTP请求
Ruby_One的博客
04-18 950
log.error("httpclientGet通信IO异常：{}:{}", url, ExceptionMessageHandler.toString(e));log.error("httpclientGet异常：{}:{}", url, ExceptionMessageHandler.toString(e));// 1 创建一个post对象。// 3 执行post请求。
http请求工具类
蓝天⊙白云的博客
12-13 270
【代码】http请求工具类。
【深入解析】C#高级HTTP请求工具类及其使用教程
最新发布
ck23456的博客
11-11 961
在.NET开发中，我们可能会遇到更为复杂的HTTP请求需求，如需要添加自定义请求头，处理POST请求的请求体等。本文将介绍一个更高级的C# HTTP请求工具类，并详细展示其使用方法。此高级HTTP请求工具类为处理复杂HTTP请求提供了强大的支持。你可以根据实际需求进行修改和扩展，使其更好地服务于你的项目。希望这个教程能够帮助到你。以上就是我今天的分享，如有任何问题，欢迎在评论区留言，我将尽快解答。
HTTP请求工具类
hangguangd的博客
08-31 379
http请求类
java发起http请求的工具类（用于请求第三方API）
weixin_44799283的博客
06-26 1818
我们在开发过程中总会遇到一些需要请求第三方接口的场景，一般第三方接口会告知我们请求地址、请求头、请求参数以及返回数据等信息，这个时候需要我们自行完成请求。下面分享几个请求第三方API可以使用到的java方法，希望对你有用。
Http请求工具类
道阻且长,行则将至 行而不辍,未来可期
08-08 1457
Http请求工具类工具类代码可以实现针对Http请求的访问以及返回。
支持http和https get和post请求工具类
09-08
支持HTTP和HTTPS Get和Post请求的工具类是一种能够方便地发送HTTP和HTTPS请求并获取响应的工具。这样的工具类通常提供了一些方法，让开发人员能够以简单的方式发送HTTP或HTTPS请求，可以包括Get请求和Post请求。下面...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值