• HttpClient远程使用大全

    一 HttpClient简介

    1.1 概述

    HttpClient只能以编程的方式通过其API用于传输和接受HTTP消息。主要实现功能：

    实现了所有 HTTP 的方法（GET、POST、PUT、HEAD、DELETE、HEAD、OPTIONS 等）

    支持 HTTPS 协议

    支持代理服务器（Nginx等）等

    支持自动（跳转）转向。

    1.2 案例工程介绍

    1.2.1 工程截图

    请求端：16-spt-http-request-demo  ：7000     响应端：16-spt-httppush-demo ：8082

    1.2.2 引入依赖

    1.     <!-- httpclient  -->
    2.     <dependency>
    3.       <groupId>org.apache.httpcomponents</groupId>
    4.       <artifactId>httpclient</artifactId>
    5.       <version>4.5.5</version>
    6.     </dependency>
    7.     <!-- fastjson -->
    8.     <dependency>
    9.       <groupId>com.alibaba</groupId>
    10.       <artifactId>fastjson</artifactId>
    11.       <version>1.2.47</version>
    12.     </dependency>

    注：SpringBoot的基本依赖配置，这里就不再多说了

    二  实操实例Get方式

    2.1 get无参数案例

    1.消费者

    1. @RestController
    2. public class HttpClientController {
    3.     @RequestMapping("/hc/api")
    4.     public String getInfo() throws Exception {
    5. // 获得Http客户端(可以理解为:你得先有一个浏览器;注意:实际上HttpClient与浏览器是不一样的)
    6.         CloseableHttpClient httpClient = HttpClientBuilder.create().build();
    7.         // 创建Get请求
    8.         HttpGet httpGet = new HttpGet("http://localhost:8082/get/noparam");
    9.          String result="";
    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.                 result=EntityUtils.toString(responseEntity);
    21.                 System.out.println("响应内容为:" + result);
    22.             }
    23.  
    24.  
    25.         } catch (ClientProtocolException e) {
    26.             e.printStackTrace();
    27.         } catch (ParseException e) {
    28.             e.printStackTrace();
    29.         } catch (IOException e) {
    30.             e.printStackTrace();
    31.         } finally {
    32.             try {
    33.                 // 释放资源
    34.                 if (httpClient != null) {
    35.                     httpClient.close();
    36.                 }
    37.                 if (response != null) {
    38.                     response.close();
    39.                 }
    40.             } catch (IOException e) {
    41.                 e.printStackTrace();
    42.             }
    43.         }
    44.         return result;
    45.     }
    46. }

    2.服务者

    1. @RestController
    2. public class HttpClientController {
    3.     @RequestMapping("/get/noparam")
    4.     public String doGetNoParam(){
    5.           return "ok 123!";
    6.     }
    7. }

    截图如下： 

    3.请求测试

    2.2 get有参数：直接拼接URL

    1.消费者

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

    2.提供者

    1.     @RequestMapping("/get/youparam1")
    2.     public String doGetYouParam(String name,Integer age){
    3.  
    4.         return "原来"+name+"都"+age+"岁";
    5.     }

    3.调用

    2.3 get有参数：使用URI获得HttpGet

    1.消费者

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

    2.提供者

    1.    @RequestMapping("/get/youparam2")
    2.     public String doGetYouParam2(String name,Integer age){
    3.  
    4.         return "原来"+name+"都"+age+"岁";
    5.     }

    3.调试

    三  实操实例Post方式

    3.1 post无参案例

    1.生产者

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

    2.消费者

    1.   @RequestMapping("/post/noparam")
    2.     public String doPostNoParam(){
    3.         return "post  请求无参数  123!";
    4.     }

    3.调用

    3.2 post有参案例

    1.消费者

    1.  @RequestMapping("/hc/post/youcan1")
    2.     public String doPostTestFour() {
    3.  
    4.         // 获得Http客户端(可以理解为:你得先有一个浏览器;注意:实际上HttpClient与浏览器是不一样的)
    5.         CloseableHttpClient httpClient = HttpClientBuilder.create().build();
    6.  
    7.         // 参数
    8.         StringBuffer params = new StringBuffer();
    9.         try {
    10.             // 字符数据最好encoding以下;这样一来，某些特殊字符才能传过去(如:某人的名字就是“&”,不encoding的话,传不过去)
    11.             params.append("name=" + URLEncoder.encode("zhangsan", "utf-8"));
    12.             params.append("&");
    13.             params.append("age=24");
    14.         } catch (UnsupportedEncodingException e1) {
    15.             e1.printStackTrace();
    16.         }
    17.  
    18.         // 创建Post请求
    19.         HttpPost httpPost = new HttpPost("http://localhost:8082//post/youparam1" + "?" + params);
    20.  
    21.         // 设置ContentType(注:如果只是传普通参数的话,ContentType不一定非要用application/json)
    22.         httpPost.setHeader("Content-Type", "application/json;charset=utf8");
    23.  
    24.         // 响应模型
    25.         CloseableHttpResponse response = null;
    26.         String result="";
    27.         try {
    28.             // 由客户端执行(发送)Post请求
    29.             response = httpClient.execute(httpPost);
    30.             // 从响应模型中获取响应实体
    31.             HttpEntity responseEntity = response.getEntity();
    32.  
    33.             System.out.println("响应状态为:" + response.getStatusLine());
    34.             if (responseEntity != null) {
    35.                 System.out.println("响应内容长度为:" + responseEntity.getContentLength());
    36.                 result=EntityUtils.toString(responseEntity);
    37.                 System.out.println("响应内容为:" + result);
    38.             }
    39.         } catch (ClientProtocolException e) {
    40.             e.printStackTrace();
    41.         } catch (ParseException e) {
    42.             e.printStackTrace();
    43.         } catch (IOException e) {
    44.             e.printStackTrace();
    45.         } finally {
    46.             try {
    47.                 // 释放资源
    48.                 if (httpClient != null) {
    49.                     httpClient.close();
    50.                 }
    51.                 if (response != null) {
    52.                     response.close();
    53.                 }
    54.             } catch (IOException e) {
    55.                 e.printStackTrace();
    56.             }
    57.         }
    58.         return result;
    59.     }

    2.消费者

    1.    @RequestMapping(value="/post/youparam1",method = RequestMethod.POST)
    2.     public String doPostYouParam(String name,Integer age){
    3.  
    4.         return "原来"+name+"都"+age+"岁";
    5.     }

    3.调用

    3.3 post有参案例2 通过对象映射

    1.消费者

    1.     @RequestMapping("/hc/post/youcan2")
    2.     public String doPostTestTwo() {
    3.  
    4.         // 获得Http客户端(可以理解为:你得先有一个浏览器;注意:实际上HttpClient与浏览器是不一样的)
    5.         CloseableHttpClient httpClient = HttpClientBuilder.create().build();
    6.  
    7.         // 创建Post请求
    8.         HttpPost httpPost = new HttpPost("http://localhost:8082/post/youparam2");
    9.         User user = new User();
    10.         user.setName("潘晓婷");
    11.         user.setAge(18);
    12.         user.setGender("女");
    13.         user.setMotto("姿势要优雅~");
    14.         // 我这里利用阿里的fastjson，将Object转换为json字符串;
    15.         // (需要导入com.alibaba.fastjson.JSON包)
    16.         String jsonString = JSON.toJSONString(user);
    17.  
    18.         StringEntity entity = new StringEntity(jsonString, "UTF-8");
    19.  
    20.         // post请求是将参数放在请求体里面传过去的;这里将entity放入post请求体中
    21.         httpPost.setEntity(entity);
    22.  
    23.         httpPost.setHeader("Content-Type", "application/json;charset=utf8");
    24.  
    25.         // 响应模型
    26.         CloseableHttpResponse response = null;
    27.         String result="";
    28.         try {
    29.             // 由客户端执行(发送)Post请求
    30.             response = httpClient.execute(httpPost);
    31.             // 从响应模型中获取响应实体
    32.             HttpEntity responseEntity = response.getEntity();
    33.  
    34.             System.out.println("响应状态为:" + response.getStatusLine());
    35.             if (responseEntity != null) {
    36.                 System.out.println("响应内容长度为:" + responseEntity.getContentLength());
    37.                 result=EntityUtils.toString(responseEntity);
    38.                 System.out.println("响应内容为:" + result);
    39.             }
    40.         } catch (ClientProtocolException e) {
    41.             e.printStackTrace();
    42.         } catch (ParseException e) {
    43.             e.printStackTrace();
    44.         } catch (IOException e) {
    45.             e.printStackTrace();
    46.         } finally {
    47.             try {
    48.                 // 释放资源
    49.                 if (httpClient != null) {
    50.                     httpClient.close();
    51.                 }
    52.                 if (response != null) {
    53.                     response.close();
    54.                 }
    55.             } catch (IOException e) {
    56.                 e.printStackTrace();
    57.             }
    58.         }
    59.         return result;
    60.     }

    2.请求者

    1.    @RequestMapping(value="/post/youparam2",method = RequestMethod.POST)
    2.     public String doPostYouParam(@RequestBody User u){
    3.         return u.toString();
    4.     }

    3.调用

    3.4 post有参案例3 通过对象映射+参数

    1.消费者

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

    2.生产者

    1.     @RequestMapping(value="/post/youparam3",method = RequestMethod.POST)
    2.     public String doPostYouParam(@RequestBody User u,Integer flag,String meaning){
    3.         return u.toString()+" flag:"+flag+" meaning:"+meaning;
    4.     }

    3.调用

  • 相关阅读:
    数据结构学习笔记（V）：树与二叉树
    Python爬虫实战：淘宝商品爬取与数据分析
    Hydra工具的使用
    架构设计杂谈
    vue-cli查看相关版本以及更新配置
    「Python实用秘技14」快速优化Python导包顺序
    ios ipa包上传需要什么工具
    线性插值方法
    qnx shell sh ，linux shell bash
    Leetcode 1758. 生成交替二进制字符串的最少操作数
  • 原文地址：https://blog.csdn.net/u011066470/article/details/134044002