• Java中常见的HttpClient调用方式

    1. 背景

    在Java应用开发中，服务暴露接口的方式分为rpc和http两种方式。优雅的httpClient封装不仅能让程序work得更好，也能在一定程度上有性能优化。Java项目中调用第三方接口的方式有：

    • 通过JDK网络类Java.net.HttpURLConnection
    • 通过common封装HttpClient
    • Springboot提供的RestTemplate.

    各种方式的优缺点和适用范式，下面一一道来。

    2. HttpClient的封装调用范式

    2.1 HttpURLConnection

    缺点：不能直接使用池化技术，需要自行处理输入输出流

    1. package com.book.xw.web.util;
    2.  
    3. import org.springframework.lang.Nullable;
    4.  
    5. import java.io.*;
    6. import java.net.HttpURLConnection;
    7. import java.net.MalformedURLException;
    8. import java.net.URL;
    9. import java.net.URLConnection;
    10.  
    11.  
    12. public class HttpClientUtil {
    13.  
    14.     /**
    15.      * http get请求，参数拼接在URL上
    16.      */
    17.     public static String doGet(String httpUrl){
    18.         HttpURLConnection connection = null;
    19.         InputStream is = null;
    20.         BufferedReader br = null;
    21.         StringBuffer result = new StringBuffer();
    22.         try {
    23.             //创建连接
    24.             URL url = new URL(httpUrl);
    25.             connection = (HttpURLConnection) url.openConnection();
    26.             //设置请求方式
    27.             connection.setRequestMethod("GET");
    28.             //设置连接超时时间
    29.             connection.setReadTimeout(15000);
    30.             //开始连接
    31.             connection.connect();
    32.             //获取响应数据
    33.             if (connection.getResponseCode() == 200) {
    34.                 //获取返回的数据
    35.                 is = connection.getInputStream();
    36.                 if (null != is) {
    37.                     br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
    38.                     String temp = null;
    39.                     while (null != (temp = br.readLine())) {
    40.                         result.append(temp);
    41.                     }
    42.                 }
    43.             }
    44.         } catch (Exception e) {
    45.             e.printStackTrace();
    46.         } finally {
    47.             if (null != br) {
    48.                 try {
    49.                     br.close();
    50.                 } catch (IOException e) {
    51.                     e.printStackTrace();
    52.                 }
    53.             }
    54.             if (null != is) {
    55.                 try {
    56.                     is.close();
    57.                 } catch (IOException e) {
    58.                     e.printStackTrace();
    59.                 }
    60.             }
    61.             //关闭远程连接
    62.             connection.disconnect();
    63.         }
    64.         return result.toString();
    65.     }
    66.  
    67.     /**
    68.      * Http post请求
    69.      */
    70.     public static String doPost(String httpUrl, String param) {
    71.         StringBuffer result = new StringBuffer();
    72.         //连接
    73.         HttpURLConnection connection = null;
    74.         OutputStream os = null;
    75.         InputStream is = null;
    76.         BufferedReader br = null;
    77.         try {
    78.             //创建连接对象
    79.             URL url = new URL(httpUrl);
    80.             //创建连接
    81.             connection = (HttpURLConnection) url.openConnection();
    82.             //设置请求方法
    83.             connection.setRequestMethod("POST");
    84.             //设置连接超时时间
    85.             connection.setConnectTimeout(15000);
    86.             //设置读取超时时间
    87.             connection.setReadTimeout(15000);
    88.             //DoOutput设置是否向httpUrlConnection输出，DoInput设置是否从httpUrlConnection读入，此外发送post请求必须设置这两个
    89.             //设置是否可读取
    90.             connection.setDoOutput(true);
    91.             connection.setDoInput(true);
    92.             //设置通用的请求属性
    93.             connection.setRequestProperty("accept", "*/*");
    94.             connection.setRequestProperty("connection", "Keep-Alive");
    95.             connection.setRequestProperty("Content-Type","application/json;charset=utf-8");
    96.  
    97.             //拼装参数
    98.             if (null != param && !param.equals("")) {
    99.                 //设置参数
    100.                 os = connection.getOutputStream();
    101.                 //拼装参数
    102.                 os.write(param.getBytes("UTF-8"));
    103.             }
    104.             
    105.             //connection.connect();
    106.             //读取响应
    107.             if (connection.getResponseCode() == 200) {
    108.                 is = connection.getInputStream();
    109.                 if (null != is) {
    110.                     br = new BufferedReader(new InputStreamReader(is, "GBK"));
    111.                     String temp = null;
    112.                     while (null != (temp = br.readLine())) {
    113.                         result.append(temp);
    114.                         result.append("\r\n");
    115.                     }
    116.                 }
    117.             }
    118.  
    119.         } catch (MalformedURLException e) {
    120.             e.printStackTrace();
    121.         } catch (Exception e) {
    122.             e.printStackTrace();
    123.         } finally {
    124.             //关闭连接
    125.             if(br!=null){
    126.                 try {
    127.                     br.close();
    128.                 } catch (IOException e) {
    129.                     e.printStackTrace();
    130.                 }
    131.             }
    132.             if(os!=null){
    133.                 try {
    134.                     os.close();
    135.                 } catch (IOException e) {
    136.                     e.printStackTrace();
    137.                 }
    138.             }
    139.             if(is!=null){
    140.                 try {
    141.                     is.close();
    142.                 } catch (IOException e) {
    143.                     e.printStackTrace();
    144.                 }
    145.             }
    146.             //关闭连接
    147.             connection.disconnect();
    148.         }
    149.         return result.toString();
    150.     }
    151. }

    2.2 apache common封装HttpClient

    引入Apache的commons jar包：


        commons-httpclient
        commons-httpclient
        3.1

    每次调用会创建一个httpClient对象，并且需要手动释放连接。 

    1. public class HttpClientUtil {
    2.     public static String doGet(String url, String charset) {
    3.         //1.生成HttpClient对象并设置参数
    4.         HttpClient httpClient = new HttpClient();
    5.         //设置Http连接超时为5秒
    6.         httpClient.getHttpConnectionManager().getParams().setConnectionTimeout(5000);
    7.         //2.生成GetMethod对象并设置参数
    8.         GetMethod getMethod = new GetMethod(url);
    9.         //设置get请求超时为5秒
    10.         getMethod.getParams().setParameter(HttpMethodParams.SO_TIMEOUT, 5000);
    11.         //设置请求重试处理，用的是默认的重试处理：请求三次
    12.         getMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER, new DefaultHttpMethodRetryHandler());
    13.         String response = "";
    14.         //3.执行HTTP GET 请求
    15.         try {
    16.             int statusCode = httpClient.executeMethod(getMethod);
    17.             //4.判断访问的状态码
    18.             if (statusCode != HttpStatus.SC_OK) {
    19.                 System.err.println("请求出错：" + getMethod.getStatusLine());
    20.             }
    21.             //5.处理HTTP响应内容
    22.             //HTTP响应头部信息，这里简单打印
    23.             Header[] headers = getMethod.getResponseHeaders();
    24.             for(Header h : headers) {
    25.                 System.out.println(h.getName() + "---------------" + h.getValue());
    26.             }
    27.             //读取HTTP响应内容，这里简单打印网页内容
    28.             //读取为字节数组
    29.             byte[] responseBody = getMethod.getResponseBody();
    30.             response = new String(responseBody, charset);
    31.             System.out.println("-----------response:" + response);
    32.             //读取为InputStream，在网页内容数据量大时候推荐使用
    33.             //InputStream response = getMethod.getResponseBodyAsStream();
    34.         } catch (HttpException e) {
    35.             e.printStackTrace();
    36.         } catch (IOException e) {
    37.             //发生网络异常
    38.             System.out.println("发生网络异常!");
    39.         } finally {
    40.             //6.释放连接
    41.             getMethod.releaseConnection();
    42.         }
    43.         return response;
    44.     }
    45.     
    46.     public static String doPost(String url, JSONObject json){
    47.         HttpClient httpClient = new HttpClient();
    48.         PostMethod postMethod = new PostMethod(url);
    49.  
    50.         postMethod.addRequestHeader("accept", "*/*");
    51.         postMethod.addRequestHeader("connection", "Keep-Alive");
    52.         //设置json格式传送
    53.         postMethod.addRequestHeader("Content-Type", "application/json;charset=GBK");
    54.         //添加请求参数
    55.         postMethod.addParameter("xxx", json.getString("xxx"));
    56.  
    57.         String res = "";
    58.         try {
    59.             int code = httpClient.executeMethod(postMethod);
    60.             if (code == 200){
    61.                 res = postMethod.getResponseBodyAsString();
    62.                 System.out.println(res);
    63.             }
    64.         } catch (IOException e) {
    65.             e.printStackTrace();
    66.         }finally {
    67.             postMethod.releaseConnection();
    68.         }
    69.         return res;
    70.     }
    71. }

    2.3 CloseableHttpClient

    相比较HttpClient而言，可以使用连接池保持连接，并且过期自动释放。引入jar包


        org.apache.httpcomponents
        httpclient
        4.5.2

    1. package com.book.xw.common.util.utils;
    2.  
    3. import com.alibaba.fastjson.JSON;
    4. import org.apache.http.Header;
    5. import org.apache.http.HttpStatus;
    6. import org.apache.http.client.config.RequestConfig;
    7. import org.apache.http.client.methods.CloseableHttpResponse;
    8. import org.apache.http.client.methods.HttpGet;
    9. import org.apache.http.client.methods.HttpPost;
    10. import org.apache.http.config.Registry;
    11. import org.apache.http.config.RegistryBuilder;
    12. import org.apache.http.conn.socket.ConnectionSocketFactory;
    13. import org.apache.http.conn.socket.PlainConnectionSocketFactory;
    14. import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
    15. import org.apache.http.conn.ssl.TrustSelfSignedStrategy;
    16. import org.apache.http.entity.StringEntity;
    17. import org.apache.http.impl.client.CloseableHttpClient;
    18. import org.apache.http.impl.client.DefaultHttpRequestRetryHandler;
    19. import org.apache.http.impl.client.HttpClients;
    20. import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
    21. import org.apache.http.ssl.SSLContextBuilder;
    22. import org.apache.http.util.EntityUtils;
    23.  
    24. import java.io.IOException;
    25. import java.security.KeyManagementException;
    26. import java.security.KeyStoreException;
    27. import java.security.NoSuchAlgorithmException;
    28.  
    29. public class HttpCloseableClient {
    30.     // 池化管理
    31.     private static PoolingHttpClientConnectionManager poolConnManager = null;
    32.     // 它是线程安全的，所有的线程都可以使用它一起发送http请求
    33.     private static CloseableHttpClient httpClient;
    34.     static {
    35.         try {
    36.             SSLContextBuilder builder = new SSLContextBuilder();
    37.             builder.loadTrustMaterial(null, new TrustSelfSignedStrategy());
    38.             SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(builder.build());
    39.             // 配置同时支持 HTTP 和 HTPPS
    40.             Registry socketFactoryRegistry = RegistryBuilder.create().register("http", PlainConnectionSocketFactory.getSocketFactory()).register("https", sslsf).build();
    41.             // 初始化连接管理器
    42.             poolConnManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
    43.             // 同时最多连接数
    44.             poolConnManager.setMaxTotal(640);
    45.             // 设置最大路由
    46.             poolConnManager.setDefaultMaxPerRoute(320);
    47.             // 初始化httpClient
    48.             httpClient = getConnection();
    49.         } catch (NoSuchAlgorithmException e) {
    50.             e.printStackTrace();
    51.         } catch (KeyStoreException e) {
    52.             e.printStackTrace();
    53.         } catch (KeyManagementException e) {
    54.             e.printStackTrace();
    55.         }
    56.     }
    57.  
    58.     public static CloseableHttpClient getConnection() {
    59.         RequestConfig config = RequestConfig.custom().setConnectTimeout(5000)
    60.                 .setConnectionRequestTimeout(5000).setSocketTimeout(5000).build();
    61.         CloseableHttpClient httpClient = HttpClients.custom()
    62.                 // 设置连接池管理
    63.                 .setConnectionManager(poolConnManager)
    64.                 .setDefaultRequestConfig(config)
    65.                 // 设置重试次数
    66.                 .setRetryHandler(new DefaultHttpRequestRetryHandler(2, false)).build();
    67.         return httpClient;
    68.     }
    69.  
    70.     public static String httpGet(String url) {
    71.         HttpGet httpGet = new HttpGet(url);
    72.         CloseableHttpResponse response = null;
    73.         try {
    74.             response = httpClient.execute(httpGet);
    75.             String result = EntityUtils.toString(response.getEntity());
    76.             int code = response.getStatusLine().getStatusCode();
    77.             if (code == HttpStatus.SC_OK) {
    78.                 return result;
    79.             } else {
    80.                 return null;
    81.             }
    82.         } catch (IOException e) {
    83.             e.printStackTrace();
    84.         } finally {
    85.             try {
    86.                 if (response != null)
    87.                     response.close();
    88.             } catch (IOException e) {
    89.                 e.printStackTrace();
    90.             }
    91.         }
    92.         return null;
    93.     }
    94.     public static String post(String uri, Object params, Header... heads) {
    95.         HttpPost httpPost = new HttpPost(uri);
    96.         CloseableHttpResponse response = null;
    97.         try {
    98.             StringEntity paramEntity = new StringEntity(JSON.toJSONString(params));
    99.             paramEntity.setContentEncoding("UTF-8");
    100.             paramEntity.setContentType("application/json");
    101.             httpPost.setEntity(paramEntity);
    102.             if (heads != null) {
    103.                 httpPost.setHeaders(heads);
    104.             }
    105.             response = httpClient.execute(httpPost);
    106.             int code = response.getStatusLine().getStatusCode();
    107.             String result = EntityUtils.toString(response.getEntity());
    108.             if (code == HttpStatus.SC_OK) {
    109.                 return result;
    110.             } else {
    111.                 return null;
    112.             }
    113.         } catch (IOException e) {
    114.             e.printStackTrace();
    115.         } finally {
    116.             try {
    117.                 if(response != null) {
    118.                     response.close();
    119.                 }
    120.             } catch (IOException e) {
    121.                 e.printStackTrace();
    122.             }
    123.         }
    124.         return null;
    125.     }
    126. }

     2.4 OkHttp3

    pom文件引入依赖包


        com.squareup.okhttp3
        okhttp
        3.10.0

    1. @Slf4j
    2. public class OkHttpClient {
    3.     private static final MediaType JSON = MediaType.parse("application/json; charset=utf-8");
    4.  
    5.     private volatile static okhttp3.OkHttpClient client;
    6.  
    7.     private static final int MAX_IDLE_CONNECTION = Integer
    8.             .parseInt(ConfigManager.get("httpclient.max_idle_connection"));
    9.  
    10.     private static final long KEEP_ALIVE_DURATION = Long
    11.             .parseLong(ConfigManager.get("httpclient.keep_alive_duration"));
    12.  
    13.     private static final long CONNECT_TIMEOUT = Long.parseLong(ConfigManager.get("httpclient.connectTimeout"));
    14.  
    15.     private static final long READ_TIMEOUT = Long.parseLong(ConfigManager.get("httpclient. "));
    16.  
    17.     /**
    18.      * 单例模式(双重检查模式) 
    19.      */
    20.     private static okhttp3.OkHttpClient getInstance() {
    21.         if (client == null) {
    22.             synchronized (okhttp3.OkHttpClient.class) {
    23.                 if (client == null) {
    24.                     client = new okhttp3.OkHttpClient.Builder()
    25.                             .connectTimeout(CONNECT_TIMEOUT, TimeUnit.SECONDS)
    26.                             .readTimeout(READ_TIMEOUT, TimeUnit.SECONDS)
    27.                             .connectionPool(new ConnectionPool(MAX_IDLE_CONNECTION, KEEP_ALIVE_DURATION, TimeUnit.MINUTES))
    28.                             .build();
    29.                 }
    30.             }
    31.         }
    32.         return client;
    33.     }
    34.  
    35.     public static String doPost(String url, String json) throws IOException {
    36.         RequestBody body = RequestBody.create(JSON, json);
    37.         Request request = new Request.Builder()
    38.                 .url(url)
    39.                 .post(body)
    40.                 .build();
    41.         try {
    42.             Response response = OkHttpClient.getInstance().newCall(request).execute();
    43.             if (response.isSuccessful()) {
    44.                 String result = response.body().string();
    45.                 log.info("syncPost response = {}, responseBody= {}", response, result);
    46.                 return result;
    47.             }
    48.             String result = response.body().string();
    49.             log.info("syncPost response = {}, responseBody= {}", response, result);
    50.             throw new IOException("三方接口返回http状态码为" + response.code());
    51.         } catch (Exception e) {
    52.             log.error("syncPost() url:{} have a ecxeption {}", url, e);
    53.             throw new RuntimeException("syncPost() have a ecxeption {}" + e.getMessage());
    54.         }
    55.     }
    56.  
    57.     public static String doGet(String url, Map headParamsMap) throws IOException {
    58.         Request request;
    59.         final Request.Builder builder = new Request.Builder().url(url);
    60.         try {
    61.             if (!CollectionUtils.isEmpty(headParamsMap)) {
    62.                 final Iterator> iterator = headParamsMap.entrySet()
    63.                         .iterator();
    64.                 while (iterator.hasNext()) {
    65.                     final Map.Entry entry = iterator.next();
    66.                     builder.addHeader(entry.getKey(), (String) entry.getValue());
    67.                 }
    68.             }
    69.             request = builder.build();
    70.             Response response = OkHttpClient.getInstance().newCall(request).execute();
    71.             String result = response.body().string();
    72.             log.info("syncGet response = {},responseBody= {}", response, result);
    73.             if (!response.isSuccessful()) {
    74.                 throw new IOException("三方接口返回http状态码为" + response.code());
    75.             }
    76.             return result;
    77.         } catch (Exception e) {
    78.             log.error("remote interface url:{} have a ecxeption {}", url, e);
    79.             throw new RuntimeException("三方接口返回异常");
    80.         }
    81.     }
    82.  
    83. }

     2.5 RestTemplate

    1. // 先声明bean
    2. @Configuration
    3. public class RestTemplateConfig {
    4.     @Bean
    5.     public RestTemplate restTemplate(ClientHttpRequestFactory factory){
    6.         return new RestTemplate(factory);
    7.     }
    8.     @Bean
    9.     public ClientHttpRequestFactory simpleClientHttpRequestFactory(){
    10.         SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
    11.         factory.setConnectTimeout(15000);
    12.         factory.setReadTimeout(5000);
    13.         return factory;
    14.     }
    15. }

    其余地方直接使用API即可：

    image-20220415205801633

  • 相关阅读:
    【Linux】翻山越岭——进程地址空间
    牛客月赛55 至至子的长链剖分
    Codeforces Round #800 (Div. 2)
    给爷肝！Alibaba架构师纯手工打造神仙级“2022版Java面试手册”
    linux 性能分析perf
    供应链和物流的自动化新时代
    Protocol Buffers 3 学习
    python 中内置函数ord()返回字符串的ASCII数值
    京东运营数据分析：2023年8月京东宠物主粮行业品牌销售排行榜
    第一章 基础算法(三)
  • 原文地址：https://blog.csdn.net/chenwiehuang/article/details/126735175