java项目中调用外部接口工具类-HttpUtils

已于 2024-05-22 17:26:42 修改
阅读量700 收藏 10
点赞数 7
分类专栏： Java工具类 文章标签： java
于 2024-04-29 10:54:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_42917261/article/details/138305013
版权

项目中调用外部接口工具类

package com.common.utils;
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.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
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.entity.StringEntity;
import org.apache.http.entity.mime.HttpMultipartMode;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.entity.mime.content.ContentBody;
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.ssl.SSLContexts;
import org.apache.http.ssl.TrustStrategy;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.SSLContext;
import java.io.*;
import java.nio.charset.Charset;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.util.Map;

public class HttpUtils {
    public static Logger logger = LoggerFactory.getLogger(HttpUtil.class);
    private static CloseableHttpClient singletonHttpsClient = null;
    private static CloseableHttpClient defaultHttpClient = null;

    static {
        singletonHttpsClient = getSingletonHttpsClient();
        defaultHttpClient = HttpClients.createDefault();
    }

    /**
     * 单向httpsClient
     * @return
     */
    public static CloseableHttpClient getSingletonHttpsClient(){
        // 创建一个注册工厂， 用来注册http/https请求
        RegistryBuilder<ConnectionSocketFactory> registryBuilder = RegistryBuilder.create();
        ConnectionSocketFactory socketFactory = new PlainConnectionSocketFactory();
        // 注册http请求
        registryBuilder.register("http", socketFactory);

        try {
            // 实例化一个keyStore认证库
            KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
            // 信任所有
            TrustStrategy anyTrustStrategy = (x509Certificate, s) -> true;
            // 信任所有host
            HostnameVerifier verifier = (s, sslSession) -> true;
            // KeyStore&TrustStrategy加载到ssl上下文
            SSLContext sslContext = SSLContexts.custom().loadTrustMaterial(trustStore, anyTrustStrategy).build();
            // 此方法是生成一个Socket工厂，https请求在真实请求接口前，需提前发起socket请求验证，参数是ssl上下文以及信任所有host的方法
            LayeredConnectionSocketFactory sslSF = new SSLConnectionSocketFactory(sslContext, verifier);
            // 注册https请求
            registryBuilder.register("https", sslSF);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (KeyStoreException e) {
            e.printStackTrace();
        } catch (KeyManagementException e) {
            e.printStackTrace();
        }
        Registry<ConnectionSocketFactory> registry = registryBuilder.build();
        // 设置连接管理器
        PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager(registry);
        // 返回生成的CloseableHttpClient
        return HttpClientBuilder.create().setConnectionManager(connectionManager).build();
    }

    /**
     * post请求（text/plain）
     * @param url
     * @param data
     * @param headerParam
     * @param charset
     * @return
     */
    public static String doPost(String url, String data, JSONObject headerParam, String charset) {
        CloseableHttpClient httpClient = null;
        HttpPost httpPost = null;
        String result = null;
        try {
            if(url.contains("https")){
                httpClient = singletonHttpsClient;
            } else {
                httpClient = defaultHttpClient;
            }
            httpPost = new HttpPost(url);
            // 设置头部参数
            if(headerParam != null){
                for(String key : headerParam.keySet()){
                    httpPost.addHeader(key, headerParam.getString(key));
                }
                if(!headerParam.containsKey("Content-Type")){
                    httpPost.addHeader("Content-Type", "text/plain;charset=utf-8");
                }
                if(!headerParam.containsKey("Content-Length")){
                    //httpPost.addHeader("Content-Length", String.valueOf(data.length()));
                }
            } else {
                httpPost.addHeader("Content-Type", "text/plain;charset=utf-8");
                //httpPost.addHeader("Content-Length", String.valueOf(data.length()));
            }
            StringEntity entity = new StringEntity(data, charset);
            entity.setContentEncoding(charset);
            httpPost.setEntity(entity);
            CloseableHttpResponse response = httpClient.execute(httpPost);
            if(response != null){
                HttpEntity resEntity = response.getEntity();
                if(resEntity != null){
                    result = EntityUtils.toString(resEntity, charset);
                }
                response.close();
            }
        } catch (Exception e){
            logger.error("httpUtil do post fail:{}",e.getMessage());
        }
        return result;
    }

    /**
     * post请求（multipart/form-data）
     * @param url
     * @param paramBody
     * @param headerParam
     * @param boundary
     * @param charset
     * @return
     */
    public static String doPost(String url, Map<String, ContentBody> paramBody, JSONObject headerParam, String boundary, String charset) {
        CloseableHttpClient httpClient = null;
        HttpPost httpPost = null;
        String result = null;
        try {
            if(url.contains("https")){
                httpClient = singletonHttpsClient;
            } else {
                httpClient = defaultHttpClient;
            }
            httpPost = new HttpPost(url);
            // 设置头部参数
            if(headerParam != null){
                for(String key : headerParam.keySet()){
                    if(headerParam.containsKey("Content-Type")){
                        continue;
                    }
                    httpPost.addHeader(key, headerParam.getString(key));
                }
                if(!headerParam.containsKey("Content-Length")){
                    //httpPost.addHeader("Content-Length", String.valueOf(data.length()));
                }
            } else {
                //httpPost.addHeader("Content-Length", String.valueOf(data.length()));
            }
            MultipartEntityBuilder multipartEntityBuilder = MultipartEntityBuilder.create();
            multipartEntityBuilder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);
            multipartEntityBuilder.setCharset(Charset.forName(charset));
            if(StringUtils.isNotBlank(boundary)){
                multipartEntityBuilder.setBoundary(boundary);
            }
            if(paramBody != null){
                for(Map.Entry<String, ContentBody> entry : paramBody.entrySet()){
                    multipartEntityBuilder.addPart(entry.getKey(), entry.getValue());
                }
            }
            HttpEntity entity = multipartEntityBuilder.build();
            httpPost.setEntity(entity);
            CloseableHttpResponse response = httpClient.execute(httpPost);
            if(response != null){
                HttpEntity resEntity = response.getEntity();
                if(resEntity != null){
                    result = EntityUtils.toString(resEntity, charset);
                }
                response.close();
            }
        } catch (Exception e){
            e.printStackTrace();
        }
        return result;
    }

    public static HttpResponse doPostByResponse(String url, String data, JSONObject headerParam, String charset) {
        CloseableHttpClient httpClient = null;
        HttpPost httpPost = null;
        String result = null;
        try {
            if(url.contains("https")){
                httpClient = singletonHttpsClient;
            } else {
                httpClient = defaultHttpClient;
            }
            //httpClient = HttpClients.custom().setSSLSocketFactory(getSSLConnectionSocketFactory()).build();
            httpPost = new HttpPost(url);
            // 设置头部参数
            if(headerParam != null){
                for(String key : headerParam.keySet()){
                    httpPost.addHeader(key, headerParam.getString(key));
                }
                if(!headerParam.containsKey("Content-Type")){
                    httpPost.addHeader("Content-Type", "text/plain;charset=utf-8");
                }
                if(!headerParam.containsKey("Content-Length")){
                    httpPost.addHeader("Content-Length", String.valueOf(data.length()));
                }
            } else {
                httpPost.addHeader("Content-Type", "text/plain;charset=utf-8");
                httpPost.addHeader("Content-Length", String.valueOf(data.length()));
            }
            StringEntity entity = new StringEntity(data, charset);
            entity.setContentEncoding(charset);
            httpPost.setEntity(entity);
            return httpClient.execute(httpPost);
        } catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }

    /**
     * post请求（text/plain）
     * @param url
     * @param data
     * @param charset
     * @return
     */
    public static String doPost(String url, String data, String charset) {
        CloseableHttpClient httpClient = null;
        HttpPost httpPost = null;
        String result = null;
        try {
            if(url.contains("https")){
                httpClient = singletonHttpsClient;
            } else {
                httpClient = defaultHttpClient;
            }
            httpPost = new HttpPost(url);
            // 设置头部参数
            httpPost.addHeader("Content-Type", "text/plain;charset=utf-8");
            StringEntity entity = new StringEntity(data, charset);
            entity.setContentEncoding(charset);
            httpPost.setEntity(entity);
            CloseableHttpResponse response = httpClient.execute(httpPost);
            if(response != null){
                HttpEntity resEntity = response.getEntity();
                if(resEntity != null){
                    result = EntityUtils.toString(resEntity, charset);
                }
                response.close();
            }

        } catch (Exception e){
            logger.error("httpUtil do post fail:{}",e.getMessage());
        }
        return result;
    }

    /**
     * get请求（multipart/form-data）
     * @param url
     * @param headerParam
     * @param charset
     * @return
     */
    public static String doGet(String url, JSONObject headerParam, String charset) {
        CloseableHttpClient httpClient = null;
        HttpGet httpGet = null;
        String result = null;
        try {
            if(url.contains("https")){
                httpClient = singletonHttpsClient;
            } else {
                httpClient = defaultHttpClient;
            }
            httpGet = new HttpGet(url);
            // 设置头部参数
            if(headerParam != null){
                for(String key : headerParam.keySet()){
                    if(headerParam.containsKey("Content-Type")){
                        continue;
                    }
                    httpGet.addHeader(key, headerParam.getString(key));
                }
                if(!headerParam.containsKey("Content-Length")){
                    //httpPost.addHeader("Content-Length", String.valueOf(data.length()));
                }
            } else {
                //httpPost.addHeader("Content-Length", String.valueOf(data.length()));
            }

            CloseableHttpResponse response = httpClient.execute(httpGet);
            if(response != null){
                HttpEntity resEntity = response.getEntity();
                if(resEntity != null){
                    result = EntityUtils.toString(resEntity, charset);
                }
                response.close();
            }
        } catch (Exception e){
            e.printStackTrace();
        }
        return result;
    }

    /**
     * get请求（text/plain）
     * @param url
     * @param charset
     * @return
     */
    public static String doGet(String url, String charset) {
        CloseableHttpClient httpClient = null;
        HttpGet httpGet = null;
        String result = null;
        try {
            if(url.contains("https")){
                httpClient = singletonHttpsClient;
            } else {
                httpClient = defaultHttpClient;
            }
            httpGet = new HttpGet(url);
            // 设置头部参数
            httpGet.addHeader("Content-Type", "text/plain;charset=utf-8");
            CloseableHttpResponse response = httpClient.execute(httpGet);
            if(response != null){
                HttpEntity resEntity = response.getEntity();
                if(resEntity != null){
                    result = EntityUtils.toString(resEntity, charset);
                }
                response.close();
            }
        } catch (Exception e){
            e.printStackTrace();
        }
        return result;
    }

    /**
     * post请求下载文件
     * @param url
     * @param data
     * @param headerParam
     * @param localPath
     * @return
     */
    public static boolean doPostDownLoadFile(String url, String data, JSONObject headerParam, String localPath) {
        CloseableHttpClient httpClient = null;
        HttpPost httpPost = null;
        boolean result = false;
        try {
            if(url.contains("https")){
                httpClient = singletonHttpsClient;
            } else {
                httpClient = defaultHttpClient;
            }
            httpPost = new HttpPost(url);
            // 设置头部参数
            if(headerParam != null){
                for(String key : headerParam.keySet()){
                    httpPost.addHeader(key, headerParam.getString(key));
                }
                if(!headerParam.containsKey("Content-Type")){
                    httpPost.addHeader("Content-Type", "text/plain;charset=utf-8");
                }
                if(!headerParam.containsKey("Content-Length")){
                    //httpGet.addHeader("Content-Length", String.valueOf(data.length()));
                }
            } else {
                httpPost.addHeader("Content-Type", "text/plain;charset=utf-8");
                // httpGet.addHeader("Content-Length", String.valueOf(data.length()));
            }
            StringEntity entity = new StringEntity(data, "UTF-8");
            entity.setContentEncoding("UTF-8");
            httpPost.setEntity(entity);
            CloseableHttpResponse response = httpClient.execute(httpPost);
            if(response != null){
                HttpEntity resEntity = response.getEntity();
                if(resEntity != null){
                    InputStream is = resEntity.getContent();
                    File file = new File(localPath);
                    FileOutputStream fos = new FileOutputStream(file);
                    byte[] buffer = new byte[1024];
                    int len = 0;
                    while((len = is.read(buffer)) != -1){
                        fos.write(buffer, 0, len);
                    }
                    fos.close();
                    is.close();
                    result = true;
                }
                response.close();
            }
        } catch (Exception e){
            e.printStackTrace();
        }
        return result;
    }

    /**
     * get请求下载文件
     * @param url
     * @param headerParam
     * @param localPath
     * @return
     */
    public static boolean doGetDownLoadFile(String url, JSONObject headerParam, String localPath) {
        CloseableHttpClient httpClient = null;
        HttpGet httpGet = null;
        boolean result = false;
        try {
            if(url.contains("https")){
                httpClient = singletonHttpsClient;
            } else {
                httpClient = defaultHttpClient;
            }
            httpGet = new HttpGet(url);
            // 设置头部参数
            if(headerParam != null){
                for(String key : headerParam.keySet()){
                    httpGet.addHeader(key, headerParam.getString(key));
                }
                if(!headerParam.containsKey("Content-Type")){
                    httpGet.addHeader("Content-Type", "text/plain;charset=utf-8");
                }
                if(!headerParam.containsKey("Content-Length")){
                    //httpGet.addHeader("Content-Length", String.valueOf(data.length()));
                }
            } else {
                httpGet.addHeader("Content-Type", "text/plain;charset=utf-8");
                // httpGet.addHeader("Content-Length", String.valueOf(data.length()));
            }
            CloseableHttpResponse response = httpClient.execute(httpGet);
            if(response != null){
                HttpEntity resEntity = response.getEntity();
                if(resEntity != null){
                    InputStream is = resEntity.getContent();
                    File file = new File(localPath);
                    FileOutputStream fos = new FileOutputStream(file);
                    byte[] buffer = new byte[1024];
                    int len = 0;
                    while((len = is.read(buffer)) != -1){
                        fos.write(buffer, 0, len);
                    }
                    fos.close();
                    is.close();
                    result = true;
                }
                response.close();
            }
        } catch (Exception e){
            e.printStackTrace();
        }
        return result;
    }
    
}
java发起POST方法请求第三方接口（编码处理）
专注于计算机研发知识和资讯分享
10-06 741
HttpMessageNotReadableException ,有可能是编码问题导致的JSON解析失败。调用jdk的javac命令执行编译，javac默认采用系统字符集。使用命令编译可加上-,告诉虚拟机启动的时候以什么字符集编码来解析我们的class字节码文件。告诉虚拟机启动的时候以什么字符集编码来解析我们的class字节码文件。针对编码阶段出现的中文，在这一步骤就需要操作系统安装中文字体以支持中文。避免，编码问题，造成请求参数解析失败。使用场景： 调用第三方平台接口。
java请求第三方工具类；包含: json传参,get传参,formdata传参
qq_43582260的博客
02-01 833
java请求第三方工具类;包含: json传参,get传参,formdata传参 闲话不说 直接上代码 package com.isoftstone.tdappservice.util; import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSONObject; import com.isoftstone.tdappservice.constant.ServerConstant; import org.apache.http.Const
Java 调用Http接口工具类
weixin_45067120的博客
08-27 738
工具类使用以及源码一、实列使用二、工具类代码HttpClientUtils ： 一、实列使用 二、工具类代码 HttpClientUtils ： import org.apache.http.*; import org.apache.http.auth.AuthScope; import org.apache.http.auth.UsernamePasswordCredentials; import org.apache.http.client.CredentialsProvider; import or
Java 调用第三方接口方法
热门推荐
qq_41128049的博客
04-25 3万+
Java 调用第三方接口方法 一、 通过JDK网络类Java.net.HttpURLConnection 1.java.net包下的原生java api提供的http请求 使用步骤： 1、通过统一资源定位器（java.net.URL）获取连接器（java.net.URLConnection）。 2、设置请求的参数。 3、发送请求。 4、以输入流的形式获取返回内容。 5、关闭输入流。 2.HttpClientUtil工具类 /** * jdk 调用第三方接口 * @author hsq */ pub
调用第三方接口http和https工具类二合一
最新发布
Dream-Start的博客
05-12 93
【代码】调用第三方接口http和https工具类二合一。
java调用第三方接口工具类
格林王子举哥
04-17 2132
get请求方式，参数放url后面 post请求方式，参数放url后面 post请求方法，参数以json格式传输 package com.sport.sportcompetitionserver.common.utils; import com.alibaba.fastjson.JSONObject; import org.apache.http.HttpResponse; import org.apache.http.HttpStatus; import org.apache.http....
java调用第三方接口工具类 (HttpClientUtils.java)
weixin_43652507的博客
08-10 825
CloseableHttpClient httpClient = HttpClients.createDefault();
java调用工具类_JAVA接口调用工具类
weixin_39733821的博客
02-19 649
package com.zving.util;import org.springframework.http.HttpEntity;import org.springframework.http.HttpHeaders;import org.springframework.http.HttpMethod;import org.springframework.http.ResponseEntity;...
JAVA 调用外部接口
BugRoot的博客
08-04 1万+
系统需要调用guo wai一个接口，由于调用的guowai接口，需要通过proxy请求 现在有3个方案 1.使用proxy进行http请求 2.直接使用guo wai服务器部署项目 3.使用HK服务器作为中介获取返回数据 1：问题，代理不稳定 2：问题，相对于较繁琐 推荐用3 当不想每次写完代码，部署到HK服务器进行测试，可以先本地使用proxy进行测试，或者使用proxy IP。 工具都有提供端口号，具体可以咨询软件提供商 如需要用SoapUI，Postman测试,请看Utils内的 HTTP Auth认
JAVA 调用https接口， java.security.cert.CertificateException
a8605428的博客
10-23 1557
package com.easycare.store.util; import java.security.cert.CertificateException; import java.security.cert.X509Certificate; import javax.net.ssl.SSLContext; import javax.net.ssl.TrustMa...
基于Java实现企业微信群聊机器人-文件上传+消息推送（保证可用）
weixin_37689136的博客
03-31 3112
在开发过程中，经常会发生一些运行时异常，需要及时通知运维和开发同学，修复bug并更新系统，避免造成更大的异常和损失，本文主要讲述基于Java如何通过机器人发送消息和上传文档到企业微信群聊。
HttpClientUtil工具类，调用第三方接口
10-25
该工具类是java 调用第三方接口时需要使用到的。HttpClientUtil 包含get和post方法。
Java调用第三方接口工具类（json、form）
weixin_34387468的博客
12-14 694
  1、JSON值访问 /** * 调用对方接口方法 * @param path 对方或第三方提供的路径 * @param data 向对方或第三方发送的数据，大多数情况下给对方发送JSON数据让对方解析 */ public static void interfaceUtil(String path,String data) { try { URL url = n...
Java调用第三方接口示范
lip86的专栏
06-04 416
在项目开发中经常会遇到调用第三方接口的情况，比如说调用第三方的天气预报接口。 使用流程 【1】准备工作：在项目的工具包下导入HttpClientUtil这个工具类，或者也可以使用Spring框架的restTemplate来调用，上面有调用接口的方法【分为Get和Post方式的有参和无参调用】： package com.njsc.credit.util; import java.io....
Java 接口调用工具类
记录工作开发中遇到的技术难点，方便自己查看，也希望可以帮助到他人...
07-11 581
Post方式 import org.springframework.http.HttpEntity; import org.springframework.http.HttpHeaders; import org.springframework.web.client.RestTemplate; public class RestTemplateUtil { private RestTemplateUtil() { } public static RestTemplate getI
Java调用第三方接口的方法
y516369的博客
11-28 6442
Java调用第三方接口的方法
Java模拟http请求调用远程接口工具类（转）
Mistra的博客
06-07 2583
package ln; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.PrintWriter; import java.util.HashMap; import java.util.List; import java.util.
Java访问外部接口工具类
wangpei930228的博客
03-24 448
使用场景：本地Java工程需要访问外部接口获取数据。 第一步：添加mven依赖 <dependency> <groupId>org.apache.httpcomponents</groupId> <artifactId>httpclient</artifactId> <version>4.5.10</version> </dependency> 第二步：编写工具类 pac
java中http调用接口的工具类
weixin_34192993的博客
03-28 890
2019独角兽企业重金招聘Python工程师标准>>> ...
[smsprev4@smspre1 PLCX]$ gdb core.32345 PLCXPro GNU gdb (GDB) Red Hat Enterprise Linux (7.2-64.AXS4.2) Copyright (C) 2010 Free Software Foundation, Inc. License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html> This is free software: you are free to change and redistribute it. There is NO WARRANTY, to the extent permitted by law. Type "show copying" and "show warranty" for details. This GDB was configured as "x86_64-redhat-linux-gnu". For bug reporting instructions, please see: <http://www.gnu.org/software/gdb/bugs/>... "/app/smsprev4/sbin/PLCX/core.32345" is a core file. Please specify an executable to debug. "/app/smsprev4/sbin/PLCX/PLCXPro" is not a core dump: File format not recognized怎么查看错误
06-06
这个错误信息表明，你需要指定一个可执行文件来调试，而不是指定一个core dump文件。你可以尝试使用以下命令来调试可执行文件： ``` gdb PLCXPro ``` 当你进入GDB调试器时，可以使用以下命令来加载core dump文件： ``` core-file core.32345 ``` 然后你就可以使用GDB来分析core dump文件了。如果你仍然遇到问题，可以提供更多的上下文和细节，以便我更好地帮助你。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值