Android开源项目xUtils HttpUtils模块分析

叁歲伎倆 2022-08-03 15:43 263阅读 0赞

**使用HttpUtils 只需要new 出一个实例便可。**

**public class HttpFragment extends Fragment \{**

**// 同步请求 必须在异步块儿中执行  
private String testGetSync() \{  
RequestParams params = new RequestParams();  
params.addQueryStringParameter("wd", "lidroid");  
  
HttpUtils http = new HttpUtils();  
http.configCurrentHttpCacheExpiry(1000 \* 10);  
try \{  
ResponseStream responseStream = http.sendSync(HttpRequest.HttpMethod.GET, "http://www.baidu.com/s", params);  
//int statusCode = responseStream.getStatusCode();  
//Header\[\] headers = responseStream.getBaseResponse().getAllHeaders();  
return responseStream.readString();  
\} catch (Exception e) \{  
LogUtils.e(e.getMessage(), e);  
\}  
return null;  
\}**

**\}**

**RequestParams 类包含很多关于http 属性设置的方法（set and get ）**

**是一个属性设置的工具类**

**public class RequestParams \{  
  
private String charset = HTTP.UTF\_8;  
  
private List<HeaderItem> headers;  
private List<NameValuePair> queryStringParams;  
private HttpEntity bodyEntity;  
private List<NameValuePair> bodyParams;  
private HashMap<String, ContentBody> fileParams;  
  
private Priority priority;**

**\}**

**/\*  
\* Copyright (c) 2013. wyouflf (wyouflf@gmail.com)  
\*  
\* Licensed under the Apache License, Version 2.0 (the "License");  
\* you may not use this file except in compliance with the License.  
\* You may obtain a copy of the License at  
\*  
\* http://www.apache.org/licenses/LICENSE-2.0  
\* Unless required by applicable law or agreed to in writing, software  
\* distributed under the License is distributed on an "AS IS" BASIS,  
\* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  
\* See the License for the specific language governing permissions and  
\* limitations under the License.  
\*/  
  
package com.lidroid.xutils;  
  
import android.text.TextUtils;  
import com.lidroid.xutils.exception.HttpException;  
import com.lidroid.xutils.http.\*;  
import com.lidroid.xutils.http.callback.HttpRedirectHandler;  
import com.lidroid.xutils.http.callback.RequestCallBack;  
import com.lidroid.xutils.http.client.DefaultSSLSocketFactory;  
import com.lidroid.xutils.http.client.HttpRequest;  
import com.lidroid.xutils.http.client.RetryHandler;  
import com.lidroid.xutils.http.client.entity.GZipDecompressingEntity;  
import com.lidroid.xutils.task.PriorityExecutor;  
import com.lidroid.xutils.util.OtherUtils;  
import org.apache.http.\*;  
import org.apache.http.client.CookieStore;  
import org.apache.http.client.HttpClient;  
import org.apache.http.client.protocol.ClientContext;  
import org.apache.http.conn.params.ConnManagerParams;  
import org.apache.http.conn.params.ConnPerRouteBean;  
import org.apache.http.conn.scheme.PlainSocketFactory;  
import org.apache.http.conn.scheme.Scheme;  
import org.apache.http.conn.scheme.SchemeRegistry;  
import org.apache.http.conn.ssl.SSLSocketFactory;  
import org.apache.http.impl.client.DefaultHttpClient;  
import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;  
import org.apache.http.params.BasicHttpParams;  
import org.apache.http.params.HttpConnectionParams;  
import org.apache.http.params.HttpParams;  
import org.apache.http.params.HttpProtocolParams;  
import org.apache.http.protocol.BasicHttpContext;  
import org.apache.http.protocol.HTTP;  
import org.apache.http.protocol.HttpContext;  
  
import java.io.File;  
import java.io.IOException;  
  
public class HttpUtils \{  
  
public final static HttpCache sHttpCache = new HttpCache();  
  
private final DefaultHttpClient httpClient;  
private final HttpContext httpContext = new BasicHttpContext();  
  
private HttpRedirectHandler httpRedirectHandler;  
  
public HttpUtils() \{  
this(HttpUtils.DEFAULT\_CONN\_TIMEOUT, null);  
\}  
  
public HttpUtils(int connTimeout) \{  
this(connTimeout, null);  
\}  
  
public HttpUtils(String userAgent) \{  
this(HttpUtils.DEFAULT\_CONN\_TIMEOUT, userAgent);  
\}  
  
public HttpUtils(int connTimeout, String userAgent) \{  
HttpParams params = new BasicHttpParams();  
  
ConnManagerParams.setTimeout(params, connTimeout);  
HttpConnectionParams.setSoTimeout(params, connTimeout);  
HttpConnectionParams.setConnectionTimeout(params, connTimeout);  
  
if (TextUtils.isEmpty(userAgent)) \{  
userAgent = OtherUtils.getUserAgent(null);  
\}  
HttpProtocolParams.setUserAgent(params, userAgent);  
  
ConnManagerParams.setMaxConnectionsPerRoute(params, new ConnPerRouteBean(10));  
ConnManagerParams.setMaxTotalConnections(params, 10);  
  
HttpConnectionParams.setTcpNoDelay(params, true);  
HttpConnectionParams.setSocketBufferSize(params, 1024 \* 8);  
HttpProtocolParams.setVersion(params, HttpVersion.HTTP\_1\_1);  
  
SchemeRegistry schemeRegistry = new SchemeRegistry();  
schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));  
schemeRegistry.register(new Scheme("https", DefaultSSLSocketFactory.getSocketFactory(), 443));  
  
httpClient = new DefaultHttpClient(new ThreadSafeClientConnManager(params, schemeRegistry), params);  
  
httpClient.setHttpRequestRetryHandler(new RetryHandler(DEFAULT\_RETRY\_TIMES));  
  
httpClient.addRequestInterceptor(new HttpRequestInterceptor() \{  
@Override  
public void process(org.apache.http.HttpRequest httpRequest, HttpContext httpContext) throws org.apache.http.HttpException, IOException \{  
if (!httpRequest.containsHeader(HEADER\_ACCEPT\_ENCODING)) \{  
httpRequest.addHeader(HEADER\_ACCEPT\_ENCODING, ENCODING\_GZIP);  
\}  
\}  
\});  
  
httpClient.addResponseInterceptor(new HttpResponseInterceptor() \{  
@Override  
public void process(HttpResponse response, HttpContext httpContext) throws org.apache.http.HttpException, IOException \{  
final HttpEntity entity = response.getEntity();  
if (entity == null) \{  
return;  
\}  
final Header encoding = entity.getContentEncoding();  
if (encoding != null) \{  
for (HeaderElement element : encoding.getElements()) \{  
if (element.getName().equalsIgnoreCase("gzip")) \{  
response.setEntity(new GZipDecompressingEntity(response.getEntity()));  
return;  
\}  
\}  
\}  
\}  
\});  
\}  
  
// \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* default settings & fields \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
  
private String responseTextCharset = HTTP.UTF\_8;  
  
private long currentRequestExpiry = HttpCache.getDefaultExpiryTime();  
  
private final static int DEFAULT\_CONN\_TIMEOUT = 1000 \* 15; // 15s  
  
private final static int DEFAULT\_RETRY\_TIMES = 3;  
  
private static final String HEADER\_ACCEPT\_ENCODING = "Accept-Encoding";  
private static final String ENCODING\_GZIP = "gzip";  
  
private final static int DEFAULT\_POOL\_SIZE = 3;  
private final static PriorityExecutor EXECUTOR = new PriorityExecutor(DEFAULT\_POOL\_SIZE);  
  
public HttpClient getHttpClient() \{  
return this.httpClient;  
\}  
  
// \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* config \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
  
public HttpUtils configResponseTextCharset(String charSet) \{  
if (!TextUtils.isEmpty(charSet)) \{  
this.responseTextCharset = charSet;  
\}  
return this;  
\}  
  
public HttpUtils configHttpRedirectHandler(HttpRedirectHandler httpRedirectHandler) \{  
this.httpRedirectHandler = httpRedirectHandler;  
return this;  
\}  
  
public HttpUtils configHttpCacheSize(int httpCacheSize) \{  
sHttpCache.setCacheSize(httpCacheSize);  
return this;  
\}  
  
public HttpUtils configDefaultHttpCacheExpiry(long defaultExpiry) \{  
HttpCache.setDefaultExpiryTime(defaultExpiry);  
currentRequestExpiry = HttpCache.getDefaultExpiryTime();  
return this;  
\}  
  
public HttpUtils configCurrentHttpCacheExpiry(long currRequestExpiry) \{  
this.currentRequestExpiry = currRequestExpiry;  
return this;  
\}  
  
public HttpUtils configCookieStore(CookieStore cookieStore) \{  
httpContext.setAttribute(ClientContext.COOKIE\_STORE, cookieStore);  
return this;  
\}  
  
public HttpUtils configUserAgent(String userAgent) \{  
HttpProtocolParams.setUserAgent(this.httpClient.getParams(), userAgent);  
return this;  
\}  
  
public HttpUtils configTimeout(int timeout) \{  
final HttpParams httpParams = this.httpClient.getParams();  
ConnManagerParams.setTimeout(httpParams, timeout);  
HttpConnectionParams.setConnectionTimeout(httpParams, timeout);  
return this;  
\}  
  
public HttpUtils configSoTimeout(int timeout) \{  
final HttpParams httpParams = this.httpClient.getParams();  
HttpConnectionParams.setSoTimeout(httpParams, timeout);  
return this;  
\}  
  
public HttpUtils configRegisterScheme(Scheme scheme) \{  
this.httpClient.getConnectionManager().getSchemeRegistry().register(scheme);  
return this;  
\}  
  
public HttpUtils configSSLSocketFactory(SSLSocketFactory sslSocketFactory) \{  
Scheme scheme = new Scheme("https", sslSocketFactory, 443);  
this.httpClient.getConnectionManager().getSchemeRegistry().register(scheme);  
return this;  
\}  
  
public HttpUtils configRequestRetryCount(int count) \{  
this.httpClient.setHttpRequestRetryHandler(new RetryHandler(count));  
return this;  
\}  
  
public HttpUtils configRequestThreadPoolSize(int threadPoolSize) \{  
HttpUtils.EXECUTOR.setPoolSize(threadPoolSize);  
return this;  
\}  
  
// \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* send request \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
  
public <T> HttpHandler<T> send(HttpRequest.HttpMethod method, String url,  
RequestCallBack<T> callBack) \{  
return send(method, url, null, callBack);  
\}  
  
public <T> HttpHandler<T> send(HttpRequest.HttpMethod method, String url, RequestParams params,  
RequestCallBack<T> callBack) \{  
if (url == null) throw new IllegalArgumentException("url may not be null");  
  
HttpRequest request = new HttpRequest(method, url);  
return sendRequest(request, params, callBack);  
\}  
  
public ResponseStream sendSync(HttpRequest.HttpMethod method, String url) throws HttpException \{  
return sendSync(method, url, null);  
\}  
  
public ResponseStream sendSync(HttpRequest.HttpMethod method, String url, RequestParams params) throws HttpException \{  
if (url == null) throw new IllegalArgumentException("url may not be null");  
  
HttpRequest request = new HttpRequest(method, url);  
return sendSyncRequest(request, params);  
\}  
  
// \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* download \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
  
public HttpHandler<File> download(String url, String target,  
RequestCallBack<File> callback) \{  
return download(HttpRequest.HttpMethod.GET, url, target, null, false, false, callback);  
\}  
  
public HttpHandler<File> download(String url, String target,  
boolean autoResume, RequestCallBack<File> callback) \{  
return download(HttpRequest.HttpMethod.GET, url, target, null, autoResume, false, callback);  
\}  
  
public HttpHandler<File> download(String url, String target,  
boolean autoResume, boolean autoRename, RequestCallBack<File> callback) \{  
return download(HttpRequest.HttpMethod.GET, url, target, null, autoResume, autoRename, callback);  
\}  
  
public HttpHandler<File> download(String url, String target,  
RequestParams params, RequestCallBack<File> callback) \{  
return download(HttpRequest.HttpMethod.GET, url, target, params, false, false, callback);  
\}  
  
public HttpHandler<File> download(String url, String target,  
RequestParams params, boolean autoResume, RequestCallBack<File> callback) \{  
return download(HttpRequest.HttpMethod.GET, url, target, params, autoResume, false, callback);  
\}  
  
public HttpHandler<File> download(String url, String target,  
RequestParams params, boolean autoResume, boolean autoRename, RequestCallBack<File> callback) \{  
return download(HttpRequest.HttpMethod.GET, url, target, params, autoResume, autoRename, callback);  
\}  
  
public HttpHandler<File> download(HttpRequest.HttpMethod method, String url, String target,  
RequestParams params, RequestCallBack<File> callback) \{  
return download(method, url, target, params, false, false, callback);  
\}  
  
public HttpHandler<File> download(HttpRequest.HttpMethod method, String url, String target,  
RequestParams params, boolean autoResume, RequestCallBack<File> callback) \{  
return download(method, url, target, params, autoResume, false, callback);  
\}  
  
public HttpHandler<File> download(HttpRequest.HttpMethod method, String url, String target,  
RequestParams params, boolean autoResume, boolean autoRename, RequestCallBack<File> callback) \{  
  
if (url == null) throw new IllegalArgumentException("url may not be null");  
if (target == null) throw new IllegalArgumentException("target may not be null");  
  
HttpRequest request = new HttpRequest(method, url);  
  
HttpHandler<File> handler = new HttpHandler<File>(httpClient, httpContext, responseTextCharset, callback);  
  
handler.setExpiry(currentRequestExpiry);  
handler.setHttpRedirectHandler(httpRedirectHandler);  
  
if (params != null) \{  
request.setRequestParams(params, handler);  
handler.setPriority(params.getPriority());  
\}  
handler.executeOnExecutor(EXECUTOR, request, target, autoResume, autoRename);  
return handler;  
\}  
  
  
private <T> HttpHandler<T> sendRequest(HttpRequest request, RequestParams params, RequestCallBack<T> callBack) \{  
  
HttpHandler<T> handler = new HttpHandler<T>(httpClient, httpContext, responseTextCharset, callBack);  
  
handler.setExpiry(currentRequestExpiry);  
handler.setHttpRedirectHandler(httpRedirectHandler);  
request.setRequestParams(params, handler);  
  
if (params != null) \{  
handler.setPriority(params.getPriority());  
\}  
handler.executeOnExecutor(EXECUTOR, request);  
return handler;  
\}  
  
private ResponseStream sendSyncRequest(HttpRequest request, RequestParams params) throws HttpException \{  
  
SyncHttpHandler handler = new SyncHttpHandler(httpClient, httpContext, responseTextCharset);  
  
handler.setExpiry(currentRequestExpiry);  
handler.setHttpRedirectHandler(httpRedirectHandler);  
request.setRequestParams(params);  
  
return handler.sendRequest(request);  
\}  
\}**

**一个发送请求的工具类类的集合**

**public class HttpRequest extends HttpRequestBase implements HttpEntityEnclosingRequest \{  
  
private HttpEntity entity;// 一个协议包的封装。  
  
private HttpMethod method;  
  
private URIBuilder uriBuilder;  
  
private Charset uriCharset;**

**\}**

**//一个handler 处理http 的请求，重传机制，获取缓存机制，重试机制。  
public class SyncHttpHandler \{  
  
private final AbstractHttpClient client;  
private final HttpContext context;  
  
private HttpRedirectHandler httpRedirectHandler;  
  
public void setHttpRedirectHandler(HttpRedirectHandler httpRedirectHandler) \{  
this.httpRedirectHandler = httpRedirectHandler;  
\}  
  
private String requestUrl;  
private String requestMethod;  
private String charset; // The default charset of response header info.  
  
private int retriedTimes = 0;  
  
public SyncHttpHandler(AbstractHttpClient client, HttpContext context, String charset) \{  
this.client = client;  
this.context = context;  
this.charset = charset;  
\}  
  
  
private long expiry = HttpCache.getDefaultExpiryTime();  
  
public void setExpiry(long expiry) \{  
this.expiry = expiry;  
\}  
  
public ResponseStream sendRequest(HttpRequestBase request) throws HttpException \{  
  
HttpRequestRetryHandler retryHandler = client.getHttpRequestRetryHandler();  
while (true) \{  
boolean retry = true;  
IOException exception = null;  
try \{  
requestUrl = request.getURI().toString();  
requestMethod = request.getMethod();  
if (HttpUtils.sHttpCache.isEnabled(requestMethod)) \{  
String result = HttpUtils.sHttpCache.get(requestUrl);  
if (result != null) \{  
return new ResponseStream(result);  
\}  
\}  
  
HttpResponse response = client.execute(request, context);  
return handleResponse(response);  
\} catch (UnknownHostException e) \{  
exception = e;  
retry = retryHandler.retryRequest(exception, ++retriedTimes, context);  
\} catch (IOException e) \{  
exception = e;  
retry = retryHandler.retryRequest(exception, ++retriedTimes, context);  
\} catch (NullPointerException e) \{  
exception = new IOException(e.getMessage());  
exception.initCause(e);  
retry = retryHandler.retryRequest(exception, ++retriedTimes, context);  
\} catch (HttpException e) \{  
throw e;  
\} catch (Throwable e) \{  
exception = new IOException(e.getMessage());  
exception.initCause(e);  
retry = retryHandler.retryRequest(exception, ++retriedTimes, context);  
\}  
if (!retry) \{  
throw new HttpException(exception);  
\}  
\}  
\}  
  
private ResponseStream handleResponse(HttpResponse response) throws HttpException, IOException \{  
if (response == null) \{  
throw new HttpException("response is null");  
\}  
StatusLine status = response.getStatusLine();  
int statusCode = status.getStatusCode();  
if (statusCode < 300) \{  
ResponseStream responseStream = new ResponseStream(response, charset, requestUrl, expiry);  
responseStream.setRequestMethod(requestMethod);  
return responseStream;  
\} else if (statusCode == 301 || statusCode == 302) \{  
if (httpRedirectHandler == null) \{  
httpRedirectHandler = new DefaultHttpRedirectHandler();  
\}  
HttpRequestBase request = httpRedirectHandler.getDirectRequest(response);  
if (request != null) \{  
return this.sendRequest(request);  
\}  
\} else if (statusCode == 416) \{  
throw new HttpException(statusCode, "maybe the file has downloaded completely");  
\} else \{  
throw new HttpException(statusCode, status.getReasonPhrase());  
\}  
return null;  
\}  
\}**

**http://blog.csdn.net/longwuxu/article/details/24186005?utm\_source=tuicool**

**![Center][]**

[Center]: /images/20220731/36dc711509cf4dccbed86884a53f86c2.png