devbox
繁依Fanyi0
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

使用HttpClient发送Http请求详细示例

作者：繁依Fanyi0 | 2024-03-10 10:14:21

赞

踩

httpclient发送http请求

目录

一、GET无参，HTTP发送示例

二、GET有参（方式一：拼接URL参数）

三、GET有参（方式二：使用URI方式）

四、POST有参（对象+普通参数）

五、application/x-www-form-urlencoded表单请求(示例)

知识补充：application/x-www-form-urlencoded和multipart/form-data

（1）application/x-www-urlencoded

（3）multipart/form-data

六、发送文件示例

七、发送流示例

HttpClient 是 Apache Jakarta Common 下的子项目，用来提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包，并且它支持 HTTP 协议最新的版本和建议。

HTTP和浏览器有点像，但却不是浏览器。很多人觉得既然HttpClient是一个HTTP客户端编程工具，很多人把他当做浏览器来理解，但是其实HttpClient不是浏览器，它是一个HTTP通信库，因此它只提供一个通用浏览器应用程序所期望的功能子集，最根本的区别是HttpClient中没有用户界面，浏览器需要一个渲染引擎来显示页面，并解释用户输入，例如鼠标点击显示页面上的某处，有一个布局引擎，计算如何显示HTML页面，包括级联样式表和图像。javascript解释器运行嵌入HTML页面或从HTML页面引用的javascript代码。来自用户界面的事件被传递到javascript解释器进行处理。除此之外，还有用于插件的接口，可以处理Applet，嵌入式媒体对象（如pdf文件，Quicktime电影和Flash动画）或ActiveX控件（可以执行任何操作）。HttpClient只能以编程的方式通过其API用于传输和接受HTTP消息。

在使用HttpClient前，首先需要导入其maven依赖，另外还引入了fastjson的依赖，在示例中会用到

  1. <dependency>
  2.    <groupId>org.apache.httpcomponents</groupId>
  3.    <artifactId>httpclient</artifactId>
  4.    <version>4.5.6</version>
  5. </dependency>
  6. <dependency>
  7.    <groupId>com.alibaba</groupId>
  8.    <artifactId>fastjson</artifactId>
  9.    <version>1.2.58</version>
  10. </dependency>

本文示例使用springboot的运行环境，springboot运行环境的搭建请参照我的这篇文章：快速构建一个springboot项目。

在运行测试案例前需要先启动springboot项目，然后再启动测试类进行测试，如果不知道怎样搭建springboot的单元测试，可以参照我的这篇文章：编写springboot单元测试类

以下所有示例亲测有效。

一、GET无参，HTTP发送示例

代码示例：

  1. /**
  2.      * GET---无参测试
  3.      */
  4.     @Test
  5.     public void doGetNoParam() {
  6.         // 获得Http客户端(可以理解为:你得先有一个浏览器;注意:实际上HttpClient与浏览器是不一样的)
  7.         CloseableHttpClient httpClient = HttpClientBuilder.create().build();
  8.         // 创建Get请求
  9.         HttpGet httpGet = new HttpGet("http://localhost:8080/http/doGetNoParam");
  10.         // 响应模型
  11.         CloseableHttpResponse response = null;
  12.         try {
  13.             // 由客户端执行(发送)Get请求
  14.             response = httpClient.execute(httpGet);
  15.             // 从响应模型中获取响应实体
  16.             HttpEntity responseEntity = response.getEntity();
  17.             System.out.println("响应状态为:" + response.getStatusLine());
  18.             if (responseEntity != null) {
  19.                 System.out.println("响应内容长度为:" + responseEntity.getContentLength());
  20.                 System.out.println("响应内容为:" + EntityUtils.toString(responseEntity));
  21.             }
  22.         } catch (ClientProtocolException e) {
  23.             e.printStackTrace();
  24.         } catch (ParseException e) {
  25.             e.printStackTrace();
  26.         } catch (IOException e) {
  27.             e.printStackTrace();
  28.         } finally {
  29.             try {
  30.                 // 释放资源
  31.                 if (httpClient != null) {
  32.                     httpClient.close();
  33.                 }
  34.                 if (response != null) {
  35.                     response.close();
  36.                 }
  37.             } catch (IOException e) {
  38.                 e.printStackTrace();
  39.             }
  40.         }
  41.     }

对应的接收示例：

  1. @RequestMapping("doGetNoParam")
  2. public String doGetNoParam(){
  3.         return "doGetNoParam...";
  4.     }

执行结果：

二、GET有参（方式一：拼接URL参数）

代码示例：

  1. /**
  2.      * GET---有参测试 (方式一:手动在url后面加上参数)
  3.      */
  4.     @Test
  5.     public void doGetAppendUrl() {
  6.         // 获得Http客户端(可以理解为:你得先有一个浏览器;注意:实际上HttpClient与浏览器是不一样的)
  7.         CloseableHttpClient httpClient = HttpClientBuilder.create().build();
  8.         // 参数
  9.         StringBuffer params = new StringBuffer();
  10.         try {
  11.             // 字符数据最好encoding以下;这样一来，某些特殊字符才能传过去(如:某人的名字就是“&”,不encoding的话,传不过去)
  12.             params.append("name=" + URLEncoder.encode("&&", "utf-8"));
  13.             params.append("&");
  14.             params.append("age=24");
  15.         } catch (UnsupportedEncodingException e1) {
  16.             e1.printStackTrace();
  17.         }
  18.  
  19.         // 创建Get请求
  20.         HttpGet httpGet = new HttpGet("http://localhost:8080/http/doGetAppendUrl" + "?" + params);
  21.         // 响应模型
  22.         CloseableHttpResponse response = null;
  23.         try {
  24.             // 配置信息
  25.             RequestConfig requestConfig = RequestConfig.custom()
  26.                     // 设置连接超时时间(单位毫秒)
  27.                     .setConnectTimeout(5000)
  28.                     // 设置请求超时时间(单位毫秒)
  29.                     .setConnectionRequestTimeout(5000)
  30.                     // socket读写超时时间(单位毫秒)
  31.                     .setSocketTimeout(5000)
  32.                     // 设置是否允许重定向(默认为true)
  33.                     .setRedirectsEnabled(true).build();
  34.  
  35.             // 将上面的配置信息 运用到这个Get请求里
  36.             httpGet.setConfig(requestConfig);
  37.  
  38.             // 由客户端执行(发送)Get请求
  39.             response = httpClient.execute(httpGet);
  40.  
  41.             // 从响应模型中获取响应实体
  42.             HttpEntity responseEntity = response.getEntity();
  43.             System.out.println("响应状态为:" + response.getStatusLine());
  44.             if (responseEntity != null) {
  45.                 System.out.println("响应内容长度为:" + responseEntity.getContentLength());
  46.                 System.out.println("响应内容为:" + EntityUtils.toString(responseEntity));
  47.             }
  48.         } catch (ClientProtocolException e) {
  49.             e.printStackTrace();
  50.         } catch (ParseException e) {
  51.             e.printStackTrace();
  52.         } catch (IOException e) {
  53.             e.printStackTrace();
  54.         } finally {
  55.             try {
  56.                 // 释放资源
  57.                 if (httpClient != null) {
  58.                     httpClient.close();
  59.                 }
  60.                 if (response != null) {
  61.                     response.close();
  62.                 }
  63.             } catch (IOException e) {
  64.                 e.printStackTrace();
  65.             }
  66.         }
  67.     }

对应接收示例：

  1. @GetMapping("/doGetAppendUrl")
  2.     public String doGetAppendUrl(String name,Integer age){
  3.         return name + ",ta的年龄为" + age + "岁了";
  4.     }

执行结果：

三、GET有参（方式二：使用URI方式）

代码示例：

  1. /**
  2.      * GET---有参测试 (方式二:将参数放入键值对类中,再放入URI中,从而通过URI得到HttpGet实例)
  3.      */
  4.     @Test
  5.     public void doGetByURI() {
  6.         // 获得Http客户端(可以理解为:你得先有一个浏览器;注意:实际上HttpClient与浏览器是不一样的)
  7.         CloseableHttpClient httpClient = HttpClientBuilder.create().build();
  8.  
  9.         // 参数
  10.         URI uri = null;
  11.         try {
  12.             // 将参数放入键值对类NameValuePair中,再放入集合中
  13.             List<NameValuePair> params = new ArrayList<>();
  14.             params.add(new BasicNameValuePair("name", "&&"));
  15.             params.add(new BasicNameValuePair("age", "18"));
  16.             // 设置uri信息,并将参数集合放入uri;
  17.             // 注:这里也支持一个键值对一个键值对地往里面放setParameter(String key, String value)
  18.             uri = new URIBuilder().setScheme("http").setHost("localhost")
  19.                     .setPort(8080).setPath("/http/doGetAppendUrl")
  20.                     .setParameters(params).build();
  21.         } catch (URISyntaxException e1) {
  22.             e1.printStackTrace();
  23.         }
  24.         // 创建Get请求
  25.         HttpGet httpGet = new HttpGet(uri);
  26.  
  27.         // 响应模型
  28.         CloseableHttpResponse response = null;
  29.         try {
  30.             // 配置信息
  31.             RequestConfig requestConfig = RequestConfig.custom()
  32.                     // 设置连接超时时间(单位毫秒)
  33.                     .setConnectTimeout(5000)
  34.                     // 设置请求超时时间(单位毫秒)
  35.                     .setConnectionRequestTimeout(5000)
  36.                     // socket读写超时时间(单位毫秒)
  37.                     .setSocketTimeout(5000)
  38.                     // 设置是否允许重定向(默认为true)
  39.                     .setRedirectsEnabled(true).build();
  40.  
  41.             // 将上面的配置信息 运用到这个Get请求里
  42.             httpGet.setConfig(requestConfig);
  43.  
  44.             // 由客户端执行(发送)Get请求
  45.             response = httpClient.execute(httpGet);
  46.  
  47.             // 从响应模型中获取响应实体
  48.             HttpEntity responseEntity = response.getEntity();
  49.             System.out.println("响应状态为:" + response.getStatusLine());
  50.             if (responseEntity != null) {
  51.                 System.out.println("响应内容长度为:" + responseEntity.getContentLength());
  52.                 System.out.println("响应内容为:" + EntityUtils.toString(responseEntity));
  53.             }
  54.         } catch (ClientProtocolException e) {
  55.             e.printStackTrace();
  56.         } catch (ParseException e) {
  57.             e.printStackTrace();
  58.         } catch (IOException e) {
  59.             e.printStackTrace();
  60.         } finally {
  61.             try {
  62.                 // 释放资源
  63.                 if (httpClient != null) {
  64.                     httpClient.close();
  65.                 }
  66.                 if (response != null) {
  67.                     response.close();
  68.                 }
  69.             } catch (IOException e) {
  70.                 e.printStackTrace();
  71.             }
  72.         }
  73.     }

对应的接收示例跟上边方法一是一样的，在此就不过多描述了。

四、POST有参（对象+普通参数）

POST无参基本上跟GET传参差不多，就是new HttpPost()而已。Post传基本参数，可以通过拼接Url的方式，也可以使用URI的方式，此示例把对象传参和基本传参结合在一起，以便囊括常用的传参方式。

使用URI传递普通参数，使用Entity传递对象参数，其中用到的User对象是自己创建的简单对象类型，里边有一些Get和Set方法，在此就不一一列举了。

代码示例：

  1. /**
  2.      * POST---有参测试(普通参数 + 对象参数)
  3.      */
  4.     @Test
  5.     public void doPostUseParam() {
  6.         // 获得Http客户端(可以理解为:你得先有一个浏览器;注意:实际上HttpClient与浏览器是不一样的)
  7.         CloseableHttpClient httpClient = HttpClientBuilder.create().build();
  8.         // 创建Post请求
  9.         // 参数
  10.         URI uri = null;
  11.         try {
  12.             // 将参数放入键值对类NameValuePair中,再放入集合中
  13.             List<NameValuePair> params = new ArrayList<>();
  14.             params.add(new BasicNameValuePair("flag", "8"));
  15.             params.add(new BasicNameValuePair("meaning", "哈哈哈"));
  16.             // 设置uri信息,并将参数集合放入uri;
  17.             // 注:这里也支持一个键值对一个键值对地往里面放setParameter(String key, String value)
  18.             uri = new URIBuilder().setScheme("http").setHost("localhost").setPort(8080)
  19.                     .setPath("/http/doPostUseParam").setParameters(params).build();
  20.         } catch (URISyntaxException e1) {
  21.             e1.printStackTrace();
  22.         }
  23.         HttpPost httpPost = new HttpPost(uri);
  24.         // 创建user参数
  25.         User user = new User();
  26.         user.setUserName("Merry");
  27.         user.setUserSex("女");
  28.         // 将user对象转换为json字符串，并放入entity中
  29.         StringEntity entity = new StringEntity(JSON.toJSONString(user), "UTF-8");
  30.         // post请求是将参数放在请求体里面传过去的;这里将entity放入post请求体中
  31.         httpPost.setEntity(entity);
  32.         httpPost.setHeader("Content-Type", "application/json;charset=utf8");
  33.         // 响应模型
  34.         CloseableHttpResponse response = null;
  35.         try {
  36.             // 由客户端执行(发送)Post请求
  37.             response = httpClient.execute(httpPost);
  38.             // 从响应模型中获取响应实体
  39.             HttpEntity responseEntity = response.getEntity();
  40.  
  41.             System.out.println("响应状态为:" + response.getStatusLine());
  42.             if (responseEntity != null) {
  43.                 System.out.println("响应内容长度为:" + responseEntity.getContentLength());
  44.                 System.out.println("响应内容为:" + EntityUtils.toString(responseEntity));
  45.             }
  46.         } catch (ClientProtocolException e) {
  47.             e.printStackTrace();
  48.         } catch (ParseException e) {
  49.             e.printStackTrace();
  50.         } catch (IOException e) {
  51.             e.printStackTrace();
  52.         } finally {
  53.             try {
  54.                 // 释放资源
  55.                 if (httpClient != null) {
  56.                     httpClient.close();
  57.                 }
  58.                 if (response != null) {
  59.                     response.close();
  60.                 }
  61.             } catch (IOException e) {
  62.                 e.printStackTrace();
  63.             }
  64.         }
  65.     }

防止响应乱码，可以主动设置编码

String response = EntityUtils.toString(responseEntity, UTF_8);

对应接收示例：

  1. @PostMapping("/doPostUseParam")
  2.     public String doPostUseParam(@RequestBody User user, String meaning, Integer flag) {
  3.         return user.getUserName() + ",ta是" + user.getUserSex() + "生。这意味着" + meaning + flag;
  4.     }

执行结果：

五、application/x-www-form-urlencoded表单请求(示例)

代码示例：

  1. /**
  2.      * POST---application/x-www-form-urlencoded 表单请求
  3.      */
  4.     @Test
  5.     public void doPostUseForm() {
  6.         // 获得Http客户端(可以理解为:你得先有一个浏览器;注意:实际上HttpClient与浏览器是不一样的)
  7.         CloseableHttpClient httpClient = HttpClientBuilder.create().build();
  8.         HttpPost httpPost = new HttpPost("http://localhost:8080/http/doPostUseForm");
  9.         httpPost.setHeader("Content-Type","application/x-www-form-urlencoded");
  10.  
  11.         // 将参数放入键值对类NameValuePair中,再放入集合中
  12.         List<NameValuePair> params = new ArrayList<>();
  13.         params.add(new BasicNameValuePair("bookName", "语文"));
  14.         params.add(new BasicNameValuePair("message", "这是一本好书"));
  15.         UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(params, UTF_8);
  16.         httpPost.setEntity(formEntity);
  17.  
  18.         CloseableHttpResponse response = null;
  19.         try {
  20.             // 由客户端执行(发送)Post请求
  21.             response = httpClient.execute(httpPost);
  22.             // 从响应模型中获取响应实体
  23.             HttpEntity responseEntity = response.getEntity();
  24.             System.out.println("响应状态为:" + response.getStatusLine());
  25.             if (responseEntity != null) {
  26.                 System.out.println("响应内容长度为:" + responseEntity.getContentLength());
  27.                 System.out.println("响应内容为:" + EntityUtils.toString(responseEntity));
  28.             }
  29.         } catch (ClientProtocolException e) {
  30.             e.printStackTrace();
  31.         } catch (ParseException e) {
  32.             e.printStackTrace();
  33.         } catch (IOException e) {
  34.             e.printStackTrace();
  35.         } finally {
  36.             try {
  37.                 // 释放资源
  38.                 if (httpClient != null) {
  39.                     httpClient.close();
  40.                 }
  41.                 if (response != null) {
  42.                     response.close();
  43.                 }
  44.             } catch (IOException e) {
  45.                 e.printStackTrace();
  46.             }
  47.         }
  48.     }

对应接收示例：

  1. @PostMapping("/doPostUseForm")
  2.     public String doPostUseForm(String bookName, String message) {
  3.         return bookName + ":" + message;
  4.     }

知识补充：application/x-www-form-urlencoded和multipart/form-data

一个 HTML 表单中的 enctype 有三种类型

  • application/x-www-urlencoded
  • multipart/form-data
  • text-plain

默认情况下是 application/x-www-urlencoded，当表单使用 POST 请求时，数据会被以 x-www-urlencoded 方式编码到 Body 中来传送，而如果 GET 请求，则是附在 url 链接后面来发送。GET 请求只支持 ASCII 字符集，因此，如果我们要发送更大字符集的内容，我们应使用 POST 请求。
如果要发送大量的二进制数据（non-ASCII），application/x-www-form-urlencoded 显然是低效的，因为它需要用 3 个字符来表示一个 non-ASCII 的字符。因此，这种情况下，应该使用 “multipart/form-data” 格式。

application / x-www-form-urlencoded对于发送大量二进制数据或包含非ASCII字符的文本效率低下。

multipart / form-data应该用于提交包含文件，非ASCII数据和二进制数据的表单。

（1）application/x-www-urlencoded

我们在通过 HTTP 向服务器发送 POST 请求提交数据，都是通过 form 表单形式提交的，代码如下：

  1. <FORM method="post" action="http://w.sohu.com" >
  2.     <INPUT type="text" name="txt1">
  3.     <INPUT type="text" name="txt2">
  4.  </FORM>

提交时会向服务器端发出这样的数据（已经去除部分不相关的头信息），数据如下：

  1. POST / HTTP/1.1
  2. Content-Type:application/x-www-form-urlencoded
  3. Accept-Encoding: gzip, deflate
  4. Host: w.sohu.com
  5. Content-Length: 21
  6. Connection: Keep-Alive
  7. Cache-Control: no-cache
  8.  
  9. txt1=hello&txt2=world

对于普通的 HTML Form POST请求，它会在头信息里使用 Content-Length 注明内容长度。请求头信息每行一条，空行之后便是 Body，即“内容”（entity）。内容的格式是在头信息中的 Content-Type 指定的，如上是 application/x-www-form-urlencoded，这意味着消息内容会经过 URL 格式编码，就像在 GET请 求时 URL 里的 QueryString 那样。如：txt1=hello&txt2=world。

（3）multipart/form-data

multipart/form-data 定义在 rfc2388 中，最早的 HTTP POST 是不支持文件上传的，给编程开发带来很多问题。但是在1995年，ietf 出台了 rfc1867，也就是《RFC 1867 -Form-based File Upload in HTML》，用以支持文件上传。所以 Content-Type 的类型扩充了multipart/form-data 用以支持向服务器发送二进制数据。因此，发送 POST 请求时候，表单 属性 enctype 共有二个值可选，这个属性管理的是表单的 MIME 编码：

  • ① application/x-www-form-urlencoded (默认值)
  • ② multipart/form-data

注：form 表单中 enctype 的默认值是 enctype="application/x- www-form-urlencoded".
通过 form 表单提交文件操作如下：

  1. <FORM method="POST" action="http://w.sohu.com/t2/upload.do" enctype="multipart/form-data">
  2.     <INPUT type="text" name="city" value="Santa colo">
  3.     <INPUT type="text" name="desc">
  4.     <INPUT type="file" name="pic">
  5.  </FORM>

浏览器将会发送以下数据：

  1. POST /t2/upload.do HTTP/1.1
  2. User-Agent: SOHUWapRebot
  3. Accept-Language: zh-cn,zh;q=0.5
  4. Accept-Charset: GBK,utf-8;q=0.7,*;q=0.7
  5. Connection: keep-alive
  6. Content-Length: 60408
  7. Content-Type:multipart/form-data; boundary=ZnGpDtePMx0KrHh_G0X99Yef9r8JZsRJSXC
  8. Host: w.sohu.com
  9.  
  10. --ZnGpDtePMx0KrHh_G0X99Yef9r8JZsRJSXC
  11. Content-Disposition: form-data; name="city"
  12.  
  13. Santa colo
  14. --ZnGpDtePMx0KrHh_G0X99Yef9r8JZsRJSXC
  15. Content-Disposition: form-data;name="desc"
  16. Content-Type: text/plain; charset=UTF-8
  17. Content-Transfer-Encoding: 8bit
  18.  
  19. ...
  20. --ZnGpDtePMx0KrHh_G0X99Yef9r8JZsRJSXC
  21. Content-Disposition: form-data;name="pic"; filename="photo.jpg"
  22. Content-Type: application/octet-stream
  23. Content-Transfer-Encoding: binary
  24.  
  25. ... binary data of the jpg ...
  26. --ZnGpDtePMx0KrHh_G0X99Yef9r8JZsRJSXC--

从上面的 multipart/form-data 格式发送的请求的样式来看，它包含了多个 Parts，每个 Part 都包含头信息部分，
Part 头信息中必须包含一个 Content-Disposition 头，其他的头信息则为可选项， 比如 Content-Type 等。
Content-Disposition 包含了 type 和 一个名字为 name 的 parameter，type 是 form-data，name 参数的值则为表单控件（也即 field）的名字，如果是文件，那么还有一个 filename 参数，值就是文件名。对于可选的 Content-Type（如果没有的话），默认就是 text/plain。

注意：
如果文件内容是通过填充表单来获得，那么上传的时候，Content-Type 会被自动设置（识别）成相应的格式，如果没法识别，那么就会被设置成 “application/octet-stream”。

六、发送文件示例

如果想要灵活方便的传输文件的话，除了引入org.apache.httpcomponents基本的httpclient依赖外再额外引入org.apache.httpcomponents的httpmime依赖。
P.S.：即便不引入httpmime依赖，也是能传输文件的，不过功能不够强大。

在pom.xml中额外引入：

  1. <!--如果需要灵活的传输文件，引入此依赖后会更加方便-->
  2.         <dependency>
  3.             <groupId>org.apache.httpcomponents</groupId>
  4.             <artifactId>httpmime</artifactId>
  5.             <version>4.5.5</version>
  6.         </dependency>

代码示例：

  1. /**
  2.      *
  3.      * 发送文件
  4.      *
  5.      * multipart/form-data传递文件(及相关信息)
  6.      *
  7.      * 注:如果想要灵活方便的传输文件的话，
  8.      *    除了引入org.apache.httpcomponents基本的httpclient依赖外
  9.      *    再额外引入org.apache.httpcomponents的httpmime依赖。
  10.      *    追注:即便不引入httpmime依赖，也是能传输文件的，不过功能不够强大。
  11.      *
  12.      */
  13.     @Test
  14.     public void doPostUseFile() {
  15.         CloseableHttpClient httpClient = HttpClientBuilder.create().build();
  16.         HttpPost httpPost = new HttpPost("http://localhost:8080/http/doPostUseFile");
  17.         CloseableHttpResponse response = null;
  18.         try {
  19.             MultipartEntityBuilder multipartEntityBuilder = MultipartEntityBuilder.create();
  20.             // 第一个文件
  21.             String filesKey = "files";
  22.             File file1 = new File("D:\\MyFiles\\poi\\picture.jpg");
  23.             multipartEntityBuilder.addBinaryBody(filesKey, file1);
  24.             // 第二个文件(多个文件的话，使用同一个key就行，后端用数组或集合进行接收即可)
  25.             File file2 = new File("D:\\MyFiles\\poi\\图片.jpg");
  26.             // 防止服务端收到的文件名乱码。 我们这里可以先将文件名URLEncode，然后服务端拿到文件名时在URLDecode。就能避免乱码问题。
  27.             // 文件名其实是放在请求头的Content-Disposition里面进行传输的，如其值为form-data; name="files"; filename="头像.jpg"
  28.             multipartEntityBuilder.addBinaryBody(filesKey, file2, ContentType.DEFAULT_BINARY, URLEncoder.encode(file2.getName(), "utf-8"));
  29.             // 其它参数(注:自定义contentType，设置UTF-8是为了防止服务端拿到的参数出现乱码)
  30.             ContentType contentType = ContentType.create("text/plain", Charset.forName("UTF-8"));
  31.             multipartEntityBuilder.addTextBody("name", "邓沙利文", contentType);
  32.             multipartEntityBuilder.addTextBody("age", "25", contentType);
  33.  
  34.             HttpEntity httpEntity = multipartEntityBuilder.build();
  35.             httpPost.setEntity(httpEntity);
  36.  
  37.             response = httpClient.execute(httpPost);
  38.             HttpEntity responseEntity = response.getEntity();
  39.             System.out.println("HTTPS响应状态为:" + response.getStatusLine());
  40.             if (responseEntity != null) {
  41.                 System.out.println("HTTPS响应内容长度为:" + responseEntity.getContentLength());
  42.                 // 主动设置编码，来防止响应乱码
  43.                 String responseStr = EntityUtils.toString(responseEntity, StandardCharsets.UTF_8);
  44.                 System.out.println("HTTPS响应内容为:" + responseStr);
  45.             }
  46.         } catch (ParseException | IOException e) {
  47.             e.printStackTrace();
  48.         } finally {
  49.             try {
  50.                 // 释放资源
  51.                 if (httpClient != null) {
  52.                     httpClient.close();
  53.                 }
  54.                 if (response != null) {
  55.                     response.close();
  56.                 }
  57.             } catch (IOException e) {
  58.                 e.printStackTrace();
  59.             }
  60.         }
  61.     }

对应的接收示例：

  1. @PostMapping("/doPostUseFile")
  2.     public String doPostUseFile(@RequestParam("name") String name,
  3.                                 @RequestParam("age") Integer age,
  4.                                 @RequestParam("files") List<MultipartFile> multipartFiles) throws UnsupportedEncodingException {
  5.         StringBuilder sb = new StringBuilder();
  6.         sb.append("\n");
  7.         sb.append("name=").append(name)
  8.                 .append("\tage=").append(age);
  9.         String fileName;
  10.         for(MultipartFile file : multipartFiles){
  11.             sb.append("\n文件信息:\n");
  12.             fileName = file.getOriginalFilename();
  13.             if(fileName == null){
  14.                 continue;
  15.             }
  16.             // 防止中文乱码问题
  17.             fileName = URLDecoder.decode(fileName, "utf-8");
  18.             sb.append("\t文件名:").append(fileName);
  19.             sb.append("\t文件大小:").append(file.getSize() * 1.0 /1024).append("KB");
  20.             sb.append("\tContentType:").append(file.getContentType());
  21.             sb.append("\n");
  22.         }
  23.         return sb.toString();
  24.     }

执行结果：

七、发送流示例

代码示例：

  1. /**
  2.      * 发送流
  3.      */
  4.     @Test
  5.     public void doPostUseStream() {
  6.         CloseableHttpClient httpClient = HttpClientBuilder.create().build();
  7.         HttpPost httpPost = new HttpPost("http://localhost:8080/http/doPostUseStream?name=邓沙利文");
  8.         CloseableHttpResponse response = null;
  9.         try {
  10.             InputStream stream = new ByteArrayInputStream("流啊流~".getBytes());
  11.             InputStreamEntity InputStream = new InputStreamEntity(stream);
  12.             httpPost.setEntity(InputStream);
  13.  
  14.             response = httpClient.execute(httpPost);
  15.             HttpEntity responseEntity = response.getEntity();
  16.             System.out.println("HTTPS响应状态为:" + response.getStatusLine());
  17.             if (responseEntity != null) {
  18.                 System.out.println("HTTPS响应内容长度为:" + responseEntity.getContentLength());
  19.                 // 主动设置编码，来防止响应乱码
  20.                 String responseStr = EntityUtils.toString(responseEntity, StandardCharsets.UTF_8);
  21.                 System.out.println("HTTPS响应内容为:" + responseStr);
  22.             }
  23.         } catch (ParseException | IOException e) {
  24.             e.printStackTrace();
  25.         } finally {
  26.             try {
  27.                 // 释放资源
  28.                 if (httpClient != null) {
  29.                     httpClient.close();
  30.                 }
  31.                 if (response != null) {
  32.                     response.close();
  33.                 }
  34.             } catch (IOException e) {
  35.                 e.printStackTrace();
  36.             }
  37.         }
  38.     }

接收端示例：

  1. @PostMapping("/doPostUseStream")
  2.     public String doPostUseStream(@RequestParam("name") String name,
  3.                                   InputStream stream) throws IOException {
  4.         StringBuilder sb = new StringBuilder();
  5.         sb.append("\nname值为:").append(name);
  6.         sb.append("\n输入数据流内容为:");
  7.         BufferedReader bf = new BufferedReader(new InputStreamReader(stream, StandardCharsets.UTF_8));
  8.         String line;
  9.         while((line = bf.readLine()) != null){
  10.             sb.append(line);
  11.         }
  12.         return sb.toString();
  13.     }

执行结果：

最后总结一下：使用HttpClient发送HTTP请求基本分为四步：

  1. 创建Http客户端
  2. 创建request请求
  3. 执行Reuest请求
  4. 关闭资源
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/217781
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号