httpclient
client帮助文档
前言超文本传输协议（HTTP）也许是当今互联网上使用的最重要的协议了。
Web服务，有网络功能的设备和网络计算的发展，都持续扩展了HTTP协议的角色，超越了用户使用的Web 浏览器范畴，同时，也增加了需要HTTP协议支持的应用程序的数量。
尽管包提供了基本通过HTTP访问资源的功能，但它没有提供全面的灵活性和其它很多应用程序需要的功能。
HttpClient就是寻求弥补这项空白的组件，通过提供一个有效的，保持更新的，功能丰富的软件包来实现客户端最新的HTTP标准和建议。
为扩展而设计，同时为基本的HTTP协议提供强大的支持，HttpClient组件也许就是构建HTTP客户端应用程序，比如web浏览器，web服务端，利用或扩展HTTP协议进行分布式通信的系统的开发人员的关注点。
1. HttpClient的范围基于HttpCore[/httpcomponents-core/index.html]的客户端HTTP运输实现库基于经典（阻塞）I/O内容无关2. 什么是HttpClient不能做的HttpClient 不是一个浏览器。
它是一个客户端的HTTP通信实现库。
HttpClient的目标是发送和接收HTTP报文。
HttpClient不会去缓存内容，执行嵌入在HTML页面中的javascript 代码，猜测内容类型，重新格式化请求/重定向URI，或者其它和HTTP运输无关的功能。
第一章基础1.1 执行请求HttpClient 最重要的功能是执行HTTP方法。
一个HTTP方法的执行包含一个或多个HTTP 请求/HTTP响应交换，通常由HttpClient的内部来处理。
而期望用户提供一个要执行的请求对象，而HttpClient期望传输请求到目标服务器并返回对应的响应对象，或者当执行不成功时抛出异常。
很自然地，HttpClient API的主要切入点就是定义描述上述规约的HttpClient接口。
这里有一个很简单的请求执行过程的示例：HttpClient httpclient = new DefaultHttpClient();HttpGet httpget = new HttpGet("http://localhost/");HttpResponse response = httpclient.execute(httpget);HttpEntity entity = response.getEntity();if (entity != null) {InputStream instream = entity.getContent();int l;byte[] tmp = new byte[2048];while ((l = instream.read(tmp)) != -1) {}}1.1.1 HTTP请求所有HTTP请求有一个组合了方法名，请求URI和HTTP协议版本的请求行。
C# 自带 HttpClient我这段代码为什么会报请求没完成就发另一个呢 我觉得完成了啊
C# 自带 HttpClient我这段代码为什么会报请求没完成就发
另一个呢我觉得完成了啊
C# 自带的 HttpClient 封装了访问 HTTP 服务的方法。
它可以使用GET 和 POST 等方法及时发送 HTTP 请求并获取 HTTP 响应的返回值。
但是在使用的过程中，有时候会发生一种情况，就是在一次请求还没
有完成时，就会发起另一次请求，从而导致报错。
主要原因是因为 C# 中的 Httpclient 并没有设置最大连接数的限制，因此可能会出现快速攻击的行为而失败。
另外，使用过程中，重复建
立 HttpClient 实例的情况也可能会出现失败的情况。
毕竟，如果不
断的建立新的 HttpClient 实例，则会造成内存占用问题，也可能导
致请求失败。
总而言之，要避免 HttpClient 报请求没完成就发另一个的情况，要
做的就是控制好 HttpClient 的连接数，避免连接数过多，把建立实
例的行为放在一个固定的循环外，避免在一个请求未完成前就去建立
新的实例。
HttpClient,DefaultHttpClient使用详解
HttpClient,DefaultHttpClient使⽤详解HttpClient:是⼀个接⼝⾸先需要先创建⼀个DefaultHttpClient的实例HttpClient httpClient=new DefaultHttpClient();发送GET请求:先创建⼀个HttpGet对象,传⼊⽬标的⽹络地址,然后调⽤HttpClient的execute()⽅法即可:httpClient.execute(httpGet);发送POST请求:创建⼀个HttpPost对象,传⼊⽬标的⽹络地址:通过⼀个NameValuePair集合来存放待提交的参数,并将这个参数集合传⼊到⼀个UrlEncodedFormEntity中,然后调⽤HttpPost的setEntity()⽅法将构建好的UrlEncodedFormEntity传⼊:List<NameValuePair>params=newArrayList<NameValuePair>();Params.add(new BasicNameValuePair(“username”,”admin”));Params.add(new BasicNameValuePair(“password”,”123456”));UrlEncodedFormEntity entity=newUrlEncodedFormEntity(params,”utf-8”);httpPost.setEntity(entity);调⽤HttpClient的execute()⽅法,并将HttpPost对象传⼊即可:HttpClient.execute(HttpPost);执⾏execute()⽅法之后会返回⼀个HttpResponse对象,服务器所返回的所有信息就保护在HttpResponse⾥⾯.先取出服务器返回的状态码,如果等于200就说明请求和响应都成功了:If(httpResponse.getStatusLine().getStatusCode()==200){//请求和响应都成功了HttpEntityentity=HttpResponse.getEntity();//调⽤getEntity()⽅法获取到⼀个HttpEntity实例Stringresponse=EntityUtils.toString(entity,”utf-8”);//⽤EntityUtils.toString()这个静态⽅法将HttpEntity转换成字符串,防⽌服务器返回的数据带有中⽂,所以在转换的时候将字符集指定成utf-8就可以了}Http协议的重要性相信不⽤我多说了，HttpClient相⽐传统JDK⾃带的URLConnection，增加了易⽤性和灵活性（具体区别，⽇后我们再讨论），它不仅是客户端发送Http请求变得容易，⽽且也⽅便了开发⼈员测试接⼝（基于Http协议的），即提⾼了开发的效率，也⽅便提⾼代码的健壮性。
HTTPClient用法
HttpClient的用法HTTP 协议可能是现在 Internet 上使用得最多、最重要的协议了，越来越多的 Java 应用程序需要直接通过HTTP 协议来访问网络资源。
Commons-httpclient项目就是专门设计来简化HTTP客户端与服务器进行各种通讯编程。
通过它可以让原来很头疼的事情现在轻松的解决，例如你不再管是HTTP或者HTTPS的通讯方式，告诉它你想使用HTTPS方式，剩下的事情交给 httpclient替你完成。
首先，我们必须安装好 HttpClient。
HttpClient 可以在/commons/httpclient/downloads.html下载.HttpClient 用到了 Apache Jakarta common 下的子项目 logging，你可以从这个地址/site/downloads /downloads_commons-logging.cgi下载到 common logging，从下载后的压缩包中取出 commons-logging.jar 加到 CLASSPATH 中.HttpClient 用到了 Apache Jakarta common 下的子项目 codec，你可以从这个地址/site/downloads /downloads_commons-codec.cgi 下载到最新的 common codec，从下载后的压缩包中取出 commons-codec-1.x.jar 加到 CLASSPATH 中1．读取网页(HTTP/HTTPS)内容下面是我们给出的一个简单的例子用来访问某个页面package http.demo;import java.io.IOException;import mons.httpclient.*;import mons.httpclient.methods.*;/*** 最简单的HTTP客户端,用来演示通过GET或者POST方式访问某个页面* @author Liudong*/public class SimpleClient {public static void main(String[] args) throws IOException{HttpClient client = new HttpClient();//设置代理服务器地址和端口//client.getHostConfiguration().setProxy("proxy_host_addr",proxy_port);//使用GET方法，如果服务器需要通过HTTPS连接，那只需要将下面URL中的http换成https HttpMethod method = new GetMethod("");//使用POST方法//HttpMethod method = new PostMethod("");client.executeMethod(method);//打印服务器返回的状态System.out.println(method.getStatusLine());//打印返回的信息System.out.println(method.getResponseBodyAsString());//释放连接method.releaseConnection();}}在这个例子中首先创建一个HTTP客户端(HttpClient)的实例，然后选择提交的方法是GET或者 POST，最后在HttpClient实例上执行提交的方法，最后从所选择的提交方法中读取服务器反馈回来的结果。
java使用httpclient发送postgetputdelete请求
java使用httpclient发送postgetputdelete请求1.发送POST请求：使用HttpClient发送POST请求非常简单。
需要创建一个HttpClient对象，然后通过HttpPost对象来设置请求的URL和请求体。
接下来，将HttpPost对象传递给HttpClient的execute方法，以执行POST请求。
最后，从HttpResponse对象中获取响应体。
以下是一个示例代码，演示了如何使用HttpClient发送POST请求：```public class HttpClientExamplepublic static void main(String[] args)try// 创建HttpClient对象// 创建HttpPost对象，并设置URL//设置请求体String requestBody = "data=test";StringEntity entity = new StringEntity(requestBody);//执行POST请求//从响应中获取响应体HttpEntity responseEntity = response.getEntity(;String responseBody = EntityUtils.toString(responseEntity);System.out.println(responseBody);} catch (Exception e)e.printStackTrace(;}}```2.发送GET请求：发送GET请求与发送POST请求的过程类似。
只需创建一个HttpGet 对象，并设置请求的URL。
接下来，将HttpGet对象传递给HttpClient 的execute方法，以执行GET请求。
再从HttpResponse对象中获取响应体。
以下是一个示例代码，演示了如何使用HttpClient发送GET请求：```public class HttpClientExamplepublic static void main(String[] args)try// 创建HttpClient对象// 创建HttpGet对象，并设置URL//执行GET请求//从响应中获取响应体String responseBody =EntityUtils.toString(response.getEntity();System.out.println(responseBody);} catch (Exception e)e.printStackTrace(;}}```3.发送PUT请求：发送PUT请求与发送POST请求的方法类似。
浅谈HttpClient、okhttp和RestTemplate的区别
浅谈HttpClient、okhttp和RestTemplate的区别⼀、HttpClient1、pom依赖<!--HttpClient--><dependency><groupId>commons-httpclient</groupId><artifactId>commons-httpclient</artifactId><version>3.1</version></dependency>2、HttpClient代码实现public class HttpClientUtil {/*** httpClient的get请求⽅式* 使⽤GetMethod来访问⼀个URL对应的⽹页实现步骤：* 1.⽣成⼀个HttpClient对象并设置相应的参数；* 2.⽣成⼀个GetMethod对象并设置响应的参数；* 3.⽤HttpClient⽣成的对象来执⾏GetMethod⽣成的Get⽅法；* 4.处理响应状态码；* 5.若响应正常，处理HTTP响应内容；* 6.释放连接。
* @param url* @param charset* @return*/public static String doGet(String url, String charset) {//1.⽣成HttpClient对象并设置参数HttpClient httpClient = new HttpClient();//设置Http连接超时为5秒httpClient.getHttpConnectionManager().getParams().setConnectionTimeout(5000);//2.⽣成GetMethod对象并设置参数GetMethod getMethod = new GetMethod(url);//设置get请求超时为5秒getMethod.getParams().setParameter(HttpMethodParams.SO_TIMEOUT, 5000);//设置请求重试处理，⽤的是默认的重试处理：请求三次getMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER, new DefaultHttpMethodRetryHandler());String response = "";//3.执⾏HTTP GET 请求try {int statusCode = httpClient.executeMethod(getMethod);//4.判断访问的状态码if (statusCode != HttpStatus.SC_OK) {System.err.println("请求出错：" + getMethod.getStatusLine());}//5.处理HTTP响应内容//HTTP响应头部信息，这⾥简单打印Header[] headers = getMethod.getResponseHeaders();for(Header h : headers) {System.out.println(h.getName() + "---------------" + h.getValue());}//读取HTTP响应内容，这⾥简单打印⽹页内容//读取为字节数组byte[] responseBody = getMethod.getResponseBody();response = new String(responseBody, charset);System.out.println("-----------response:" + response);//读取为InputStream，在⽹页内容数据量⼤时候推荐使⽤//InputStream response = getMethod.getResponseBodyAsStream();} catch (HttpException e) {//发⽣致命的异常，可能是协议不对或者返回的内容有问题System.out.println("请检查输⼊的URL!");e.printStackTrace();} catch (IOException e) {//发⽣⽹络异常System.out.println("发⽣⽹络异常!");} finally {//6.释放连接getMethod.releaseConnection();}return response;}/*** post请求* @param url* @param json* @return*/public static String doPost(String url, JSONObject json){HttpClient httpClient = new HttpClient();PostMethod postMethod = new PostMethod(url);postMethod.addRequestHeader("accept", "*/*");postMethod.addRequestHeader("connection", "Keep-Alive");//设置json格式传送postMethod.addRequestHeader("Content-Type", "application/json;charset=GBK");//必须设置下⾯这个HeaderpostMethod.addRequestHeader("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.81 Safari/537.36"); //添加请求参数postMethod.addParameter("commentId", json.getString("commentId"));String res = "";try {int code = httpClient.executeMethod(postMethod);if (code == 200){res = postMethod.getResponseBodyAsString();System.out.println(res);}} catch (IOException e) {e.printStackTrace();}return res;}public static void main(String[] args) {System.out.println(doGet("/cc/json/mobile_tel_segment.htm?tel=130********", "GBK"));System.out.println("-----------分割线------------");System.out.println("-----------分割线------------");System.out.println("-----------分割线------------");JSONObject jsonObject = new JSONObject();jsonObject.put("commentId", "130********");System.out.println(doPost("/cc/json/mobile_tel_segment.htm?tel=130********", jsonObject));}}3、建议代码复杂，还得操⼼资源回收等。
C#中HttpClient的简单使用
C#中HttpClient的简单使⽤介绍当我们在开发客户端还有少部分服务端程序时，数据需要从 Webapi 服务器取得。
在以前我使⽤的⽐较多的时和，在新的 .Net 版本中，团队为其带来了更多的可选择性——新的。
它有着更加灵活的 API。
发送请求和接收响应主要是通过 HttpRequestMessage 和HttpResponseMessage 这来给你个类，通过属性 Content 获取 http 响应内容。
区别HttpClient 与 WebClient 和 HttpWebRequest 相⽐，有以下⼏个主义的1. HttpClient 实例初始化时不与服务器域名或者主机地址绑定，也就是說可以通过⼀个 HttpClient 实例发送多个不同的请求（⽐如同⼀个HttpClient 请求和两个服务器数据）2. HttpClient 通过设置 DefaultHeaders 设置 HttpHeader 并且应⽤于该实例的所有请求3. HttpClient 使⽤可以很容易的处理异步请求（Async / Await）使⽤⽅法HttpClient 提供有与 Http Method 匹配的⽅法，⽐如 GET / POST / PUT ...等。
先实现模拟⼀个 GET 请求，代码如下// 传⼊参数 url 为请求地址async Task Get(string uri = "/search";){// 使⽤ using 语法建⽴⼀个明确周期的 HttpClient 实例using (HttpClient client = new HttpClient()){try{// 设置超时限制，有效防⽌浪费资源client.Timeout = TimeSpan.FromSeconds(30);//使⽤ GetAsync 进⾏异步 HTTPGET 请求HttpResponseMessage response = await client.GetAsync(uri);// 判断服务器响应代码是否为 2XXresponse.EnsureSuccessStatusCode();//使⽤ await 语法读取响应内容string responseBody = await response.Content.ReadAsStringAsync();Console.WriteLine(responseBody);}catch (HttpRequestException e){Console.WriteLine("Error Message :{0} ", e.Message);}}}除了直接使⽤与 Http Method 对应的⽅法外，还可以单独构建 HttpRequestMessage 实例进⾏请求async Task Get(string uri = "/search";){using (HttpClient client = new HttpClient()){HttpRequestMessage httpRequest = new HttpRequestMessage(HttpMethod.Get, uri);await client.SendAsync(httpRequest).ContinueWith(responseTask =>{Console.WriteLine("Response: {0}", responseTask.Result);});}}⾄于 Post 请求，对于初次接触 HttpClient 的⼈可能显得有些复杂，⽐较折腾，另⼀篇⽂章再讲解。
HttpClient、RestTemplate和Feign相关知识
HttpClient、RestTemplate和Feign相关知识#先了解⼀下HTTP 协议史前时期 HTTP 协议在我们的⽣活中随处可见，打开⼿机或者电脑，只要你上⽹，不论是⽤ iPhone、Android、Windows 还是 Mac，不论是⽤浏览器还是 App，不论是看新闻、短视频还是听⾳乐、玩游戏，后⾯总会有 HTTP 在默默为你服务。
据 NetCraft 公司统计，⽬前全球⾄少有 16 亿个⽹站、2 亿多个独⽴域名，⽽这个庞⼤⽹络世界的底层运转机制就是 HTTP。
那么，在享受如此便捷舒适的⽹络⽣活时，你有没有想过，HTTP 协议是怎么来的？它最开始是什么样⼦的？⼜是如何⼀步⼀步发展到今天，⼏乎“统治”了整个互联⽹世界的呢？ 20 世纪 60 年代，美国国防部⾼等研究计划署（ARPA）建⽴了 ARPA ⽹，它有四个分布在各地的节点，被认为是如今互联⽹的“始祖”。
然后在 70 年代，基于对 ARPA ⽹的实践和思考，研究⼈员发明出了著名的 TCP/IP 协议。
由于具有良好的分层结构和稳定的性能，TCP/IP 协议迅速战胜其他竞争对⼿流⾏起来，并在 80 年代中期进⼊了 UNIX 系统内核，促使更多的计算机接⼊了互联⽹。
创世纪 1989 年，任职于欧洲核⼦研究中⼼（CERN）的蒂姆·伯纳斯 - 李（Tim Berners-Lee）发表了⼀篇论⽂，提出了在互联⽹上构建超链接⽂档系统的构想。
这篇论⽂中他确⽴了三项关键技术。
URI：即统⼀资源标识符，作为互联⽹上资源的唯⼀⾝份；HTML：即超⽂本标记语⾔，描述超⽂本⽂档；HTTP：即超⽂本传输协议，⽤来传输超⽂本。
所以在这⼀年，我们的HTTP诞⽣了。
HTTP/0.9 20 世纪 90 年代初期的互联⽹世界⾮常简陋，计算机处理能⼒低，存储容量⼩，⽹速很慢，还是⼀⽚“信息荒漠”。
⽹络上绝⼤多数的资源都是纯⽂本，很多通信协议也都使⽤纯⽂本，所以 HTTP 的设计也不可避免地受到了时代的限制。
Httpclient表单，json,multipartform-data提交---总结常用的方法
Httpclient表单，json,multipartform-data提交---总结常⽤的⽅法最近在项⽬中，⼀直在使⽤HttpClient 中的⽅法，这⾥我进⾏⼀些⽅法的汇总，也是结合了⼀些⼤⽜写的代码，以备不时之需 官话：HttpClient 是Apache Jakarta Common 下的⼦项⽬，可以⽤来提供⾼效的、最新的、功能丰富的⽀持 HTTP 协议的客户端编程⼯具包，并且它⽀持 HTTP 协议最新的版本和建议 在我的博客我的常⽤⼯具了中有关于httpclient 的常⽤⽅法，在平常的开发中是⾜够⽤了----------在这⾥我细致的总结⼀下 1.我们在使⽤httpclient 第⼀步就是创建CloseableHttpClient 实例，这也是官⽅推荐⽅法：CloseableHttpClient httpclient = HttpClients.createDefault() 2.创建 httpget 与 httppost 的实例，我们进⾏⽹络连接的关键步骤：//post 请求HttpPost httppost =new HttpPost(url);// get请求HttpGet httpget =new HttpGet(url); 3. addHeader(arg0, arg1) ：见名知意，可以为我们请求加上请求头，cookie//加cookie 头httppost.addHeader("Cookie","JSESSIONID=fnwebidwn==");//User-Agenthttppost.addHeader("User-Agent","Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36"); ...... 4. httppost.setEntity(entity); 放⼊需要传递的参数，只出现在post ⽅法中，因为get直接在地址后⾯追加参数。
HttpClient设置连接超时时间
HttpClient设置连接超时时间使⽤HttpClient，⼀般都需要设置连接超时时间和获取数据超时时间。
这两个参数很重要，⽬的是为了防⽌访问其他http时，由于超时导致⾃⼰的应⽤受影响。
4.5版本中，这两个参数的设置都抽象到了RequestConfig中，由相应的Builder构建，具体的例⼦如下:CloseableHttpClient httpclient = HttpClients.createDefault();HttpGet httpGet = new HttpGet("");RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(5000).setConnectionRequestTimeout(1000).setSocketTimeout(5000).build();httpGet.setConfig(requestConfig);CloseableHttpResponse response = null;try {response = httpclient.execute(httpGet);} catch (IOException e) {e.printStackTrace();}System.out.println("得到的结果:" + response.getStatusLine());//得到请求结果HttpEntity entity = response.getEntity();//得到请求回来的数据String s = EntityUtils.toString(response.getEntity(), "UTF-8");System.out.println(s);setConnectTimeout：设置连接超时时间，单位毫秒。
Feign使用HttpClient和OkHttp方式
Feign使用HttpClient和OkHttp方式1. Feign使用HttpClient方式：Feign默认使用的是JDK自带的HttpURLConnection作为HTTP客户端，但也可以使用HttpClient进行替换。
使用HttpClient方式需要添加对应的依赖，例如Apache HttpClient。
a.添加依赖：```xml<dependency><version>4.5.13</version></dependency>```b. 配置FeignClient：```javapublic class FeignClientConfigreturn HttpClientBuilder.create(.build(;}public Feign.Builder feignBuilde}}c. 使用FeignClient：```javapublic interface ExampleClientString getExample(;}```2. Feign使用OkHttp方式：OkHttp是一个高效的HTTP客户端库，Feign也可以使用OkHttp替代默认的HTTP客户端。
a.添加依赖：```xml<dependency><version>4.9.1</version></dependency><dependency><groupId>io.github.openfeign</groupId><version>11.6</version></dependency>b. 配置FeignClient：```javapublic class FeignClientConfigpublic OkHttpClient okHttpClienreturn new OkHttpClient(;}public Feign.Builder feignBuildereturn Feign.builder(.client(new OkHttpClient();}}```c. 使用FeignClient：```javapublic interface ExampleClientString getExample(;}```总结：Feign支持使用HttpClient和OkHttp作为HTTP客户端，可以根据实际需求选择适合的方式。
HttpClient详细使用示例详解
HttpClient详细使⽤⽰例详解⽬录进⼊正题详细使⽤⽰例HttpClient 是Apache Jakarta Common 下的⼦项⽬，可以⽤来提供⾼效的、最新的、功能丰富的⽀持 HTTP 协议的客户端编程⼯具包，并且它⽀持 HTTP 协议最新的版本和建议。
HTTP 协议可能是现在 Internet 上使⽤得最多、最重要的协议了，越来越多的 Java 应⽤程序需要直接通过 HTTP 协议来访问⽹络资源。
虽然在 JDK 的 java net包中已经提供了访问 HTTP 协议的基本功能，但是对于⼤部分应⽤程序来说，JDK 库本⾝提供的功能还不够丰富和灵活。
HttpClient 是 Apache Jakarta Common 下的⼦项⽬，⽤来提供⾼效的、最新的、功能丰富的⽀持 HTTP 协议的客户端编程⼯具包，并且它⽀持 HTTP 协议最新的版本和建议。
HTTP和浏览器有点像，但却不是浏览器。
很多⼈觉得既然HttpClient是⼀个HTTP客户端编程⼯具，很多⼈把他当做浏览器来理解，但是其实HttpClient不是浏览器，它是⼀个HTTP通信库，因此它只提供⼀个通⽤浏览器应⽤程序所期望的功能⼦集，最根本的区别是HttpClient中没有⽤户界⾯，浏览器需要⼀个渲染引擎来显⽰页⾯，并解释⽤户输⼊，例如⿏标点击显⽰页⾯上的某处，有⼀个布局引擎，计算如何显⽰HTML页⾯，包括级联样式表和图像。
javascript解释器运⾏嵌⼊HTML页⾯或从HTML页⾯引⽤的javascript代码。
来⾃⽤户界⾯的事件被传递到javascript解释器进⾏处理。
除此之外，还有⽤于插件的接⼝，可以处理Applet，嵌⼊式媒体对象（如pdf⽂件，Quicktime电影和Flash动画）或ActiveX控件（可以执⾏任何操作）。
HttpClient只能以编程的⽅式通过其API⽤于传输和接受HTTP消息。
HttpClient的主要功能：实现了所有 HTTP 的⽅法（GET、POST、PUT、HEAD、DELETE、HEAD、OPTIONS 等）⽀持 HTTPS 协议⽀持代理服务器（Nginx等）等⽀持⾃动（跳转）转向……进⼊正题环境说明：JDK1.8、SpringBoot准备环节第⼀步：在pom.xml中引⼊HttpClient的依赖第⼆步：引⼊fastjson依赖注：本⼈引⼊此依赖的⽬的是，在后续⽰例中，会⽤到“将对象转化为json字符串的功能”，也可以引其他有此功能的依赖。
C#中HttpWebRequest、WebClient、HttpClient的使用详解
C#中HttpWebRequest、WebClient、HttpClient的使⽤详解HttpWebRequest:命名空间： ，这是.NET创建者最初开发⽤于使⽤HTTP请求的标准类。
使⽤HttpWebRequest可以让开发者控制请求/响应流程的各个⽅⾯，如 timeouts, cookies, headers, protocols。
另⼀个好处是HttpWebRequest类不会阻塞UI线程。
例如，当您从响应很慢的API服务器下载⼤⽂件时，您的应⽤程序的UI不会停⽌响应。
HttpWebRequest通常和WebResponse⼀起使⽤，⼀个发送请求，⼀个获取数据。
HttpWebRquest更为底层⼀些，能够对整个访问过程有个直观的认识，但同时也更加复杂⼀些。
123 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 //POST⽅法public static string HttpPost(string Url, string postDataStr){HttpWebRequest request = (HttpWebRequest)WebRequest.Create(Url);request.Method = "POST";request.ContentType = "application/x-www-form-urlencoded";Encoding encoding = Encoding.UTF8;byte[] postData = encoding.GetBytes(postDataStr);request.ContentLength = postData.Length;Stream myRequestStream = request.GetRequestStream();myRequestStream.Write(postData, 0, postData.Length);myRequestStream.Close();HttpWebResponse response = (HttpWebResponse)request.GetResponse();Stream myResponseStream = response.GetResponseStream();StreamReader myStreamReader = new StreamReader(myResponseStream, encoding);string retString = myStreamReader.ReadToEnd();myStreamReader.Close();myResponseStream.Close();return retString;}//GET⽅法public static string HttpGet(string Url, string postDataStr){HttpWebRequest request = (HttpWebRequest)WebRequest.Create(Url + (postDataStr == ""? "": "?") + postDataStr); request.Method = "GET";request.ContentType = "text/html;charset=UTF-8";HttpWebResponse response = (HttpWebResponse)request.GetResponse();Stream myResponseStream = response.GetResponseStream();StreamReader myStreamReader = new StreamReader(myResponseStream, Encoding.GetEncoding("utf-8"));string retString = myStreamReader.ReadToEnd();myStreamReader.Close();myResponseStream.Close();return retString;}WebClient：命名空间，WebClient是⼀种更⾼级别的抽象，是HttpWebRequest为了简化最常见任务⽽创建的，使⽤过程中你会发现他缺少基本的header，timeoust的设置，不过这些可以通过继承httpwebrequest来实现。
关于httpclient的总结
3..setCredentials(newAuthScope("localhost",443),
4.newUsernamePasswordCredentials("username","password"));
Java代码
1.(3)如果不想获取HTTPClient返回的信息
21.for(inti =0; i < cookies.size(); i++) {
22.System.out.println("Local cookie: "+ cookies.get(i));
23.}
24.//获取消息头的信息
25.Header[] headers = response.getAllHeaders();
5.File file =newFile(args[0]);
6.InputStreamEntity reqEntity =newInputStreamEntity(
7.newFileInputStream(file), -1);
8.reqEntity.setContentType("binary/octet-stream");
12.HttpResponse response = httpclient.execute(httpget, localContext);
13.//获取本地信息
14.HttpEntity entity = response.getEntity();
15.System.out.println(response.getStatusLine());
C#客户端HttpClient请求认证及数据传输
C#客户端HttpClient请求认证及数据传输⽬录⼀，授权认证1. 基础认证⽰例2. JWT 认证⽰例3. Cookie ⽰例⼆，请求类型三，数据传输1. Query2. Header3. 表单4. JSON5. 上传⽂件⼀，授权认证客户端请求服务器时，需要通过授权认证许可，⽅能获取服务器资源，⽬前⽐较常见的认证⽅式有 Basic 、JWT、Cookie。
HttpClient 是 C# 中的 HTTP/HTTPS 客户端，⽤于发送 HTTP 请求和接收来⾃通过 URI 确认的资源的 HTTP 响应。
下⾯以具体代码做⽰范。
1. 基础认证⽰例// Basic基础认证public async Task Basic(string user, string password, string url){// 如果认证页⾯是 https 的，请参考⼀下 jwt 认证的 HttpClientHandler// 创建 clientHttpClient client = new HttpClient();// 创建⾝份认证// using .Http.Headers;AuthenticationHeaderValue authentication = new AuthenticationHeaderValue("Basic",Convert.ToBase64String(Encoding.UTF8.GetBytes($"{user}:{password}")));client.DefaultRequestHeaders.Authorization = authentication;byte[] response = await client.GetByteArrayAsync(url);client.Dispose();}可以看到 Basic 认证的安全程度⾮常低，多⽤于路由器和嵌⼊式设备，⽽且往往不会使⽤ HTTPS。
httpclient使用详解
httpclient使用详解Http协议的重要性相信不用我多说了，HttpClient相比传统JDK自带的URLConnection，增加了易用性和灵活性（具体区别，日后我们再讨论），它不仅是客户端发送Http请求变得容易，而且也方便了开发人员测试接口（基于Http协议的），即提高了开发的效率，也方便提高代码的健壮性。
因此熟练掌握HttpClient是很重要的必修内容，掌握HttpClient后，相信对于Http协议的了解会更加深入。
一、简介HttpClient是Apache Jakarta Common下的子项目，用来提供高效的、最新的、功能丰富的支持HTTP协议的客户端编程工具包，并且它支持HTTP协议最新的版本和建议。
HttpClient已经应用在很多的项目中，比如Apache Jakarta上很著名的另外两个开源项目Cactus和HTMLUnit都使用了HttpClient。
下载地址: /downloads.cgi二、特性1. 基于标准、纯净的Java语言。
实现了Http1.0和Http1.12. 以可扩展的面向对象的结构实现了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策略。
httpclient超时时间设置及代理设置
httpclient超时时间设置及代理设置设置HttpClient的超时时间，⾮常有必要性，因为httpclient 默认超时时间很长，⾃⼰可以测试⼀下是多久，设置超时时间否则会影响⾃⼰系统的业务逻辑，例如阻塞系统，影响系统的吞吐量，占⽤线程数。
httpclient 4.4版本之后将这些设置封装到 RequestConfig 对象⾥，其中 setConnectTimeout 是设置连接到⽬标 URL 的等待时长，超过这个时间还没连上就抛出连接超时；setConnectionRequestTimeout 是从connect Manager（连接池）获取连接的等待时长，这个版本是共享连接池的；setSocketTimeout 是连接到⽬标URL 之后等待返回响应的时长，即超过这个时间就放弃本次调⽤并抛出 SocketTimeoutException:Read Time Outpublic static RequestConfig getRequestConfig(){RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(10000).setSocketTimeout(10000).setConnectionRequestTimeout(6000).build();return requestConfig;}有时候我们线上访问外部第三⽅的接⼝的时候，不想暴露真实机器的IP，或者我们的机器不能访问外⽹的时候，我们可以通过代理服务器来访问，代理服务器充当内⽹与外⽹链接的中间⼈。
httpclient 4.4后设置代理的 IP、端⼝被封装到 RequestConfig 对象⾥，通过 HttpHost 对象封装代理的 IP、端⼝和协议。
这⾥需要注意的⼀点是，如果你的⽬标 URL 是 HTTP 协议的，那么你的代理也应该是 HTTP 协议的，如下 HttpHost 的构造⽅法可以指定代理服务的协议，不传默认为HTTPpublic static RequestConfig getRequestConfig(){HttpHost proxy = new HttpHost("代理ip",443,"HTTP");//代理RequestConfig requestConfig = RequestConfig.custom().setProxy(proxy).setConnectTimeout(10000).setSocketTimeout(10000).setConnectionRequestTimeout(6000).build();return requestConfig;}然后通过 HttpPost 或 HttpGet 的setConfig()⽅法使其应⽤到该 configHttpPost httpPost = new HttpPost(url);if(null != requestConfig){httpPost.setConfig(requestConfig);}。
Java调用HttpHttps接口（4）--HttpClient调用HttpHttps接口
Java调⽤HttpHttps接⼝（4）--HttpClient调⽤HttpHttps接⼝HttpClient是Apache HttpComponents项⽬下的⼀个组件，是Commons-HttpClient的升级版，两者api调⽤写法也很类似。
⽂中所使⽤到的软件版本：Java 1.8.0_191、HttpClient 4.5.10。
1、服务端参见2、调⽤Http接⼝2.1、GET请求public static void get() {String requestPath = "http://localhost:8080/demo/httptest/getUser?userId=1000&userName=李⽩";CloseableHttpClient httpClient = HttpClients.createDefault();try {HttpGet get = new HttpGet(requestPath);CloseableHttpResponse response = httpClient.execute(get);System.out.println("GET返回状态：" + response.getStatusLine());HttpEntity responseEntity = response.getEntity();System.out.println("GET返回结果：" + EntityUtils.toString(responseEntity));//流畅api调⽤String result = Request.Get(requestPath).execute().returnContent().asString(Charset.forName("utf-8"));System.out.println("GET fluent返回结果：" + result);} catch (Exception e) {e.printStackTrace();} finally {close(httpClient);}}2.2、POST请求(发送键值对数据）public static void post() {String requestPath = "http://localhost:8080/demo/httptest/getUser";CloseableHttpClient httpClient = HttpClients.createDefault();try {HttpPost post = new HttpPost(requestPath);List<NameValuePair> list = new ArrayList<NameValuePair>();list.add(new BasicNameValuePair("userId", "1000"));list.add(new BasicNameValuePair("userName", "李⽩"));post.setEntity(new UrlEncodedFormEntity(list, "utf-8"));CloseableHttpResponse response = httpClient.execute(post);System.out.println("POST返回状态：" + response.getStatusLine());HttpEntity responseEntity = response.getEntity();System.out.println("POST返回结果：" + EntityUtils.toString(responseEntity));//流畅api调⽤String result = Request.Post(requestPath).bodyForm(Form.form().add("userId", "1000").add("userName", "李⽩").build(), Charset.forName("utf-8")).execute().returnContent().asString(Charset.forName("utf-8"));System.out.println("POST fluent返回结果：" + result);} catch (Exception e) {e.printStackTrace();} finally {close(httpClient);}}2.3、POST请求(发送JSON数据）public static void post2() {String requestPath = "http://localhost:8080/demo/httptest/addUser";CloseableHttpClient httpClient = HttpClients.createDefault();try {HttpPost post = new HttpPost(requestPath);post.setHeader("Content-type", "application/json");String param = "{\"userId\": \"1001\",\"userName\":\"杜甫\"}";post.setEntity(new StringEntity(param, "utf-8"));CloseableHttpResponse response = httpClient.execute(post);System.out.println("POST json返回状态：" + response.getStatusLine());HttpEntity responseEntity = response.getEntity();System.out.println("POST josn返回结果：" + EntityUtils.toString(responseEntity));//流畅api调⽤String result = Request.Post(requestPath).addHeader("Content-type", "application/json").bodyString(param, ContentType.APPLICATION_JSON).execute().returnContent().asString(Charset.forName("utf-8"));System.out.println("POST json fluent返回结果：" + result);} catch (Exception e) {e.printStackTrace();} finally {close(httpClient);}}2.4、上传⽂件public static void upload() {String requestPath = "http://localhost:8080/demo/httptest/upload";CloseableHttpClient httpClient = HttpClients.createDefault();try {HttpPost post = new HttpPost(requestPath);FileInputStream fileInputStream = new FileInputStream("d:/a.jpg");post.setEntity(new InputStreamEntity(fileInputStream));CloseableHttpResponse response = httpClient.execute(post);System.out.println("upload返回状态：" + response.getStatusLine());HttpEntity responseEntity = response.getEntity();System.out.println("upload返回结果：" + EntityUtils.toString(responseEntity));//流畅api调⽤String result = Request.Post(requestPath).bodyStream(new FileInputStream("d:/a.jpg")).execute().returnContent().asString(Charset.forName("utf-8"));System.out.println("upload fluent返回结果：" + result);} catch (Exception e) {e.printStackTrace();} finally {close(httpClient);}}2.5、上传⽂件及发送键值对数据public static void multi() {String requestPath = "http://localhost:8080/demo/httptest/multi";CloseableHttpClient httpClient = HttpClients.createDefault();try {HttpPost post = new HttpPost(requestPath);FileBody file = new FileBody(new File("d:/a.jpg"));HttpEntity requestEntity = MultipartEntityBuilder.create().addPart("file", file).addPart("param1", new StringBody("参数1", ContentType.create(ContentType.TEXT_PLAIN.getMimeType(), "utf-8"))) .addPart("param2", new StringBody("参数2", ContentType.create(ContentType.TEXT_PLAIN.getMimeType(), "utf-8"))) .build();post.setEntity(requestEntity);CloseableHttpResponse response = httpClient.execute(post);System.out.println("multi返回状态：" + response.getStatusLine());HttpEntity responseEntity = response.getEntity();System.out.println("multi返回结果：" + EntityUtils.toString(responseEntity));//流畅api调⽤String result = Request.Post(requestPath).body(MultipartEntityBuilder.create().addPart("file", file).addPart("param1", new StringBody("参数1", ContentType.create(ContentType.TEXT_PLAIN.getMimeType(), "utf-8"))) .addPart("param2", new StringBody("参数2", ContentType.create(ContentType.TEXT_PLAIN.getMimeType(), "utf-8"))) .build()).execute().returnContent().asString(Charset.forName("utf-8"));System.out.println("multi fluent返回结果：" + result);} catch (Exception e) {e.printStackTrace();} finally {close(httpClient);}}2.6、完整例⼦package com.inspur.demo.http.client;import java.io.File;import java.io.FileInputStream;import java.io.IOException;import java.nio.charset.Charset;import java.util.ArrayList;import java.util.List;import org.apache.http.HttpEntity;import ValuePair;import org.apache.http.client.entity.UrlEncodedFormEntity;import org.apache.http.client.fluent.Form;import org.apache.http.client.fluent.Request;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.entity.ContentType;import org.apache.http.entity.InputStreamEntity;import org.apache.http.entity.StringEntity;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;/*** 通过HttpClient调⽤Http接⼝*/public class HttpClientCase {/*** GET请求*/public static void get() {String requestPath = "http://localhost:8080/demo/httptest/getUser?userId=1000&userName=李⽩";CloseableHttpClient httpClient = HttpClients.createDefault();try {HttpGet get = new HttpGet(requestPath);CloseableHttpResponse response = httpClient.execute(get);System.out.println("GET返回状态：" + response.getStatusLine());HttpEntity responseEntity = response.getEntity();System.out.println("GET返回结果：" + EntityUtils.toString(responseEntity));//流畅api调⽤String result = Request.Get(requestPath).execute().returnContent().asString(Charset.forName("utf-8"));System.out.println("GET fluent返回结果：" + result);} catch (Exception e) {e.printStackTrace();} finally {close(httpClient);}}/*** POST请求(发送键值对数据)*/public static void post() {String requestPath = "http://localhost:8080/demo/httptest/getUser";CloseableHttpClient httpClient = HttpClients.createDefault();try {HttpPost post = new HttpPost(requestPath);List<NameValuePair> list = new ArrayList<NameValuePair>();list.add(new BasicNameValuePair("userId", "1000"));list.add(new BasicNameValuePair("userName", "李⽩"));post.setEntity(new UrlEncodedFormEntity(list, "utf-8"));CloseableHttpResponse response = httpClient.execute(post);System.out.println("POST返回状态：" + response.getStatusLine());HttpEntity responseEntity = response.getEntity();System.out.println("POST返回结果：" + EntityUtils.toString(responseEntity));//流畅api调⽤String result = Request.Post(requestPath).bodyForm(Form.form().add("userId", "1000").add("userName", "李⽩").build(), Charset.forName("utf-8")) .execute().returnContent().asString(Charset.forName("utf-8"));System.out.println("POST fluent返回结果：" + result);} catch (Exception e) {e.printStackTrace();} finally {close(httpClient);}}/*** POST请求(发送json数据)*/public static void post2() {String requestPath = "http://localhost:8080/demo/httptest/addUser";CloseableHttpClient httpClient = HttpClients.createDefault();try {HttpPost post = new HttpPost(requestPath);post.setHeader("Content-type", "application/json");String param = "{\"userId\": \"1001\",\"userName\":\"杜甫\"}";post.setEntity(new StringEntity(param, "utf-8"));CloseableHttpResponse response = httpClient.execute(post);System.out.println("POST json返回状态：" + response.getStatusLine());HttpEntity responseEntity = response.getEntity();System.out.println("POST josn返回结果：" + EntityUtils.toString(responseEntity));//流畅api调⽤String result = Request.Post(requestPath).addHeader("Content-type", "application/json").bodyString(param, ContentType.APPLICATION_JSON).execute().returnContent().asString(Charset.forName("utf-8"));System.out.println("POST json fluent返回结果：" + result);} catch (Exception e) {e.printStackTrace();} finally {close(httpClient);}}/*** 上传⽂件*/public static void upload() {String requestPath = "http://localhost:8080/demo/httptest/upload";CloseableHttpClient httpClient = HttpClients.createDefault();try {HttpPost post = new HttpPost(requestPath);FileInputStream fileInputStream = new FileInputStream("d:/a.jpg");post.setEntity(new InputStreamEntity(fileInputStream));CloseableHttpResponse response = httpClient.execute(post);System.out.println("upload返回状态：" + response.getStatusLine());HttpEntity responseEntity = response.getEntity();System.out.println("upload返回结果：" + EntityUtils.toString(responseEntity));//流畅api调⽤String result = Request.Post(requestPath).bodyStream(new FileInputStream("d:/a.jpg")).execute().returnContent().asString(Charset.forName("utf-8"));System.out.println("upload fluent返回结果：" + result);} catch (Exception e) {e.printStackTrace();} finally {close(httpClient);}}/*** 上传⽂件及发送键值对数据*/public static void multi() {String requestPath = "http://localhost:8080/demo/httptest/multi";CloseableHttpClient httpClient = HttpClients.createDefault();try {HttpPost post = new HttpPost(requestPath);FileBody file = new FileBody(new File("d:/a.jpg"));HttpEntity requestEntity = MultipartEntityBuilder.create().addPart("file", file).addPart("param1", new StringBody("参数1", ContentType.create(ContentType.TEXT_PLAIN.getMimeType(), "utf-8"))) .addPart("param2", new StringBody("参数2", ContentType.create(ContentType.TEXT_PLAIN.getMimeType(), "utf-8"))) .build();post.setEntity(requestEntity);CloseableHttpResponse response = httpClient.execute(post);System.out.println("multi返回状态：" + response.getStatusLine());HttpEntity responseEntity = response.getEntity();System.out.println("multi返回结果：" + EntityUtils.toString(responseEntity));//流畅api调⽤String result = Request.Post(requestPath).body(MultipartEntityBuilder.create().addPart("file", file).addPart("param1", new StringBody("参数1", ContentType.create(ContentType.TEXT_PLAIN.getMimeType(), "utf-8"))) .addPart("param2", new StringBody("参数2", ContentType.create(ContentType.TEXT_PLAIN.getMimeType(), "utf-8"))).build()).execute().returnContent().asString(Charset.forName("utf-8"));System.out.println("multi fluent返回结果：" + result);} catch (Exception e) {e.printStackTrace();} finally {close(httpClient);}}private static void close(CloseableHttpClient httpClient) {try {if (httpClient != null) {httpClient.close();}} catch (IOException e) {e.printStackTrace();}}public static void main(String[] args) {get();post();post2();upload();multi();}}View Code3、调⽤Https接⼝与调⽤Http接⼝不⼀样的部分主要在设置ssl部分，其ssl的设置与HttpsURLConnection很相似(参见)；下⾯⽤GET请求来演⽰ssl的设置，其他调⽤⽅式类似。
HttpClient连接池的一些思考
HttpClient连接池的⼀些思考前⾔在分布式系统中，http服务调⽤少不了HttpClient⼯具类。
相信⼤家使⽤apache的HttpClient进⾏http的交互处理已经很长时间了，⽽httpclient内部其实使⽤了http连接池，想必⼤家也没有关⼼过连接池的管理。
事实上，通过分析httpclient源码，发现它很优雅地隐藏了所有的连接池管理细节，开发者完全不⽤花太多时间去思考连接池的问题。
但是连接池的⼀些常⽤配置和原理都需要我们多少掌握⼀些，避免错⽤导致⽣产环境出现⽆法预知的bug。
我之前遇到过⽣产环境系统使⽤HttpClient⼯具类导致系统假死的问题。
情景1：httpclient调⽤服务时没有设置超时时间，http线程都处于⾃⾝阻塞状态，拖垮应⽤服务器。
情景2：httpclient连接池单个路由最⼤连接数设置不合理，业务⾼峰期时⽆法及时从连接池中获取连接，导致http线程都处于BLOCKED（阻塞于锁）状态，逐渐拖垮应⽤服务器。
从以上两个场景分析⼀下，⾸先对于超时时间的设置，要考虑http请求连接超时、http请求读取内容超时、从连接池中获取可⽤http连接超时，要根据具体的业务场景合理化配置。
还有就是最⼤连接池数和每个路由最⼤连接数配置，也需要考虑哪些业务是否有业务⾼峰期然后合理配置，针对特殊的业务设置使⽤唯⼀的HttpClient，即为该业务创建指定的线程池。
Apache官⽹例⼦CloseableHttpClient httpclient = HttpClients.createDefault();HttpGet httpget = new HttpGet("http://localhost/");CloseableHttpResponse response = httpclient.execute(httpget);try {HttpEntity entity = response.getEntity();if (entity != null) {long len = entity.getContentLength();if (len != -1 && len < 2048) {System.out.println(EntityUtils.toString(entity));} else {// Stream content out}}} finally {response.close();}HttpClient及其连接池配置整个线程池中最⼤连接数 MAX_CONNECTION_TOTAL = 800路由到某台主机最⼤并发数，是MAX_CONNECTION_TOTAL（整个线程池中最⼤连接数）的⼀个细分 ROUTE_MAX_COUNT = 500重试次数，防⽌失败情况 RETRY_COUNT = 3客户端和服务器建⽴连接的超时时间 CONNECTION_TIME_OUT = 5000客户端从服务器读取数据的超时时间 READ_TIME_OUT = 7000从连接池中获取连接的超时时间 CONNECTION_REQUEST_TIME_OUT = 5000连接空闲超时，清楚闲置的连接 CONNECTION_IDLE_TIME_OUT = 5000连接保持存活时间 DEFAULT_KEEP_ALIVE_TIME_MILLIS = 20 * 1000MaxtTotal和DefaultMaxPerRoute的区别MaxtTotal是整个池⼦的⼤⼩；DefaultMaxPerRoute是根据连接到的主机对MaxTotal的⼀个细分；HttpClient连接池模型HttpClient从连接池中获取连接源码分析org.apache.http.pool.AbstractConnPoolprivate E getPoolEntryBlocking(final T route, final Object state,final long timeout, final TimeUnit tunit,final PoolEntryFuture<E> future)throws IOException, InterruptedException, TimeoutException {Date deadline = null;if (timeout > 0) {deadline = new Date(System.currentTimeMillis() + tunit.toMillis(timeout));}this.lock.lock();try {final RouteSpecificPool<T, C, E> pool = getPool(route);//这是每⼀个路由细分出来的连接池E entry = null;while (entry == null) {Asserts.check(!this.isShutDown, "Connection pool shut down");//从池⼦中获取⼀个可⽤连接并返回for (;;) {entry = pool.getFree(state);if (entry == null) {break;}if (entry.isExpired(System.currentTimeMillis())) {entry.close();} else if (this.validateAfterInactivity > 0) {if (entry.getUpdated() + this.validateAfterInactivity <= System.currentTimeMillis()) {if (!validate(entry)) {entry.close();}}}if (entry.isClosed()) {this.available.remove(entry);pool.free(entry, false);} else {break;}}if (entry != null) {this.available.remove(entry);this.leased.add(entry);onReuse(entry);return entry;}//创建新的连接// New connection is neededfinal int maxPerRoute = getMax(route);//获取当前路由最⼤并发数// Shrink the pool prior to allocating a new connectionfinal int excess = Math.max(0, pool.getAllocatedCount() + 1 - maxPerRoute);if (excess > 0) {//如果当前路由对应的连接池的连接超过最⼤路由并发数，获取到最后使⽤的⼀次连接，释放掉for (int i = 0; i < excess; i++) {final E lastUsed = pool.getLastUsed();if (lastUsed == null) {break;}lastUsed.close();this.available.remove(lastUsed);pool.remove(lastUsed);}}//尝试创建新的连接if (pool.getAllocatedCount() < maxPerRoute) {//当前路由对应的连接池可⽤空闲连接数+当前路由对应的连接池已⽤连接数 < 当前路由对应的连接池最⼤并发数final int totalUsed = this.leased.size();final int freeCapacity = Math.max(this.maxTotal - totalUsed, 0);if (freeCapacity > 0) {final int totalAvailable = this.available.size();if (totalAvailable > freeCapacity - 1) {//线程池中可⽤空闲连接数 > (线程池中最⼤连接数 - 线程池中已⽤连接数 - 1)if (!this.available.isEmpty()) {final E lastUsed = this.available.removeLast();lastUsed.close();final RouteSpecificPool<T, C, E> otherpool = getPool(lastUsed.getRoute());otherpool.remove(lastUsed);}}final C conn = this.connFactory.create(route);entry = pool.add(conn);this.leased.add(entry);return entry;}}boolean success = false;try {pool.queue(future);this.pending.add(future);success = future.await(deadline);} finally {// In case of 'success', we were woken up by the// connection pool and should now have a connection// waiting for us, or else we're shutting down.// Just continue in the loop, both cases are checked.pool.unqueue(future);this.pending.remove(future);}// check for spurious wakeup vs. timeoutif (!success && (deadline != null) &&(deadline.getTime() <= System.currentTimeMillis())) {break;}}throw new TimeoutException("Timeout waiting for connection");} finally {this.lock.unlock();}}HttpClient从连接池中获取连接流程图连接重⽤和保持策略http的长连接复⽤，其判定规则主要分两类。
httpclient
Header locationHeader = postMethod.getResponseHeader("location");
String location = null;
if (locationHeader != null) {
//执行getMethod
int statusCode = client.executeMethod(getMethod);
if (statusCode != HttpStatus.SC_OK) {
System.err.println("Method failed: " + getMethod.getStatusLine());
System.out.println(new String(responseBody));
下面是程序的完整代码，这些代码也可在附件中的test.GetSample中找到。
package test;
import java.io.IOException;
import mons.httpclient.*;
? 创建GET方法的实例。在GET方法的构造函数中传入待连接的地址即可。用GetMethod将会自动处理转发过程，如果想要把自动处理转发过程去掉的话，可以调用方法setFollowRedirects(false)。
GetMethod getMethod = new GetMethod("/");
// HttpClient对于要求接受后继服务的请求，象POST和PUT等不能自动处理转发
// 301或者302
if (statusCode == HttpStatus.SC_MOVED_PERMANENTLY ||
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
1.1 1.2 1.3 1.4 1.5 1.6 什么是 httpclient httpclient的工作原理 如何使用httpclient httpclient的常用方法
1.1 什么是httpclient？
HTTP 协议可能是现在 Internet 上使用得最多、最重 要的协议了，越来越多的 Java 应用程序需要直接通 过 HTTP 协议来访问网络资源。虽然在 JDK 的 java net包中已经提供了访问 HTTP 协议的基本功能，但 是对于大部分应用程序来说，JDK 库本身提供的功能 还不够丰富和灵活。HttpClient是 Apache Jakarta Common 下的子项目，用来提供高效的、最新的、 功能丰富的支持 HTTP 协议的客户端编程工具包，并 且它支持 HTTP 协议最新的版本和建议。HttpClient 已经应用在很多的项目中，比如 Apache Jakarta 上 很著名的另外两个开源项目 Cactus 和 HTMLUnit 都 使用了 HttpClient。现在HttpClient最新版本为 HttpClient 4.2 (GA)
• Httpclient的Get方法 • Httpclient的Post方法
1.3 如何使用httpclient
步骤三： 在完成了前两个实例的创建之后，就需要 调用httpclient的execute()方法，该方法的 参数为方法实例，代码如下：
HttpResponse httpResponse = httpClient.execute(httpget);1.4 httpclient Nhomakorabea常用方法
1.2 httpclient的工作原理
1.3 如何使用httpclient
步骤一： 在使用httpclient时我们必须得要创建一个 httpclient的实例，代码如下：
HttpClient httpClient = new DefaultHttpClient();
1.3 如何使用httpclient
步骤二： 在创建了httpclient的实例过后需要选择建 立连接时需要使用的方法（具体将在1.3节 中详细讲解）并创建方法实例，代码如下：
HttpPost httppost = new HttpPost(strUrl); HttpGet httpget = new HttpPost(strUrl); 这两段代码我们一次只会使用其中一句，根据具 体情况而定。