`
令狐冲0660
  • 浏览: 15200 次
  • 性别: Icon_minigender_1
  • 来自: 成都
文章分类
社区版块
存档分类
最新评论

使用HttpClient管理HTTP请求

javahttphttpclient 
阅读更多

HTTP请求工具类，基于HttpClient4.5.1实现，可以帮你在程序后台默默完成POST、GET请求，使用方法参见注释，上代码：

 

HttpHandler httpHandler = new HttpHandler();
try {

	httpHandler.init();

	Map resultMap = httpHandler.doGet("http://www.baidu.com");
	if (CollectionUtil.isNotEmpty(resultMap)) {

		String result = new String((byte[]) resultMap.get(HttpHandler.BODY_KEY));

		System.out.println(result);
	}
} catch (Exception ex) {

	ex.printStackTrace();
} finally {

	httpHandler.destroy();
}

 

另外有大量的重载方法用于一些特殊场合，参数、Cookie等都可以通过Map动态传递，如需连续请求，连续调用同一对象即可，代码也支持自动跳转。

 

工具类源码：

 

/**
 * HttpHandler.java
 * Copyright ® 2012 窦海宁
 * All right reserved
 */

package org.aiyu.core.common.util.net;

import java.io.File;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.zip.GZIPInputStream;

import org.aiyu.core.common.util.CollectionUtil;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.HttpHost;
import org.apache.http.HttpRequest;
import org.apache.http.HttpResponse;
import org.apache.http.client.CookieStore;
import org.apache.http.client.HttpRequestRetryHandler;
import org.apache.http.client.config.CookieSpecs;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.config.RequestConfig.Builder;
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.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.entity.mime.HttpMultipartMode;
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.BasicCookieStore;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.DefaultConnectionKeepAliveStrategy;
import org.apache.http.impl.client.DefaultHttpRequestRetryHandler;
import org.apache.http.impl.client.DefaultRedirectStrategy;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.cookie.BasicClientCookie;
import org.apache.http.util.EntityUtils;
import org.apache.log4j.Logger;

/**
 * <p>Http工具类
 * 
 * <p>Http工具类，为系统提供通用Http访问操作方法：
 * <p>
 * <p>1、发送GET请求；
 * <p>2、发送POST请求。
 * 
 * @author  窦海宁, chong0660@sina.com
 * @since   AiyuCommonCore-1.0
 * @version AiyuCommonCore-1.0
 */
public class HttpHandler {

	//日志对象
	private static final Logger logger = Logger.getLogger(HttpHandler.class);

	private static final String DEFAULT_CHARSET    = "UTF-8";

	public static final String BODY_KEY            = "body";
	public static final String REDIRECT_BODY_KEY   = "redirect_body";
	public static final String HEADER_KEY          = "header";
	public static final String REDIRECT_HEADER_KEY = "redirect_header";
	public static final String COOKIE_KEY          = "cookie";

	//浏览器Agent
	public static final String USER_AGENT_FIREFOX  = "Mozilla/5.0 (Windows NT 6.1; WOW64; Trident/7.0; rv:11.0) like Gecko";

	private String                charset       = null; //字符编码，默认为UTF-8
	private String                proxyUrl      = null; //代理服务器地址
	private int                   proxyPort     = 0;    //代理服务器端口号
	private int                   timeout       = 0;    //请求超时时间

	private int                   cookieVersion = 0;
	private String                cookiePath    = null;
	private String                cookieDomain  = null;
	private CookieStore           cookieStore   = null;
	private HttpClientContext     localContext  = null; //本地会话上下文

	private CloseableHttpClient   httpClient    = null;
	private CloseableHttpResponse httpResponse  = null;

	/**
	 * <p>默认构造函数
	 * 
	 * @modify 窦海宁, 2017-01-17
	 */
	public HttpHandler() {

		if (StringUtils.isBlank(this.charset)) {

			this.charset = HttpHandler.DEFAULT_CHARSET;
		}
	}

	/**
	 * <p>初始化访问对象
	 * 
	 * @modify 窦海宁, 2017-01-17
	 */
	public void init() {

		//设置默认的恢复策略，在发生异常时候将自动重试3次，在这里你也可以设置成自定义的恢复策略
		HttpRequestRetryHandler retryHandler = new DefaultHttpRequestRetryHandler();

		//配置超时时间（连接服务端超时1秒，请求数据返回超时2秒）
		RequestConfig requestConfig = RequestConfig.custom().setCookieSpec(CookieSpecs.DEFAULT).build();

		this.cookieStore  = new BasicCookieStore();
		this.localContext = HttpClientContext.create();

		//设置默认跳转以及存储cookie
		this.httpClient   = HttpClientBuilder.create()
							.setRedirectStrategy(new DefaultRedirectStrategy())
							.setKeepAliveStrategy(new DefaultConnectionKeepAliveStrategy())
							.setRetryHandler(retryHandler).setDefaultRequestConfig(requestConfig).build();

		this.localContext.setCookieStore(this.cookieStore);
	}

	/**
	 * <p>关闭访问对象并释放资源
	 * 
	 * @modify 窦海宁, 2017-01-17
	 */
	public void destroy() {

		if (this.httpClient != null) {

			try {

				this.httpClient.close();
			} catch (Exception ex) {

				ex.printStackTrace();
			}
		}

		System.gc();
	}

	/**
	 * <p>发送GET请求
	 * 
	 * @param  url GET请求地址
	 * 
	 * @return 与当前请求对应的响应内容集合
	 * 
	 * @modify 窦海宁, 2017-01-15
	 */
	public Map doGet(String url) {

		return this.doGet(url , null , null);
	}

	/**
	 * <p>发送GET请求
	 * 
	 * @param  url       GET请求地址
	 * @param  headerMap GET请求头参数容器
	 * @param  charset   参数字符集名称
	 * 
	 * @return 与当前请求对应的响应内容集合
	 * 
	 * @modify 窦海宁, 2017-01-15
	 */
	public Map doGet(String url , Map headerMap) {

		return this.doGet(url , null , null , headerMap);
	}

	/**
	 * <p>发送GET请求
	 * 
	 * @param  url       GET请求地址
	 * @param  cookieMap POST请求Cookie参数容器
	 * @param  headerMap GET请求头参数容器
	 * 
	 * @return 与当前请求对应的响应内容集合
	 * 
	 * @modify 窦海宁, 2017-01-15
	 */
	public Map doGet(String url , Map cookieMap , Map headerMap) {

		return this.doGet(url , null , cookieMap , headerMap);
	}

	/**
	 * <p>发送GET请求
	 * 
	 * @param  url            GET请求地址
	 * @param  queryStringMap 查询字符串参数容器
	 * @param  cookieMap      POST请求Cookie参数容器
	 * @param  headerMap      GET请求头参数容器
	 * 
	 * @return 与当前请求对应的响应内容容器，包括响应头、响应主体，可通过本类提供的静态常量作为键值提取
	 * 
	 * @modify 窦海宁, 2017-01-15
	 */
	public Map doGet(String url , Map queryStringMap , Map cookieMap , Map headerMap) {

		Map resultMap = null;

		try {

			HttpGet httpGet       = new HttpGet(this.createUrl(url , queryStringMap));
			Builder configBuilder = RequestConfig.custom();

			//设置请求超时时间（毫秒）
			if (this.timeout > 0) {

				configBuilder.setSocketTimeout(this.timeout);
				configBuilder.setConnectTimeout(this.timeout);
				configBuilder.setConnectionRequestTimeout(this.timeout);
			}

			//设置代理
			if (StringUtils.isNotBlank(this.proxyUrl)) {

				HttpHost proxy = new HttpHost(this.proxyUrl , this.proxyPort);

				configBuilder.setProxy(proxy);
			}

			//设置默认Cookie环境
			if (StringUtils.isBlank(this.cookiePath)) {

				this.cookiePath = httpGet.getURI().getPath();
			}
			if (StringUtils.isBlank(this.cookieDomain)) {

				this.cookieDomain = httpGet.getURI().getHost();
			}

			//设置请求策略
			httpGet.setConfig(configBuilder.build());

			//设置请求头
			this.addHeader(headerMap , httpGet);
			//设置请求Cookie
			this.addCookie(cookieMap);

			this.httpResponse = this.httpClient.execute(httpGet , this.localContext);
			if (this.httpResponse.getStatusLine().getStatusCode() == 200) {

				resultMap = new HashMap();

				//读取头内容
				Map      responseHeaderMap = new HashMap();
				Header[] headerArray       = this.httpResponse.getAllHeaders();
				for (int i = 0 ; i < headerArray.length ; i++) {

					responseHeaderMap.put(headerArray[i].getName() , headerArray[i].getValue());
				}
				resultMap.put(HttpHandler.HEADER_KEY , responseHeaderMap);

				//读取内容
				resultMap.put(HttpHandler.BODY_KEY , this.getBody(this.httpResponse));
			} else {

				System.err.println("Method failed: " + this.httpResponse.getStatusLine());
			}

			EntityUtils.consume(this.httpResponse.getEntity());

			this.initCookieEnvironment();
		} catch (Exception ex) {

			ex.printStackTrace();
		} finally {

			this.closeHttpResponse();
		}

		return resultMap;
	}

	/**
	 * <p>发送POST请求（如返回跳转指令，该方法会自动以GET方式跳转）
	 * 
	 * @param  url   POST请求地址
	 * @param  param 请求参数实体对象
	 * 
	 * @return 与当前请求对应的响应内容字节数组
	 * 
	 * @modify 窦海宁, 2017-01-15
	 */
	public Map doPost(String url , Object param) {

		return this.doPost(url , null , null , null , param);
	}

	/**
	 * <p>发送POST请求（如返回跳转指令，该方法会自动以GET方式跳转）
	 * 
	 * @param  url       POST请求地址
	 * @param  headerMap POST请求头参数容器
	 * @param  param     请求参数实体对象
	 * 
	 * @return 与当前请求对应的响应内容字节数组
	 * 
	 * @modify 窦海宁, 2017-01-15
	 */
	public Map doPost(String url , Map headerMap , Object param) {

		return this.doPost(url , null , null , headerMap , param);
	}

	/**
	 * <p>发送POST请求（如返回跳转指令，该方法会自动以GET方式跳转）
	 * 
	 * @param  url            POST请求地址
	 * @param  queryStringMap 查询字符串参数容器
	 * @param  headerMap      POST请求头参数容器
	 * @param  param          请求参数实体对象
	 * 
	 * @return 与当前请求对应的响应内容容器，包括响应头、响应主体，可通过本类提供的静态常量作为键值提取
	 * 
	 * @modify 窦海宁, 2017-01-15
	 */
	public Map doPost(String url , Map queryStringMap , Map headerMap , Object param) {

		return this.doPost(url , queryStringMap , null , headerMap , param);
	}

	/**
	 * <p>发送POST请求（如返回跳转指令，该方法会自动以GET方式跳转）
	 * 
	 * @param  url            POST请求地址
	 * @param  queryStringMap 查询字符串参数容器
	 * @param  cookieMap      POST请求Cookie参数容器
	 * @param  headerMap      POST请求头参数容器
	 * @param  param          请求参数实体对象
	 * 
	 * @return 与当前请求对应的响应内容容器，包括响应头、响应主体，可通过本类提供的静态常量作为键值提取
	 * 
	 * @modify 窦海宁, 2017-01-15
	 */
	public Map doPost(String url , Map queryStringMap , Map cookieMap , Map headerMap , Object param) {

		Map    resultMap   = null;
		String redirectUrl = null;

		try {

			HttpPost httpPost      = new HttpPost(this.createUrl(url , queryStringMap));
			Builder  configBuilder = RequestConfig.custom();

			//设置请求超时时间（毫秒）
			if (this.timeout > 0) {

				configBuilder.setSocketTimeout(this.timeout);
				configBuilder.setConnectTimeout(this.timeout);
				configBuilder.setConnectionRequestTimeout(this.timeout);
			}

			//设置代理
			if (StringUtils.isNotBlank(this.proxyUrl)) {

				HttpHost proxy = new HttpHost(this.proxyUrl , this.proxyPort);

				configBuilder.setProxy(proxy);
			}

			//设置默认Cookie环境
			this.cookiePath   = httpPost.getURI().getPath();
			this.cookieDomain = httpPost.getURI().getHost();

			//设置请求策略
			httpPost.setConfig(configBuilder.build());

			//设置请求头
			this.addHeader(headerMap , httpPost);
			//设置请求Cookie
			this.addCookie(cookieMap);
			//设置请求参数
			HttpEntity postEntity = this.addParam(param , httpPost);

			httpPost.setEntity(postEntity);

			this.httpResponse = this.httpClient.execute(httpPost , this.localContext);

			switch (this.httpResponse.getStatusLine().getStatusCode())
			{
			case 301 :
			case 302 :
			case 304 :

				redirectUrl = this.httpResponse.getFirstHeader("Location").getValue();

			case 200 :
			case 500 :

				resultMap = new HashMap();

				//读取头内容
				Map      responseHeaderMap = new HashMap();
				Header[] headerArray       = httpPost.getAllHeaders();
				for (int i = 0 ; i < headerArray.length ; i++) {

					responseHeaderMap.put(headerArray[i].getName() , headerArray[i].getValue());
				}
				resultMap.put(HttpHandler.HEADER_KEY , responseHeaderMap);

				//读取内容
				resultMap.put(HttpHandler.BODY_KEY , this.getBody(this.httpResponse));

				break;

			default :

				System.err.println("Method failed: " + this.httpResponse.getStatusLine());
			}

			EntityUtils.consume(this.httpResponse.getEntity());
		} catch (Exception ex) {

			ex.printStackTrace();
		} finally {

			this.closeHttpResponse();
		}

		if (StringUtils.isNotBlank(redirectUrl)) {

			if (!StringUtils.startsWith(redirectUrl , "http://")) {

				redirectUrl = StringUtils.substringBeforeLast(url , "/") + "/" + redirectUrl;
			}

			headerMap.put("Referer" , url);

			Map redirectResultMap = this.doGet(redirectUrl , headerMap);
			Map redirectHeaderMap = (Map) redirectResultMap.get(HttpHandler.HEADER_KEY);

			resultMap.put(HttpHandler.REDIRECT_HEADER_KEY , redirectResultMap.get(HttpHandler.HEADER_KEY));
			resultMap.put(HttpHandler.REDIRECT_BODY_KEY   , redirectResultMap.get(HttpHandler.BODY_KEY));
		}

		return resultMap;
	}

	/**
	 * <p>获取响应内容
	 * 
	 * @param  httpResponse 响应对象
	 * 
	 * @return 与当前请求对应的响应内容字节数组
	 * @throws Exception 
	 * 
	 * @modify 窦海宁, 2017-01-18
	 */
	private byte[] getBody(HttpResponse httpResponse) throws Exception {

		byte[] bodyByteArray = null;

		Header contentEncodingHeader = httpResponse.getFirstHeader("Content-Encoding");
		if (contentEncodingHeader != null && StringUtils.indexOf(contentEncodingHeader.getValue().toLowerCase() , "gzip") > -1) {

			try {

				//建立gzip解压工作流
				bodyByteArray = IOUtils.toByteArray(new GZIPInputStream(httpResponse.getEntity().getContent()));
			} catch (Exception ex) {

				ex.printStackTrace();
			}
		} else {

			try {

				bodyByteArray = IOUtils.toByteArray(httpResponse.getEntity().getContent());
			} catch (IOException ex) {

				ex.printStackTrace();
			}
		}

		return bodyByteArray;
	}

	/**
	 * <p>添加查询字符串
	 * 
	 * @param  url            POST请求地址
	 * @param  queryStringMap 查询字符串参数容器
	 * 
	 * @return 拼装后的查询字符串
	 * @throws Exception 
	 * 
	 * @modify 窦海宁, 2015-10-18
	 */
	public String createUrl(String url , Map queryStringMap) throws Exception {

		StringBuffer queryStringBuffer = new StringBuffer(url);

		if (CollectionUtil.isNotEmpty(queryStringMap)) {

			//拼装查询字符串
			queryStringBuffer.append("?");
			Iterator iterator = queryStringMap.keySet().iterator();
			while (iterator.hasNext()) {

				Object key = iterator.next();
				try {

					key = URLEncoder.encode((String) key , this.charset);

					String value = null;
					if (queryStringMap.get(key) == null) {

						value = "";
					} else {

						value = URLEncoder.encode((String) queryStringMap.get(key) , this.charset);
					}

					queryStringBuffer.append(key).append("=").append(value);
				} catch (UnsupportedEncodingException ex) {

					ex.printStackTrace();
				}
				if (iterator.hasNext()) {

					queryStringBuffer.append("&");
				}
			}
		}

		return queryStringBuffer.toString();
	}

	/**
	 * <p>初始化Cookie网络环境（版本号、域名、路径信息，以会话ID变量为样本）
	 * 
	 * @modify 窦海宁, 2017-01-17
	 */
	private void initCookieEnvironment() throws Exception {

		List cookieList = this.cookieStore.getCookies();
		for (int i = 0 ; i < cookieList.size() ; i++) {

			BasicClientCookie cookie = (BasicClientCookie) cookieList.get(i);
			if (StringUtils.equalsIgnoreCase("JSESSIONID" , cookie.getName())) {

				this.cookiePath    = cookie.getPath();
				this.cookieDomain  = cookie.getDomain();
				this.cookieVersion = cookie.getVersion();
				break;
			}
		}
	}

	/**
	 * <p>添加请求Cookie
	 * 
	 * @param  cookieMap 请求Cookie参数容器
	 * 
	 * @modify 窦海宁, 2017-01-17
	 */
	private void addCookie(Map cookieMap) {

		if (CollectionUtil.isNotEmpty(cookieMap)) {

			//Cookie请求信息
			Iterator iterator = cookieMap.entrySet().iterator();
			while (iterator.hasNext()) {

				Entry entry = (Entry) iterator.next();

				BasicClientCookie cookie = new BasicClientCookie(entry.getKey().toString() , entry.getValue().toString());

				cookie.setPath(this.cookiePath);
				cookie.setDomain(this.cookieDomain);
				cookie.setVersion(this.cookieVersion);

				this.cookieStore.addCookie(cookie);
			}

			this.localContext.setCookieStore(this.cookieStore);
		}
	}

	/**
	 * <p>添加请求头
	 * 
	 * @param  headerMap   请求头参数容器
	 * @param  httpRequest 请求对象
	 * 
	 * @modify 窦海宁, 2017-02-13
	 */
	private void addHeader(Map headerMap , HttpRequest httpRequest) {

		if (CollectionUtil.isNotEmpty(headerMap)) {

			//头部请求信息
			Iterator iterator = headerMap.entrySet().iterator();
			while (iterator.hasNext()) {

				Entry entry = (Entry) iterator.next();
				if (entry.getKey() != null && entry.getValue() != null) {

					httpRequest.addHeader(entry.getKey().toString() , entry.getValue().toString());
				}
			}

			httpRequest.addHeader("Charset" , this.charset);
		}
	}

	/**
	 * <p>添加请求参数
	 * 
	 * @param  paramMap 请求参数容器
	 * @param  httpPost Post请求对象
	 * 
	 * @return 添加后的参数列表
	 * 
	 * @modify 窦海宁, 2017-02-13
	 */
	private HttpEntity addParam(Object param , HttpPost httpPost) {

		HttpEntity postEntity = null;

		if (param != null) {

			if (param instanceof String) {

				postEntity = new StringEntity((String) param , this.charset);
			} else if (param instanceof Map) {

				MultipartEntityBuilder multipartEntityBuilder = MultipartEntityBuilder.create();
				multipartEntityBuilder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);
//				multipartEntityBuilder.setCharset(Charset.forName(this.charset));

				Map      paramMap    = (Map) param;
				Iterator keyIterator = paramMap.keySet().iterator();

				boolean containFile = false;
				while (keyIterator.hasNext()) {

					Object key   = keyIterator.next();
					Object value = paramMap.get(key);
					if (value instanceof String) {

						//文本处理
						StringBody stringBody = new StringBody((String) value , ContentType.TEXT_PLAIN);
						multipartEntityBuilder.addPart((String) key , stringBody);
					} else if (value instanceof File) {

						//文件处理
						FileBody fileBody = new FileBody((File) value);
						multipartEntityBuilder.addPart((String) key , fileBody);
						containFile = true;
					} else {

						//输出错误信息
					}
				}

//				if (containFile) {
//
//					multipartEntityBuilder.setContentType(ContentType.MULTIPART_FORM_DATA);
//				} else {
//
//					multipartEntityBuilder.setContentType(ContentType.APPLICATION_FORM_URLENCODED);
//				}

				postEntity = multipartEntityBuilder.build();
			} else {

				HttpHandler.logger.debug("this -> addParam : 请求参数类型不匹配，传入参数类型为 : " + param.getClass().getName());
				//此处应抛出异常
			}
		}

		return postEntity;
	}

	/**
	 * <p>关闭请求对象
	 * 
	 * @modify 窦海宁, 2017-02-06
	 */
	private void closeHttpResponse() {

		if (this.httpResponse != null) {

			try {

				this.httpResponse.close();
			} catch (Exception ex) {

				ex.printStackTrace();
			}
		}
	}

	/*对象变量Get、Set方法*/

	public void setCharset(String charset) {
		this.charset = charset;
	}

	public void setProxyUrl(String proxyUrl) {
		this.proxyUrl = proxyUrl;
	}

	public void setProxyPort(int proxyPort) {
		this.proxyPort = proxyPort;
	}

	public void setTimeout(int timeout) {
		this.timeout = timeout;
	}

	public void setCookiePath(String cookiePath) {
		this.cookiePath = cookiePath;
	}

}
分享到：
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java使用HttpClient发送http请求

    本文将深入讲解如何使用HttpClient来发送HTTP请求，以及相关的源码分析。 首先，让我们了解HttpClient的基本用法。Apache HttpClient库提供了丰富的功能，包括GET、POST、PUT等各种HTTP方法的支持。以下是一个简单...

    HttpClient发送http请求需要的jar包

    本篇文章将详细介绍使用HttpClient库发送HTTP请求所需的基本知识。 首先，我们来关注"org.apache.http"这个包。这是HttpClient的核心包，包含了执行HTTP请求所需的主要类和接口。主要组件有： 1. **HttpClient**：...

    java HttpClient 发送GET请求和带有表单参数的POST请求教程例子

    Apache HttpClient库提供了一种强大的方法来执行HTTP请求，无论是简单的GET请求还是复杂的带有表单参数的POST请求。本文将通过具体的代码示例，详细介绍如何使用Java HttpClient来发送这两种类型的请求。 #### 二、...

    HttpClient发送http请求(post和get)需要的jar包+内符java代码案例+注解详解

    通过上述内容，你应该对使用HttpClient发送HTTP请求有了基本的理解。实践中，可以根据具体需求进行更复杂的定制和配置。在实际项目中，HttpClient是一个强大而灵活的工具，能够帮助你轻松地处理网络通信任务。

    HttpClient发送http请求(post+get)需要的jar包+内符java代码案例+注解详解

    本篇将详细介绍如何使用HttpClient发送HTTP请求，包括POST和GET方法，同时提供相关的jar包依赖以及Java代码示例，并对关键代码进行注解解释。 一、HttpClient库的引入 在Java项目中，首先需要添加HttpClient的jar包...

    HttpClient模拟get，post请求并发送请求参数（json等）

    在本文中，我们将深入探讨如何使用HttpClient进行HTTP请求操作，以及如何处理JSON数据。 首先，我们需要引入HttpClient的相关依赖。如果你使用的是Maven，可以在pom.xml文件中添加以下依赖： ```xml &lt;groupId&gt;...

    HttpClient模拟http浏览器请求

    在名为"HttpClientDemo"的压缩包文件中，可能包含了一个示例程序，展示了如何使用HttpClient进行HTTP请求。这个程序可能包含了上述提到的一些知识点，通过运行和分析代码，可以更深入地理解HttpClient的使用方法。...

    HttpClient发起HTTPs请求.rar

    在Java编程环境中，HttpClient是一个非常常用的库，用于发送HTTP请求并接收响应。在这个"HttpClient发起HTTPs请求.rar"压缩包中，我们主要关注的是如何利用HttpClient处理HTTPS协议的GET和POST请求，以及如何处理...

    Http(get)请求数据Android Studio使用HttpClient

    首先，创建一个`HttpClient`实例，这将是发送HTTP请求的基础： ```java HttpClient httpClient = new DefaultHttpClient(); ``` ## 4. 设置请求参数 创建`HttpGet`对象来表示GET请求，并设置URL： ```java ...

    java.net.URLConnection发送HTTP请求与通过Apache HttpClient发送HTTP请求比较

    首先，它的API设计较为原始，处理HTTP请求的细节较多，如设置请求头、处理重定向、管理cookies等，都需要程序员手动处理。其次，它不支持异步请求，如果需要并发发送多个请求，代码会变得复杂。 相比之下，Apache ...

    httpclient post方式发送请求

    在Java编程中，HTTPClient库是一个非常常用的工具，用于发送HTTP请求，包括POST方式的请求。本篇文章将详细讲解如何使用HTTPClient库以POST方式发送JSON格式的数据，并介绍相关依赖包。 首先，为了使用HTTPClient库...

    HttpClient异步请求

    HttpClient是Java中一个强大的HTTP客户端库，用于执行HTTP请求，包括GET和POST等操作。它提供了丰富的功能，如异步请求处理、连接管理、重试策略等，使得开发者能够高效地与Web服务进行通信。本篇文章将深入探讨...

    httpclient发送get请求和post请求demo

    首先，GET请求是最常见的HTTP请求类型，通常用于获取资源。在HttpClient中，发送GET请求可以通过`HttpGet`类实现。以下是一个简单的GET请求示例： ```java import org.apache.http.HttpEntity; import org.apache....

    httpclient和httpcore的jar包

    3. **连接管理**：HttpClient提供了PoolingHttpClientConnectionManager，可以管理HTTP连接的生命周期，复用已建立的连接，提高性能。 4. **身份验证和安全**：HttpClient支持多种认证机制，如Basic Auth、Digest ...

    安卓使用httpClient实现网络请求并通过cookie维持对话

    HttpClient是一个强大的HTTP客户端库，它允许开发者发送HTTP请求并处理响应。在Android中，我们通常使用Apache的HttpClient库，尽管在Android 6.0（API级别23）及以上版本中已被弃用，但仍然可以在兼容库中使用。 1...

    使用HttpClient必须的jar包

    1. **HttpClient核心组件**：HttpClient的核心库`httpclient-x.x.x.jar`包含了HttpClient的主要类和接口，如`CloseableHttpClient`（用于创建HTTP客户端实例）、`HttpGet`和`HttpPost`（用于发起HTTP请求）以及`...

    httpclient发送post请求.docx

    发送POST请求使用httpClient的execute()方法，并捕获返回的CloseableHttpResponse对象。在成功接收响应后，我们需要检查状态码并处理响应实体： ```java try (CloseableHttpResponse response = httpClient.execute...

    http请求工具类HttpClientUtil，get，post请求（csdn）————程序.pdf

    - 接下来，使用 HttpClient 执行 GET 请求，并获取响应。最后，将响应体转换为 JSON 对象返回。 4. **POST 请求**： - `doPostJson` 方法类似，但使用 `HttpPost` 对象。它创建一个 `HttpPost` 实例，并设置请求...

    使用httpclient访问servlet

    在Java编程中，Apache HttpClient库提供了一个强大的工具，使得我们可以轻松地实现HTTP请求，特别是在需要与Servlet进行交互时。本篇文章将详细探讨如何使用HttpClient来访问Servlet，并阐述相关的核心知识点。 ...

Magicbox
Global site tag (gtag.js) - Google Analytics