HttpClients使用详情介绍

绝地灬酷狼 2023-09-30 20:03 42阅读 0赞

## 1 HttpClient ##

### 1.1 简介 ###

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

`HttpClient`相比传统`JDK`自带的`URLConnection`，增加了易用性和灵活性（具体区别，日后我们再讨论），它不仅是客户端发送`Http`请求变得容易，而且也方便了开发人员测试接口（基于`Http`协议的），即提高了开发的效率，也方便提高代码的健壮性

### 1.2 HttpClient特性 ###

`HttpClient`特性:

1.  基于标准、纯净的`java`语言。实现了`Http1.0`和`Http1.1`
2.  以可扩展的面向对象的结构实现了`Http`全部的方法(GET, POST, PUT, DELETE, HEAD, OPTIONS, and TRACE)
3.  支持`HTTPS`协议
4.  通过`Http`代理建立透明的连接
5.  利用`CONNECT`方法通过`Http`代理建立隧道的\`https连接
6.  `Basic, Digest, NTLMv1, NTLMv2, NTLM2 Session, SNPNEGO/Kerberos`认证方案
7.  插件式的自定义认证方案
8.  便携可靠的套接字工厂使它更容易的使用第三方解决方案
9.  连接管理器支持多线程应用。支持设置最大连接数，同时支持设置每个主机的最大连接数，发现并关闭过期的连接
10. 自动处理`Set-Cookie`中的`Cookie`
11. 插件式的自定义`Cookie`策略
12. `Request`的输出流可以避免流中内容直接缓冲到`socket`服务器
13. `Response`的输入流可以有效的从`socket`服务器直接读取相应内容
14. 在`http1.0`和`http1.1`中利用`KeepAlive`保持持久连接
15. 直接获取服务器发送的`response code`和 `headers`
16. 设置连接超时的能力
17. 实验性的支持\`http1.1 response caching
18. 源代码基于`Apache License` 可免费获取

### 1.3 使用方法 ###

使用`HttpClient`发送请求、接收响应很简单，一般需要如下几步即可:

1.  创建`HttpClient`对象
2.  创建请求方法的实例，并指定请求`URL`。如果需要发送`GET`请求，创建`HttpGet`对象；如果需要发送`POST`请求，创建`HttpPost`对象。
3.  如果需要发送请求参数，可调用`HttpGet、HttpPost`共同的`setParams(HetpParams params)`方法来添加请求参数；对于`HttpPost`对象而言，也可调用`setEntity(HttpEntity entity)`方法来设置请求参数，参数则必须用`NameValuePair[]`数组存储
4.  调用`HttpClient`对象的`execute(HttpUriRequest request)`发送请求，该方法返回一个`HttpResponse`
5.  调用`HttpResponse的getAllHeaders()`、`getHeaders(String name)`等方法可获取服务器的响应头；调用`HttpResponse`的`getEntity()`方法可获取`HttpEntity`对象，该对象包装了服务器的响应内容。程序可通过该对象获取服务器的响应内容
6.  释放连接。无论执行方法是否成功，都必须释放连接

### 1.4 实例 ###

#### 1.4.1 HttpClient连接SSL ####

public class HttpClientTest {
          
      
        @Test  
        public void jUnitTest() {
          
            get();  
        }  
      
        /** 
         * HttpClient连接SSL 
         */  
        public void ssl() {
          
            CloseableHttpClient httpclient = null;  
            try {
          
                KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());  
                FileInputStream instream = new FileInputStream(new File("d:\\tomcat.keystore"));  
                try {
          
                    // 加载keyStore d:\\tomcat.keystore    
                    trustStore.load(instream, "123456".toCharArray());  
                } catch (CertificateException e) {
          
                    e.printStackTrace();  
                } finally {
          
                    try {
          
                        instream.close();  
                    } catch (Exception ignore) {
          
                    }  
                }  
                // 相信自己的CA和所有自签名的证书  
                SSLContext sslcontext = SSLContexts.custom().loadTrustMaterial(trustStore, new TrustSelfSignedStrategy()).build();  
                // 只允许使用TLSv1协议  
                SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslcontext, new String[] {
         "TLSv1" }, null,  
                SSLConnectionSocketFactory.BROWSER_COMPATIBLE_HOSTNAME_VERIFIER);  
                httpclient = HttpClients.custom().setSSLSocketFactory(sslsf).build();  
                // 创建http请求(get方式)  
                HttpGet httpget = new HttpGet("https://localhost:8080/xxx");  
                System.out.println("executing request" + httpget.getRequestLine());  
                CloseableHttpResponse response = httpclient.execute(httpget);  
                try {
          
                    HttpEntity entity = response.getEntity();  
                    System.out.println("----------------------------------------");  
                    System.out.println(response.getStatusLine());  
                    if (entity != null) {
          
                        System.out.println("Response content length: " + entity.getContentLength());  
                        System.out.println(EntityUtils.toString(entity));  
                        EntityUtils.consume(entity);  
                    }  
                } finally {
          
                    response.close();  
                }  
            } catch (ParseException e) {
          
                e.printStackTrace();  
            } catch (IOException e) {
          
                e.printStackTrace();  
            } catch (KeyManagementException e) {
          
                e.printStackTrace();  
            } catch (NoSuchAlgorithmException e) {
          
                e.printStackTrace();  
            } catch (KeyStoreException e) {
          
                e.printStackTrace();  
            } finally {
          
                if (httpclient != null) {
          
                    try {
          
                        httpclient.close();  
                    } catch (IOException e) {
          
                        e.printStackTrace();  
                    }  
                }  
            }  
        }

#### 1.4.2 POST提交 ####

/** 
         * post方式提交表单（模拟用户登录请求） 
         */  
        public void postForm() {
          
            // 创建默认的httpClient实例.    
            CloseableHttpClient httpclient = HttpClients.createDefault();  
            // 创建httppost    
            HttpPost httppost = new HttpPost("http://localhost:8080/xxxxxx");  
            // 创建参数队列    
            List<NameValuePair> formparams = new ArrayList<NameValuePair>();  
            formparams.add(new BasicNameValuePair("username", "admin"));  
            formparams.add(new BasicNameValuePair("password", "123456"));  
            UrlEncodedFormEntity uefEntity;  
            try {
          
                uefEntity = new UrlEncodedFormEntity(formparams, "UTF-8");  
                httppost.setEntity(uefEntity);  
                System.out.println("executing request " + httppost.getURI());  
                CloseableHttpResponse response = httpclient.execute(httppost);  
                try {
          
                    HttpEntity entity = response.getEntity();  
                    if (entity != null) {
          
                        System.out.println("--------------------------------------");  
                        System.out.println("Response content: " + EntityUtils.toString(entity, "UTF-8"));  
                        System.out.println("--------------------------------------");  
                    }  
                } finally {
          
                    response.close();  
                }  
            } catch (ClientProtocolException e) {
          
                e.printStackTrace();  
            } catch (UnsupportedEncodingException e1) {
          
                e1.printStackTrace();  
            } catch (IOException e) {
          
                e.printStackTrace();  
            } finally {
          
                // 关闭连接,释放资源    
                try {
          
                    httpclient.close();  
                } catch (IOException e) {
          
                    e.printStackTrace();  
                }  
            }  
        }

public String doPost()  
        {
          
            String uriAPI = "http://XXXXXX";//Post方式没有参数在这里  
            String result = "";  
            HttpPost httpRequst = new HttpPost(uriAPI);//创建HttpPost对象  
              
            List <NameValuePair> params = new ArrayList<NameValuePair>();  
            params.add(new BasicNameValuePair("str", "I am Post String"));  
              
            try {
          
                httpRequst.setEntity(new UrlEncodedFormEntity(params,HTTP.UTF_8));  
                HttpResponse httpResponse = new DefaultHttpClient().execute(httpRequst);  
                if(httpResponse.getStatusLine().getStatusCode() == 200)  
                {
          
                    HttpEntity httpEntity = httpResponse.getEntity();  
                    result = EntityUtils.toString(httpEntity);//取出应答字符串  
                }  
            } catch (UnsupportedEncodingException e) {
          
                // TODO Auto-generated catch block  
                e.printStackTrace();  
                result = e.getMessage().toString();  
            }  
            catch (ClientProtocolException e) {
          
                // TODO Auto-generated catch block  
                e.printStackTrace();  
                result = e.getMessage().toString();  
            }  
            catch (IOException e) {
          
                // TODO Auto-generated catch block  
                e.printStackTrace();  
                result = e.getMessage().toString();  
            }  
            return result;  
        }

以发送连接请求时，需要设置链接超时和请求超时等参数，否则会长期停止或者崩溃。

HttpParams httpParameters = new BasicHttpParams();  
    HttpConnectionParams.setConnectionTimeout(httpParameters, 10*1000);//设置请求超时10秒  
    HttpConnectionParams.setSoTimeout(httpParameters, 10*1000); //设置等待数据超时10秒  
    HttpConnectionParams.setSocketBufferSize(params, 8192);  
    HttpClient httpclient = new DefaultHttpClient(httpParameters); //此时构造DefaultHttpClient时将参数传入

#### 1.4.3 GET请求 ####

/** 
         * 发送 get请求 
         */  
        public void get() {
          
            CloseableHttpClient httpclient = HttpClients.createDefault();  
            try {
          
                // 创建httpget.    
                HttpGet httpget = new HttpGet("http://www.xxxx.com/");  
                System.out.println("executing request " + httpget.getURI());  
                // 执行get请求.    
                CloseableHttpResponse response = httpclient.execute(httpget);  
                try {
          
                    // 获取响应实体    
                    HttpEntity entity = response.getEntity();  
                    System.out.println("--------------------------------------");  
                    // 打印响应状态    
                    System.out.println(response.getStatusLine());  
                    if (entity != null) {
          
                        // 打印响应内容长度    
                        System.out.println("Response content length: " + entity.getContentLength());  
                        // 打印响应内容    
                        System.out.println("Response content: " + EntityUtils.toString(entity));  
                    }  
                    System.out.println("------------------------------------");  
                } finally {
          
                    response.close();  
                }  
            } catch (ClientProtocolException e) {
          
                e.printStackTrace();  
            } catch (ParseException e) {
          
                e.printStackTrace();  
            } catch (IOException e) {
          
                e.printStackTrace();  
            } finally {
          
                // 关闭连接,释放资源    
                try {
          
                    httpclient.close();  
                } catch (IOException e) {
          
                    e.printStackTrace();  
                }  
            }  
        }

public String doGet()  
        {
          
            String uriAPI = "http://XXXXX?str=I+am+get+String";  
            String result= "";  
    //      HttpGet httpRequst = new HttpGet(URI uri);  
    //      HttpGet httpRequst = new HttpGet(String uri);  
    //      创建HttpGet或HttpPost对象，将要请求的URL通过构造方法传入HttpGet或HttpPost对象。  
            HttpGet httpRequst = new HttpGet(uriAPI);  
      
    //      new DefaultHttpClient().execute(HttpUriRequst requst);  
            try {
          
       //使用DefaultHttpClient类的execute方法发送HTTP GET请求，并返回HttpResponse对象。  
                HttpResponse httpResponse = new DefaultHttpClient().execute(httpRequst);//其中HttpGet是HttpUriRequst的子类  
                if(httpResponse.getStatusLine().getStatusCode() == 200)  
                {
          
                    HttpEntity httpEntity = httpResponse.getEntity();  
                    result = EntityUtils.toString(httpEntity);//取出应答字符串  
                // 一般来说都要删除多余的字符   
                    result.replaceAll("\r", "");//去掉返回结果中的"\r"字符，否则会在结果字符串后面显示一个小方格    
                }  
                       else   
                            httpRequst.abort();  
               } catch (ClientProtocolException e) {
          
                // TODO Auto-generated catch block  
                e.printStackTrace();  
                result = e.getMessage().toString();  
            } catch (IOException e) {
          
                // TODO Auto-generated catch block  
                e.printStackTrace();  
                result = e.getMessage().toString();  
            }  
            return result;  
        }

#### 1.4.4 上传文件 ####

/** 
         * 上传文件 
         */  
        public void upload() {
          
            CloseableHttpClient httpclient = HttpClients.createDefault();  
            try {
          
                HttpPost httppost = new HttpPost("http://localhost:8080/xxxx");  
      
                FileBody bin = new FileBody(new File("F:\\image\\sendpix0.jpg"));  
                StringBody comment = new StringBody("A binary file of some kind", ContentType.TEXT_PLAIN);  
      
                HttpEntity reqEntity = MultipartEntityBuilder.create().addPart("bin", bin).addPart("comment", comment).build();  
      
                httppost.setEntity(reqEntity);  
      
                System.out.println("executing request " + httppost.getRequestLine());  
                CloseableHttpResponse response = httpclient.execute(httppost);  
                try {
          
                    System.out.println("----------------------------------------");  
                    System.out.println(response.getStatusLine());  
                    HttpEntity resEntity = response.getEntity();  
                    if (resEntity != null) {
          
                        System.out.println("Response content length: " + resEntity.getContentLength());  
                    }  
                    EntityUtils.consume(resEntity);  
                } finally {
          
                    response.close();  
                }  
            } catch (ClientProtocolException e) {
          
                e.printStackTrace();  
            } catch (IOException e) {
          
                e.printStackTrace();  
            } finally {
          
                try {
          
                    httpclient.close();  
                } catch (IOException e) {
          
                    e.printStackTrace();  
                }  
            }  
        }  
    }

### get（httpGet）请求 ###

我们知道get请求大多数需要参数，并且以?的形势拼接在URL后面，所以需要两个参数（URL和param），当不需要参数时，可以传空。返回值我比较喜欢用Object，无论里面返回JSONObject，或者是String，都可以，下面展示代码：

public static Object doGet(String url, Map<String, String> param) {
        
    
            //创建HttpClient对象
            CloseableHttpClient httpclient = HttpClients.createDefault();
            //返回的字符串
            String resultString = "";
            JSONObject jsonObject = new JSONObject();
            CloseableHttpResponse response = null;
            try {
        
                //创建url
                URIBuilder builder = new URIBuilder(url);
                if (param != null) {
        
                    for (String key : param.keySet()) {
        
                        builder.addParameter(key, param.get(key));
                    }
                }
                //创建get请求
                HttpGet httpGet = new HttpGet(builder.toString());
                // 执行请求
                response = httpclient.execute(httpGet);
                //判断返回值是否为200
                if (response.getStatusLine().getStatusCode() == 200) {
        
                    resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
                }
                //将字符串转JSONObject（可以获取里面得某个元素），也可以直接返回字符串
                jsonObject = JSONObject.parseObject(resultString);
            } catch (Exception e) {
        
                e.printStackTrace();
            }
            return jsonObject;
        }

### post（httpPost）请求 ###

对于post请求我们大多需要传一个实体，在controller用@RequestBody接收，此时我们传输的应在Body中，并且格式为Json，在请求中如果设置参数类型，默认application/x-www-form-urlencoded;charset=utf-8，这样接收方会报错（type不匹配），我们需要单独设置参数类型，下面展示代码：

public static String doPostJson(String url, Map<String, String> param) {
        
            // 创建Httpclient对象
            CloseableHttpClient httpClient = HttpClients.createDefault();
            CloseableHttpResponse response = null;
            String resultString = "";
            try {
        
                // 创建Http Post请求
                HttpPost httpPost = new HttpPost(url);
                // 创建请求内容
                String json = JSONObject.toJSON(param).toString();
                // 设置参数为Json，模拟表单
                StringEntity entity = new StringEntity(json, ContentType.APPLICATION_JSON);
                // 把参数赋值给请求
                httpPost.setEntity(entity);
                // 执行http请求
                response = httpClient.execute(httpPost);
                if (response.getStatusLine().getStatusCode() == 200) {
        
                    resultString = EntityUtils.toString(response.getEntity(), "utf-8");
                }
            } catch (Exception e) {
        
                e.printStackTrace();
            } finally {
        
                try {
        
                    response.close();
                } catch (IOException e) {
        
                    e.printStackTrace();
                }
            }
            return resultString;
        }

### delete（httpDelete）请求 ###

对于delete请求我们也需要参数，可能是一个id，可能是一个实体，但是看源码发现delete没有传参数的方法，但是poet可以，对比发现他们的父类不同，所以我想到，重写一个HttpDelete，让他的父类继承自HttpPost的父类。下面展示代码：

@NotThreadSafe
    class HttpDeleteWithBody extends HttpEntityEnclosingRequestBase {
        
        public static final String METHOD_NAME = "DELETE";
    
        @Override
        public String getMethod() {
        
            return METHOD_NAME;
        }
    
        public HttpDeleteWithBody(final String uri) {
        
            this.setURI(URI.create(uri));
        }
    
        public HttpDeleteWithBody(final URI uri) {
        
            this.setURI(uri);
        }
    
        public HttpDeleteWithBody() {
        
            super();
        }
    }

public static String doDelete(String url,Map<String,String> param) {
        
            // 创建Httpclient对象
            CloseableHttpClient httpClient = HttpClients.createDefault();
            CloseableHttpResponse response = null;
            String resultString = "";
            try {
        
                // 创建自己创建的HttpDeleteWithBody请求
                HttpDeleteWithBody httpDelete = new HttpDeleteWithBody(url);
                // 创建请求内容
                String json = JSONObject.toJSON(param).toString();
                // 设置参数为Json，模拟表单
                StringEntity entity = new StringEntity(json, ContentType.APPLICATION_JSON);
                // 把参数赋值给请求
                httpDelete.setEntity(entity);
                // 执行http请求
                response = httpClient.execute(httpDelete);
                if (response.getStatusLine().getStatusCode() == 200) {
        
                	resultString = EntityUtils.toString(response.getEntity(), "utf-8");
                }
            } catch (Exception e) {
        
                e.printStackTrace();
            } finally {
        
                try {
        
                    response.close();
                } catch (IOException e) {
        
                    e.printStackTrace();
                }
            }
            return resultString;
        }