• 通用HttpClient封装

    一、封装通用HttpClient，兼容Http/Https接口调用，方便业务层交互使用.

    二、使用Pom文件如下:

    1.         
    2.             org.projectlombok
    3.             lombok
    4.             1.18.2
    5.             provided
    6.         
    7.         
    8.             org.apache.commons
    9.             commons-lang3
    10.             3.12.0
    11.         
    12.         
    13.             org.apache.commons
    14.             commons-collections4
    15.             4.4
    16.         
    17.         
    18.             org.apache.httpcomponents
    19.             httpclient
    20.             4.5.6
    21.

     三、HttpClient封装诉求如下.

    ①、兼容Http/Https,目前采用跳过证书校验.

    ②、基于HttpClient连接池化以及过期、空闲连接清理.

    ③、各种超时时间设置以及重试策略.

    ④、简单易用,方便扩展和维护,减低使用配置.

    ⑤、其他j微服务调用可在此基础上封装XXXClient只需要一些鉴权和url参数就可以快速对接使用.

    1. package com.boot.skywalk;
    2.  
    3. import lombok.Data;
    4. /**
    5.  * 通用响应
    6.  */
    7. @Data
    8. public class HttpResult {
    9.     /**
    10.      * 响应的状态码
    11.      */
    12.     private int code;
    13.     /**
    14.      * 响应体
    15.      */
    16.     private String body;
    17. }
    1. package com.boot.skywalk.exception;
    2. /**
    3.  * 全局异常
    4.  */
    5. public class GlobalException extends RuntimeException {
    6.     public GlobalException(){
    7.         super();
    8.     }
    9.  
    10.     public GlobalException(String message){
    11.         super(message);
    12.     }
    13.  
    14.     public GlobalException(Throwable cause){
    15.         super(cause);
    16.     }
    17.  
    18.     public GlobalException(String message,Throwable cause) {
    19.         super(message, cause);
    20.     }
    21. }

    RestClient封装如下:代码比较简单 

    1. package com.boot.skywalk;
    2.  
    3. import com.alibaba.fastjson.JSON;
    4. import com.boot.skywalk.exception.GlobalException;
    5. import lombok.extern.slf4j.Slf4j;
    6. import org.apache.commons.collections4.CollectionUtils;
    7. import org.apache.commons.collections4.MapUtils;
    8. import org.apache.commons.lang3.StringUtils;
    9. import org.apache.http.HttpEntity;
    10. import org.apache.http.HttpEntityEnclosingRequest;
    11. import org.apache.http.HttpRequest;
    12. import org.apache.http.NameValuePair;
    13. import org.apache.http.client.HttpRequestRetryHandler;
    14. import org.apache.http.client.config.RequestConfig;
    15. import org.apache.http.client.entity.UrlEncodedFormEntity;
    16. import org.apache.http.client.methods.CloseableHttpResponse;
    17. import org.apache.http.client.methods.HttpDelete;
    18. import org.apache.http.client.methods.HttpGet;
    19. import org.apache.http.client.methods.HttpPost;
    20. import org.apache.http.client.methods.HttpPut;
    21. import org.apache.http.client.protocol.HttpClientContext;
    22. import org.apache.http.client.utils.URIBuilder;
    23. import org.apache.http.config.Registry;
    24. import org.apache.http.config.RegistryBuilder;
    25. import org.apache.http.conn.ConnectTimeoutException;
    26. import org.apache.http.conn.HttpClientConnectionManager;
    27. import org.apache.http.conn.socket.ConnectionSocketFactory;
    28. import org.apache.http.conn.socket.PlainConnectionSocketFactory;
    29. import org.apache.http.conn.ssl.NoopHostnameVerifier;
    30. import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
    31. import org.apache.http.entity.StringEntity;
    32. import org.apache.http.impl.client.CloseableHttpClient;
    33. import org.apache.http.impl.client.DefaultHttpRequestRetryHandler;
    34. import org.apache.http.impl.client.HttpClients;
    35. import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
    36. import org.apache.http.message.BasicNameValuePair;
    37. import org.apache.http.protocol.HttpContext;
    38. import org.apache.http.util.EntityUtils;
    39.  
    40. import javax.net.ssl.SSLContext;
    41. import javax.net.ssl.SSLException;
    42. import javax.net.ssl.TrustManager;
    43. import javax.net.ssl.X509TrustManager;
    44. import java.io.BufferedReader;
    45. import java.io.Closeable;
    46. import java.io.IOException;
    47. import java.io.InterruptedIOException;
    48. import java.net.URISyntaxException;
    49. import java.net.UnknownHostException;
    50. import java.nio.charset.Charset;
    51. import java.nio.charset.StandardCharsets;
    52. import java.security.KeyManagementException;
    53. import java.security.NoSuchAlgorithmException;
    54. import java.security.cert.CertificateException;
    55. import java.util.ArrayList;
    56. import java.util.HashMap;
    57. import java.util.List;
    58. import java.util.Map;
    59. import java.util.Objects;
    60. import java.util.concurrent.TimeUnit;
    61.  
    62. /**
    63.  * Http通用:RestClient
    64.  */
    65. @Slf4j
    66. public final class RestClient {
    67.     private static final RestClient INSTANCE = new RestClient();
    68.     /**
    69.      * 建立连接时间
    70.      */
    71.     private static final int CONNECTION_TIME = 3000;
    72.     /**
    73.      * 发送请求时间
    74.      */
    75.     private static final int CONNECTION_REQUEST_TIME = 30000;
    76.     /**
    77.      * 读取数据时间
    78.      */
    79.     private static final int SOCKET_TIME = 180000;
    80.     /**
    81.      * 重试次数
    82.      */
    83.     private static final int RETRY = 3;
    84.     /**
    85.      * 请求类型:FORM表单
    86.      */
    87.     private static final String REQUEST_TYPE_FORM = "application/x-www-form-urlencoded; charset=UTF-8";
    88.     /**
    89.      * 请求类型:JSON体
    90.      */
    91.     private static final String REQUEST_TYPE_JSON = "application/json; charset=utf-8";
    92.  
    93.     private RestClient() {
    94.     }
    95.  
    96.     /**
    97.      * Http Get:不带请求参数
    98.      *
    99.      * @param url       url
    100.      * @param headerMap headerMap
    101.      * @return String
    102.      */
    103.     public String get(String url, Map headerMap) {
    104.         return get(url, headerMap, null);
    105.     }
    106.  
    107.     /**
    108.      * Http Get:带请求参数
    109.      *
    110.      * @param url       url
    111.      * @param headerMap headerMap
    112.      * @param params    params
    113.      * @return String
    114.      */
    115.     public String get(String url, Map headerMap, Map params) {
    116.         checkUrl(url);
    117.         checkHeader(headerMap);
    118.         return doGet(url, headerMap, params, StandardCharsets.UTF_8);
    119.     }
    120.  
    121.     /**
    122.      * Http Post:Form表单不带请求参数
    123.      *
    124.      * @param url       URL
    125.      * @param headerMap headerMap
    126.      * @return String
    127.      */
    128.     public String post(String url, Map headerMap) {
    129.         return doPostForForm(url, headerMap, null, StandardCharsets.UTF_8);
    130.     }
    131.  
    132.     /**
    133.      * Http Post:根据请头识别FORM表单还是JSON体
    134.      *
    135.      * @param url url
    136.      * @param map map
    137.      * @return String
    138.      */
    139.     public String post(String url, Map headerMap, Map map) {
    140.         checkUrl(url);
    141.         checkHeader(headerMap);
    142.         checkBody(map);
    143.         String contentType = (String) headerMap.get("Content-type");
    144.         if (REQUEST_TYPE_FORM.equalsIgnoreCase(contentType)) {
    145.             return doPostForForm(url, headerMap, map, StandardCharsets.UTF_8);
    146.         } else if (REQUEST_TYPE_JSON.equalsIgnoreCase(contentType)) {
    147.             return doPostForJson(url, headerMap, map, StandardCharsets.UTF_8);
    148.         } else {
    149.             log.error("not support this post type");
    150.             throw new GlobalException("not support this post type");
    151.         }
    152.     }
    153.  
    154.     /**
    155.      * HTTP Put:Form表单方式不带参数
    156.      * Content-type:application/x-www-form-urlencoded; charset=UTF-8
    157.      * @param url url
    158.      * @param headerMap headerMap
    159.      * @return String
    160.      */
    161.     public static String put(String url, Map headerMap) {
    162.         checkUrl(url);
    163.         checkHeader(headerMap);
    164.         return doPut(url, headerMap, null);
    165.     }
    166.  
    167.     /**
    168.      * Http Delete:不带参数的表单形式
    169.      * Content-type:application/x-www-form-urlencoded; charset=UTF-8
    170.      * @param url url
    171.      * @param headerMap header
    172.      * @return HttpResult
    173.      */
    174.     public static String delete(String url, Map headerMap){
    175.         checkUrl(url);
    176.         checkHeader(headerMap);
    177.         return doDelete(url, headerMap, null);
    178.     }
    179.  
    180.     /**
    181.      * HTTP Get:带请求参数
    182.      *
    183.      * @param url       请求的url地址 ?之前的地址
    184.      * @param headerMap 请求头
    185.      * @param params    请求的参数
    186.      * @param charset   编码格式
    187.      * @return String
    188.      */
    189.     public static String doGet(String url, Map headerMap, Map params, Charset charset) {
    190.         StringBuffer resultBuffer = null;
    191.         BufferedReader bufferedReader = null;
    192.         CloseableHttpResponse response = null;
    193.         URIBuilder uriBuilder = null;
    194.         String result = null;
    195.         try {
    196.             uriBuilder = new URIBuilder(url);
    197.             if(MapUtils.isNotEmpty(params)) {
    198.                 for (Map.Entry entry : params.entrySet()) {
    199.                     uriBuilder.setParameter(entry.getKey(), entry.getValue().toString());
    200.                 }
    201.             }
    202.             HttpGet httpGet = new HttpGet(uriBuilder.build());
    203.             headerMap.forEach((key, value) -> {
    204.                 httpGet.addHeader(key, value.toString());
    205.             });
    206.             response = httpClient().execute(httpGet);
    207.             if (Objects.nonNull(response.getEntity())) {
    208.                 result = EntityUtils.toString(response.getEntity(), StandardCharsets.UTF_8);
    209.             }
    210.         } catch (URISyntaxException e) {
    211.             log.error("url synctax error", e);
    212.         } catch (Exception e) {
    213.             log.error("execute get request error", e);
    214.         } finally {
    215.             close(response);
    216.         }
    217.         return result;
    218.     }
    219.  
    220.     /**
    221.      * HTTP Post:Form表单方式
    222.      * Content-type:application/x-www-form-urlencoded; charset=UTF-8
    223.      *
    224.      * @param url       请求的url地址?之前的地址
    225.      * @param headerMap 请求头的参数
    226.      * @param paramMap  请求的参数
    227.      * @param charset   编码格式
    228.      * @return String
    229.      */
    230.     public static String doPostForForm(String url, Map headerMap, Map paramMap, Charset charset) {
    231.         List pairs = null;
    232.         CloseableHttpResponse response = null;
    233.         String result = null;
    234.         pairs = new ArrayList<>(paramMap.size());
    235.         for (Map.Entry entry : paramMap.entrySet()) {
    236.             if (entry.getValue() != null) {
    237.                 pairs.add(new BasicNameValuePair(entry.getKey(), entry.getValue().toString()));
    238.             }
    239.         }
    240.         HttpPost httpPost = new HttpPost(url);
    241.         headerMap.forEach((key, value) -> {
    242.             httpPost.setHeader(key, value.toString());
    243.         });
    244.         if (CollectionUtils.isNotEmpty(pairs)) {
    245.             httpPost.setEntity(new UrlEncodedFormEntity(pairs, charset));
    246.         }
    247.         try {
    248.             response = httpClient().execute(httpPost);
    249.             HttpEntity entity = response.getEntity();
    250.             if (entity != null) {
    251.                 result = EntityUtils.toString(entity, charset);
    252.             }
    253.         } catch (Exception e) {
    254.             log.error("execute post request error", e);
    255.         } finally {
    256.             close(response);
    257.         }
    258.         return result;
    259.     }
    260.  
    261.     /**
    262.      * HTTP Post:JSON形式
    263.      * Content-type:application/json; charset=utf-8
    264.      *
    265.      * @param url       请求的url地址?之前的地址
    266.      * @param headerMap 请求头的参数
    267.      * @param bodyMap   请求的参数
    268.      * @param charset   编码格式
    269.      * @return String
    270.      */
    271.     public static String doPostForJson(String url, Map headerMap, Map bodyMap, Charset charset) {
    272.         CloseableHttpResponse response = null;
    273.         String result = null;
    274.         HttpPost httpPost = new HttpPost(url);
    275.         // Body参数设置到请求体中
    276.         httpPost.setEntity(new StringEntity(JSON.toJSONString(bodyMap), charset));
    277.         headerMap.forEach((key, value) -> {
    278.             httpPost.setHeader(key, value.toString());
    279.         });
    280.         try {
    281.             response = httpClient().execute(httpPost);
    282.             HttpEntity entity = response.getEntity();
    283.             if (entity != null) {
    284.                 result = EntityUtils.toString(entity, charset);
    285.             }
    286.         } catch (Exception e) {
    287.             log.error("execute post request error", e);
    288.         } finally {
    289.             close(response);
    290.         }
    291.         return result;
    292.     }
    293.  
    294.     /**
    295.      * HTTP Put:Form表单方式带参数
    296.      * Content-type:application/x-www-form-urlencoded; charset=UTF-8
    297.      *
    298.      * @param url url
    299.      * @param headerMap headerMap
    300.      * @param paramMap paramMap
    301.      * @return String
    302.      */
    303.     public static String doPut(String url, Map headerMap, Map paramMap) {
    304.         HttpPut httpPut = new HttpPut(url);
    305.         String result = null;
    306.         CloseableHttpResponse response = null;
    307.         List parameters = new ArrayList<>();
    308.         if (MapUtils.isNotEmpty(paramMap)) {
    309.             for (Map.Entry entry : paramMap.entrySet()) {
    310.                 parameters.add(new BasicNameValuePair(entry.getKey(), entry.getValue().toString()));
    311.             }
    312.         }
    313.         UrlEncodedFormEntity entity = new UrlEncodedFormEntity(parameters, StandardCharsets.UTF_8);
    314.         httpPut.setEntity(entity);
    315.         headerMap.forEach((key, value) -> {
    316.             httpPut.setHeader(key, value.toString());
    317.         });
    318.         try {
    319.             response = httpClient().execute(httpPut);
    320.             int code = response.getStatusLine().getStatusCode();
    321.             if (response.getEntity() != null) {
    322.                 result = EntityUtils.toString(response.getEntity(), StandardCharsets.UTF_8);
    323.             }
    324.         } catch (IOException e) {
    325.             log.error("io error", e);
    326.         } catch (Exception e) {
    327.             log.error("execute put request error", e);
    328.         } finally {
    329.             close(response);
    330.         }
    331.         return result;
    332.     }
    333.  
    334.     /**
    335.      * Http Delete:不带参数的表单形式
    336.      * Content-type:application/x-www-form-urlencoded; charset=UTF-8
    337.      * @param url url
    338.      * @param headerMap headerMap
    339.      * @param paramMap paramMap
    340.      * @return String
    341.      */
    342.     public static String doDelete(String url, Map headerMap, Map paramMap) {
    343.         URIBuilder uriBuilder = null;
    344.         String result = null;
    345.         CloseableHttpResponse response = null;
    346.         try {
    347.             uriBuilder = new URIBuilder(url);
    348.             if (MapUtils.isNotEmpty(paramMap)) {
    349.                 for (Map.Entry entry : paramMap.entrySet()) {
    350.                     uriBuilder.setParameter(entry.getKey(), entry.getValue().toString());
    351.                 }
    352.             }
    353.             HttpDelete httpDelete = new HttpDelete(uriBuilder.build());
    354.             headerMap.forEach((key, value) -> {
    355.                 httpDelete.setHeader(key, value.toString());
    356.             });
    357.             response = httpClient().execute(httpDelete);
    358.             int code = response.getStatusLine().getStatusCode();
    359.             if (Objects.nonNull(response.getEntity())) {
    360.                 result = EntityUtils.toString(response.getEntity(), StandardCharsets.UTF_8);
    361.             }
    362.         } catch (URISyntaxException e) {
    363.             log.error("url synctax error", e);
    364.         } catch (Exception e) {
    365.             log.error("execute post request error", e);
    366.         } finally {
    367.             close(response);
    368.         }
    369.         return result;
    370.     }
    371.  
    372.     public static RestClient getInstance() {
    373.         return INSTANCE;
    374.     }
    375.  
    376.     /**
    377.      * 忽略证书验证的CloseableHttpClient对象,适配Http/Https
    378.      *
    379.      * @return CloseableHttpClient
    380.      */
    381.     public static CloseableHttpClient httpClient() {
    382.         CloseableHttpClient closeableHttpClient = null;
    383.         try {
    384.             SSLContext sc = SSLContext.getInstance("SSL");
    385.             sc.init(null, getTrustingManager(), new java.security.SecureRandom());
    386.             // 使用上面的策略初始化上下文
    387.             SSLConnectionSocketFactory socketFactory = new SSLConnectionSocketFactory(sc,
    388.                     new String[]{"SSLv3", "TLSv1", "TLSv1.1", "TLSv1.2"}, null, NoopHostnameVerifier.INSTANCE);
    389.             closeableHttpClient = HttpClients.custom()
    390.                     // 设置超时时间
    391.                     .setDefaultRequestConfig(getRequestConfig())
    392.                     // 设置连接池
    393.                     .setConnectionManager(getPoolingManager())
    394.                     // 设置重试策略,框架层面重试,可以在业务层面重试
    395.                     //.setRetryHandler(getRetryHandler())
    396.                     .setRetryHandler(new DefaultHttpRequestRetryHandler(0, false))
    397.                     // 连接池清理过期连接
    398.                     .evictExpiredConnections()
    399.                     // 连接池释放空闲连接
    400.                     .evictIdleConnections(60, TimeUnit.SECONDS)
    401.                     .build();
    402.         } catch (KeyManagementException e) {
    403.             log.error("KeyManagement error", e);
    404.         } catch (NoSuchAlgorithmException e) {
    405.             log.error("No Such Algorithm error", e);
    406.         }
    407.         return closeableHttpClient;
    408.     }
    409.  
    410.     /**
    411.      * 信任所有证书
    412.      *
    413.      * @return TrustManager[]
    414.      */
    415.     private static TrustManager[] getTrustingManager() {
    416.         TrustManager[] trustAllCerts = new TrustManager[]{new X509TrustManager() {
    417.             @Override
    418.             public void checkClientTrusted(java.security.cert.X509Certificate[] x509Certificates, String s) throws CertificateException {
    419.             }
    420.             @Override
    421.             public void checkServerTrusted(java.security.cert.X509Certificate[] x509Certificates, String s) throws CertificateException {
    422.             }
    423.             @Override
    424.             public java.security.cert.X509Certificate[] getAcceptedIssuers() {
    425.                 return null;
    426.             }
    427.         }};
    428.         return trustAllCerts;
    429.     }
    430.  
    431.     /**
    432.      * Http连接池配置
    433.      *
    434.      * @return HttpClientConnectionManager
    435.      */
    436.     public static HttpClientConnectionManager getPoolingManager() throws NoSuchAlgorithmException, KeyManagementException {
    437.         SSLContext sslContext = SSLContext.getInstance("TLSv1.2");
    438.         sslContext.init(null, null, null);
    439.         SSLContext.setDefault(sslContext);
    440.         Registry socketFactoryRegistry =
    441.                 RegistryBuilder.create()
    442.                         .register("http", PlainConnectionSocketFactory.INSTANCE)
    443.                         .register("https", new SSLConnectionSocketFactory(sslContext)).build();
    444.         PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
    445.         // 设置整个连接池最大连接数
    446.         connectionManager.setMaxTotal(200);
    447.         // 最大路由
    448.         connectionManager.setDefaultMaxPerRoute(10);
    449.         return connectionManager;
    450.     }
    451.  
    452.     /**
    453.      * 封装RequestConfig
    454.      *
    455.      * @return RequestConfig
    456.      */
    457.     public static RequestConfig getRequestConfig() {
    458.         RequestConfig requestConfig = RequestConfig.custom().
    459.                 setConnectTimeout(getConnectionTime()).
    460.                 setConnectionRequestTimeout(getConnectionRequestTime())
    461.                 .setSocketTimeout(getSocketTime()).build();
    462.         return requestConfig;
    463.     }
    464.  
    465.     /**
    466.      * HttpClient的重试策略
    467.      *
    468.      * @return HttpRequestRetryHandler
    469.      */
    470.     public static HttpRequestRetryHandler getRetryHandler() {
    471.         HttpRequestRetryHandler retryHandler = new HttpRequestRetryHandler() {
    472.             public boolean retryRequest(
    473.                     IOException exception,
    474.                     int executionCount,
    475.                     HttpContext context) {
    476.                 // 重试三次
    477.                 if (executionCount >= RETRY) {
    478.                     return false;
    479.                 }
    480.                 if (exception instanceof InterruptedIOException) {
    481.                     // 超时
    482.                     return false;
    483.                 }
    484.                 if (exception instanceof UnknownHostException) {
    485.                     // 目标服务器不可达
    486.                     return false;
    487.                 }
    488.                 if (exception instanceof ConnectTimeoutException) {
    489.                     // 连接被拒绝
    490.                     return false;
    491.                 }
    492.                 if (exception instanceof SSLException) {
    493.                     // SSL握手异常
    494.                     return false;
    495.                 }
    496.                 HttpClientContext clientContext = HttpClientContext.adapt(context);
    497.                 HttpRequest request = clientContext.getRequest();
    498.                 boolean idempotent = !(request instanceof HttpEntityEnclosingRequest);
    499.                 if (idempotent) {
    500.                     // 如果请求是幂等的,就再次尝试
    501.                     return true;
    502.                 }
    503.                 return false;
    504.             }
    505.         };
    506.         return retryHandler;
    507.     }
    508.  
    509.     public static Integer getConnectionTime() {
    510.         return CONNECTION_TIME;
    511.     }
    512.  
    513.     public static Integer getConnectionRequestTime() {
    514.         return CONNECTION_REQUEST_TIME;
    515.     }
    516.  
    517.     public static Integer getSocketTime() {
    518.         return SOCKET_TIME;
    519.     }
    520.  
    521.     /**
    522.      * 校验url,支持扩展
    523.      *
    524.      * @param url
    525.      */
    526.     private static void checkUrl(String url) {
    527.         if (StringUtils.isBlank(url)) {
    528.             log.error("rest client request url not null");
    529.             throw new GlobalException("rest client request url not null");
    530.         }
    531.     }
    532.  
    533.     /**
    534.      * 校验Header,支持扩展
    535.      *
    536.      * @param headerMap
    537.      */
    538.     private static void checkHeader(Map headerMap) {
    539.         if (MapUtils.isEmpty(headerMap)) {
    540.             log.error("rest client request header not null");
    541.             throw new GlobalException("rest client request header not null");
    542.         }
    543.     }
    544.  
    545.     /**
    546.      * 校验Body,支持扩展
    547.      *
    548.      * @param bodyMap
    549.      */
    550.     private static void checkBody(Map bodyMap) {
    551.         if (MapUtils.isEmpty(bodyMap)) {
    552.             log.error("rest client request param map  not null");
    553.             throw new GlobalException("rest client request map  not null");
    554.         }
    555.     }
    556.  
    557.     /**
    558.      * 关闭流资源
    559.      *
    560.      * @param closeable
    561.      */
    562.     private static void close(Closeable closeable) {
    563.         try {
    564.             closeable.close();
    565.         } catch (IOException e) {
    566.             log.error("close error", e);
    567.         }
    568.     }

    四、测试请求

    ①、Http+Get无参数

    1.         String url="http://test.code.com/skywalk/test/log/filter";
    2.         Map headerMap = new HashMap<>();
    3.         headerMap.put("Content-type", "application/json; charset=utf-8");
    4.         headerMap.put("Accept", "application/json");
    5.         String string = RestClient.getInstance().get(url, headerMap);
    6.         System.out.println(string);

     ②、Https接口+Post表单

    这里调用阿里云接口手机号码+IP归属地Https接口为例【云厂商目前都提供一些免费的Https接口供测试使用的，非常方便，这里使用AppCode鉴权】

    1.         String url = "https://jmipquery3.market.alicloudapi.com/ip/query-v3/";
    2.         Map headerMap = new HashMap<>();
    3.         headerMap.put("Content-type", "application/x-www-form-urlencoded; charset=UTF-8");
    4.         headerMap.put("Accept", "application/json");
    5.         headerMap.put("Authorization", "APPCODE 你的code");
    6.         Map bodyMap = new HashMap<>();
    7.         bodyMap.put("ip", "117.173.222.90");
    8.         String string = RestClient.getInstance().post(url, headerMap, bodyMap);
    9.         System.out.println(string);

     ③、Https接口+Get带参数

    1.         String url = "https://api04.aliyun.venuscn.com/mobile";
    2.         Map headerMap = new HashMap<>();
    3.         Map bodyMap = new HashMap<>();
    4.         headerMap.put("Content-type", "text/html; charset=utf-8");
    5.         headerMap.put("Accept", "application/json");
    6.         headerMap.put("Authorization", "APPCODE 你的code");
    7.         bodyMap.put("mobile", "18138434699");

     

    关于重试说明：

    ①、不重试写法:

    setRetryHandler(new DefaultHttpRequestRetryHandler(0, false))

    ②、默认是重试三次

    1.     public DefaultHttpRequestRetryHandler() {
    2.         this(3, false);
    3.     }

      ③、自定义重试策略，哪些异常需要，哪些异常不需要.

    1.     public static HttpRequestRetryHandler getRetryHandler() {
    2.         HttpRequestRetryHandler retryHandler = new HttpRequestRetryHandler() {
    3.             public boolean retryRequest(
    4.                     IOException exception,
    5.                     int executionCount,
    6.                     HttpContext context) {
    7.                 // 重试三次
    8.                 if (executionCount >= RETRY) {
    9.                     return false;
    10.                 }
    11.                 if (exception instanceof InterruptedIOException) {
    12.                     // 超时
    13.                     return false;
    14.                 }
    15.                 if (exception instanceof UnknownHostException) {
    16.                     // 目标服务器不可达
    17.                     return false;
    18.                 }
    19.                 if (exception instanceof ConnectTimeoutException) {
    20.                     // 连接被拒绝
    21.                     return false;
    22.                 }
    23.                 if (exception instanceof SSLException) {
    24.                     // SSL握手异常
    25.                     return false;
    26.                 }
    27.                 HttpClientContext clientContext = HttpClientContext.adapt(context);
    28.                 HttpRequest request = clientContext.getRequest();
    29.                 boolean idempotent = !(request instanceof HttpEntityEnclosingRequest);
    30.                 if (idempotent) {
    31.                     // 如果请求是幂等的,就再次尝试
    32.                     return true;
    33.                 }
    34.                 return false;
    35.             }
    36.         };
    37.         return retryHandler;
    38.     }

    ④、业务层调用可以使用函数式接口或者while循环重试调用三次.

    更多业务参数参考这篇博客：HttpClient专题

    【附录HttpStatus】

     ①、Apache下HttpClient的HttpStatus。

    1. package org.apache.http;
    2.  
    3. /**
    4.  * Constants enumerating the HTTP status codes.
    5.  * All status codes defined in RFC1945 (HTTP/1.0), RFC2616 (HTTP/1.1), and
    6.  * RFC2518 (WebDAV) are listed.
    7.  *
    8.  * @see StatusLine
    9.  * @see RFC1945 (HTTP/1.0)
    10.  * @see RFC2616 (HTTP/1.1)
    11.  * @see RFC2518 (WebDAV)
    12.  * @since 4.0
    13.  */
    14. public interface HttpStatus {
    15.  
    16.     // --- 1xx Informational ---
    17.  
    18.     /** {@code 100 Continue} (HTTP/1.1 - RFC 2616) */
    19.     int SC_CONTINUE = 100;
    20.     /** {@code 101 Switching Protocols} (HTTP/1.1 - RFC 2616)*/
    21.     int SC_SWITCHING_PROTOCOLS = 101;
    22.     /** {@code 102 Processing} (WebDAV - RFC 2518) */
    23.     int SC_PROCESSING = 102;
    24.  
    25.     // --- 2xx Success ---
    26.  
    27.     /** {@code 200 OK} (HTTP/1.0 - RFC 1945) */
    28.     int SC_OK = 200;
    29.     /** {@code 201 Created} (HTTP/1.0 - RFC 1945) */
    30.     int SC_CREATED = 201;
    31.     /** {@code 202 Accepted} (HTTP/1.0 - RFC 1945) */
    32.     int SC_ACCEPTED = 202;
    33.     /** {@code 203 Non Authoritative Information} (HTTP/1.1 - RFC 2616) */
    34.     int SC_NON_AUTHORITATIVE_INFORMATION = 203;
    35.     /** {@code 204 No Content} (HTTP/1.0 - RFC 1945) */
    36.     int SC_NO_CONTENT = 204;
    37.     /** {@code 205 Reset Content} (HTTP/1.1 - RFC 2616) */
    38.     int SC_RESET_CONTENT = 205;
    39.     /** {@code 206 Partial Content} (HTTP/1.1 - RFC 2616) */
    40.     int SC_PARTIAL_CONTENT = 206;
    41.     /**
    42.      * {@code 207 Multi-Status} (WebDAV - RFC 2518)
    43.      * or
    44.      * {@code 207 Partial Update OK} (HTTP/1.1 - draft-ietf-http-v11-spec-rev-01?)
    45.      */
    46.     int SC_MULTI_STATUS = 207;
    47.  
    48.     // --- 3xx Redirection ---
    49.  
    50.     /** {@code 300 Mutliple Choices} (HTTP/1.1 - RFC 2616) */
    51.     int SC_MULTIPLE_CHOICES = 300;
    52.     /** {@code 301 Moved Permanently} (HTTP/1.0 - RFC 1945) */
    53.     int SC_MOVED_PERMANENTLY = 301;
    54.     /** {@code 302 Moved Temporarily} (Sometimes {@code Found}) (HTTP/1.0 - RFC 1945) */
    55.     int SC_MOVED_TEMPORARILY = 302;
    56.     /** {@code 303 See Other} (HTTP/1.1 - RFC 2616) */
    57.     int SC_SEE_OTHER = 303;
    58.     /** {@code 304 Not Modified} (HTTP/1.0 - RFC 1945) */
    59.     int SC_NOT_MODIFIED = 304;
    60.     /** {@code 305 Use Proxy} (HTTP/1.1 - RFC 2616) */
    61.     int SC_USE_PROXY = 305;
    62.     /** {@code 307 Temporary Redirect} (HTTP/1.1 - RFC 2616) */
    63.     int SC_TEMPORARY_REDIRECT = 307;
    64.  
    65.     // --- 4xx Client Error ---
    66.  
    67.     /** {@code 400 Bad Request} (HTTP/1.1 - RFC 2616) */
    68.     int SC_BAD_REQUEST = 400;
    69.     /** {@code 401 Unauthorized} (HTTP/1.0 - RFC 1945) */
    70.     int SC_UNAUTHORIZED = 401;
    71.     /** {@code 402 Payment Required} (HTTP/1.1 - RFC 2616) */
    72.     int SC_PAYMENT_REQUIRED = 402;
    73.     /** {@code 403 Forbidden} (HTTP/1.0 - RFC 1945) */
    74.     int SC_FORBIDDEN = 403;
    75.     /** {@code 404 Not Found} (HTTP/1.0 - RFC 1945) */
    76.     int SC_NOT_FOUND = 404;
    77.     /** {@code 405 Method Not Allowed} (HTTP/1.1 - RFC 2616) */
    78.     int SC_METHOD_NOT_ALLOWED = 405;
    79.     /** {@code 406 Not Acceptable} (HTTP/1.1 - RFC 2616) */
    80.     int SC_NOT_ACCEPTABLE = 406;
    81.     /** {@code 407 Proxy Authentication Required} (HTTP/1.1 - RFC 2616)*/
    82.     int SC_PROXY_AUTHENTICATION_REQUIRED = 407;
    83.     /** {@code 408 Request Timeout} (HTTP/1.1 - RFC 2616) */
    84.     int SC_REQUEST_TIMEOUT = 408;
    85.     /** {@code 409 Conflict} (HTTP/1.1 - RFC 2616) */
    86.     int SC_CONFLICT = 409;
    87.     /** {@code 410 Gone} (HTTP/1.1 - RFC 2616) */
    88.     int SC_GONE = 410;
    89.     /** {@code 411 Length Required} (HTTP/1.1 - RFC 2616) */
    90.     int SC_LENGTH_REQUIRED = 411;
    91.     /** {@code 412 Precondition Failed} (HTTP/1.1 - RFC 2616) */
    92.     int SC_PRECONDITION_FAILED = 412;
    93.     /** {@code 413 Request Entity Too Large} (HTTP/1.1 - RFC 2616) */
    94.     int SC_REQUEST_TOO_LONG = 413;
    95.     /** {@code 414 Request-URI Too Long} (HTTP/1.1 - RFC 2616) */
    96.     int SC_REQUEST_URI_TOO_LONG = 414;
    97.     /** {@code 415 Unsupported Media Type} (HTTP/1.1 - RFC 2616) */
    98.     int SC_UNSUPPORTED_MEDIA_TYPE = 415;
    99.     /** {@code 416 Requested Range Not Satisfiable} (HTTP/1.1 - RFC 2616) */
    100.     int SC_REQUESTED_RANGE_NOT_SATISFIABLE = 416;
    101.     /** {@code 417 Expectation Failed} (HTTP/1.1 - RFC 2616) */
    102.     int SC_EXPECTATION_FAILED = 417;
    103.  
    104.     /**
    105.      * Static constant for a 418 error.
    106.      * {@code 418 Unprocessable Entity} (WebDAV drafts?)
    107.      * or {@code 418 Reauthentication Required} (HTTP/1.1 drafts?)
    108.      */
    109.     // not used
    110.     // public static final int SC_UNPROCESSABLE_ENTITY = 418;
    111.  
    112.     /**
    113.      * Static constant for a 419 error.
    114.      * {@code 419 Insufficient Space on Resource}
    115.      * (WebDAV - draft-ietf-webdav-protocol-05?)
    116.      * or {@code 419 Proxy Reauthentication Required}
    117.      * (HTTP/1.1 drafts?)
    118.      */
    119.     int SC_INSUFFICIENT_SPACE_ON_RESOURCE = 419;
    120.     /**
    121.      * Static constant for a 420 error.
    122.      * {@code 420 Method Failure}
    123.      * (WebDAV - draft-ietf-webdav-protocol-05?)
    124.      */
    125.     int SC_METHOD_FAILURE = 420;
    126.     /** {@code 422 Unprocessable Entity} (WebDAV - RFC 2518) */
    127.     int SC_UNPROCESSABLE_ENTITY = 422;
    128.     /** {@code 423 Locked} (WebDAV - RFC 2518) */
    129.     int SC_LOCKED = 423;
    130.     /** {@code 424 Failed Dependency} (WebDAV - RFC 2518) */
    131.     int SC_FAILED_DEPENDENCY = 424;
    132.     /** {@code 429 Too Many Requests} (Additional HTTP Status Codes - RFC 6585) */
    133.     int SC_TOO_MANY_REQUESTS = 429;
    134.  
    135.     // --- 5xx Server Error ---
    136.  
    137.     /** {@code 500 Server Error} (HTTP/1.0 - RFC 1945) */
    138.     int SC_INTERNAL_SERVER_ERROR = 500;
    139.     /** {@code 501 Not Implemented} (HTTP/1.0 - RFC 1945) */
    140.     int SC_NOT_IMPLEMENTED = 501;
    141.     /** {@code 502 Bad Gateway} (HTTP/1.0 - RFC 1945) */
    142.     int SC_BAD_GATEWAY = 502;
    143.     /** {@code 503 Service Unavailable} (HTTP/1.0 - RFC 1945) */
    144.     int SC_SERVICE_UNAVAILABLE = 503;
    145.     /** {@code 504 Gateway Timeout} (HTTP/1.1 - RFC 2616) */
    146.     int SC_GATEWAY_TIMEOUT = 504;
    147.     /** {@code 505 HTTP Version Not Supported} (HTTP/1.1 - RFC 2616) */
    148.     int SC_HTTP_VERSION_NOT_SUPPORTED = 505;
    149.  
    150.     /** {@code 507 Insufficient Storage} (WebDAV - RFC 2518) */
    151.     int SC_INSUFFICIENT_STORAGE = 507;
    152.  
    153. }

     ②、Spring框架的HttpStatus。

    1. package org.springframework.http;
    2.  
    3. import org.springframework.lang.Nullable;
    4.  
    5. /**
    6.  * Enumeration of HTTP status codes.
    7.  *
    8.  * 
      The HTTP status code series can be retrieved via {@link #series()}.
    9.  *
    10.  * @author Arjen Poutsma
    11.  * @author Sebastien Deleuze
    12.  * @author Brian Clozel
    13.  * @since 3.0
    14.  * @see HttpStatus.Series
    15.  * @see HTTP Status Code Registry
    16.  * @see List of HTTP status codes - Wikipedia
    17.  */
    18. public enum HttpStatus {
    19.  
    20. 	// 1xx Informational
    21.  
    22. 	/**
    23. 	 * {@code 100 Continue}.
    24. 	 * @see HTTP/1.1: Semantics and Content, section 6.2.1
    25. 	 */
    26. 	CONTINUE(100, Series.INFORMATIONAL, "Continue"),
    27. 	/**
    28. 	 * {@code 101 Switching Protocols}.
    29. 	 * @see HTTP/1.1: Semantics and Content, section 6.2.2
    30. 	 */
    31. 	SWITCHING_PROTOCOLS(101, Series.INFORMATIONAL, "Switching Protocols"),
    32. 	/**
    33. 	 * {@code 102 Processing}.
    34. 	 * @see WebDAV
    35. 	 */
    36. 	PROCESSING(102, Series.INFORMATIONAL, "Processing"),
    37. 	/**
    38. 	 * {@code 103 Checkpoint}.
    39. 	 * @see A proposal for supporting
    40. 	 * resumable POST/PUT HTTP requests in HTTP/1.0
    41. 	 */
    42. 	CHECKPOINT(103, Series.INFORMATIONAL, "Checkpoint"),
    43.  
    44. 	// 2xx Success
    45.  
    46. 	/**
    47. 	 * {@code 200 OK}.
    48. 	 * @see HTTP/1.1: Semantics and Content, section 6.3.1
    49. 	 */
    50. 	OK(200, Series.SUCCESSFUL, "OK"),
    51. 	/**
    52. 	 * {@code 201 Created}.
    53. 	 * @see HTTP/1.1: Semantics and Content, section 6.3.2
    54. 	 */
    55. 	CREATED(201, Series.SUCCESSFUL, "Created"),
    56. 	/**
    57. 	 * {@code 202 Accepted}.
    58. 	 * @see HTTP/1.1: Semantics and Content, section 6.3.3
    59. 	 */
    60. 	ACCEPTED(202, Series.SUCCESSFUL, "Accepted"),
    61. 	/**
    62. 	 * {@code 203 Non-Authoritative Information}.
    63. 	 * @see HTTP/1.1: Semantics and Content, section 6.3.4
    64. 	 */
    65. 	NON_AUTHORITATIVE_INFORMATION(203, Series.SUCCESSFUL, "Non-Authoritative Information"),
    66. 	/**
    67. 	 * {@code 204 No Content}.
    68. 	 * @see HTTP/1.1: Semantics and Content, section 6.3.5
    69. 	 */
    70. 	NO_CONTENT(204, Series.SUCCESSFUL, "No Content"),
    71. 	/**
    72. 	 * {@code 205 Reset Content}.
    73. 	 * @see HTTP/1.1: Semantics and Content, section 6.3.6
    74. 	 */
    75. 	RESET_CONTENT(205, Series.SUCCESSFUL, "Reset Content"),
    76. 	/**
    77. 	 * {@code 206 Partial Content}.
    78. 	 * @see HTTP/1.1: Range Requests, section 4.1
    79. 	 */
    80. 	PARTIAL_CONTENT(206, Series.SUCCESSFUL, "Partial Content"),
    81. 	/**
    82. 	 * {@code 207 Multi-Status}.
    83. 	 * @see WebDAV
    84. 	 */
    85. 	MULTI_STATUS(207, Series.SUCCESSFUL, "Multi-Status"),
    86. 	/**
    87. 	 * {@code 208 Already Reported}.
    88. 	 * @see WebDAV Binding Extensions
    89. 	 */
    90. 	ALREADY_REPORTED(208, Series.SUCCESSFUL, "Already Reported"),
    91. 	/**
    92. 	 * {@code 226 IM Used}.
    93. 	 * @see Delta encoding in HTTP
    94. 	 */
    95. 	IM_USED(226, Series.SUCCESSFUL, "IM Used"),
    96.  
    97. 	// 3xx Redirection
    98.  
    99. 	/**
    100. 	 * {@code 300 Multiple Choices}.
    101. 	 * @see HTTP/1.1: Semantics and Content, section 6.4.1
    102. 	 */
    103. 	MULTIPLE_CHOICES(300, Series.REDIRECTION, "Multiple Choices"),
    104. 	/**
    105. 	 * {@code 301 Moved Permanently}.
    106. 	 * @see HTTP/1.1: Semantics and Content, section 6.4.2
    107. 	 */
    108. 	MOVED_PERMANENTLY(301, Series.REDIRECTION, "Moved Permanently"),
    109. 	/**
    110. 	 * {@code 302 Found}.
    111. 	 * @see HTTP/1.1: Semantics and Content, section 6.4.3
    112. 	 */
    113. 	FOUND(302, Series.REDIRECTION, "Found"),
    114. 	/**
    115. 	 * {@code 302 Moved Temporarily}.
    116. 	 * @see HTTP/1.0, section 9.3
    117. 	 * @deprecated in favor of {@link #FOUND} which will be returned from {@code HttpStatus.valueOf(302)}
    118. 	 */
    119. 	@Deprecated
    120. 	MOVED_TEMPORARILY(302, Series.REDIRECTION, "Moved Temporarily"),
    121. 	/**
    122. 	 * {@code 303 See Other}.
    123. 	 * @see HTTP/1.1: Semantics and Content, section 6.4.4
    124. 	 */
    125. 	SEE_OTHER(303, Series.REDIRECTION, "See Other"),
    126. 	/**
    127. 	 * {@code 304 Not Modified}.
    128. 	 * @see HTTP/1.1: Conditional Requests, section 4.1
    129. 	 */
    130. 	NOT_MODIFIED(304, Series.REDIRECTION, "Not Modified"),
    131. 	/**
    132. 	 * {@code 305 Use Proxy}.
    133. 	 * @see HTTP/1.1: Semantics and Content, section 6.4.5
    134. 	 * @deprecated due to security concerns regarding in-band configuration of a proxy
    135. 	 */
    136. 	@Deprecated
    137. 	USE_PROXY(305, Series.REDIRECTION, "Use Proxy"),
    138. 	/**
    139. 	 * {@code 307 Temporary Redirect}.
    140. 	 * @see HTTP/1.1: Semantics and Content, section 6.4.7
    141. 	 */
    142. 	TEMPORARY_REDIRECT(307, Series.REDIRECTION, "Temporary Redirect"),
    143. 	/**
    144. 	 * {@code 308 Permanent Redirect}.
    145. 	 * @see RFC 7238
    146. 	 */
    147. 	PERMANENT_REDIRECT(308, Series.REDIRECTION, "Permanent Redirect"),
    148.  
    149. 	// --- 4xx Client Error ---
    150.  
    151. 	/**
    152. 	 * {@code 400 Bad Request}.
    153. 	 * @see HTTP/1.1: Semantics and Content, section 6.5.1
    154. 	 */
    155. 	BAD_REQUEST(400, Series.CLIENT_ERROR, "Bad Request"),
    156. 	/**
    157. 	 * {@code 401 Unauthorized}.
    158. 	 * @see HTTP/1.1: Authentication, section 3.1
    159. 	 */
    160. 	UNAUTHORIZED(401, Series.CLIENT_ERROR, "Unauthorized"),
    161. 	/**
    162. 	 * {@code 402 Payment Required}.
    163. 	 * @see HTTP/1.1: Semantics and Content, section 6.5.2
    164. 	 */
    165. 	PAYMENT_REQUIRED(402, Series.CLIENT_ERROR, "Payment Required"),
    166. 	/**
    167. 	 * {@code 403 Forbidden}.
    168. 	 * @see HTTP/1.1: Semantics and Content, section 6.5.3
    169. 	 */
    170. 	FORBIDDEN(403, Series.CLIENT_ERROR, "Forbidden"),
    171. 	/**
    172. 	 * {@code 404 Not Found}.
    173. 	 * @see HTTP/1.1: Semantics and Content, section 6.5.4
    174. 	 */
    175. 	NOT_FOUND(404, Series.CLIENT_ERROR, "Not Found"),
    176. 	/**
    177. 	 * {@code 405 Method Not Allowed}.
    178. 	 * @see HTTP/1.1: Semantics and Content, section 6.5.5
    179. 	 */
    180. 	METHOD_NOT_ALLOWED(405, Series.CLIENT_ERROR, "Method Not Allowed"),
    181. 	/**
    182. 	 * {@code 406 Not Acceptable}.
    183. 	 * @see HTTP/1.1: Semantics and Content, section 6.5.6
    184. 	 */
    185. 	NOT_ACCEPTABLE(406, Series.CLIENT_ERROR, "Not Acceptable"),
    186. 	/**
    187. 	 * {@code 407 Proxy Authentication Required}.
    188. 	 * @see HTTP/1.1: Authentication, section 3.2
    189. 	 */
    190. 	PROXY_AUTHENTICATION_REQUIRED(407, Series.CLIENT_ERROR, "Proxy Authentication Required"),
    191. 	/**
    192. 	 * {@code 408 Request Timeout}.
    193. 	 * @see HTTP/1.1: Semantics and Content, section 6.5.7
    194. 	 */
    195. 	REQUEST_TIMEOUT(408, Series.CLIENT_ERROR, "Request Timeout"),
    196. 	/**
    197. 	 * {@code 409 Conflict}.
    198. 	 * @see HTTP/1.1: Semantics and Content, section 6.5.8
    199. 	 */
    200. 	CONFLICT(409, Series.CLIENT_ERROR, "Conflict"),
    201. 	/**
    202. 	 * {@code 410 Gone}.
    203. 	 * @see 
    204. 	 *     HTTP/1.1: Semantics and Content, section 6.5.9
    205. 	 */
    206. 	GONE(410, Series.CLIENT_ERROR, "Gone"),
    207. 	/**
    208. 	 * {@code 411 Length Required}.
    209. 	 * @see 
    210. 	 *     HTTP/1.1: Semantics and Content, section 6.5.10
    211. 	 */
    212. 	LENGTH_REQUIRED(411, Series.CLIENT_ERROR, "Length Required"),
    213. 	/**
    214. 	 * {@code 412 Precondition failed}.
    215. 	 * @see 
    216. 	 *     HTTP/1.1: Conditional Requests, section 4.2
    217. 	 */
    218. 	PRECONDITION_FAILED(412, Series.CLIENT_ERROR, "Precondition Failed"),
    219. 	/**
    220. 	 * {@code 413 Payload Too Large}.
    221. 	 * @since 4.1
    222. 	 * @see 
    223. 	 *     HTTP/1.1: Semantics and Content, section 6.5.11
    224. 	 */
    225. 	PAYLOAD_TOO_LARGE(413, Series.CLIENT_ERROR, "Payload Too Large"),
    226. 	/**
    227. 	 * {@code 413 Request Entity Too Large}.
    228. 	 * @see HTTP/1.1, section 10.4.14
    229. 	 * @deprecated in favor of {@link #PAYLOAD_TOO_LARGE} which will be
    230. 	 * returned from {@code HttpStatus.valueOf(413)}
    231. 	 */
    232. 	@Deprecated
    233. 	REQUEST_ENTITY_TOO_LARGE(413, Series.CLIENT_ERROR, "Request Entity Too Large"),
    234. 	/**
    235. 	 * {@code 414 URI Too Long}.
    236. 	 * @since 4.1
    237. 	 * @see 
    238. 	 *     HTTP/1.1: Semantics and Content, section 6.5.12
    239. 	 */
    240. 	URI_TOO_LONG(414, Series.CLIENT_ERROR, "URI Too Long"),
    241. 	/**
    242. 	 * {@code 414 Request-URI Too Long}.
    243. 	 * @see HTTP/1.1, section 10.4.15
    244. 	 * @deprecated in favor of {@link #URI_TOO_LONG} which will be returned from {@code HttpStatus.valueOf(414)}
    245. 	 */
    246. 	@Deprecated
    247. 	REQUEST_URI_TOO_LONG(414, Series.CLIENT_ERROR, "Request-URI Too Long"),
    248. 	/**
    249. 	 * {@code 415 Unsupported Media Type}.
    250. 	 * @see 
    251. 	 *     HTTP/1.1: Semantics and Content, section 6.5.13
    252. 	 */
    253. 	UNSUPPORTED_MEDIA_TYPE(415, Series.CLIENT_ERROR, "Unsupported Media Type"),
    254. 	/**
    255. 	 * {@code 416 Requested Range Not Satisfiable}.
    256. 	 * @see HTTP/1.1: Range Requests, section 4.4
    257. 	 */
    258. 	REQUESTED_RANGE_NOT_SATISFIABLE(416, Series.CLIENT_ERROR, "Requested range not satisfiable"),
    259. 	/**
    260. 	 * {@code 417 Expectation Failed}.
    261. 	 * @see 
    262. 	 *     HTTP/1.1: Semantics and Content, section 6.5.14
    263. 	 */
    264. 	EXPECTATION_FAILED(417, Series.CLIENT_ERROR, "Expectation Failed"),
    265. 	/**
    266. 	 * {@code 418 I'm a teapot}.
    267. 	 * @see HTCPCP/1.0
    268. 	 */
    269. 	I_AM_A_TEAPOT(418, Series.CLIENT_ERROR, "I'm a teapot"),
    270. 	/**
    271. 	 * @deprecated See
    272. 	 * 
    273. 	 *     WebDAV Draft Changes
    274. 	 */
    275. 	@Deprecated
    276. 	INSUFFICIENT_SPACE_ON_RESOURCE(419, Series.CLIENT_ERROR, "Insufficient Space On Resource"),
    277. 	/**
    278. 	 * @deprecated See
    279. 	 * 
    280. 	 *     WebDAV Draft Changes
    281. 	 */
    282. 	@Deprecated
    283. 	METHOD_FAILURE(420, Series.CLIENT_ERROR, "Method Failure"),
    284. 	/**
    285. 	 * @deprecated
    286. 	 * See 
    287. 	 *     WebDAV Draft Changes
    288. 	 */
    289. 	@Deprecated
    290. 	DESTINATION_LOCKED(421, Series.CLIENT_ERROR, "Destination Locked"),
    291. 	/**
    292. 	 * {@code 422 Unprocessable Entity}.
    293. 	 * @see WebDAV
    294. 	 */
    295. 	UNPROCESSABLE_ENTITY(422, Series.CLIENT_ERROR, "Unprocessable Entity"),
    296. 	/**
    297. 	 * {@code 423 Locked}.
    298. 	 * @see WebDAV
    299. 	 */
    300. 	LOCKED(423, Series.CLIENT_ERROR, "Locked"),
    301. 	/**
    302. 	 * {@code 424 Failed Dependency}.
    303. 	 * @see WebDAV
    304. 	 */
    305. 	FAILED_DEPENDENCY(424, Series.CLIENT_ERROR, "Failed Dependency"),
    306. 	/**
    307. 	 * {@code 425 Too Early}.
    308. 	 * @since 5.2
    309. 	 * @see RFC 8470
    310. 	 */
    311. 	TOO_EARLY(425, Series.CLIENT_ERROR, "Too Early"),
    312. 	/**
    313. 	 * {@code 426 Upgrade Required}.
    314. 	 * @see Upgrading to TLS Within HTTP/1.1
    315. 	 */
    316. 	UPGRADE_REQUIRED(426, Series.CLIENT_ERROR, "Upgrade Required"),
    317. 	/**
    318. 	 * {@code 428 Precondition Required}.
    319. 	 * @see Additional HTTP Status Codes
    320. 	 */
    321. 	PRECONDITION_REQUIRED(428, Series.CLIENT_ERROR, "Precondition Required"),
    322. 	/**
    323. 	 * {@code 429 Too Many Requests}.
    324. 	 * @see Additional HTTP Status Codes
    325. 	 */
    326. 	TOO_MANY_REQUESTS(429, Series.CLIENT_ERROR, "Too Many Requests"),
    327. 	/**
    328. 	 * {@code 431 Request Header Fields Too Large}.
    329. 	 * @see Additional HTTP Status Codes
    330. 	 */
    331. 	REQUEST_HEADER_FIELDS_TOO_LARGE(431, Series.CLIENT_ERROR, "Request Header Fields Too Large"),
    332. 	/**
    333. 	 * {@code 451 Unavailable For Legal Reasons}.
    334. 	 * @see 
    335. 	 * An HTTP Status Code to Report Legal Obstacles
    336. 	 * @since 4.3
    337. 	 */
    338. 	UNAVAILABLE_FOR_LEGAL_REASONS(451, Series.CLIENT_ERROR, "Unavailable For Legal Reasons"),
    339.  
    340. 	// --- 5xx Server Error ---
    341.  
    342. 	/**
    343. 	 * {@code 500 Internal Server Error}.
    344. 	 * @see HTTP/1.1: Semantics and Content, section 6.6.1
    345. 	 */
    346. 	INTERNAL_SERVER_ERROR(500, Series.SERVER_ERROR, "Internal Server Error"),
    347. 	/**
    348. 	 * {@code 501 Not Implemented}.
    349. 	 * @see HTTP/1.1: Semantics and Content, section 6.6.2
    350. 	 */
    351. 	NOT_IMPLEMENTED(501, Series.SERVER_ERROR, "Not Implemented"),
    352. 	/**
    353. 	 * {@code 502 Bad Gateway}.
    354. 	 * @see HTTP/1.1: Semantics and Content, section 6.6.3
    355. 	 */
    356. 	BAD_GATEWAY(502, Series.SERVER_ERROR, "Bad Gateway"),
    357. 	/**
    358. 	 * {@code 503 Service Unavailable}.
    359. 	 * @see HTTP/1.1: Semantics and Content, section 6.6.4
    360. 	 */
    361. 	SERVICE_UNAVAILABLE(503, Series.SERVER_ERROR, "Service Unavailable"),
    362. 	/**
    363. 	 * {@code 504 Gateway Timeout}.
    364. 	 * @see HTTP/1.1: Semantics and Content, section 6.6.5
    365. 	 */
    366. 	GATEWAY_TIMEOUT(504, Series.SERVER_ERROR, "Gateway Timeout"),
    367. 	/**
    368. 	 * {@code 505 HTTP Version Not Supported}.
    369. 	 * @see HTTP/1.1: Semantics and Content, section 6.6.6
    370. 	 */
    371. 	HTTP_VERSION_NOT_SUPPORTED(505, Series.SERVER_ERROR, "HTTP Version not supported"),
    372. 	/**
    373. 	 * {@code 506 Variant Also Negotiates}
    374. 	 * @see Transparent Content Negotiation
    375. 	 */
    376. 	VARIANT_ALSO_NEGOTIATES(506, Series.SERVER_ERROR, "Variant Also Negotiates"),
    377. 	/**
    378. 	 * {@code 507 Insufficient Storage}
    379. 	 * @see WebDAV
    380. 	 */
    381. 	INSUFFICIENT_STORAGE(507, Series.SERVER_ERROR, "Insufficient Storage"),
    382. 	/**
    383. 	 * {@code 508 Loop Detected}
    384. 	 * @see WebDAV Binding Extensions
    385.  	 */
    386. 	LOOP_DETECTED(508, Series.SERVER_ERROR, "Loop Detected"),
    387. 	/**
    388. 	 * {@code 509 Bandwidth Limit Exceeded}
    389.  	 */
    390. 	BANDWIDTH_LIMIT_EXCEEDED(509, Series.SERVER_ERROR, "Bandwidth Limit Exceeded"),
    391. 	/**
    392. 	 * {@code 510 Not Extended}
    393. 	 * @see HTTP Extension Framework
    394. 	 */
    395. 	NOT_EXTENDED(510, Series.SERVER_ERROR, "Not Extended"),
    396. 	/**
    397. 	 * {@code 511 Network Authentication Required}.
    398. 	 * @see Additional HTTP Status Codes
    399. 	 */
    400. 	NETWORK_AUTHENTICATION_REQUIRED(511, Series.SERVER_ERROR, "Network Authentication Required");
    401.  
    402.  
    403. 	private static final HttpStatus[] VALUES;
    404.  
    405. 	static {
    406. 		VALUES = values();
    407. 	}
    408.  
    409.  
    410. 	private final int value;
    411.  
    412. 	private final Series series;
    413.  
    414. 	private final String reasonPhrase;
    415.  
    416. 	HttpStatus(int value, Series series, String reasonPhrase) {
    417. 		this.value = value;
    418. 		this.series = series;
    419. 		this.reasonPhrase = reasonPhrase;
    420. 	}
    421.  
    422.  
    423. 	/**
    424. 	 * Return the integer value of this status code.
    425. 	 */
    426. 	public int value() {
    427. 		return this.value;
    428. 	}
    429.  
    430. 	/**
    431. 	 * Return the HTTP status series of this status code.
    432. 	 * @see HttpStatus.Series
    433. 	 */
    434. 	public Series series() {
    435. 		return this.series;
    436. 	}
    437.  
    438. 	/**
    439. 	 * Return the reason phrase of this status code.
    440. 	 */
    441. 	public String getReasonPhrase() {
    442. 		return this.reasonPhrase;
    443. 	}
    444.  
    445. 	/**
    446. 	 * Whether this status code is in the HTTP series
    447. 	 * {@link org.springframework.http.HttpStatus.Series#INFORMATIONAL}.
    448. 	 * 
      This is a shortcut for checking the value of {@link #series()}.
    449. 	 * @since 4.0
    450. 	 * @see #series()
    451. 	 */
    452. 	public boolean is1xxInformational() {
    453. 		return (series() == Series.INFORMATIONAL);
    454. 	}
    455.  
    456. 	/**
    457. 	 * Whether this status code is in the HTTP series
    458. 	 * {@link org.springframework.http.HttpStatus.Series#SUCCESSFUL}.
    459. 	 * 
      This is a shortcut for checking the value of {@link #series()}.
    460. 	 * @since 4.0
    461. 	 * @see #series()
    462. 	 */
    463. 	public boolean is2xxSuccessful() {
    464. 		return (series() == Series.SUCCESSFUL);
    465. 	}
    466.  
    467. 	/**
    468. 	 * Whether this status code is in the HTTP series
    469. 	 * {@link org.springframework.http.HttpStatus.Series#REDIRECTION}.
    470. 	 * 
      This is a shortcut for checking the value of {@link #series()}.
    471. 	 * @since 4.0
    472. 	 * @see #series()
    473. 	 */
    474. 	public boolean is3xxRedirection() {
    475. 		return (series() == Series.REDIRECTION);
    476. 	}
    477.  
    478. 	/**
    479. 	 * Whether this status code is in the HTTP series
    480. 	 * {@link org.springframework.http.HttpStatus.Series#CLIENT_ERROR}.
    481. 	 * 
      This is a shortcut for checking the value of {@link #series()}.
    482. 	 * @since 4.0
    483. 	 * @see #series()
    484. 	 */
    485. 	public boolean is4xxClientError() {
    486. 		return (series() == Series.CLIENT_ERROR);
    487. 	}
    488.  
    489. 	/**
    490. 	 * Whether this status code is in the HTTP series
    491. 	 * {@link org.springframework.http.HttpStatus.Series#SERVER_ERROR}.
    492. 	 * 
      This is a shortcut for checking the value of {@link #series()}.
    493. 	 * @since 4.0
    494. 	 * @see #series()
    495. 	 */
    496. 	public boolean is5xxServerError() {
    497. 		return (series() == Series.SERVER_ERROR);
    498. 	}
    499.  
    500. 	/**
    501. 	 * Whether this status code is in the HTTP series
    502. 	 * {@link org.springframework.http.HttpStatus.Series#CLIENT_ERROR} or
    503. 	 * {@link org.springframework.http.HttpStatus.Series#SERVER_ERROR}.
    504. 	 * 
      This is a shortcut for checking the value of {@link #series()}.
    505. 	 * @since 5.0
    506. 	 * @see #is4xxClientError()
    507. 	 * @see #is5xxServerError()
    508. 	 */
    509. 	public boolean isError() {
    510. 		return (is4xxClientError() || is5xxServerError());
    511. 	}
    512.  
    513. 	/**
    514. 	 * Return a string representation of this status code.
    515. 	 */
    516. 	@Override
    517. 	public String toString() {
    518. 		return this.value + " " + name();
    519. 	}
    520.  
    521.  
    522. 	/**
    523. 	 * Return the {@code HttpStatus} enum constant with the specified numeric value.
    524. 	 * @param statusCode the numeric value of the enum to be returned
    525. 	 * @return the enum constant with the specified numeric value
    526. 	 * @throws IllegalArgumentException if this enum has no constant for the specified numeric value
    527. 	 */
    528. 	public static HttpStatus valueOf(int statusCode) {
    529. 		HttpStatus status = resolve(statusCode);
    530. 		if (status == null) {
    531. 			throw new IllegalArgumentException("No matching constant for [" + statusCode + "]");
    532. 		}
    533. 		return status;
    534. 	}
    535.  
    536. 	/**
    537. 	 * Resolve the given status code to an {@code HttpStatus}, if possible.
    538. 	 * @param statusCode the HTTP status code (potentially non-standard)
    539. 	 * @return the corresponding {@code HttpStatus}, or {@code null} if not found
    540. 	 * @since 5.0
    541. 	 */
    542. 	@Nullable
    543. 	public static HttpStatus resolve(int statusCode) {
    544. 		// Use cached VALUES instead of values() to prevent array allocation.
    545. 		for (HttpStatus status : VALUES) {
    546. 			if (status.value == statusCode) {
    547. 				return status;
    548. 			}
    549. 		}
    550. 		return null;
    551. 	}
    552.  
    553.  
    554. 	/**
    555. 	 * Enumeration of HTTP status series.
    556. 	 * 
      Retrievable via {@link HttpStatus#series()}.
    557. 	 */
    558. 	public enum Series {
    559.  
    560. 		INFORMATIONAL(1),
    561. 		SUCCESSFUL(2),
    562. 		REDIRECTION(3),
    563. 		CLIENT_ERROR(4),
    564. 		SERVER_ERROR(5);
    565.  
    566. 		private final int value;
    567.  
    568. 		Series(int value) {
    569. 			this.value = value;
    570. 		}
    571.  
    572. 		/**
    573. 		 * Return the integer value of this status series. Ranges from 1 to 5.
    574. 		 */
    575. 		public int value() {
    576. 			return this.value;
    577. 		}
    578.  
    579. 		/**
    580. 		 * Return the {@code Series} enum constant for the supplied {@code HttpStatus}.
    581. 		 * @param status a standard HTTP status enum constant
    582. 		 * @return the {@code Series} enum constant for the supplied {@code HttpStatus}
    583. 		 * @deprecated as of 5.3, in favor of invoking {@link HttpStatus#series()} directly
    584. 		 */
    585. 		@Deprecated
    586. 		public static Series valueOf(HttpStatus status) {
    587. 			return status.series;
    588. 		}
    589.  
    590. 		/**
    591. 		 * Return the {@code Series} enum constant for the supplied status code.
    592. 		 * @param statusCode the HTTP status code (potentially non-standard)
    593. 		 * @return the {@code Series} enum constant for the supplied status code
    594. 		 * @throws IllegalArgumentException if this enum has no corresponding constant
    595. 		 */
    596. 		public static Series valueOf(int statusCode) {
    597. 			Series series = resolve(statusCode);
    598. 			if (series == null) {
    599. 				throw new IllegalArgumentException("No matching constant for [" + statusCode + "]");
    600. 			}
    601. 			return series;
    602. 		}
    603.  
    604. 		/**
    605. 		 * Resolve the given status code to an {@code HttpStatus.Series}, if possible.
    606. 		 * @param statusCode the HTTP status code (potentially non-standard)
    607. 		 * @return the corresponding {@code Series}, or {@code null} if not found
    608. 		 * @since 5.1.3
    609. 		 */
    610. 		@Nullable
    611. 		public static Series resolve(int statusCode) {
    612. 			int seriesCode = statusCode / 100;
    613. 			for (Series series : values()) {
    614. 				if (series.value == seriesCode) {
    615. 					return series;
    616. 				}
    617. 			}
    618. 			return null;
    619. 		}
    620. 	}
    621.  
    622. }

    HttpMethod

    1. package org.springframework.http;
    2.  
    3. import java.util.HashMap;
    4. import java.util.Map;
    5.  
    6. import org.springframework.lang.Nullable;
    7.  
    8. /**
    9.  * Enumeration of HTTP request methods. Intended for use
    10.  * with {@link org.springframework.http.client.ClientHttpRequest}
    11.  * and {@link org.springframework.web.client.RestTemplate}.
    12.  *
    13.  * @author Arjen Poutsma
    14.  * @author Juergen Hoeller
    15.  * @since 3.0
    16.  */
    17. public enum HttpMethod {
    18.  
    19. 	GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS, TRACE;
    20.  
    21.  
    22. 	private static final Map mappings = new HashMap<>(16);
    23.  
    24. 	static {
    25. 		for (HttpMethod httpMethod : values()) {
    26. 			mappings.put(httpMethod.name(), httpMethod);
    27. 		}
    28. 	}
    29.  
    30.  
    31. 	/**
    32. 	 * Resolve the given method value to an {@code HttpMethod}.
    33. 	 * @param method the method value as a String
    34. 	 * @return the corresponding {@code HttpMethod}, or {@code null} if not found
    35. 	 * @since 4.2.4
    36. 	 */
    37. 	@Nullable
    38. 	public static HttpMethod resolve(@Nullable String method) {
    39. 		return (method != null ? mappings.get(method) : null);
    40. 	}
    41.  
    42.  
    43. 	/**
    44. 	 * Determine whether this {@code HttpMethod} matches the given method value.
    45. 	 * @param method the HTTP method as a String
    46. 	 * @return {@code true} if it matches, {@code false} otherwise
    47. 	 * @since 4.2.4
    48. 	 */
    49. 	public boolean matches(String method) {
    50. 		return name().equals(method);
    51. 	}
    52.  
    53. }
  • 相关阅读:
    Shell及Linux三剑客grep、sed、awk
    jQuery学习：属性
    Reflection - 浅谈Python反射
    F28069的cpu定时器
    CMake入门教程【核心篇】设置和使用缓存变量
    Go坑：time.After可能导致的内存泄露问题分析
    Elasticsearch查询
    BBR/CUBIC 共存时的 buffer 挤兑
    什么是数据中心的测试负载？
    ubuntu 18.04 OAK-D系列相机运行VINS-Fusion 双目+IMU
  • 原文地址：https://blog.csdn.net/HcJsJqJSSM/article/details/126797480