Util工具类 URLConnectionUtil - 20141211 封装为访问网络框架

/**
* 参考 [http://blog.csdn.net/chenlaic/article/details/6208292]
*/
public class URLConnectionUtil {

private static final String TAG = "URLConnectionUtil";

private static final String POST = "POST";
private static final String GET = "GET";
private static final String DELETE = "DELETE";
private static final String PUT = "PUT";

private static String prepareParam(Map<String, Object> paramMap) {
StringBuffer sb = new StringBuffer();
if (paramMap == null || paramMap.isEmpty()) {
return "";
} else {
for (String key : paramMap.keySet()) {
String value = (String) paramMap.get(key);
if (sb.length() < 1) {
sb.append(key).append("=").append(value);
} else {
sb.append("&").append(key).append("=").append(value);
}
}
return sb.toString();
}
}

public static InputStream doPost(String urlStr, Map<String, Object> paramMap) throws Exception {
URL url = new URL(urlStr);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod(POST);
String paramStr = prepareParam(paramMap);
conn.setDoInput(true);
conn.setDoOutput(true);
OutputStream os = conn.getOutputStream();
os.write(paramStr.toString().getBytes("utf-8"));
os.close();

return conn.getInputStream();
}

public static InputStream doGet(String urlStr, Map<String, Object> paramMap) throws Exception {
String paramStr = prepareParam(paramMap);
if (paramStr != null && paramStr.trim().length() > 0) {
urlStr += "?" + paramStr;
}
URL url = new URL(urlStr);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod(GET);
conn.setRequestProperty("Content-Type", "text/html; charset=UTF-8");

conn.connect();
return conn.getInputStream();
}

public static InputStream doPut(String urlStr, Map<String, Object> paramMap) throws Exception {
URL url = new URL(urlStr);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod(PUT);
String paramStr = prepareParam(paramMap);
conn.setDoInput(true);
conn.setDoOutput(true);
OutputStream os = conn.getOutputStream();
os.write(paramStr.toString().getBytes("utf-8"));
os.close();
return conn.getInputStream();
}

public static void doDelete(String urlStr, Map<String, Object> paramMap) throws Exception {
String paramStr = prepareParam(paramMap);
if (paramStr != null && paramStr.trim().length() > 0) {
urlStr += "?" + paramStr;
}
URL url = new URL(urlStr);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setDoOutput(true);
conn.setRequestMethod(DELETE);
// shielding of code is wrong ，java.net.ProtocolException: HTTP method
// DELETE doesn't support output
/*
* OutputStream os = conn.getOutputStream();
* os.write(paramStr.toString().getBytes("utf-8")); os.close();
*/
if (conn.getResponseCode() == 200) {
Log.i(TAG, "doDelete() success");
} else {
Log.i(TAG, conn.getResponseCode() + "");
}
}

}

package com.example.demo.util;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

import android.util.Log;

public class StreamUtil {

private static final String TAG = "StreamUtil";

public static String inputStreamToString(InputStream inputStream) {
BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
String result = "";
try {
String line;
while ((line = br.readLine()) != null) {
result += "/n" + line;
}
br.close();
result = result.substring("/n".length());
} catch (IOException e) {
e.printStackTrace();
}
Log.i(TAG, "inputStreamToString() result:" + result);
return result;
}
}

public class HttpClient {

private static final String TAG = "HttpClient";

public static final String GET = "GET";
public static final String POST = "POST";
public static final String UTF_8 = "UTF-8";
public static final String httpStatusCode = "httpStatusCode";
public static final int ConnectTimeout = 30 * 1000;
public static final int ReadTimeout = 30 * 1000;

public static String post(String reqURL, Map<String, String> params)
throws Exception {
HttpURLConnection conn = null;
OutputStream out = null;
InputStream in = null;
try {
URL url = new URL(reqURL);
conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod(POST);
conn.setDoInput(true);
conn.setDoOutput(true);
conn.setConnectTimeout(ConnectTimeout);
conn.setReadTimeout(ReadTimeout);

byte[] data = convertParams(params).getBytes(UTF_8);
if (data.length > 0) {
out = conn.getOutputStream();
out.write(data);
out.flush(); // 清空缓冲区,发送数据
}

int tatusCode = conn.getResponseCode();
if (tatusCode == 200) {
in = conn.getInputStream();
return Utils.inputStreamToString(in);
} else {
return httpStatusCode + tatusCode;
}
} catch (Exception e) {
Log.i(TAG, e.getMessage());
throw new Exception("HttpClient post Exception");
} finally {
if (out != null) {
try {
out.close();
} catch (Exception e) {
e.printStackTrace();
}
}
if (in != null) {
try {
in.close();
} catch (Exception e) {
e.printStackTrace();
}
}
if (conn != null) {
conn.disconnect();
conn = null;
}
}
}

public static String get(String reqURL, Map<String, String> params)
throws Exception {
HttpURLConnection conn = null;
OutputStream out = null;
InputStream in = null;
try {
String data = convertParams(params);
if (data.length() > 0)
reqURL = reqURL + "?" + data;
URL url = new URL(reqURL);
conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod(GET);
conn.setRequestProperty("Content-Type", "text/html; charset="
+ UTF_8);
conn.setConnectTimeout(ConnectTimeout);
conn.setReadTimeout(ReadTimeout);

conn.connect();

int statusCode = conn.getResponseCode();
if (statusCode == 200) {
in = conn.getInputStream();
return Utils.inputStreamToString(in);
} else {
return httpStatusCode + statusCode;
}
} catch (Exception e) {
Log.i(TAG, e.getMessage());
throw new Exception("HttpClient get Exception");
} finally {
if (out != null) {
try {
out.close();
} catch (Exception e) {
e.printStackTrace();
}
}
if (in != null) {
try {
in.close();
} catch (Exception e) {
e.printStackTrace();
}
}
if (conn != null) {
conn.disconnect();
conn = null;
}
}
}

private static String convertParams(Map<String, String> params) {
if (params == null || params.isEmpty())
return "";
StringBuffer sb = new StringBuffer();
for (String key : params.keySet()) {
if (sb.length() > 1)
sb.append("&");
sb.append(key).append("=").append(params.get(key));
}
return sb.toString();
}

}

/**
* @author wangpeng
*
*/
public class HttpClient {

private static final String TAG = HttpClient.class.getSimpleName();

public static final String GET = "GET";
public static final String POST = "POST";
public static final String UTF_8 = "UTF-8";
public static final String httpStatusCode = "httpStatusCode";
public static final int ConnectTimeout = 20 * 1000;
public static final int ReadTimeout = 20 * 1000;

public static String post(String reqURL, Map<String, String> params) {
HttpURLConnection conn = null;
BufferedOutputStream out = null;
BufferedInputStream in = null;
try {
URL url = new URL(reqURL);
conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod(POST);
conn.setDoInput(true);
conn.setDoOutput(true);
conn.setConnectTimeout(ConnectTimeout);
conn.setReadTimeout(ReadTimeout);

byte[] data = convertParams(params).getBytes(UTF_8);
if (data.length > 0) {
out = new BufferedOutputStream(conn.getOutputStream(), 8 * 1024);
out.write(data);
out.flush(); // clear cache, send data
}

int statusCode = conn.getResponseCode();
if (statusCode == 200) {
in = new BufferedInputStream(conn.getInputStream(), 8 * 1024);
return BaseUtils.inputStreamToString(in);
} else {
return httpStatusCode + statusCode;
}
} catch (Exception e) {
Log.i(TAG, e.getMessage());
throw new RuntimeException("HttpClient post Exception");
} finally {
if (conn != null)
conn.disconnect();
try {
if (in != null)
in.close();
if (out != null)
out.close();
} catch (Exception e) {
e.printStackTrace();
}

}
}

public static String get(String reqURL, Map<String, String> params) {
HttpURLConnection conn = null;
BufferedInputStream in = null;
try {
String data = convertParams(params);
if (data.length() > 0)
reqURL = reqURL + "?" + data;
URL url = new URL(reqURL);
conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod(GET);
conn.setRequestProperty("Content-Type", "text/html; charset="
+ UTF_8);
conn.setConnectTimeout(ConnectTimeout);
conn.setReadTimeout(ReadTimeout);

conn.connect();

int statusCode = conn.getResponseCode();
if (statusCode == 200) {
in = new BufferedInputStream(conn.getInputStream(), 8 * 1024);
return BaseUtils.inputStreamToString(in);
} else {
return httpStatusCode + statusCode;
}
} catch (Exception e) {
Log.i(TAG, e.getMessage());
throw new RuntimeException("HttpClient get Exception");
} finally {
if (conn != null)
conn.disconnect();
try {
if (in != null)
in.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}

private static String convertParams(Map<String, String> params) {
if (params == null || params.isEmpty())
return "";
StringBuffer sb = new StringBuffer();
for (String key : params.keySet()) {
if (sb.length() > 1)
sb.append("&");
sb.append(key).append("=").append(params.get(key));
}
return sb.toString();
}

}

/**
* @author wangpeng
*/
public class HttpManager {

private Activity activity;
private ExecutorService executor;

public HttpManager(final Activity activity) {
this.activity = activity;
this.executor = Executors.newSingleThreadExecutor();
}

public void request(final String method, final String url,
final Map<String, String> params, final Listener listener,
final ErrorListener errorListener, final boolean useDiskCache) {
LogUtils.logd("request:\n" + "url:" + url + ",params:" + params);
executor.execute(new Runnable() {
@Override
public void run() {
try {
if (useDiskCache) {
final InputStream in = DiskLruCacheUtils.get(activity,
DiskLruCacheUtils.object, url + params);

if (in != null) {
activity.runOnUiThread(new Runnable() {
@Override
public void run() {
String cacheResult = BaseUtils
.inputStreamToString(in);
listener.onResponse(cacheResult);
}
});
}
}

final String result = method.equals(HttpClient.POST) ? HttpClient
.post(url, params) : HttpClient.get(url, params);
// receive success
if (!result.contains(HttpClient.httpStatusCode)) {
activity.runOnUiThread(new Runnable() {
@Override
public void run() {
LogUtils.logd("response:\n" + result);
listener.onResponse(result);
}
});

if (useDiskCache)
DiskLruCacheUtils
.save(activity,
DiskLruCacheUtils.object,
url + params,
new ByteArrayInputStream(result
.getBytes()));
} else {
activity.runOnUiThread(new Runnable() {
@Override
public void run() {
LogUtils.loge("http error for service [url:" + url
+ ",params:" + params + "]");
errorListener.onError();
}
});

}
} catch (Exception e) {
activity.runOnUiThread(new Runnable() {
@Override
public void run() {
LogUtils.loge("http error for net [url:" + url
+ ",params:" + params + "]");
errorListener.onError();
}
});
}
}
});
}

public void stop() {
shutdownAndAwaitTermination();
}

public interface Listener {
void onResponse(String response);
}

public interface ErrorListener {
void onError();
}

private void shutdownAndAwaitTermination() {
// Disable new tasks from being submitted
executor.shutdown();
try {
// Wait a while for existing tasks to terminate
if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
executor.shutdownNow(); // Cancel currently executing tasks
// Wait a while for tasks to respond to being cancelled
if (!executor.awaitTermination(60, TimeUnit.SECONDS))
System.err.println("Pool did not terminate");
}
} catch (InterruptedException ie) {
// (Re-)Cancel if current thread also interrupted
executor.shutdownNow();
// Preserve interrupt status
Thread.currentThread().interrupt();
}
}
}

/**
* @author wangpeng
*/
public class HttpUtils {

public boolean useDiskCahce = true;

private Activity activity;
private ErrorListener errorListener;

private HttpUtils() {
}

public static HttpUtils init(Activity activity, ErrorListener errorListener) {
HttpUtils httpUtils = new HttpUtils();
httpUtils.activity = activity;
httpUtils.errorListener = errorListener;
return httpUtils;
}

public void post(String url, final Map<String, String> params,
final Listener listener) {
if (activity == null) {
throw new IllegalArgumentException(
"activity has not init in http utils");
}

HttpManager manager = new HttpManager(activity);

manager.request(HttpClient.POST, url, params, listener, errorListener,
useDiskCahce);
}

public void get(String url, final Map<String, String> params,
final Listener listener) {
if (activity == null) {
throw new IllegalArgumentException(
"activity has not init in http utils");
}

HttpManager manager = new HttpManager(activity);

manager.request(HttpClient.GET, url, params, listener, errorListener,
useDiskCahce);
}
}

package com.example.f.demo.utils;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.util.HashMap;
import java.util.Map;

import android.graphics.Bitmap;
import android.os.Environment;

public class BaseUtils {
/**
* 根据传入参数，以key对应value的形式初始化一个hashmap对象
*
* @param <T>
*/
public static Map<String, String> initMap(Object... params) {
if (params == null || params.length < 1 || params.length % 2 != 0)
return null;
Map<String, String> map = new HashMap<String, String>();
for (int i = 0; i < params.length; i = i + 2)
map.put(String.valueOf(params[i]), String.valueOf(params[i + 1]));
return map;
}

public static boolean hasSDCard() {
return Environment.MEDIA_MOUNTED.equals(Environment
.getExternalStorageState());
}

public static String inputStreamToString(InputStream in) {
StringBuffer out = new StringBuffer();
byte[] b = new byte[8 * 1024];
try {
for (int n; (n = in.read(b)) != -1;) {
out.append(new String(b, 0, n));
}
} catch (IOException e) {
e.printStackTrace();
}
return out.toString();
}

public static boolean inputStreamToOutputStream(InputStream input,
OutputStream output) {
BufferedOutputStream out = null;
BufferedInputStream in = null;
in = new BufferedInputStream(input, 8 * 1024);
out = new BufferedOutputStream(output, 8 * 1024);
int b;
try {
while ((b = in.read()) != -1) {
out.write(b);
}
return true;
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (out != null)
out.close();
if (in != null)
in.close();
} catch (final IOException e) {
e.printStackTrace();
}
}
return false;
}

public static InputStream bitmapToInputStream(Bitmap bitmap) {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
bitmap.compress(Bitmap.CompressFormat.PNG, 100, baos);
InputStream sbs = new ByteArrayInputStream(baos.toByteArray());
return sbs;
}

public static InputStream byteToInputStream(byte[] bytes) {
ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
return bais;
}

}