HttpClient详细解释

最新推荐文章于 2023-09-04 13:30:00 发布
最新推荐文章于 2023-09-04 13:30:00 发布
阅读量650 收藏 2
点赞数
分类专栏： Java 文章标签： HttpClient

Http协议的重要性相信不用我多说了，HttpClient相比传统JDK自带的URLConnection，增加了易用性和灵活性（具体区别，日后我们再讨论），它不仅是客户端发送Http请求变得容易，而且也方便了开发人员测试接口（基于Http协议的），即提高了开发的效率，也方便提高代码的健壮性。因此熟练掌握HttpClient是很重要的必修内容，掌握HttpClient后，相信对于Http协议的了解会更加深入。

org.apache.commons.httpclient.HttpClient与org.apache.http.client.HttpClient的区别

  1. Commons的HttpClient项目现在是生命的尽头，不再被开发,  
  2. 已被Apache HttpComponents项目HttpClient和的HttpCore  
  3. 模组取代，提供更好的性能和更大的灵活性。  

一、简介

HttpClient是Apache Jakarta Common下的子项目，用来提供高效的、最新的、功能丰富的支持HTTP协议的客户端编程工具包，并且它支持HTTP协议最新的版本和建议。HttpClient已经应用在很多的项目中，比如Apache Jakarta上很著名的另外两个开源项目Cactus和HTMLUnit都使用了HttpClient。

下载地址: http://hc.apache.org/downloads.cgi

二、特性

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 可免费获取。

三、使用方法

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

1. 创建HttpClient对象。

2. 创建请求方法的实例，并指定请求URL。如果需要发送GET请求，创建HttpGet对象；如果需要发送POST请求，创建HttpPost对象。

3. 如果需要发送请求参数，可调用HttpGet、HttpPost共同的setParams(HetpParams params)方法来添加请求参数；对于HttpPost对象而言，也可调用setEntity(HttpEntity entity)方法来设置请求参数。

4. 调用HttpClient对象的execute(HttpUriRequest request)发送请求，该方法返回一个HttpResponse。

5. 调用HttpResponse的getAllHeaders()、getHeaders(String name)等方法可获取服务器的响应头；调用HttpResponse的getEntity()方法可获取HttpEntity对象，该对象包装了服务器的响应内容。程序可通过该对象获取服务器的响应内容。

6. 释放连接。无论执行方法是否成功，都必须释放连接

相关jar包

  1. commons-cli-1.2.jar  
  2. commons-codec-1.9.jar  
  3. commons-logging-1.2.jar  
  4. fluent-hc-4.5.1.jar  
  5. httpclient-4.5.1.jar  
  6. httpclient-cache-4.5.1.jar  
  7. httpclient-win-4.5.1.jar  
  8. httpcore-4.4.3.jar  
  9. httpcore-ab-4.4.3.jar  
  10. httpcore-nio-4.4.3.jar  
  11. httpmime-4.5.1.jar  
  12. jna-4.1.0.jar  
  13. jna-platform-4.1.0.jar  

最简单post请求, 源自 http://my.oschina.net/xinxingegeya/blog/282683

package a;  
   
import java.io.FileInputStream;  
import java.io.IOException;  
import java.util.ArrayList;  
import java.util.List;  
import java.util.Properties;  
   
import org.apache.http.HttpEntity;  
import org.apache.http.HttpResponse;  
import org.apache.http.NameValuePair;  
import org.apache.http.client.HttpClient;  
import org.apache.http.client.config.RequestConfig;  
import org.apache.http.client.entity.UrlEncodedFormEntity;  
import org.apache.http.client.methods.HttpPost;  
import org.apache.http.impl.client.DefaultHttpClient;  
import org.apache.http.message.BasicNameValuePair;  
import org.apache.http.util.EntityUtils;  
   
public class First {  
    public static void main(String[] args) throws Exception{  
        List<NameValuePair> formparams = new ArrayList<NameValuePair>();  
        formparams.add(new BasicNameValuePair("account", ""));  
        formparams.add(new BasicNameValuePair("password", ""));  
        HttpEntity reqEntity = new UrlEncodedFormEntity(formparams, "utf-8");  
    
        RequestConfig requestConfig = RequestConfig.custom()  
        .setConnectTimeout(5000)//一、连接超时：connectionTimeout-->指的是连接一个url的连接等待时间  
                .setSocketTimeout(5000)// 二、读取数据超时：SocketTimeout-->指的是连接上一个url，获取response的返回等待时间  
                .setConnectionRequestTimeout(5000)  
                .build();  
    
        HttpClient client = new DefaultHttpClient();  
        HttpPost post = new HttpPost("http://cnivi.com.cn/login");  
        post.setEntity(reqEntity);  
        post.setConfig(requestConfig);  
        HttpResponse response = client.execute(post);  
    
        if (response.getStatusLine().getStatusCode() == 200) {  
            HttpEntity resEntity = response.getEntity();  
            String message = EntityUtils.toString(resEntity, "utf-8");  
            System.out.println(message);  
        } else {  
            System.out.println("请求失败");  
        }  
    }  
   
}

四、实例

主要用到的包：

package com.test;  
      
import java.io.File;  
import java.io.FileInputStream;  
import java.io.IOException;  
import java.io.UnsupportedEncodingException;  
import java.security.KeyManagementException;  
import java.security.KeyStore;  
import java.security.KeyStoreException;  
import java.security.NoSuchAlgorithmException;  
import java.security.cert.CertificateException;  
import java.util.ArrayList;  
import java.util.List;  
import javax.net.ssl.SSLContext;  
import org.apache.http.HttpEntity;  
import org.apache.http.NameValuePair;  
import org.apache.http.ParseException;  
import org.apache.http.client.ClientProtocolException;  
import org.apache.http.client.entity.UrlEncodedFormEntity;  
import org.apache.http.client.methods.CloseableHttpResponse;  
import org.apache.http.client.methods.HttpGet;  
import org.apache.http.client.methods.HttpPost;  
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;  
import org.apache.http.conn.ssl.SSLContexts;  
import org.apache.http.conn.ssl.TrustSelfSignedStrategy;  
import org.apache.http.entity.ContentType;  
import org.apache.http.entity.mime.MultipartEntityBuilder;  
import org.apache.http.entity.mime.content.FileBody;  
import org.apache.http.entity.mime.content.StringBody;  
import org.apache.http.impl.client.CloseableHttpClient;  
import org.apache.http.impl.client.HttpClients;  
import org.apache.http.message.BasicNameValuePair;  
import org.apache.http.util.EntityUtils;  
import org.apache.http.client.config.RequestConfig;  
import org.junit.Test;  
public class HttpClientTest {  
　　//方法见下........  
}

HttpClientUtils工具类

package com.bobo.code.web.controller.technology.httpcomponents;  
   
   
import org.apache.http.HttpEntity;  
import org.apache.http.HttpHost;  
import org.apache.http.HttpResponse;  
import org.apache.http.NameValuePair;  
import org.apache.http.client.HttpClient;  
import org.apache.http.client.config.RequestConfig;  
import org.apache.http.client.methods.HttpUriRequest;  
import org.apache.http.client.methods.RequestBuilder;  
import org.apache.http.conn.routing.HttpRoute;  
import org.apache.http.impl.client.CloseableHttpClient;  
import org.apache.http.impl.client.HttpClientBuilder;  
import org.apache.http.impl.client.HttpClients;  
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;  
import org.apache.http.message.BasicNameValuePair;  
import org.apache.http.util.EntityUtils;  
    
import java.io.IOException;  
import java.util.*;  
    
public class HttpClientUtils {  
    
    private static PoolingHttpClientConnectionManager connectionManager = null;  
    private static HttpClientBuilder httpBuilder = null;  
    private static RequestConfig requestConfig = null;  
    
    private static int MAXCONNECTION = 10;  
    
    private static int DEFAULTMAXCONNECTION = 5;  
    
    private static String IP = "cnivi.com.cn";  
    private static int PORT = 80;  
    
    static {  
        //设置http的状态参数  
        requestConfig = RequestConfig.custom()  
                .setSocketTimeout(5000)  
                .setConnectTimeout(5000)  
                .setConnectionRequestTimeout(5000)  
                .build();  
    
        HttpHost target = new HttpHost(IP, PORT);  
        connectionManager = new PoolingHttpClientConnectionManager();  
        connectionManager.setMaxTotal(MAXCONNECTION);//客户端总并行链接最大数  
        connectionManager.setDefaultMaxPerRoute(DEFAULTMAXCONNECTION);//每个主机的最大并行链接数  
        connectionManager.setMaxPerRoute(new HttpRoute(target), 20);  
        httpBuilder = HttpClients.custom();  
        httpBuilder.setConnectionManager(connectionManager);  
    }  
    
    public static CloseableHttpClient getConnection() {  
        CloseableHttpClient httpClient = httpBuilder.build();  
        return httpClient;  
    }  
    
    
    public static HttpUriRequest getRequestMethod(Map<String, String> map, String url, String method) {  
        List<NameValuePair> params = new ArrayList<NameValuePair>();  
        Set<Map.Entry<String, String>> entrySet = map.entrySet();  
        for (Map.Entry<String, String> e : entrySet) {  
            String name = e.getKey();  
            String value = e.getValue();  
            NameValuePair pair = new BasicNameValuePair(name, value);  
            params.add(pair);  
        }  
        HttpUriRequest reqMethod = null;  
        if ("post".equals(method)) {  
            reqMethod = RequestBuilder.post().setUri(url)  
                    .addParameters(params.toArray(new BasicNameValuePair[params.size()]))  
                    .setConfig(requestConfig).build();  
        } else if ("get".equals(method)) {  
            reqMethod = RequestBuilder.get().setUri(url)  
                    .addParameters(params.toArray(new BasicNameValuePair[params.size()]))  
                    .setConfig(requestConfig).build();  
        }  
        return reqMethod;  
    }  
    
    public static void main(String args[]) throws IOException {  
        Map<String, String> map = new HashMap<String, String>();  
        map.put("account", "");  
        map.put("password", "");  
    
        HttpClient client = getConnection();  
        HttpUriRequest post = getRequestMethod(map, "http://cnivi.com.cn/login", "post");  
        HttpResponse response = client.execute(post);  
    
        if (response.getStatusLine().getStatusCode() == 200) {  
            HttpEntity entity = response.getEntity();  
            String message = EntityUtils.toString(entity, "utf-8");  
            System.out.println(message);  
        } else {  
            System.out.println("请求失败");  
        }  
    }  
}

get方式

/** 
     * 发送 get请求 
     */   
    public void get() {   
        CloseableHttpClient httpclient = HttpClients.createDefault();   
        try {   
            // 创建httpget.     
            HttpGet httpget = new HttpGet("http://www.baidu.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();   
            }   
        }   
    }

post方式

/** 
     * 发送 post请求访问本地应用并根据传递参数不同返回不同结果 
     */   
    public void post() {   
        // 创建默认的httpClient实例.     
        CloseableHttpClient httpclient = HttpClients.createDefault();   
        // 创建httppost     
        HttpPost httppost = new HttpPost("http://localhost:8080/myDemo/Ajax/serivceJ.action");   
        // 创建参数队列     
        List<NameValuePair> formparams = new ArrayList<NameValuePair>();   
        formparams.add(new BasicNameValuePair("type", "house"));   
        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();   
            }   
        }   
    }

post方式乱码补充　

如果有乱码,可以偿试使用 StringEntity 来替换HttpEntity:

StringEntity content =new StringEntity(soapRequestData.toString(), Charset.forName("UTF-8"));// 第二个参数，设置后才会对，内容进行编码  
        content.setContentType("application/soap+xml; charset=UTF-8");  
        content.setContentEncoding("UTF-8");  
        httppost.setEntity(content);

 具体SOAP协议代码如下:

package com.isoftstone.core.service.impl;  
  
import java.io.BufferedReader;  
import java.io.File;  
import java.io.FileInputStream;  
import java.io.FileReader;  
import java.io.IOException;  
import java.io.InputStreamReader;  
import java.nio.charset.Charset;  
import java.util.Scanner;  
  
import org.apache.http.HttpEntity;  
import org.apache.http.HttpResponse;  
import org.apache.http.client.ClientProtocolException;  
import org.apache.http.client.HttpClient;  
import org.apache.http.client.entity.EntityBuilder;  
import org.apache.http.client.methods.HttpPost;  
import org.apache.http.entity.ContentType;  
import org.apache.http.entity.StringEntity;  
import org.apache.http.impl.client.HttpClients;  
import org.apache.http.util.EntityUtils;  
import org.apache.log4j.Logger;  
import org.jdom.Document;  
import org.jdom.Element;  
  
import com.isoftstone.core.common.constant.RequestConstants;  
import com.isoftstone.core.common.tools.XmlTool;  
import com.isoftstone.core.service.intf.ServiceOfStringPara;  
/** 
 * 德勤定价系统,由核心主动调用 
 * @author King 
 * 
 */  
public class DeloittePricingSingleCarImpl implements ServiceOfStringPara {  
    private  String serviceUrl = "http://10.30.0.35:7001/ZSInsUW/Auto/PricingService";  
  
    private static Logger log = Logger.getLogger(DeloittePricingSingleCarImpl.class.getName());  
  
    public String invoke(String sRequest) {  
          
        StringBuffer soapRequestData = new StringBuffer();  
        soapRequestData.append("<soapenv:Envelope");  
        soapRequestData.append("  xmlns:soapenv=\"http://schemas.xmlsoap.org/soap/envelope/\" ");  
        soapRequestData.append("  xmlns:prov=\"http://provider.webservice.zsins.dtt.com/\">");  
        soapRequestData.append(" <soapenv:Header/> ");  
        soapRequestData.append("<soapenv:Body>");  
        soapRequestData.append("<prov:executePrvPricing>");  
        soapRequestData.append("<arg0>");  
        soapRequestData.append("<![CDATA[" + sRequest + "]]>");  
        soapRequestData.append("</arg0>");  
        soapRequestData.append("</prov:executePrvPricing>");  
        soapRequestData.append(" </soapenv:Body>");  
        soapRequestData.append("</soapenv:Envelope>");  
  
        HttpClient httpclient = HttpClients.createDefault();  
        HttpPost httppost = new HttpPost(serviceUrl);  
  
        StringEntity content =new StringEntity(soapRequestData.toString(), Charset.forName("UTF-8"));// 第二个参数，设置后才会对，内容进行编码  
        content.setContentType("application/soap+xml; charset=UTF-8");  
        content.setContentEncoding("UTF-8");  
        httppost.setEntity(content);  
          
        //用下面的服务器端以UTF-8接收到的报文会乱码,原因未知  
//        HttpEntity reqEntity = EntityBuilder.create().setContentType(  
//                ContentType.TEXT_PLAIN) // .TEXT_PLAIN  
//                .setText(soapRequestData.toString()).build();  
//        httppost.setEntity(reqEntity);  
//        httppost.addHeader("Content-Type",  
//                "application/soap+xml; charset=utf-8");  
        HttpResponse response = null;  
        Document doc = null;  
        String returnXml = null;  
        String sentity = null;  
        try {  
            response = httpclient.execute(httppost);  
            HttpEntity resEntity = response.getEntity();  
            if (resEntity != null) {  
                sentity = EntityUtils.toString(resEntity, "UTF-8");  
                doc = XmlTool.getDocument(sentity, RequestConstants.ENCODE);  
                System.out.println(doc.toString());  
                Element eRoot = doc.getRootElement();  
                Element body = eRoot.getChild("Body", eRoot.getNamespace());  
                Element resp = (Element) body.getChildren().get(0);  
                Element returnele = resp.getChild("return");  
                returnXml = returnele.getText().toString();  
            }  
        } catch (ClientProtocolException e) {  
            e.printStackTrace();  
        } catch (IOException e) {  
            e.printStackTrace();  
        } catch (Exception e) {  
            e.printStackTrace();  
        } finally {  
            log.info("发送给德勤定价系统的请求报文：\n" + soapRequestData.toString());  
            log.info("德勤定价系统返回的响应报文：\n" + sentity);  
            log.info("返回给核心的的报文:\n" + returnXml);  
        }  
        return returnXml;  
    }  
      
      
    public String getServiceUrl() {  
        return serviceUrl;  
    }  
  
  
    public void setServiceUrl(String serviceUrl) {  
        this.serviceUrl = serviceUrl;  
    }  
  
  
    public static void main(String[] args) throws Exception{  
        File file = new File("D:/浙商项目资料/z浙江资料/t唐建华/德勤定价调试报文.txt");  
        System.out.println(file.exists());  
          
        String temp2 = null;  
        StringBuilder sb2 = new StringBuilder();  
        InputStreamReader isr = new InputStreamReader(new FileInputStream(file),"GBK");  
        BufferedReader br = new BufferedReader(isr);  
        temp2 = br.readLine();  
          
        while( temp2 != null ){  
            sb2.append(temp2);  
            temp2 = br.readLine();  
        }  
        String sss = sb2.toString();  
//        System.out.println(sss.toString());  
        new DeloittePricingSingleCarImpl().invoke(sss);  
    }  
}

post提交表单

/** 
     * post方式提交表单（模拟用户登录请求） 
     */   
    public void postForm() {   
        // 创建默认的httpClient实例.     
        CloseableHttpClient httpclient = HttpClients.createDefault();   
        // 创建httppost     
        HttpPost httppost = new HttpPost("http://localhost:8080/myDemo/Ajax/serivceJ.action");   
        // 创建参数队列     
        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 void upload() {   
        CloseableHttpClient httpclient = HttpClients.createDefault();   
        try {   
            HttpPost httppost = new HttpPost("http://localhost:8080/myDemo/Ajax/serivceFile.action");   
     
            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();   
            }   
        }   
    }

ssl连接

/** 
     * 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:8443/myDemo/Ajax/serivceJ.action");   
            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();   
                }   
            }   
        }   
    }

关于RequestConfig的配置:  

public void requestConfig(){  
//      新建一个RequestConfig：  
        RequestConfig defaultRequestConfig = RequestConfig.custom()  
            //一、连接目标服务器超时时间：ConnectionTimeout-->指的是连接一个url的连接等待时间  
            .setConnectTimeout(5000)  
            //二、读取目标服务器数据超时时间：SocketTimeout-->指的是连接上一个url，获取response的返回等待时间  
            .setSocketTimeout(5000)  
            //三、从连接池获取连接的超时时间:ConnectionRequestTimeout  
            .setConnectionRequestTimeout(5000)  
            .build();  
           
//      这个超时可以设置为客户端级别,作为所有请求的默认值：  
        CloseableHttpClient httpclient = HttpClients.custom()  
            .setDefaultRequestConfig(defaultRequestConfig)  
            .build();  
//       httpclient.execute(httppost);的时候可以让httppost直接享受到httpclient中的默认配置.  
           
//      Request不会继承客户端级别的请求配置，所以在自定义Request的时候，需要将客户端的默认配置拷贝过去：  
        HttpGet httpget = new HttpGet("http://www.apache.org/");  
        RequestConfig requestConfig = RequestConfig.copy(defaultRequestConfig)  
            .setProxy(new HttpHost("myotherproxy", 8080))  
            .build();  
        httpget.setConfig(requestConfig);  
//      httpget可以单独地使用新copy的requestConfig请求配置,不会对别的request请求产生影响  
    }

httpGet或httpPost 的abort()和releaseConnection()差异

//httpPost.abort();//中断请求,接下来可以开始另一段请求,所以个人理应,用这个应该可以在session中虚拟登录  
 //httpPost.releaseConnection();//释放请求.如果释放了相当于要清空session

根所以上差异,可知模拟登录可以如下:  源自 http://bbs.csdn.net/topics/390195343

package com.bms.core;  
     
import java.io.IOException;  
import java.util.ArrayList;  
import java.util.List;  
     
import org.apache.http.Consts;  
import org.apache.http.HttpEntity;  
import org.apache.http.HttpResponse;  
import org.apache.http.NameValuePair;  
import org.apache.http.client.ClientProtocolException;  
import org.apache.http.client.entity.UrlEncodedFormEntity;  
import org.apache.http.client.methods.HttpGet;  
import org.apache.http.client.methods.HttpPost;  
import org.apache.http.impl.client.DefaultHttpClient;  
import org.apache.http.message.BasicNameValuePair;  
import org.apache.http.util.EntityUtils;  
     
import com.bms.util.CommonUtil;  
     
public class Test2 {  
     
    /** 
     * @param args 
     * @throws IOException 
     * @throws ClientProtocolException 
     */  
    public static void main(String[] args) throws ClientProtocolException, IOException {  
        DefaultHttpClient httpclient = new DefaultHttpClient();  
     
         HttpGet httpGet = new HttpGet("http://www.baidu.com");  
         String body = "";  
         HttpResponse response;  
         HttpEntity entity;  
         response = httpclient.execute(httpGet);  
         entity = response.getEntity();  
         body = EntityUtils.toString(entity);//这个就是页面源码了  
         httpGet.abort();//中断请求,接下来可以开始另一段请求  
         System.out.println(body);  
         //httpGet.releaseConnection();//释放请求.如果释放了相当于要清空session  
         //以下是post方法  
         HttpPost httpPost = new HttpPost("http://www.baidu.com");//一定要改成可以提交的地址,这里用百度代替  
         List <NameValuePair> nvps = new ArrayList <NameValuePair>();  
         nvps.add(new BasicNameValuePair("name", "1"));//名值对  
         nvps.add(new BasicNameValuePair("account", "xxxx"));  
         httpPost.setEntity(new UrlEncodedFormEntity(nvps, Consts.UTF_8));  
         response = httpclient.execute(httpPost);  
         entity = response.getEntity();  
         body = EntityUtils.toString(entity);  
         System.out.println("Login form get: " + response.getStatusLine());//这个可以打印状态  
         httpPost.abort();  
         System.out.println(body);  
         httpPost.releaseConnection();  
    }  
     
}

转载：https://blog.csdn.net/zhuwukai/article/details/78644484

我不想再熬夜了
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HttpClient工具详细
11-05
搜了一下网络上别人封装的HttpClient，大部分特别简单，有一些看起来比较高级，但是用起来都不怎么好用。调用关系不清楚，结构有点混乱。所以也就萌生了自己封装HttpClient工具类的想法。要做就做最好的，本工具类...
c#：HttpClient使用详解
热门推荐
火焰
08-19 5万+
环境： window10 vs2019 .netcore 3.1 centos 7.6 一、在c#中发送http请求的方式 本部分参考：《WebClient, HttpClient, HttpWebRequest ,RestSharp之间的区别与抉择》 使用.net 平台原生提供的HttpWebRequest、WebClient和HttpClient。 使用开源的工具，如：RestSharp、Flurl。 在.net core平台下已经不推荐使用HttpWebRequest、WebClient方式了
c# HttpClient实现对http接口Get、Post表单请求
weixin_38582851的博客
01-17 1676
环境安装 在NuGet资源包管理器上下载资源包： 1 visual studio2022 打开NuGet资源包管理器： 2. 安装webAPI Client 3. 安装Multipart Reader 4. 安装Json.Net c# 实现Post form-data文件上传 internal class HttpClientUtils { public static string PostData(string filePath, string filename)
C#操作HttpClient工具类库
IT技术分享社区
02-06 6473
MessageBox.Show("HTTP POST MultipartFormData 请求失败，请检查网络或联系管理员查看服务器状态，错误消息：" + e.Message);MessageBox.Show("HTTP POST请求失败，请检查网络或联系管理员查看服务器状态，错误消息：" + e.Message);MessageBox.Show("HTTP GET请求失败，请检查网络或联系管理员查看服务器状态，错误消息：" + e.Message);//接口调用成功获取的数据。//接口调用成功数据。
C# 中使用System.Net.Http.HttpClient 模拟登录博客园 (GET/POST)
qq_42316518的博客
09-29 5868
https://www.cnblogs.com/amosli/p/3918538.html
关于c#的HttpClient的特性
皮皮君的博客
04-12 2万+
       在项目的开发过程中，需要用到POST机制将信息发送给服务器。翻阅微软资料，可以采用HttpClient类实现。实际使用过程中，发现这个类挺有脾气的，用不好特别容易出现的问题，最容易碰到的问题是下面两个:1)会建立大量的Tcp链接，耗费系统资源；2)容易出现TaskCanceledException异常，表示这个链接的发送任务被HttpClient强行取消了；    翻阅了一些资料，查...
JAVA httpclient jar下载
08-18
httpclient常用封装工具 doGet(String url, Map, String> param) doPost(String url, Map, String> param) doPostJson(String url, String json)
httpclient
03-16
此代码为http协议的客户端代码。。。。。。。。。。。。。。。。。。。。
php实现httpclient类
05-03
hp实现httpclient类示例,需要的朋友可以参考下，buffer 获取返回的字符串，referer 设置 HTTP_REFERER 的网址，response 服务器响应的 header 信息，request 发送到服务器的 header 信息。
c# https请求忽略证书验证_如何使用HttpClient来发送带客户端证书的请求，以及如何忽略掉对服务器端证书的校验...
weixin_39575775的博客
12-19 1037
importorg.apache.commons.io.IOUtils;importorg.apache.http.HttpEntity;importorg.apache.http.client.methods.CloseableHttpResponse;importorg.apache.http.client.methods.HttpGet;importorg.apache.http.conn....
关于C# HttpClient 的用法及相关问题的解决方法
黑夜中的潜行者
09-04 1441
HttpClient 旨在被实例化一次并在应用程序的整个生命周期中重复使用。为每个请求实例化一个 HttpClient 类将耗尽重负载下可用的套接字数量。工作中遇到写正常的 http post 请求会失败的问题，于是就在原有的基础上改动了写代码使用。相信大家在使用 HttpClient 的时候遇到过。，详情见代码第二个 post 请求方法。的错误，一般的解决方法就是下面这种。解决办法：在请求方法中指定。
HttpClientFactory的使用
freeherotoday的博客
01-28 3973
HttpClient的优缺点 HttpClient这个对象有点特殊，虽然继承了IDisposable接口，但它是可以被共享的（或者说可以被复用），且线程安全。从项目经验来看，倒是建议在整个应用的生命周期内，复用HttpClient实例，而不是每次RPC请求的时候就实例化一个。 在高并发的情况下，连接来不及释放，socket被耗尽，耗尽之后就会出现一个错误： #使用jemter压测复现错误信息： Unable to connect to the remote serverSystem.Net.Sockets.
httpClient请求https接口实现
碎片令人怀念的的博客
07-15 4201
最近项目中和外部接口交互时遇到问题，项目本身是http形式的接口协议，需要请求https的接口协议，代码中使用的是httpClient进行实现， 1、pom文件引入： <dependency> <groupId>org.apache.httpcomponents</groupId> <artifactId>httpclient</artifactId>
C# HttpClient教程
CoderYang
06-01 1万+
在日常开发中经常会用到别人写的接口数据，那么访问该接口的方式很多。这里我们主要学习使用HttpClient类发送各种请求操作。
httpclient来进行https访问
zhaokuner的专栏
06-09 1万+
引用：http://jimmyleeee.blog.163.com/blog/static/9309618200981032419802/ 用了大半天时间才了解如何使用httpclient来进行https访问，现记录，已备后忘。 httpclient完全支持ssl连接方式。通常，如果不需要进行客户端认证和服务器端认证的ssl连接，httpclient的处理方式是和http方式完全一
C#-HttpClient框架用法
最新发布
qq_42538588的博客
09-04 2025
在本文中，我们将介绍http的定义、优点和缺点、以及如何使用C#中的HttpClient对象进行初始化和创建初始化时的配置类。此外，我们还将演示如何封装POST方法来发送HTTP请求。 首先，让我们来了解http的定义。HTTP（超文本传输协议）是一种用于传输超文本的协议，它允许Web服务器向客户端传输信息。与HTTP相比，HTTPS提供了加密通信，以确保数据的安全性。 尽管HTTP有很多好处，但它也有一些缺点。其中之一是性能问题，特别是在处理大量请求时。此外，HTTP不支持长连接，这意味着每次请求都需
【C#通过HttpClient 访问WEbService】
qq_15599679的博客
08-12 931
C#通过HttpClient 访问WEbService
C#中使用HttpClient来Post数据的内容HttpContent的各种格式
m0_50623581的博客
01-06 5437
一、以下是最常用的四种类型: （1）、application/x-www-form-urlencoded 这应该是最常见的 POST 提交数据的方式了。浏览器的原生 表单，如果不设置 enctype 属性，那么最终就会以 application/x-www-form-urlencoded 方式提交数据。 First name: Last name: （2）、multipart/form-data 这也是常见的post请求方式，一般用来上传文件，各大服务器的支持也比较好。所以我们使用表
C# HttpClientUtil 工具类 表单请求提交 附件上传下载
u010613052的博客
01-02 4898
废话不多说，直接上干货！ 以下就是常用的Post 、Delete、Get（查询用）、Put请求。 如不满足，后面还有表单提交，附件上传、下载代码。 public class HttpClientUtil { /// /// post请求 /// /// /// post数据 /
httpclient详细代码
03-26
抱歉，我无法提供完整的 `httpclient` 代码。由于您没有指定编程语言，以下是一个Java中使用`httpclient`进行GET请求的示例： ```java import java.io.IOException; import org.apache.http.HttpEntity; import org...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值