实现调用android URLConnection封装后快速下载，并且可以获取到实时下载速度(get和put方法未验证)。 在while 中加个参数控制 中断.

package com.aotu.mobileinspect.http.api;


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLConnection;
import java.util.List;
import java.util.Map;


import android.app.Activity;
import android.content.Context;
import android.net.ConnectivityManager;
import android.util.Log;


/**
 * 类说明 ：实现调用接口后快速下载，并且可以获取到实时下载速度(get和put方法未验证)。 在while 中加个参数控制 中断.

 * @version 创建时间：2016年11月13日 上午11:29:03
 */
public class DoHttpRequest {
private static int TIMEOUT = 10000;
private static int TIMEOUT_CONNECTTIME = TIMEOUT;// 连接时间
private static int TIMEOUT_READTIME = TIMEOUT;// 读取时间
private static int BUFFER_SIZE = 1024 * 1024;// 缓存空间大小


/**
* 方法说明：(本方法实现调用接口后快速下载，并且可以获取到实时下载速度) 注意页面操作时,不能直接在RequestResultListener
* 的回调中写（即不要在子线程中操作UI主线程，而是使用Handler)，会有导致sendPost()出现异常。
* 
* @author Aotu-JS ,E-mail:js@jiangjiesheng.com
* @version 创建时间：2016年11月13日 上午11:26:25
* 
* @param context
* @param url
* @param mapParams
*            Map<String, String> getmap = new HashMap<String, String>();
*            getmap.put(key, value);
* @param mDoHttpRequestListener
* @param isDetectRequestStatus
*            true 会延长请求总时间
*/
public static void doGetRequest(final Context context, final int what,
final String url, final Map<String, String> mapParams,
final DoHttpRequestListener mDoHttpRequestListener,
final boolean isDetectRequestStatus) {
new Thread(new Runnable() {


@Override
public void run() {
doGet(context, what, url, mapParams, mDoHttpRequestListener,
isDetectRequestStatus);
}
}).start();
}


/**
* 方法说明：(本方法实现调用接口后快速下载，并且可以获取到实时下载速度) 注意页面操作时,不能直接在RequestResultListener
* 的回调中写（即不要在子线程中操作UI主线程，而是使用Handler)，会有导致sendPost()出现异常。
* 
* @author Aotu-JS ,E-mail:js@jiangjiesheng.com
* @version 创建时间：2016年11月13日 下午1:32:17
* 
* @param context
* @param url
* @param paramsCount
*            参数个数 重要
* 
* @param stringParamsArray
*            数组对象要先new出来，例如String[] str = new String[3]; str[0] = "111";
*            str[1] = "222"; str[2] = "333";
* 
* @param mDoHttpRequestListener
* @param isDetectRequestStatus
*/
public static void doPutRequest(final Context context, final int what,
final String url, final int paramsCount,
final String[] stringParamsArray,
final DoHttpRequestListener mDoHttpRequestListener,
final boolean isDetectRequestStatus) {
new Thread(new Runnable() {


@Override
public void run() {
doPut(context, what, url, paramsCount, stringParamsArray,
mDoHttpRequestListener, isDetectRequestStatus);
}
}).start();
}


/**
* 方法说明：(本方法实现调用接口后快速下载，并且可以获取到实时下载速度) 注意页面操作时,不能直接在DoHttpRequestListener
* 的回调中写（即不要在子线程中操作UI主线程，而是使用Handler)，会有导致sendPost()出现异常。
* 
* @author Aotu-JS ,E-mail:js@jiangjiesheng.com
* @version 创建时间：2016年11月13日 上午11:24:30
* 
* @param context
* @param url
* @param mapParams
*            Map<String, String> getmap = new HashMap<String, String>();
*            getmap.put(key, value);
* @param mDoHttpRequestListener
* @param isDetectRequestStatus
*            true 会延长请求总时间
*/
public static void doPostRequest(final Context context, final int what,
final String url, final Map<String, String> mapParams,
final DoHttpRequestListener mDoHttpRequestListener,
final boolean isDetectRequestStatus) {
new Thread(new Runnable() {


@Override
public void run() {
doPost(context, what, url, mapParams, mDoHttpRequestListener,
isDetectRequestStatus);
}
}).start();
}


private static void doGet(Context context, int what, String url,
Map<String, String> mapParams,
DoHttpRequestListener mDoHttpRequestListener,
boolean isDetectRequestStatus) {
BufferedReader in = null;
StringBuilder sb;


if (!isInternetConnected(context)) {
if (mDoHttpRequestListener != null) {
mDoHttpRequestListener.requestNetworkConnected(what, false,
"网络已断开");
mDoHttpRequestListener.requestEnd(what, url);
mDoHttpRequestListener.requestResult(what, null);
}
return;
} else {
if (mDoHttpRequestListener != null)
mDoHttpRequestListener.requestNetworkConnected(what, true,
"网络已连接");
}


if (isDetectRequestStatus
&& !getRequestStatus(url, what, mDoHttpRequestListener)) {
mDoHttpRequestListener.requestEnd(what, url);
mDoHttpRequestListener.requestResult(what, null);
return;
}


try {
if (mapParams != null && !mapParams.isEmpty()) {
StringBuilder paramsSB = new StringBuilder();
for (String key : mapParams.keySet()) {
System.out.println(key + "--->" + mapParams.get(key));// 只是查看数据
paramsSB.append(key + "=" + mapParams.get(key) + "&");
}


String paramsStr = paramsSB.toString();
int lastIndex = paramsStr.lastIndexOf("&");
paramsStr = paramsStr.substring(0, lastIndex);
Log.e("test", "get请求 参数(有)：" + paramsStr);
url += "?" + paramsStr;
} else {
Log.e("test", "get请求 参数(无)：" + url);
}


URL realUrl = new URL(url);
Log.e("test", "get请求 URL：" + realUrl);
URLConnection conn = realUrl.openConnection();
conn.setRequestProperty("accept", "*/*");
conn.setRequestProperty("connection", "Keep-Alive");
conn.setRequestProperty("Accept-Encoding", "identity");// get total
// length
conn.setRequestProperty("Content-Type",
"application/x-www-form-urlencoded; charset=utf-8");


conn.setConnectTimeout(TIMEOUT_CONNECTTIME);
conn.setReadTimeout(TIMEOUT_READTIME);
if (mDoHttpRequestListener != null)
mDoHttpRequestListener.requestStart(what, url);
conn.connect();// start build connection


Map<String, List<String>> map = conn.getHeaderFields();
for (String key : map.keySet()) {


System.out.println(key + "--->" + map.get(key));// 只是查看数据
}


sb = new StringBuilder();
in = new BufferedReader(
new InputStreamReader(conn.getInputStream()));
int totalLength = conn.getContentLength();
Log.e("test", "length total = " + totalLength);
Log.e("test", "调用位置 6");


char[] buffer = new char[BUFFER_SIZE];// 1MB大小
int total_legth = 0;
int len = 0;


while ((len = in.read(buffer)) != -1) {
// fos.write(buffer, 0, len);
sb.append(buffer, 0, len);
total_legth += len;
int value = total_legth * 100 / totalLength;
Log.e("test", "当前进度doGet："+value+"%");
if (mDoHttpRequestListener != null)
mDoHttpRequestListener.requestcurrentProcess(what, value);
// 这里不一定能到100%，可能不到100%已经结束，可以在requestResult（）中关闭dialog，或者重新写监听的方法。
}
if (mDoHttpRequestListener != null && sb != null){
mDoHttpRequestListener.requestcurrentProcess(what, 100);
mDoHttpRequestListener.requestResult(what, sb.toString());
}


} catch (Exception e) {
if (mDoHttpRequestListener != null)
mDoHttpRequestListener.requestException(what, url, e, "捕获到异常");
e.printStackTrace();


} finally {
try {
if (in != null) {
in.close();
}
Log.e("test", "调用位置10");
} catch (IOException e) {
e.printStackTrace();
Log.e("test", "调用位置 11");
}
}


}


private static void doPut(Context context, int what, String url,
int paramsCount, String[] stringParamsArray,
DoHttpRequestListener mDoHttpRequestListener,
boolean isDetectRequestStatus) {


if (stringParamsArray == null
|| stringParamsArray.length != paramsCount) {
if (mDoHttpRequestListener != null) {
mDoHttpRequestListener.requestException(what, url, null,
"doPut--->参数长度有误！");
mDoHttpRequestListener.requestEnd(what, url);
mDoHttpRequestListener.requestResult(what, null);
}
Log.e("test", "doPut--->参数长度有误！");
return;
}
BufferedReader in = null;
StringBuilder sb;


if (!isInternetConnected(context)) {
if (mDoHttpRequestListener != null) {
mDoHttpRequestListener.requestNetworkConnected(what, false,
"网络已断开");
mDoHttpRequestListener.requestEnd(what, url);
mDoHttpRequestListener.requestResult(what, null);
}
return;
} else {
if (mDoHttpRequestListener != null)
mDoHttpRequestListener.requestNetworkConnected(what, true,
"网络已连接");
}


if (isDetectRequestStatus
&& !getRequestStatus(url, what, mDoHttpRequestListener)) {
mDoHttpRequestListener.requestEnd(what, url);
mDoHttpRequestListener.requestResult(what, null);
return;
}


try {
if (stringParamsArray != null && stringParamsArray.length != 0) {
StringBuilder paramsSB = new StringBuilder();
for (String string : stringParamsArray) {
paramsSB.append("/" + string);
}


String paramsStr = paramsSB.toString();
int firstIndex = paramsStr.indexOf("/") + 1;
paramsStr = paramsStr.substring(firstIndex);
Log.e("test", "put请求 参数(有)" + paramsStr);
if (url.endsWith("/")) {
url += paramsStr;
} else {
url += "/" + paramsStr;
}


} else {
Log.e("test", "put请求 参数(无)(可能需要检查传参对象是否为空)：" + url);
}


URL realUrl = new URL(url);
Log.e("test", "get请求 URL：" + realUrl);
URLConnection conn = realUrl.openConnection();
conn.setRequestProperty("accept", "*/*");
conn.setRequestProperty("connection", "Keep-Alive");
conn.setRequestProperty("Accept-Encoding", "identity");// get total
// length
conn.setRequestProperty("Content-Type",
"application/x-www-form-urlencoded; charset=utf-8");


conn.setConnectTimeout(TIMEOUT_CONNECTTIME);
conn.setReadTimeout(TIMEOUT_READTIME);
if (mDoHttpRequestListener != null)
mDoHttpRequestListener.requestStart(what, url);
conn.connect();// start build connection


Map<String, List<String>> map = conn.getHeaderFields();
for (String key : map.keySet()) {


System.out.println(key + "--->" + map.get(key));// 只是查看数据
}


sb = new StringBuilder();
in = new BufferedReader(
new InputStreamReader(conn.getInputStream()));
int totalLength = conn.getContentLength();
Log.e("test", "length total = " + totalLength);
Log.e("test", "调用位置 6");


char[] buffer = new char[BUFFER_SIZE];// 1MB大小
int total_legth = 0;
int len = 0;


while ((len = in.read(buffer)) != -1) {
// fos.write(buffer, 0, len);
sb.append(buffer, 0, len);
total_legth += len;
int value = total_legth * 100 / totalLength;
if (mDoHttpRequestListener != null)
mDoHttpRequestListener.requestcurrentProcess(what, value);
// 这里不一定能到100%，可能不到100%已经结束，可以在getResult（）中关闭dialog，或者重新写监听的方法。
}
if (mDoHttpRequestListener != null && sb != null){
mDoHttpRequestListener.requestcurrentProcess(what, 100);
mDoHttpRequestListener.requestResult(what, sb.toString());

}
} catch (Exception e) {
if (mDoHttpRequestListener != null)
mDoHttpRequestListener.requestException(what, url, e, "捕获到异常");
e.printStackTrace();


} finally {
try {
if (in != null) {
in.close();
}
Log.e("test", "调用位置10");
} catch (IOException e) {
e.printStackTrace();
Log.e("test", "调用位置 11");
}
}


}


private static void doPost(Context context, int what, String url,
Map<String, String> mapParams,
DoHttpRequestListener mDoHttpRequestListener,
boolean isDetectRequestStatus) {


PrintWriter out = null;
BufferedReader in = null;
StringBuilder sb = null;
Log.e("test", "调用位置 4");


if (!isInternetConnected(context)) {
if (mDoHttpRequestListener != null) {
mDoHttpRequestListener.requestNetworkConnected(what, false,
"网络已断开");
mDoHttpRequestListener.requestEnd(what, url);
mDoHttpRequestListener.requestResult(what, null);
}
return;
} else {
if (mDoHttpRequestListener != null)
mDoHttpRequestListener.requestNetworkConnected(what, true,
"网络已连接");
}
if (isDetectRequestStatus
&& !getRequestStatus(url, what, mDoHttpRequestListener)) {
mDoHttpRequestListener.requestEnd(what, url);
mDoHttpRequestListener.requestResult(what, null);
return;
}


try {
Log.e("test", "调用位置 5");
URL realUrl = new URL(url);
URLConnection conn = realUrl.openConnection();
conn.setRequestProperty("accept", "*/*");
conn.setRequestProperty("connection", "Keep-Alive");
conn.setRequestProperty("Content-Type",
"application/x-www-form-urlencoded; charset=utf-8");
conn.setRequestProperty("Accept-Encoding", "identity");// get total
// length
conn.setConnectTimeout(TIMEOUT_CONNECTTIME);
conn.setReadTimeout(TIMEOUT_READTIME);
conn.setDoOutput(true);
conn.setDoInput(true);
if (mDoHttpRequestListener != null)
mDoHttpRequestListener.requestStart(what, url);
out = new PrintWriter(conn.getOutputStream());


if (mapParams != null && !mapParams.isEmpty()) {
StringBuilder paramsSB = new StringBuilder();
for (String key : mapParams.keySet()) {
System.out.println(key + "--->" + mapParams.get(key));// 只是查看数据
paramsSB.append(key + "=" + mapParams.get(key) + "&");
}
String paramsStr = paramsSB.toString();
int lastIndex = paramsStr.lastIndexOf("&");
paramsStr = paramsStr.substring(0, lastIndex);
Log.e("test", "post请求 参数(有)：" + paramsStr);
out.print(paramsStr);


} else {
Log.e("test", "post请求 参数(无)：" + url);
}


out.flush();


in = new BufferedReader(
new InputStreamReader(conn.getInputStream()));


sb = new StringBuilder();


int totalLength = conn.getContentLength();
Log.e("test", "length total = " + totalLength);
Log.e("test", "调用位置 6");


char[] buffer = new char[BUFFER_SIZE];// 1MB大小
int total_legth = 0;
int len = 0;
while ((len = in.read(buffer)) != -1) {
// fos.write(buffer, 0, len);
sb.append(buffer, 0, len);
total_legth += len;
int value = total_legth * 100 / totalLength;
if (mDoHttpRequestListener != null)
mDoHttpRequestListener.requestcurrentProcess(what, value);
// 这里不一定能到100%，可能不到100%已经结束，可以在getResult（）中关闭dialog，或者重新写监听的方法。
}
 
if (mDoHttpRequestListener != null && sb != null){
mDoHttpRequestListener.requestcurrentProcess(what, 100);
mDoHttpRequestListener.requestResult(what, sb.toString());
}

Log.e("test", "调用位置 8");
} catch (Exception e) {
Log.e("test", "调用位置 9 异常");
if (mDoHttpRequestListener != null)
mDoHttpRequestListener.requestException(what, url, e, "捕获到异常");
e.printStackTrace();


} finally {
try {
if (out != null) {
out.close();
}
if (in != null) {
in.close();
}
Log.e("test", "调用位置10");
} catch (IOException e) {
if (mDoHttpRequestListener != null)
mDoHttpRequestListener.requestException(what, url, e,
"捕获到异常");
e.printStackTrace();
Log.e("test", "调用位置 11");
}
if (mDoHttpRequestListener != null)
mDoHttpRequestListener.requestEnd(what, url);
}
Log.e("test", "调用位置 12");


}


private static boolean getRequestStatus(String url, int what,
DoHttpRequestListener mDoHttpRequestListener) {
boolean isGoodConnected = true;
try {
URL u = new URL(url);
HttpURLConnection httpurlCon = (HttpURLConnection) u
.openConnection();
int responseCode = httpurlCon.getResponseCode();
if (responseCode == 200) {
isGoodConnected = true;
if (mDoHttpRequestListener != null)
mDoHttpRequestListener.requestStatus(what, 200);


} else if (responseCode == 404) {
isGoodConnected = false;
if (mDoHttpRequestListener != null)
mDoHttpRequestListener.requestStatus(what, 404);
} else {
isGoodConnected = false;
if (mDoHttpRequestListener != null)
mDoHttpRequestListener.requestStatus(what, responseCode);
}
} catch (Exception e) {
if (mDoHttpRequestListener != null)
mDoHttpRequestListener.requestException(what, url, e, "捕获到异常");
// isGoodConnected = false;//暂时取消
e.printStackTrace();
}
return isGoodConnected;
}


private static boolean isInternetConnected(Context context) {


try {
ConnectivityManager conmag = (ConnectivityManager) context
.getSystemService(Activity.CONNECTIVITY_SERVICE);
Boolean wifi = conmag.getNetworkInfo(ConnectivityManager.TYPE_WIFI)
.isConnectedOrConnecting();
Boolean internet = conmag.getNetworkInfo(
ConnectivityManager.TYPE_MOBILE).isConnectedOrConnecting();
if (wifi || internet) {
return true;
} else
return false;
} catch (Exception e) {
return false;
}


}


/**
* 类说明 ： 注意页面操作时,不能直接在DoHttpRequestListener
* 的回调中写（即不要在子线程中操作UI主线程，而是使用Handler)，会有导致sendPost()出现异常。
* 
* @author 作者 江节胜 E-mail:js@jiangjiesheng.com
* @version 创建时间：2016年11月13日 上午11:11:35
* 
*/
public interface DoHttpRequestListener {
/**
* 方法说明：描述网络连接状态
* 
* @param isNetworkConnected
* @param NetworkConnected
*/
public void requestNetworkConnected(int what,
boolean isNetworkConnected, String NetworkConnected);


/**
* 方法说明：请求开始
* 
* @param requestURL
*/
public void requestStart(int what, String requestURL);


/**
* 方法说明：请求返回状态(根据参数时候执行确定返回状态，会增加请求网络的总时间)
* 
* @param requestStatus
*/
public void requestStatus(int what, int requestStatus);


/**
* 方法说明：请求用于下载的当前进度
* 
* @param process
*/
public void requestcurrentProcess(int what, int process);


/**
* 方法说明：请求的返回最终结果，可为null或者"";
* 
* @param res
*/
public void requestResult(int what, String res);


/**
* 方法说明：请求结束
* 
* @param requestURL
*/
public void requestEnd(int what, String requestURL);


/**
* 方法说明：请求出现异常
* 
* @param process
*/
public void requestException(int what, String requestURL, Exception e,
String exceptionDescription);
}

}

一下是调用的地方以及 请求返回值解析是xml：

请求方法：

 Logs.d("test", "mDoHttpRequestListener");
Map<String, String> postMapParams = new HashMap<String, String>();
postMapParams.put("MovePhone", mUser.getMovePhone());
postMapParams.put("UserPWD", mUser.getUserPwd());


DoHttpRequest.doPostRequest(getApplicationContext(),
Whats.WHAT_DOWNLOAD_PROJECT_OVERVIEW,
Api.DOWNLOAD_PROJECT_OVERVIEW, postMapParams,
mDoHttpRequestListener, false);

mDoHttpRequestListener 类：

DoHttpRequestListener mDoHttpRequestListener = new DoHttpRequestListener() {


@Override
public void requestcurrentProcess(int what, int process) {
sendProgressDialogProcess(PROGRESS_DOWNLOADING_SHOWING, process);
Logs.d("test", "requestcurrentProcess");


}


@Override
public void requestStatus(int what, int requestStatus) {
Logs.d("test", "requestStatus");
}


@Override
public void requestStart(int what, String requestURL) {
// sendProgressDialogProcess(PROGRESS_DOWNLOADING_SHOWING, 0);
Logs.d("test", "requestStart");
}


@Override
public void requestResult(int what, final String res) {


if (res == null) {
tip("工程信息下载失败!");
return;
}
switch (what) {
case Whats.WHAT_DOWNLOAD_PROJECT_OVERVIEW:
List<NewProjectOverviewModel> lstModels = ParseBase.parseList(
res, NewProjectOverviewModel.class);
tip("数据下载完成 大小： " + lstModels.size() + "条");
if (lstModels != null && lstModels.size() > 0) {
if (!ProjectOverviewHelper.isExistData()) {
ProjectOverviewHelper.addAll(lstModels);
}
// ProjectOverviewHelper.addAll(lstModels);
addMarkers(lstModels);
}
break;
// case Whats.WHAT_DownLoad_NormLan_MainPart:
// List<NormLanMainPartModel> lstModels1 = ParseBase.parseList(
// res, NormLanMainPartModel.class);
// NormLanMainPartHelper.addAll(lstModels1);
// break;
// case Whats.WHAT_DOWNLOAD_NORM_LAN_POSITION:
// List<NormLanPositionModel> lstModels2 = ParseBase.parseList(
// res, NormLanPositionModel.class);
// NormLanPositionHelper.addAll(lstModels2);
// break;
// case Whats.WHAT_DOWNLOAD_NORM_LAN_CONTENT:
// new AsyncTask<Void, Void, Void>() {
// @Override
// protected void onPreExecute() {
// super.onPreExecute();
// }
//
// @Override
// protected Void doInBackground(Void... arg0) {
//
// List<NormLanContentModel> lstModels3 = ParseBase
// .parseList(res, NormLanContentModel.class);
// NormLanContentHelper.addAll(lstModels3);
// return null;
// }
//
// @Override
// protected void onPostExecute(Void result) {
// super.onPostExecute(result);
//
// }
// }.execute();
// break;


default:
break;
}
//
// List<NewProjectOverviewModel> lstModels =
// ParseBase.parseList(res,
// NewProjectOverviewModel.class);
// tip("数据下载完成 大小： " + lstModels.size() + "条");
// if (lstModels != null && lstModels.size() > 0) {
// ProjectOverviewHelper.addAll(lstModels);
// addMarkers(lstModels);
// }


}


@Override
public void requestNetworkConnected(int what,
boolean isNetworkConnected, String NetworkConnected) {
// TODO Auto-generated method stub


}


@Override
public void requestEnd(int what, String requestURL) {
// sendProgressDialogProcess(PROGRESS_DOWNLOADING_SHOWING, 100);


handler.sendEmptyMessage(DIALOG_DISMISS);


}


@Override
public void requestException(int what, String requestURL, Exception e,
String exceptionDescription) {


}
};