HttpUtils——助力高效网络通信

于 2024-08-26 05:30:00 发布
阅读量892 收藏 18
点赞数 17
分类专栏： 编程学习 JAVA基础工作中实际总结 文章标签： 知识图谱 人工智能 java 开发语言 服务器 servlet
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Andrew_Chenwq/article/details/141487547
版权

HttpUtils——助力高效网络通信

  • 使用HttpClient发送请求、接收响应很简单，一般需要如下几步即可:

  • 1、创建HttpClient对象。
2、创建请求方法的实例，并指定请求URL。如果需要发送GET请求，
创建HttpGet对象；如果需要发送POST请求，创建HttpPost对象。
3、如果需要发送请求参数，可调用HttpGet、HttpPost
共同的setParams(HttpParams params)方法来添加请求参数；
对于HttpPost对象而言，也可调用setEntity(HttpEntity entity)
方法来设置请求参数。
4、调用HttpClient对象的execute(HttpUriRequest request)
发送请求，该方法返回一个HttpResponse。
5、调用HttpResponse的getAllHeaders()、getHeaders(String name)
等方法可获取服务器的响应头；调用HttpResponse的getEntity()方法可获取HttpEntity对象，
该对象包装了服务器的响应内容。程序可通过该对象获取服务器的响应内容。
6、释放连接。无论执行方法是否成功，都必须释放连接

  • 引入依赖

  •   <!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpclient -->
    <dependency>
        <groupId>org.apache.httpcomponents</groupId>
        <artifactId>httpclient</artifactId>
        <version>4.5.13</version>
    </dependency>

  • 工具类

  • @Slf4j
public class HttpUtils {

    public static String defaultEncoding = "utf-8";

    /**
     * 发送http post请求，并返回响应实体
     *
     * @param url 请求地址
     * @return url响应实体
     */
    public static String postRequest(String url) {
        return postRequest(url, null, null);
    }

    /**
     * <p>方法名: postRequest</p>
     * <p>描述: 发送httpPost请求</p>
     *
     * @param url
     * @param params
     * @return
     */
    public static String postRequest(String url, Map<String, Object> params) {
        return postRequest(url, null, params);
    }

    /**
     * 发送http post请求，并返回响应实体
     *
     * @param url     访问的url
     * @param headers 请求需要添加的请求头
     * @param params  请求参数
     * @return
     */
    public static String postRequest(String url, Map<String, String> headers,
                                     Map<String, Object> params) {
        String result = null;
        CloseableHttpClient httpClient = buildHttpClient();
        HttpPost httpPost = new HttpPost(url);
        if (null != headers && headers.size() > 0) {
            for (Entry<String, String> entry : headers.entrySet()) {
                String key = entry.getKey();
                String value = entry.getValue();
                httpPost.addHeader(new BasicHeader(key, value));
            }
        }

        if(isJSON(params.toString())){
            /**
             * json格式
             */
            StringEntity requestEntity = new StringEntity(params.toString(), "utf-8");
            requestEntity.setContentEncoding("UTF-8");
            httpPost.setHeader("Content-type", "application/json");
            httpPost.setEntity(requestEntity);
        }else{
            /**
             * 名称值对节点类型
             */
            if (null != params && params.size() > 0) {
                List<NameValuePair> pairList = new ArrayList<NameValuePair>(params.size());
                for (Map.Entry<String, Object> entry : params.entrySet()) {
                    NameValuePair pair = new BasicNameValuePair(entry.getKey(), entry.getValue().toString());
                    pairList.add(pair);
                }
                httpPost.setEntity(new UrlEncodedFormEntity(pairList, Charset.forName(defaultEncoding)));
            }
        }


        try {
            CloseableHttpResponse response = httpClient.execute(httpPost);
            try {
                HttpEntity entity = response.getEntity();
                if (entity != null) {
                    log.info("【POST请求信息】,请求地址:{},请求参数:{}", url, params);
                    result = EntityUtils.toString(entity, Charset.forName(defaultEncoding));
                    log.info("【POST请求信息】,请求地址:{},请求参数:{},返回结果:{}", url, params,result);
                }
            } finally {
                response.close();
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            try {
                httpClient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return result;
    }

    /**
     * 发送http get请求
     *
     * @param url 请求url
     * @return url返回内容
     */
    public static String getRequest(String url) {
        return getRequest(url, null);
    }


    /**
     * 发送http get请求
     *
     * @param url    请求的url
     * @param params 请求的参数
     * @return
     */
    public static String getRequest(String url, Map<String, Object> params) {
        return getRequest(url, null, params);
    }

    /**
     * 发送http get请求
     *
     * @param url        请求的url
     * @param headersMap 请求头
     * @param params     请求的参数
     * @return
     */
    public static String getRequest(String url, Map<String, String> headersMap, Map<String, Object> params) {
        String result = null;
        CloseableHttpClient httpClient = buildHttpClient();
        try {
            String apiUrl = url;
            if (null != params && params.size() > 0) {
                StringBuffer param = new StringBuffer();
                int i = 0;
                for (String key : params.keySet()) {
                    if (i == 0)
                        param.append("?");
                    else
                        param.append("&");
                    param.append(key).append("=").append(params.get(key));
                    i++;
                }
                apiUrl += param;
            }

            HttpGet httpGet = new HttpGet(apiUrl);
            if (null != headersMap && headersMap.size() > 0) {
                for (Entry<String, String> entry : headersMap.entrySet()) {
                    String key = entry.getKey();
                    String value = entry.getValue();
                    httpGet.addHeader(new BasicHeader(key, value));
                }
            }
            CloseableHttpResponse response = httpClient.execute(httpGet);
            try {
                HttpEntity entity = response.getEntity();
                if (null != entity) {
                    log.info("【GET请求信息】,请求地址:{},请求参数:{}", url, params);
                    result = EntityUtils.toString(entity, defaultEncoding);
                    log.info("【GET请求信息】,请求地址:{},请求参数:{},返回结果:{}", url, params,result);
                }
            } finally {
                response.close();
            }
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (ParseException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                httpClient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return result;
    }

    /**
     * 创建httpclient,支持http、https
     *
     * @return
     */
    public static CloseableHttpClient buildHttpClient() {
        try {
            RegistryBuilder<ConnectionSocketFactory> builder = RegistryBuilder
                    .create();
            ConnectionSocketFactory factory = new PlainConnectionSocketFactory();
            builder.register("http", factory);
            KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
            SSLContext context = SSLContexts.custom().useTLS()
                    .loadTrustMaterial(trustStore, new TrustStrategy() {
                        public boolean isTrusted(X509Certificate[] chain,
                                                 String authType) throws CertificateException {
                            return true;
                        }
                    }).build();
            LayeredConnectionSocketFactory sslFactory = new SSLConnectionSocketFactory(
                    context,
                    SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
            builder.register("https", sslFactory);
            Registry<ConnectionSocketFactory> registry = builder.build();
            PoolingHttpClientConnectionManager manager = new PoolingHttpClientConnectionManager(registry);
            ConnectionConfig connConfig = ConnectionConfig.custom()
                    .setCharset(Charset.forName(defaultEncoding)).build();
            SocketConfig socketConfig = SocketConfig.custom()
                    .setSoTimeout(100000).build();
            manager.setDefaultConnectionConfig(connConfig);
            manager.setDefaultSocketConfig(socketConfig);
            return HttpClientBuilder.create().setConnectionManager(manager)
                    .build();
        } catch (KeyStoreException e) {
            e.printStackTrace();
        } catch (KeyManagementException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return null;
    }


    public static boolean isJSON(String str) {
        boolean result = false;
        try {
            Object obj=JSON.parse(str);
            result = true;
        } catch (Exception e) {
            result=false;
        }
        return result;
    }

    public static void main(String[] args) {
        String url1 = "http://192.168.56.101:8196/test/get1";
        String result = HttpUtils.getRequest(url1);
        System.out.println(result);

        String url2 = "http://192.168.56.101:8196/test/get2";
        Map<String, Object> params = new HashMap<>();
        params.put("name", "一安未来1");
        params.put("addr", "北京1");
        String result2 = HttpUtils.postRequest(url2, null,params);
        System.out.println(result2);

        String url3 = "http://192.168.56.101:8196/test/get3";
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("name", "一安未来2");
        jsonObject.put("addr", "北京2");
        String result3 = HttpUtils.postRequest(url3, null,jsonObject);
        System.out.println(result3);
    }

【GET请求信息】,请求地址:http://192.168.56.101:8196/test/get1,请求参数:null
【GET请求信息】,请求地址:https://192.168.56.101:8196/test/get1,请求参数:null,返回结果:{"result":"success"}

【POST请求信息】,请求地址:http://192.168.56.101:8196/test/get2,请求参数:{name=一安未来1, addr=北京1}
【POST请求信息】,请求地址:http://192.168.56.101:8196/test/get2,请求参数:{name=一安未来1, addr=北京1},返回结果:{"name":"一安未来1","addr":"北京1"}

【POST请求信息】,请求地址:http://192.168.56.101:8196/test/get3,请求参数:{"name":"一安未来2","addr":"北京2"}
【POST请求信息】,请求地址:http://192.168.56.101:8196/test/get3,请求参数:{"name":"一安未来2","addr":"北京2"},返回结果:{"name":"一安未来2","addr":"北京2"}

}

  • 接口类

  • @RestController
public class TestController {


    @GetMapping("get1")
    public String test1(){
        return "{\"result\":\"success\"}";
    }


    @PostMapping("get2")
    private Map<String, Object> test2(@RequestParam Map<String,Object> map){
        return map;
    }

    @PostMapping("get3")
    private Map test3(@RequestBody Map<String,Object> map){
        return map;
    }

}
IT枫斗者
关注
专栏目录
HTTPUtils工具类
09-11
最全httpClient工具类 .
httputils网络请求工具
06-28
HttpUtils网络请求工具类,可以获取网络上的数据转化给JSON数据然后处理成自己的想要的数据 http://blog.csdn.net/qq_30552993/article/details/51774509
Http 工具类
liu_qunfeng的博客
05-18 159
/** * 分类： * 1.饿汉式 * &lt;p&gt; * 2.懒汉式 * &lt;p&gt; * 1.子线程请求数据 * 2.将数据发送到主线程 * &lt;p&gt; * handler -- android中的一种通信机制 * 线程间的通信 * 原理： */public class HttpUtils {    private static final String TAG = "Htt...
HttpUtils工具类（一）常见的HttpUtils工具类及如何自定义java的http连接池
最新发布
m0_52767002的博客
08-15 1238
一、几种常见的Http调用方式一、几种常见的Http调用方式OKhttp是一个功能强大的 HTTP 客户端库，支持同步和异步请求。它适用于处理更加复杂的场景，如认证、连接池、多线程、上传文件等。
httpUtils
Nightliar的博客
05-24 661
package com.common.util; import java.io.IOException; import java.net.URISyntaxException; import java.nio.charset.StandardCharsets; import java.security.KeyManagementException; import java.security.Ke
HttpUtils
满分博的博客
07-29 333
public class HttpUtils { private static HttpUtils httpUtils; private getjsonlisten getjsonlisten; public static HttpUtils getInstance() { if (httpUtils==null){ httpUti...
打造一个通用的网络请求引擎HttpUtils
05-30
本教程将探讨如何构建一个通用的网络请求引擎——HttpUtils，它能够处理多种类型的HTTP请求，如GET、POST，并具备错误处理、异步调用等功能。我们将深入理解网络请求的基本原理，学习相关API的使用，以及如何优化...
HttpUtils.zip
04-07
总的来说，`HttpUtils.zip`提供了一个便捷的网络请求解决方案，结合了HttpClient和OkHttp的优点，使得开发者能够快速集成网络功能，专注于业务逻辑的实现。如果你在使用过程中有任何问题或建议，可以在相关平台上...
HttpUtils.rar
09-14
在软件开发中，HTTP协议是网络通信的基础，用于客户端与服务器之间的数据交换。Java作为一种广泛使用的编程语言，对于HTTP请求的支持至关重要。"HttpUtils"这个工具类正是为了解决这个问题，提供了一种简洁、高效的...
HttpUtils 请求工具类
09-17
自己写的基于Java自带URL请求 处理get,post 不明白的，里面直接运行可以跑,
httpUtil
zhf_123666的博客
03-22 407
//java学习交流QQ群716298150 package com.common.utils; import java.io.BufferedReader; import java.io.DataOutputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.i...
Java请求Http接口-hutool的HttpUtil(超详细-附带工具类)
热门推荐
苍煜
08-18 3万+
HttpUtil是应对简单场景下Http请求的工具类封装，此工具封装了HttpRequest对象常用操作，可以保证在一个方法之内完成Http请求。此模块基于JDK的HttpUrlConnection封装完成，完整支持https、代理和文件上传。
https get httputils
07-16
https get和httputils是两个不同的概念。 首先，https是一种安全的网络协议，它在http的基础上增加了加密机制，用于保护网站访问的安全性。https使用SSL（Secure Sockets Layer）或TLS（Transport Layer Security）协议来实现数据传输的加密和身份认证。相比于http，https更加安全可靠，能够有效防止信息泄漏和数据被篡改的风险。 其次，httputils是一个常用的网络请求工具类，主要用于简化和封装http请求的操作。通过httputils可以方便地进行http请求，如发送get请求、post请求等。它提供了一系列方法来设置请求参数、获取响应结果，并支持异步请求和文件上传等功能。httputils的使用可以简化开发过程，提高开发效率。 综上所述，https get和httputils是两个不同领域的概念。https get是指使用https协议发送get请求，以实现安全的数据传输；httputils是一个工具库，用于简化http请求的操作。它们在网络通信和开发技术中发挥着各自的作用，都对提高网络安全性和开发效率有着重要的意义。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

IT枫斗者

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值