httpclient
C# 自带 HttpClient我这段代码为什么会报请求没完成就发另一个呢 我觉得完成了啊
C# 自带 HttpClient我这段代码为什么会报请求没完成就发
另一个呢我觉得完成了啊
C# 自带的 HttpClient 封装了访问 HTTP 服务的方法。
它可以使用GET 和 POST 等方法及时发送 HTTP 请求并获取 HTTP 响应的返回值。
但是在使用的过程中，有时候会发生一种情况，就是在一次请求还没
有完成时，就会发起另一次请求，从而导致报错。
主要原因是因为 C# 中的 Httpclient 并没有设置最大连接数的限制，因此可能会出现快速攻击的行为而失败。
另外，使用过程中，重复建
立 HttpClient 实例的情况也可能会出现失败的情况。
毕竟，如果不
断的建立新的 HttpClient 实例，则会造成内存占用问题，也可能导
致请求失败。
总而言之，要避免 HttpClient 报请求没完成就发另一个的情况，要
做的就是控制好 HttpClient 的连接数，避免连接数过多，把建立实
例的行为放在一个固定的循环外，避免在一个请求未完成前就去建立
新的实例。
使用HttpClient实现文件的上传下载方法
使⽤HttpClient实现⽂件的上传下载⽅法1 HTTPHTTP 协议可能是现在 Internet 上使⽤得最多、最重要的协议了，越来越多的 Java 应⽤程序需要直接通过 HTTP 协议来访问⽹络资源。
虽然在 JDK 的 包中已经提供了访问 HTTP 协议的基本功能，但是对于⼤部分应⽤程序来说，JDK 库本⾝提供的功能还不够丰富和灵活。
HttpClient ⽤来提供⾼效的、最新的、功能丰富的⽀持 HTTP 协议的客户端编程⼯具包，并且它⽀持HTTP 协议最新的版本和建议。
⼀般的情况下我们都是使⽤Chrome或者其他浏览器来访问⼀个WEB服务器，⽤来浏览页⾯查看信息或者提交⼀些数据、⽂件上传下载等等。
所访问的这些页⾯有的仅仅是⼀些普通的页⾯，有的需要⽤户登录后⽅可使⽤，或者需要认证以及是⼀些通过加密⽅式传输，例如HTTPS。
⽬前我们使⽤的浏览器处理这些情况都不会构成问题。
但是⼀旦我们有需求不通过浏览器来访问服务器的资源呢？那该怎么办呢？下⾯以本地客户端发起⽂件的上传、下载为例做个⼩Demo。
HttpClient有两种形式，⼀种是org.apache.http下的，⼀种是mons.httpclient.HttpClient。
2 ⽂件上传⽂件上传可以使⽤两种⽅式实现，⼀种是PostMethod⽅式，⼀种是HttpPost⽅式。
两者的处理⼤同⼩异。
PostMethod是使⽤FileBody将⽂件包装流包装起来，HttpPost是使⽤FilePart将⽂件流包装起来。
在传递⽂件流给服务端的时候，都可以同时传递其他的参数。
2.1 客户端处理2.1.1 PostMethod⽅式将⽂件封装到FilePart中，放⼊Part数组，同时，其他参数可以放⼊StringPart中，这⾥没有写，只是单纯的将参数以setParameter的⽅式进⾏设置。
此处的HttpClient是mons.httpclient.HttpClient。
浅谈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、建议代码复杂，还得操⼼资源回收等。
异步httpclient（httpasyncclient）的使用与总结
异步httpclient（httpasyncclient）的使⽤与总结参考：1. 前⾔应⽤层的⽹络模型有同步与异步。
同步意味当前线程是阻塞的，只有本次请求完成后才能进⾏下⼀次请求;异步意味着所有的请求可以同时塞⼊缓冲区,不阻塞当前的线程;httpclient在4.x之后开始提供基于nio的异步版本httpasyncclient,httpasyncclient借助了Java并发库和nio进⾏封装(虽说NIO是同步⾮阻塞IO,但是HttpAsyncClient提供了回调的机制,与netty类似,所以可以模拟类似于AIO的效果),其调⽤⽅式⾮常便捷,但是其中也有许多需要注意的地⽅。
2. pom⽂件本⽂依赖4.1.2,当前最新的客户端版本是4.1.3maven repository 地址<dependency><groupId>org.apache.httpcomponents</groupId><artifactId>httpclient</artifactId><version>4.5.2</version></dependency><dependency><groupId>org.apache.httpcomponents</groupId><artifactId>httpcore</artifactId><version>4.4.5</version></dependency><dependency><groupId>org.apache.httpcomponents</groupId><artifactId>httpcore-nio</artifactId><version>4.4.5</version></dependency><dependency><groupId>org.apache.httpcomponents</groupId><artifactId>httpasyncclient</artifactId><version>4.1.2</version></dependency>12345678910111213141516171819202122233. 简单的实例public class TestHttpClient {public static void main(String[] args){RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(50000).setSocketTimeout(50000).setConnectionRequestTimeout(1000).build();//配置io线程IOReactorConfig ioReactorConfig = IOReactorConfig.custom().setIoThreadCount(Runtime.getRuntime().availableProcessors()).setSoKeepAlive(true).build();//设置连接池⼤⼩ConnectingIOReactor ioReactor=null;try {ioReactor = new DefaultConnectingIOReactor(ioReactorConfig);} catch (IOReactorException e) {e.printStackTrace();}PoolingNHttpClientConnectionManager connManager = new PoolingNHttpClientConnectionManager(ioReactor); connManager.setMaxTotal(100);connManager.setDefaultMaxPerRoute(100);final CloseableHttpAsyncClient client = HttpAsyncClients.custom().setConnectionManager(connManager).setDefaultRequestConfig(requestConfig).build();//构造请求String url = "http://127.0.0.1:9200/_bulk";HttpPost httpPost = new HttpPost(url);StringEntity entity = null;try {String a = "{ \"index\": { \"_index\": \"test\", \"_type\": \"test\"} }\n" +"{\"name\": \"上海\",\"age\":33}\n";entity = new StringEntity(a);} catch (UnsupportedEncodingException e) {e.printStackTrace();}httpPost.setEntity(entity);//startclient.start();//异步请求client.execute(httpPost, new Back());while(true){try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}}}static class Back implements FutureCallback<HttpResponse>{private long start = System.currentTimeMillis();Back(){}public void completed(HttpResponse httpResponse) {try {System.out.println("cost is:"+(System.currentTimeMillis()-start)+":"+EntityUtils.toString(httpResponse.getEntity())); } catch (IOException e) {e.printStackTrace();}}public void failed(Exception e) {System.err.println(" cost is:"+(System.currentTimeMillis()-start)+":"+e);}public void cancelled() {2 3 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 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66717273747576777879808182834. ⼏个重要的参数4.1 TimeOut(3个)的设置ConnectTimeout : 连接超时,连接建⽴时间,三次握⼿完成时间。
HttpClient接口测试之会话保持
HttpClient接⼝测试之会话保持HttpClient接⼝测试之会话保持HttpClient4.X⾃带会话保持功能，使⽤同⼀个HttpClient未关闭的连接即可保持登陆会话，如果多个HttpClient想要使⽤⼀个登陆会话，则需要保存会话信息，其中⼀种⽅法是使⽤HttpClientContext。
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.methods.CloseableHttpResponse;import org.apache.http.client.methods.HttpGet;import org.apache.http.client.methods.HttpPost;import org.apache.http.client.protocol.HttpClientContext;import org.apache.http.impl.client.CloseableHttpClient;import org.apache.http.impl.client.HttpClients;import org.apache.http.message.BasicNameValuePair;import org.apache.http.protocol.BasicHttpContext;import org.apache.http.protocol.HttpContext;import org.apache.http.util.EntityUtils;import org.junit.Test;import com.test.tools.Regular;public class HttpClientTest {String loginUrl = "http://**.***.com/user/login.do";private static HttpContext localContext = new BasicHttpContext();private static HttpClientContext context = HttpClientContext.adapt(localContext);@Testpublic void Test() throws Exception {CloseableHttpClient httpClient = HttpClients.createDefault();try {// 模拟表单List<NameValuePair> params = new ArrayList<NameValuePair>();params.add(new BasicNameValuePair("username", "admin"));params.add(new BasicNameValuePair("password", "admin"));UrlEncodedFormEntity entity = new UrlEncodedFormEntity(params, "UTF-8");HttpPost httpPost = new HttpPost(loginUrl);httpPost.setEntity(entity);// 将HttpClientContext传⼊execute()中CloseableHttpResponse response = httpClient.execute(httpPost, context);try {HttpEntity responseEntity = response.getEntity();System.out.println(EntityUtils.toString(responseEntity));} finally {response.close();}} finally {httpClient.close();进⼊⾸页设置相同的HttpClientContext正则提取响应信息中的⽤户名通过这种⽅式可以进⾏接⼝测试，也可以加⼊断⾔事务，添加多线程并发进⾏接⼝性能测试。
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 的设计也不可避免地受到了时代的限制。
HttpClient3、4基本用法
=======================HttpClient3 Get========================
GetMethod get = new GetMethod(url)
HttpMethodParams params = new HttpMethodParams();
httpclient.getParams().setParameter(E_EXPECT_CONTINUE, Boolean.FALSE);
httpclient.getParams().setParameter(CoreProtocolPNames.HTTP_CONTENT_CHARSET, charset == null ? CHARSET_GBK : charset);
//httpclient.setHttpRequestRetryHandler(requestRetryHandler);//请求重试Handler
//httpclient.setRedirectHandler();//重定向的处理(默认的DefaultRedirectHandler能够支持get,head自动重eout(5000);//http连接超时
cmp.setSoTimeout(5000);//读数据超时
client.getParams().setParameter(HttpMethodParams.HTTP_CONTENT_CHARSET, "UTF-8");//编码
//Map结构的参数转为NameValuePair列表
protected List<NameValuePair> getParamsList(Map<String, String> paramsMap) {
（精华）2020年9月13日C#基础知识点网络编程HttpClient详解
（精华）2020年9⽉13⽇C#基础知识点⽹络编程HttpClient详解(精华)2020年9⽉13⽇ C#基础知识点⽹络编程HttpClient详解⼀、HttpClient⽤法HttpClient 提供的⽅法：GetAsync(String) //以异步操作将GET请求发送给指定的URIGetAsync(URI) //以异步操作将GET请求发送给指定的URIGetAsync(String, HttpCompletionOption) //以异步操作的HTTP完成选项发送GET请求到指定的URIGetAsync(String, CancellationToken) //以异步操作的取消标记发送GET请求到指定URIGetAsync(Uri, HttpCompletionOption) //以异步操作的HTTP完成选项发送GET请求到指定的URIGetAsync(Uri, HttpCompletionOption, CancellationToken) //以异步操作的HTTP完成选项和取消标记发送DELETE请求到指定的URIGetAsync(Uri, HttpCompletionOption, CancellationToken) //以异步操作的HTTP完成选项和取消标记发送DELETE请求到指定的URIGetByteArrayAsync(String) //将GET请求发送到指定URI并在异步操作中以字节数组的形式返回响应正⽂GetByteArrayAsync(Uri) //将GET请求发送到指定URI并在⼀异步操作中以字节数组形式返回响应正⽂GetHashCode //⽤作特定类型的哈希函数，继承⾃ObjectGetStreamAsync(String) //将GET请求发送到指定URI并在异步操作中以流的形式返回响应正⽂GetStreamAsync(Uri) //将GET请求发送到指定URI并在异步操作以流的形式返回响应正⽂GetStreamAsync(String) //将GET请求发送到指定URI并在异步操作中以字符串的形式返回响应正⽂GetStringAsync(Uri) //将GET请求发送到指定URI并在异步操作中以字符串形式返回响应正⽂using(var httpClient = new HttpClient()){<!-- -->//other codes}以上⽤法是不推荐的，HttpClient 这个对象有点特殊，虽然继承了 IDisposable 接⼝，但它是可以被共享的（或者说可以被复⽤），且线程安全。
httpclient4 中文版帮助文档
httpclient4 中文版帮助文档，最新官方版翻译版前言超文本传输协议（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设置连接超时时间使⽤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客户端，可以根据实际需求选择适合的方式。
Android-25_网络通信(2)—HttpClient
第25讲网络通信(2)—HttpClient一、HttpClient为了更好的处理向web站点的请求，包括处理Session、Cookie等细节问题，Apache开源组织提供了一个HttpClient项目（HttpClient就是一个增强版本的HttpURLConnection），扩展了HttpURLConnection的功能，Android将这个HttpClient所在的包集成了进来，较之HttpURLConnection，采用HttpClient发送请求，接收响应更为简单。
例：修改上面的Android客户端程序，采用HttpClient来发送GET和POST请求。
先创建一个能将InputStream转换成一个字节数组的工具类：public class StreamUtil {public static byte[] convertStreamToByte(InputStream in){ ByteArrayOutputStream baos = new ByteArrayOutputStream();byte [] buffer = new byte[1024];int len =0;try {while((len=in.read(buffer))!=-1){baos.write(buffer,0,len);}byte [] result = baos.toByteArray();return result;} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}return null;}}（1）发送GET请求public int login_HttpClient_Get(String username ,String password){ String baseURL ="http://192.168.101.62:8080/LoginDemoServer/servlet/LoginServlet";String path = baseURL+"?username="+username+"&password="+password;try {HttpClient client = new DefaultHttpClient(); //创建一个浏览器的客户端HttpGet httpGet = new HttpGet(path); //创建一个请求对象HttpResponse httpResponse = client.execute(httpGet); //将请求发送出去if(httpResponse.getStatusLine().getStatusCode()==200){Log.i("test", "网络连接成功，采用HttpClient的get请求");//进一步判断，返回回来的字符串是InputStream in =httpResponse.getEntity().getContent(); //得到服务器响应的输入流byte buffer[] = StreamUtil.convertStreamToByte(in);String result = new String(buffer).trim(); //.trim()去掉字符串前后空格换行等无用的字符Log.i("test", result+"--------------");if(result.equals("success")){Log.i("test", "登陆成功");return LOGINSUCCESS;}else{Log.i("test", "用户名密码错误");return LOGINFAILURE;}}else{//连接失败Log.i("test", "网络连接失败");return NETFAILURE;}} catch (Exception e) {// TODO Auto-generated catch blocke.printStackTrace();}return 0;}（2）发送Post请求public int login_HttpClient_Post(String username ,String password){ String baseURL ="http://192.168.101.62:8080/LoginDemoServer/servlet/LoginServlet";HttpClient client = new DefaultHttpClient(); //创建一个浏览器的客户端HttpPost httpPost = new HttpPost(baseURL);try {username=new String(username.getBytes("utf8"),"iso8859-1");password=new String(password.getBytes("utf8"),"iso8859-1");} catch (UnsupportedEncodingException e1) {// TODO Auto-generated catch blocke1.printStackTrace();}if(httpResponse.getStatusLine().getStatusCode()==200){Log.i("test", "网络连接成功，采用HttpClient的post请求");InputStream in =httpResponse.getEntity().getContent(); //得到服务器响应的输入流byte buffer[] = StreamUtil.convertStreamToByte(in);String result = new String(buffer).trim(); //.trim()去掉字符串前后空格换行等无用的字符Log.i("test", result+"--------------");if(result.equals("success")){Log.i("test", "登陆成功");return LOGINSUCCESS;}else{Log.i("test", "用户名密码错误");return LOGINFAILURE;}}else{//连接失败Log.i("test", "网络连接失败");return NETFAILURE;}} catch (Exception e) {// TODO Auto-generated catch blocke.printStackTrace();}return 0;}二、数据提交的乱码处理---使用HttpClient（1）Post请求：发送时：在Android端，先将需要发送的文字：username=new String(username.getBytes("utf8"),"iso8859-1");values.add(new BasicNameValuePair("username",username)); //将转码后的字符串加入到Post 请求的参数中去。
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字符串的功能”，也可以引其他有此功能的依赖。
HttpClient 4.3教程(转载)
HttpClient提供URIBuilder工具类来简化URIs的创建和修改过程。
1. URI uri = new URIBuilder()2. .setScheme("http")3. .setHost("")4. .setPath("/search")5. .setParameter("q", "httpclient")6. .setParameter("btnG", "Google Search")7. .setParameter("aq", "f")8. .setParameter("oq", "")9. .build();10. HttpGet httpget = new HttpGet(uri);11. System.out.println(httpget.getURI());上述代码会在控制台输出：1. /search?q=httpclient&btnG=Google+Search&aq=f&oq=1.1.2. HTTP响应服务器收到客户端的http请求后，就会对其进行解析，然后把响应发给客户端，这个响应就是HTTP response.HTTP响应第一行是协议版本，之后是数字状态码和相关联的文本段。
1. HttpResponse response = new BasicHttpResponse(HttpVersion.HTTP_1_1,2. HttpStatus.SC_OK, "OK");3.4. System.out.println(response.getProtocolVersion());5. System.out.println(response.getStatusLine().getStatusCode());6. System.out.println(response.getStatusLine().getReasonPhrase());7. System.out.println(response.getStatusLine().toString());上述代码会在控制台输出：1. HTTP/1.12. 2003. OK4. HTTP/1.1 200 OK1.1.3. 消息头一个Http消息可以包含一系列的消息头，用来对http消息进行描述，比如消息长度，消息类型等等。
关于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());
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);}。
关于Http持久连接和HttpClient连接池的深入理解
关于Http持久连接和HttpClient连接池的深⼊理解⼀、背景HTTP协议是⽆状态的协议，即每⼀次请求都是互相独⽴的。
因此它的最初实现是，每⼀个http请求都会打开⼀个tcp socket连接，当交互完毕后会关闭这个连接。
HTTP协议是全双⼯的协议，所以建⽴连接与断开连接是要经过三次握⼿与四次挥⼿的。
显然在这种设计中，每次发送Http请求都会消耗很多的额外资源，即连接的建⽴与销毁。
于是，HTTP协议的也进⾏了发展，通过持久连接的⽅法来进⾏socket连接复⽤。
从图中可以看到：在串⾏连接中，每次交互都要打开关闭连接在持久连接中，第⼀次交互会打开连接，交互结束后连接并不关闭，下次交互就省去了建⽴连接的过程。
持久连接的实现有两种：HTTP/1.0+的keep-alive与HTTP/1.1的持久连接。
⼆、HTTP/1.0+的Keep-Alive从1996年开始，很多HTTP/1.0浏览器与服务器都对协议进⾏了扩展，那就是“keep-alive”扩展协议。
注意，这个扩展协议是作为1.0的补充的“实验型持久连接”出现的。
keep-alive已经不再使⽤了，最新的HTTP/1.1规范中也没有对它进⾏说明，只是很多应⽤延续了下来。
使⽤HTTP/1.0的客户端在⾸部中加上"Connection:Keep-Alive"，请求服务端将⼀条连接保持在打开状态。
服务端如果愿意将这条连接保持在打开状态，就会在响应中包含同样的⾸部。
如果响应中没有包含"Connection:Keep-Alive"⾸部，则客户端会认为服务端不⽀持keep-alive，会在发送完响应报⽂之后关闭掉当前连接。
通过keep-alive补充协议，客户端与服务器之间完成了持久连接，然⽽仍然存在着⼀些问题：在HTTP/1.0中keep-alive不是标准协议，客户端必须发送Connection:Keep-Alive来激活keep-alive连接。
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 ||
HttpClient如何设置超时时间
HttpClient如何设置超时时间今天分享⼀个巨坑，就是 HttpClient。
这玩意有多坑呢？就是每个版本都变，近⽇笔者深受其害。
先看⼀下代码，我要发送请求调⽤⼀个c++接⼝。
public static String doPostWithJSON(String url, String json) throws Exception {CloseableHttpClient client = HttpClients.createDefault();HttpPost httpPost = new HttpPost(url);httpPost.setHeader("Content-Type","application/json;charset=UTF-8");StringEntity se = new StringEntity(json, Charset.forName("UTF-8"));se.setContentType("application/json");httpPost.setEntity(se);CloseableHttpResponse response = client.execute(httpPost);HttpEntity entity = response.getEntity();String result = EntityUtils.toString(entity, "UTF-8");return result;}嗯，坑爹的地⽅来了，这个玩意发送请求，没设置超时时间，只要不响应，他能⼀直在这等着，这谁能受得了。
我要加个超时时间。
第⼆个⼤坑来了。
我记得以前设置超时时间是这样的。
client.setConnectionTimeout(10000);client.setTimeout(10000);我发现，特么没这个⽅法。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
HttpClient连接SSL
1）生成KeyStore keytool -genkey -alias tomcat -keyalg RSA -validity 60 -keystore D:\tomcat.keystore
参数说明 : -genkey表示生成密钥 -validity指定证书有效期，这里是60 天 -alias指定别名，这里是tomcat -keyalg指定算法，这里是RSA -keystore指定存储位置，这里是D:\tomcat.keystore 使用的自定义密码为 123456 *其中 您的名字与姓氏是什么？localhost 是网站的域名或者ip, 根据实 际情况填写.否者会出现证书上的名称无效
post传递参数
// 创建默认的httpClient实例. HttpClient httpclient = new DefaultHttpClient(); // 创建httppost HttpPost httppost = new HttpPost( "http://localhost:8080/HttpDemo/ddd/aaa!serivceJ.action"); // 创建参数队列 List<NameValuePair> formparams = new ArrayList<NameValuePair>(); formparams.add(new BasicNameValuePair("type", "house")); UrlEncodedFormEntity uefEntity;
HttpClient连接SSL
3) 用httpClient访问https
DefaultHttpClient httpclient = new DefaultHttpClient(); 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 (Exception e){ // TODO Auto-generated catch block e.printStackTrace(); }finally{ try{ instream.close(); }catch (Exception ignore){ } }
post传递参数
try{ uefEntity = new UrlEncodedFormEntity(formparams, "UTF-8"); httppost.setEntity(uefEntity); System.out.println("executing request " + httppost.getURI()); HttpResponse response; response = httpclient.execute(httppost); HttpEntity entity = response.getEntity(); if (entity != null){ System.out.println("--------------------------------------"); System.out.println("Response content: " + EntityUtils.toString(entity, "UTF-8")); System.out.println("--------------------------------------"); } }
HttpClient连接SSL
1）生成KeyStore
cmd keytool -genkey -alias tomcat -keyalg RSA -validity 60 -keystore D:\tomcat.keystore 输入keystore密码： Keystore 密码太短 -至少必须为6个字符 输入keystore密码： 再次输入新密码: 您的名字与姓氏是什么？ [Unknown]： localhost 您的组织单位名称是什么？ [Unknown]： ailk 您的组织名称是什么？ [Unknown]： ailk 您所在的城市或区域名称是什么？ [Unknown]： nj 您所在的州或省份名称是什么？ [Unknown]： js 该单位的两字母国家代码是什么 [Unknown]： CN CN=localhost, OU=ailk, O=ailk, L=nj, ST=js, C=CN 正确吗？ [否]： Y 输入<tomcat>的主密码 （如果和 keystore 密码相同，按回车）： 再次输入新密码:
get的使用
//打印响应状态 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 { //关闭连接,释放资源 httpclient.getConnectionManager().shutdown(); }
HttpConnection代表了一个http连接
.
get的使用
//创建默认的httpClient实例. HttpClient httpclient = new DefaultHttpClient(); try { //创建httpget. HttpGet httpget = new HttpGet("/"); System.out.println("executing request " + httpget.getURI()); //执行get请求. HttpResponse response = httpclient.execute(httpget); //获取响应实体 HttpEntity entity = response.getEntity(); System.out.println("--------------------------------------");
基于标准,纯净的java语言.实现了Http1.0和Http1.1 以可扩展的面向对象的结构实现了Http全部的方法(GET, POST, PUT, DELETE, HEAD, OPTIONS, and TRACE) 支持HTTPS协议 通过Http代理建立透明的连接 利用CONNECT方法通过Http代理建立隧道的https连 接 Basic, Digest, NTLMv1, NTLMv2, NTLM2 Session, SNPNEGO/Kerberos认证方案 插件式的自定义认证方案 便携可靠的套接字工厂使它更容易的用第三方解决案 连接管理器支持多线程应用.支持设置最大连接数,同时 支持设置每个主机的最大连.发现并关闭过期的连接
培训内容
HttpClient简介
HttpClient基本功能的使用
HttpClient 是 Apache Jakarta Common 下的子项目，用来提供高效的、 最新的、功能丰富的支持 HTTP 协议的客户端编程工具包，并且它支持 HTTP 协议最新的版本和建议。HttpClient 已经应用在很多的项目中，比如 Apache Jakarta 上很著名的另外两个开源项目 Cactus 和 HTMLUnit 都使 用了 HttpClient。
post传递参数
public void serivceJ(){ try{ HttpServletResponse response = ServletActionContext.getResponse(); HttpServletRequest request = ServletActionContext.getRequest(); response.setCharacterEncoding("UTF-8"); String type = request.getParameter("type"); String c = "none"; if ("car".equalsIgnoreCase(type)){ c = "Hello:给你一辆宝马"; }else if ("house".equalsIgnoreCase(type)){ c = "Hello:给你一栋别墅"; }else{ c = "Hello:参数错了"; } response.getWriter().write(c); }catch (IOException e){ e.printStackTrace(); }}
Automatic Cookie handling for reading Set-Cookie: headers from the server and sending them back out in a Cookie: header when appropriate 插件式的自定义Cookie策略 Request output streams to avoid buffering any content body by streaming directly to the socket server Response input streams to efficiently read the response body by streaming directly from the socket to server.directly from the socket to server 在http1.0和http1.1中利用KeepAlive保持久连接 直接获取服务器发送的response code和headers 设置连接超时的能力 实验性的支持http1.1 response caching caching 源代码基于Apache License可免费获取