HTTP工具类封装与http请求响应

这篇具有很好参考价值的文章主要介绍了HTTP工具类封装与http请求响应。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

一、前言

在Java web系统中经常需要与外部接口进行对接,比较多的方式就是是http的方式。在springboot中,我们可以直接使用封装的feign如:我们去请求微信的接口,定义一个client客户端,使用feign框架去请求就可以。但是也有很多系统没有使用feign的框架,那就需要使用http工具类了。

@FeignClient(name = "weixin", url = "https://api.weixin.qq.com/")
public interface WXCLient {

    /**
     * 获取微信token
     * @param appid
     * @param secret
     * @return
     */
    @GetMapping("cgi-bin/token")
    Map<String, Object> gettoken(@RequestParam("appid") String appid, 
    @RequestParam("secret") String secret, @RequestParam("grant_type") String grant_type);

    /**
     * 获取微信token
     *
     * @param appid
     * @param secret
     * @return
     */
    @GetMapping("cgi-bin/token")
    Map<String, Object> getQRtoken(@RequestParam("appid") String appid, @RequestParam("secret") String secret, @RequestParam("grant_type") String grant_type);

    
    /**
     * 小程序登录
     *
     * @param appid
     * @param secret
     * @param grant_type
     * @param jsCode
     * @return  map {"session_key": "", "openid": ""}
     */
    @GetMapping("sns/jscode2session")
    Map<String, Object> jscode2session(@RequestParam("appid") String appid, @RequestParam("secret") String secret, @RequestParam("grant_type") String grant_type, @RequestParam("js_code") String jsCode);
    /**
     * 根据access_token和code获取微信登录信息
     *
     * @param access_token
     * @param code
     * @return
     */
    @GetMapping("cgi-bin/user/getUserInfo")
    Map<String, Object> getuserinfo(@RequestParam("access_token") String access_token, @RequestParam("code") String code);


    /**
     * @param access_token
     * @param userId
     * @return
     */
    @GetMapping("cgi-bin/user/get")
    Map<String, Object> get(@RequestParam("access_token") String access_token, @RequestParam("userid") String userId);

    /**
     * 获取微信用户手机号
     *
     * @param bodyMap
     * @param accessToken
     * @return
     */
    @PostMapping("wxa/business/getuserphonenumber")
    Map<String, Object> getPhone(@RequestParam("access_token") String accessToken, @RequestBody Map<String, Object> bodyMap);

    /**
     * 创建特定路径的微信小程序二维码
     *
     * @param bodyMap {"path":"", "with": 430}
     * @param accessToken
     * @return 返回的图片 Buffer
     */
    @PostMapping("cgi-bin/wxaapp/createwxaqrcode")
    Response createwxaqrcode(@RequestParam("access_token") String accessToken, @RequestBody Map<String, Object> bodyMap);
    
    
    /**
     * 获取urlscheme
     * @param accessToken
     * @param bodyMap
     * @return
     */
    @PostMapping("wxa/generatescheme")
    Map<String, Object>  generatescheme(@RequestParam("access_token") String accessToken, @RequestBody Map<String, Object> bodyMap);

    
    /**
     * 通过短信链接跳转
     * 获取generate_urllink
     * @param accessToken
     * @param bodyMap
     * @return
     */
    @PostMapping("wxa/generate_urllink")
    Map<String, Object>  generateUrllink(@RequestParam("access_token") String accessToken, @RequestBody Map<String, Object> bodyMap);

    
    /**
     * 二维码
     *该接口用于获取小程序码,适用于需要的码数量极多的业务场景。通过该接口生成的小程序码,永久有效,数量暂无限制。
     * @param accessToken
     * @param bodyMap
     * @return
     */
    @PostMapping("wxa/getwxacodeunlimit")
    byte[] getwxacodeunlimit(@RequestParam("access_token") String accessToken, @RequestBody Map<String, Object> bodyMap);
    
    /**
	     * 二维码
	     *该接口用于获取小程序码,适用于需要的码数量较少的业务场景。通过该接口生成的小程序码,永久有效,有数量限制,详见获取小程序码。
     * @param accessToken
     * @param bodyMap
     * @return
     */
    @PostMapping("wxa/getwxacode")
    byte[] getwxacode(@RequestParam("access_token") String accessToken, @RequestBody Map<String, Object> bodyMap);

    

}

二、http工具类

public class HttpUtils {
    private static Log logger = LogFactory.getLog(HttpUtils.class);

    public static String doGet(String url, Map<String, String> param) {

        // 创建Httpclient对象
        CloseableHttpClient httpclient = HttpClients.createDefault();

        String resultString = "";
        CloseableHttpResponse response = null;
        try {
            // 创建uri
            URIBuilder builder = new URIBuilder(url);
            if (param != null) {
                for (String key : param.keySet()) {
                    builder.addParameter(key, param.get(key));
                }
            }
            URI uri = builder.build();

            // 创建http GET请求
            HttpGet httpGet = new HttpGet(uri);

            // 执行请求
            response = httpclient.execute(httpGet);
            // 判断返回状态是否为200
            if (response.getStatusLine().getStatusCode() == 200) {
                resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (response != null) {
                    response.close();
                }
                httpclient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return resultString;
    }

    public static String doGet(String url) {
        return doGet(url, null);
    }

    public static String doPost(String url, Map<String, String> param) {
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            RequestConfig requestConfig = RequestConfig.custom().setConnectionRequestTimeout(3000)
                    .setSocketTimeout(3000).setConnectTimeout(3000).build();
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost(url);
            httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded");
            httpPost.setConfig(requestConfig);

            // 创建参数列表
            if (param != null) {
                List<NameValuePair> paramList = new ArrayList<>();
                for (String key : param.keySet()) {
                    paramList.add(new BasicNameValuePair(key, (String) param.get(key)));
                }
                // 模拟表单
                UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList, "utf-8");
                httpPost.setEntity(entity);
            }
            // 执行http请求
            response = httpClient.execute(httpPost);
            resultString = EntityUtils.toString(response.getEntity(), "utf-8");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (response != null) {
                    response.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return resultString;
    }

    public static String doPost(String url, Map<String, String> param, Map<String, String> headerParam) {
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            RequestConfig requestConfig = RequestConfig.custom().setConnectionRequestTimeout(10000)
                    .setSocketTimeout(10000).setConnectTimeout(10000).build();
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost(url);
            httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded");
            httpPost.setConfig(requestConfig);
            if (headerParam != null) {
                for (Map.Entry<String, String> entry : headerParam.entrySet()) {
                    httpPost.setHeader(entry.getKey(), entry.getValue());
                }
            }

            // 创建参数列表
            if (param != null) {
                List<NameValuePair> paramList = new ArrayList<>();
                for (String key : param.keySet()) {
                    paramList.add(new BasicNameValuePair(key, (String) param.get(key)));
                }
                // 模拟表单
                UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList, "utf-8");
                httpPost.setEntity(entity);
            }
            // 执行http请求
            response = httpClient.execute(httpPost);
            resultString = EntityUtils.toString(response.getEntity(), "utf-8");
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("请求异常", e);
        } finally {
            try {
                if (response != null) {
                    response.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return resultString;
    }

    public static String doPostJson(String url, Map<String, String> param) {
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost(url);
            httpPost.addHeader("Content-Type", "application/json");
            String jsonStr = JSONUtility.objectToJson(param);
            logger.info("post json parm:" + jsonStr);
            // 创建参数列表
            httpPost.setEntity(new StringEntity(jsonStr, "UTF-8"));
            // 执行http请求
            response = httpClient.execute(httpPost);
            resultString = EntityUtils.toString(response.getEntity(), "utf-8");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (response != null) {
                    response.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return resultString;
    }

    public static String doPost(String url) {
        return doPost(url, null);
    }

    public static String jsonPostHttps(String url, JSONObject params, int connectTimeout) {
        String responseContent = null;
        HttpPost httpPost = new HttpPost(url);
        CloseableHttpClient httpClient = HttpClients.createDefault();
        try {
            RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(connectTimeout)
                    .setConnectTimeout(connectTimeout).setConnectionRequestTimeout(connectTimeout).build();
            httpPost.setHeader("Content-type", "application/x-www-form-urlencoded");
            httpPost.setEntity(new StringEntity(params.toString(), Consts.UTF_8));
            httpPost.setConfig(requestConfig);
            CloseableHttpResponse response = httpClient.execute(httpPost);

            try {
                // 执行POST请求
                HttpEntity entity = response.getEntity(); // 获取响应实体
                try {
                    if (null != entity) {
                        responseContent = EntityUtils.toString(entity, Consts.UTF_8);
                    }
                } finally {
                    if (entity != null) {
                        entity.getContent().close();
                    }
                }
            } finally {
                if (response != null) {
                    response.close();
                }
            }
        } catch (ClientProtocolException e) {
        } catch (IOException e) {
        } finally {
            httpPost.releaseConnection();
        }
        return responseContent;
    }

    public static String doPostJson(String url, String json) {
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost(url);
            httpPost.setHeader("Content-Type", "application/json");
            // 创建请求内容
            StringEntity entity = new StringEntity(json, ContentType.APPLICATION_JSON);
            httpPost.setEntity(entity);
            // 执行http请求
            response = httpClient.execute(httpPost);
            resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                response.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return resultString;
    }

    public static String doPostJson(String url, String json, Map<String, String> headerParam) {
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost(url);
            httpPost.setHeader("Content-Type", "application/json");
            if (headerParam != null) {
                for (Map.Entry<String, String> entry : headerParam.entrySet()) {
                    httpPost.setHeader(entry.getKey(), entry.getValue());
                }
            }
            // 创建请求内容
            StringEntity entity = new StringEntity(json, ContentType.APPLICATION_JSON);
            httpPost.setEntity(entity);
            // 执行http请求
            response = httpClient.execute(httpPost);
            resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                response.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return resultString;
    }

    public static String doPostStream(String url, Map<String, String> param, Map<String, InputStream> streamMap) {
        // MultipartEntityBuilder;
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost(url);
            // 创建参数列表
            MultipartEntityBuilder meBuilder = MultipartEntityBuilder.create();
            if (param != null) {
                for (String key : param.keySet()) {
                    meBuilder.addPart(key, new StringBody((String) param.get(key), ContentType.APPLICATION_JSON));
                }
            }
            if (streamMap != null) {
                for (String key : streamMap.keySet()) {
                    InputStreamBody inputStreamBody = new InputStreamBody(streamMap.get(key), key);
                    meBuilder.addPart(key, inputStreamBody);
                }
            }
            HttpEntity entity = meBuilder.build();
            httpPost.setEntity(entity);
            // 执行http请求
            response = httpClient.execute(httpPost);
            resultString = EntityUtils.toString(response.getEntity(), "utf-8");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                response.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return resultString;
    }

    public static String doPost(String url, Map<String, String> param, int connectTimeout) {
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();

        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            RequestConfig requestConfig = RequestConfig.custom().setConnectionRequestTimeout(connectTimeout)
                    .setSocketTimeout(connectTimeout).setConnectTimeout(connectTimeout).build();
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost(url);
            httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded");
            httpPost.setConfig(requestConfig);

            // 创建参数列表
            if (param != null) {
                List<NameValuePair> paramList = new ArrayList<>();
                for (String key : param.keySet()) {
                    paramList.add(new BasicNameValuePair(key, (String) param.get(key)));
                }
                // 模拟表单
                UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList, "utf-8");
                httpPost.setEntity(entity);
            }
            // 执行http请求
            response = httpClient.execute(httpPost);
            resultString = EntityUtils.toString(response.getEntity(), "utf-8");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (response != null) {
                    response.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return resultString;
    }

    public static String doPost(String url, String param, String contentType, int connectTimeout) {
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();

        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            RequestConfig requestConfig = RequestConfig.custom().setConnectionRequestTimeout(connectTimeout)
                    .setSocketTimeout(connectTimeout).setConnectTimeout(connectTimeout).build();
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost(url);
            httpPost.setHeader("Content-Type", contentType);
            httpPost.setConfig(requestConfig);

            // 创建参数列表
            if (param != null) {
//                List<NameValuePair> paramList = new ArrayList<>();
//                for (String key : param.keySet()) {
//                    paramList.add(new BasicNameValuePair("key", (String) param.get(key)));
//                }
//                // 模拟表单
//                UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList, "utf-8");
                httpPost.setEntity(new StringEntity(param, Consts.UTF_8));
            }
            // 执行http请求
            response = httpClient.execute(httpPost);
            resultString = EntityUtils.toString(response.getEntity(), "utf-8");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (response != null) {
                    response.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return resultString;
    }

三、http请求数据和响应数据详解

请求与响应的封装,计算机网络,java,http,网络协议,网络

HTTP请求数据

HTTP请求通常由四部分组成:请求行、请求头部、空行和请求体(如果有的话)。

  1. 请求行

    • 请求方法:如GET、POST、PUT、DELETE等。它告诉服务器你想要执行的操作类型。
    • URL:请求的资源的路径。
    • HTTP协议版本:客户端使用的HTTP协议版本,通常是HTTP/1.1。
  2. 请求头部:包含一系列键值对,提供了关于请求和客户端的额外信息。例如:

    • Host:请求的目标主机。
    • User-Agent:发送请求的客户端的类型和版本。
    • Accept:客户端可以处理的内容类型。
    • Content-Type:请求体的媒体类型(如果有的话)。
    • Content-Length:请求体的长度(如果有的话)。
  3. 空行:请求头部之后是一个空行,用于分隔请求头部和请求体。

  4. 请求体:包含发送给服务器的数据,通常用于POST和PUT请求。

HTTP响应数据

HTTP响应也由四部分组成:状态行、响应头部、空行和响应体。

  1. 状态行

    • HTTP协议版本:服务器使用的HTTP协议版本。
    • 状态码:一个三位数,表示请求的处理结果,如200表示成功,404表示未找到资源等。
    • 状态消息:对状态码的简短描述。
  2. 响应头部:与请求头部类似,包含一系列键值对,提供了关于响应和服务器的额外信息。例如:

    • Content-Type:响应体的媒体类型。
    • Content-Length:响应体的长度。
    • Date:响应生成的日期和时间。
    • Server:服务器软件的名称和版本。
  3. 空行:响应头部之后是一个空行,用于分隔响应头部和响应体。

  4. 响应体:包含服务器返回给客户端的数据,通常是HTML、JSON或其他类型的内容。

四、TCP的三次握手

HTTP通常建立在TCP之上,因此,当我们在谈论网络请求时,实际上在底层是通过TCP来建立和维护连接的。

以下是TCP三次握手的简要概述:

  1. SYN(同步)阶段
    • 客户端向服务器发送一个SYN包,并等待服务器确认。SYN包中包含客户端的初始序列号。
  2. SYN-ACK(同步-应答)阶段
    • 服务器收到SYN包后,向客户端发送一个SYN-ACK包作为应答。这个包中包含对客户端SYN包的确认信息(ACK)以及服务器自己的初始序列号。
  3. ACK(应答)阶段
    • 客户端收到SYN-ACK包后,再向服务器发送一个ACK包,此包包含对服务器SYN-ACK包的确认信息。

完成这三次握手后,TCP连接就建立起来了,之后客户端和服务器就可以开始传输数据了。文章来源地址https://www.toymoban.com/news/detail-857836.html

到了这里,关于HTTP工具类封装与http请求响应的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • HTTP、请求和响应

    1.规定了交互的方式:请求、响应 2.数据的格式:行、头、体 在HTTP/1.0中默认使用短连接。也就是说,客户端和服务器每进行一次HTTP操作,就建立一次连接,任务结束就中断连接。当客户端浏览器访问的某个HTML或其他类型的Web页中包含有其他的Web资源(如JavaScript文件、图像

    2024年02月20日
    浏览(39)
  • HTTP协议,请求响应

    2024年02月07日
    浏览(43)
  • Java http 响应式请求和非响应式请求有什么区别

    以下是一个使用Spring WebFlux实现真正的流式编程的案例: 运行Spring Boot应用程序,并使用浏览器或类似cURL的工具发送GET请求: 获取所有用户的请求:http://localhost:8080/users/stream 你将会看到一个持续不断的流式响应,每秒钟返回一个用户对象。这个案例中,我们使用了 @GetMapp

    2024年01月17日
    浏览(76)
  • 网站建设入门教程||HTTP 请求方法||HTTP 响应头信息

    根据 HTTP 标准,HTTP 请求可以使用多种请求方法。 HTTP1.0 定义了三种请求方法: GET, POST 和 HEAD 方法。 HTTP1.1 新增了六种请求方法:OPTIONS、PUT、PATCH、DELETE、TRACE 和 CONNECT 方法。 序号 方法 描述 1 GET 请求指定的页面信息,并返回实体主体。 2 HEAD 类似于 GET 请求,只不过返回的

    2024年02月12日
    浏览(69)
  • http请求和响应格式说明,http的get和post请求方式说明,http的请求体body的几种数据格式

    一个HTTP请求报文由 请求行(request line)、请求头部(header)、空行和请求数据 4个部分组成, 请求报文的一般格式 1、第一行必须是一个请求行(request-line),用来说明请求类型,要访问的资源以及所使用的HTTP版本 2、紧接着是一个请求头(header),用来说明服务器要使用的附加信息

    2024年02月02日
    浏览(59)
  • 《二》HTTP 请求报文和响应报文、请求方法、状态码

    请求报文: 客户端向服务器发送的请求信息,就叫做请求报文。 客户端发送一个 HTTP 请求到服务器,请求信息包含四部分:请求行、请求头、空行、请求体。 请求行:包含三部分,分别是请求方法、请求资源的路径、协议版本。 请求头:头信息,告诉服务器一些信息,在客

    2023年04月26日
    浏览(48)
  • 发送HTTP POST请求并处理响应

    发送HTTP POST请求并处理响应是Web开发中的常见任务。在Go语言中,可以使用 net/http 包来发送HTTP POST请求并处理响应。 以下是一个示例代码,演示了如何发送HTTP POST请求并处理响应: go 复制代码 package  main import  ( \\\"bytes\\\"   \\\"fmt\\\"   \\\"io/ioutil\\\"   \\\"net/http\\\"   ) func   main ()  { // 创建一

    2024年01月17日
    浏览(35)
  • Http请求响应 Ajax 过滤器

    10/10/2023 近期总结:         最近学的后端部署,web服务器运行,各种请求响应,内容很多,学的很乱,还是需要好好整理,前面JavaSE内容还没有完全掌握,再加上一边刷题,感觉压力很大哈哈。看群友们都在说找工作难,又会被打击,不过感觉一切都以实力说话,提升自己

    2024年02月07日
    浏览(49)
  • http和https的请求与响应

    HTTP协议 (HyperText Transfer Protocol,超文本传输协议):是一种发布和接收 HTML页面的方法。 HTTPS (Hypertext Transfer Protocol over Secure Socket Layer)简单讲是HTTP的安全版,在HTTP下加入SSL层。 SSL (Secure Sockets Layer 安全套接层)主要用于Web的安全传输协议,在传输层对网络连接进行加密

    2024年02月03日
    浏览(81)
  • 常见的http请求头以及响应头

    1-1 Accept 1、 Accept : text/html 浏览器可以接收服务器回发的类型为text/html 2、 Accept: */*代表浏览器可以处理所有类型 1-2 Accept-Encoding 1、 Accept-Encoding: gzip,deflate 浏览器申明自己接收的编码方法,通常指定压缩方法,是否支持压缩,支持什么压缩方法(gzip,deflate) 1-3 Accept

    2023年04月09日
    浏览(42)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包