andriod开发,简单的封装网络请求并监听返回.
一.为什么封装
因为android 4.0 以后的发送网络请求必须要放到异步线程中,而异步线程必须跟handle合作才能更新主线程中的UI,所以建议用一个类继承handler来异步处理网络请求.
二.封装哪些功能.
首先,每次发送网络请求都需要先检测网络连接是否正常.其次需要向用户提供一个提示信息,比如ProgressDialog,然后简单粗暴的把网络请求结果设为3种:1->请求成功;2->请求失败;3->连接超时.请求成功的话就返回正确的结果,请求失败就提示网络请求失败.请求超时就询问是否重连.所以需要封装的就有:
1.检测网络
/**
* 判断网络连接
*/
private boolean isNetworkConnect() {
ConnectivityManager cm = (ConnectivityManager) activity
.getSystemService(Context.CONNECTIVITY_SERVICE);
cm.getActiveNetworkInfo();
if (cm.getActiveNetworkInfo() != null) {
return cm.getActiveNetworkInfo().isAvailable();
}
return false;
}
/**
* 打开网络对话框
*/
private void whetherOpenNet() {
if (dialog != null) {
dialog.cancel();
dialog = null;
}
AlertDialog.Builder builder = new AlertDialog.Builder(activity);
builder.setTitle("网络木有连接");
builder.setMessage("是否打开网络连接");
builder.setPositiveButton("确定", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
activity.startActivityForResult(new Intent(
Settings.ACTION_WIRELESS_SETTINGS), OPEN_NETWORK);
}
});
builder.setNegativeButton("取消", null);
dialog = builder.create();
dialog.show();
}
2.进度条提示
/**
* 显示进度条提示
*
* @param message
*/
private void showPd(String message) {
showLog("start connect");
if (message == null || message.length() == 0) {
return;
}
if (pd != null) {
pd.cancel();
pd = null;
}
pd = new ProgressDialog(activity);
pd.setMessage(message);
pd.setOnCancelListener(new OnCancelListener() {
@Override
public void onCancel(DialogInterface dialog) {
requestThread.interrupt();
}
});
pd.setCancelable(true);
pd.show();
}
3.处理请求结果
/**
* 发起一个post请求,返回string对象
*
* @param stringListener
* @param isLoadCache
* true 为加载缓存，false为不加载缓存
*/
public void postRequest(final String text,
final RequestStringListener stringListener) {
if (!isNetworkConnect()) {
whetherOpenNet();
return;
}
showPd(text);
Runnable task = new Runnable() {
@Override
public void run() {
try {
final String result = postStringResult();
if (requestThread.isInterrupted()) {
showLog("is interrupted");
return;
}
if (result == null) {
netError();
return;
}
post(new Complete() {
@Override
public void run() {
super.run();
stringListener.onComplete(result);
sendEmptyMessage(REQUEST_SUCCESS);
}
});
} catch (SocketTimeoutException e) {
timeOut(text, stringListener);
e.printStackTrace();
} catch (Exception e) {
netError();
e.printStackTrace();
}
}
};
requestThread = new Thread(task);
requestThread.start();
}
/**
* 网络连接超时
*
* @param text
* @param stringListener
*/
protected void timeOut(final String text,
final RequestStringListener stringListener) {
sendEmptyMessage(REQUEST_TIMEOUT);
Looper.prepare();
post(new Complete() {
@Override
public void run() {
super.run();
new AlertDialog.Builder(activity)
.setTitle("网络连接超时")
.setNegativeButton("取消", null)
.setPositiveButton("重连",
new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog,
int which) {
showLog("重连");
postRequest(text, stringListener);
}
}).show();
}
});
}
/**
* 网络连接错误或返回数据为空
*
*/
protected void netError() {
sendEmptyMessage(REQUEST_ERROR);
Looper.prepare();
post(new Complete() {
@Override
public void run() {
super.run();
if (!isNetworkConnect()) {
whetherOpenNet();
} else {
Toast.makeText(getActivity(), "网络连接失败,请稍后重试",
Toast.LENGTH_LONG).show();
}
}
});
}
三.使用
封装完成后就可以使用了.
NetApi netApi = new NetApi(MainActivity.this,
"http://192.168.10.233:8089/web_test/json");
netApi.addParams("test", "test");
netApi.postRequest("测试请求", new RequestStringListener() {
@Override
public void onComplete(String result) {
Log.d("test", "result is --->" + result);
}
});
四.贴出完整代码
package com.example.test_android;
import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.SocketTimeoutException;
import java.net.URL;
import java.net.URLEncoder;
import java.util.HashMap;
import java.util.Map;
import org.json.JSONException;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.ProgressDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.DialogInterface.OnCancelListener;
import android.content.Intent;
import android.net.ConnectivityManager;
import android.os.Handler;
import android.os.Looper;
import android.provider.Settings;
import android.util.Log;
import android.widget.Toast;
/**
* 网络接口,post请求string或者get请求json,里面只包含一个线程,只能同时发送一个网络请求
*
* @author oldfeel
*
*/
public class NetApi extends Handler {
/** 打开网络连接 */
public static final int OPEN_NETWORK = -1;
/** 请求成功 */
public static final int REQUEST_SUCCESS = 1;
/** 请求失败 */
public static final int REQUEST_ERROR = 2;
/** 网络连接超时 */
public static final int REQUEST_TIMEOUT = 3;
/** 超时时间限制 */
private static final int TIME_OUT = 30 * 1000;
private Activity activity;
private Map<String, String> params = new HashMap<String, String>();
private String path = "";
private ProgressDialog pd;
private Thread requestThread;
private AlertDialog dialog;
/**
* 构造一个netapi对象
*
* @param context
*
* @param path
* 这次请求需要调用的url
*/
public NetApi(Activity activity, String path) {
this.activity = activity;
this.path = path;
}
/**
* 添加参数,用url编码格式
*
* @param key
* @param value
*/
public void addParams(String key, Object value) {
if (!isEmpty(key) && !isEmpty(value)) {
params.put(key.trim(), value.toString().trim());// *.trim(),取消首尾空格
}
}
/**
* 补充路径,比如添加 /信息类别id/新闻id
*
* @param objects
*/
public void addPath(Object... objects) {
for (Object object : objects) {
path = path + "/" + getUrlEncode(object);
}
}
/**
* 检查该参数是否有内容,没有的话就不用添加了
*
* @param str
* @return true为没有内容,false为有内容
*/
public boolean isEmpty(Object str) {
if (str == null || str.toString().length() == 0)
return true;
else
return false;
}
/**
* 获取url编码的字符串
*
* @param value
* @return
*/
private String getUrlEncode(Object value) {
try {
return URLEncoder.encode(value.toString().trim(), "utf-8");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
return null;
}
/**
* get请求,拼接url路径,并对参数进行urlencode
*/
public String getPath() {
if (params.size() == 0) {
return path;
}
StringBuilder sb = new StringBuilder();
boolean first = path.indexOf("?") == -1; // 不包含?(first=true)说明是第一次添加参数,包含?说明url中带有参数
for (String key : params.keySet()) {
if (first) {
first = false;
sb.append("?");
} else {
sb.append("&");
}
sb.append(key + "=" + getUrlEncode(params.get(key)));
}
return path + sb.toString();
}
/**
* post请求,传入的参数
*
* @return
*/
private String postParams() {
if (params.size() == 0) {
return path;
}
boolean isFrist = true;
StringBuilder sb = new StringBuilder();
for (String key : params.keySet()) {
if (isFrist) {
sb.append(key + "=" + params.get(key));
isFrist = false;
} else {
sb.append("&" + key + "=" + params.get(key));
}
}
return sb.toString();
}
/**
* 显示进度条提示
*
* @param message
*/
private void showPd(String message) {
showLog("start connect");
if (message == null || message.length() == 0) {
return;
}
if (pd != null) {
pd.cancel();
pd = null;
}
pd = new ProgressDialog(activity);
pd.setMessage(message);
pd.setOnCancelListener(new OnCancelListener() {
@Override
public void onCancel(DialogInterface dialog) {
requestThread.interrupt();
}
});
pd.setCancelable(true);
pd.show();
}
/**
* 发起一个post请求,返回string对象
*
* @param stringListener
* @param isLoadCache
* true 为加载缓存，false为不加载缓存
*/
public void postRequest(final String text,
final RequestStringListener stringListener) {
if (!isNetworkConnect()) {
whetherOpenNet();
return;
}
showPd(text);
Runnable task = new Runnable() {
@Override
public void run() {
try {
final String result = postStringResult();
if (requestThread.isInterrupted()) {
showLog("is interrupted");
return;
}
if (result == null) {
netError();
return;
}
post(new Complete() {
@Override
public void run() {
super.run();
stringListener.onComplete(result);
sendEmptyMessage(REQUEST_SUCCESS);
}
});
} catch (SocketTimeoutException e) {
timeOut(text, stringListener);
e.printStackTrace();
} catch (Exception e) {
netError();
e.printStackTrace();
}
}
};
requestThread = new Thread(task);
requestThread.start();
}
/**
* 网络连接超时
*
* @param text
* @param stringListener
*/
protected void timeOut(final String text,
final RequestStringListener stringListener) {
sendEmptyMessage(REQUEST_TIMEOUT);
Looper.prepare();
post(new Complete() {
@Override
public void run() {
super.run();
new AlertDialog.Builder(activity)
.setTitle("网络连接超时")
.setNegativeButton("取消", null)
.setPositiveButton("重连",
new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog,
int which) {
showLog("重连");
postRequest(text, stringListener);
}
}).show();
}
});
}
/**
* 网络连接错误或返回数据为空
*
*/
protected void netError() {
sendEmptyMessage(REQUEST_ERROR);
Looper.prepare();
post(new Complete() {
@Override
public void run() {
super.run();
if (!isNetworkConnect()) {
whetherOpenNet();
} else {
Toast.makeText(getActivity(), "网络连接失败,请稍后重试",
Toast.LENGTH_LONG).show();
}
}
});
}
/**
* 发送post上传文件,获取字符串结果
*
* @param isLoadCache
* true为加载缓存，false为不加载缓存
*/
public String postStringResult() throws IOException, JSONException {
showLog("path is " + path);
showLog("post is " + postParams());
HttpURLConnection conn = getConn(path, "POST");
// 配置post请求的参数
DataOutputStream outputStream = new DataOutputStream(
conn.getOutputStream());
outputStream.writeBytes(postParams());
outputStream.flush();
outputStream.close();
if (conn.getResponseCode() == HttpURLConnection.HTTP_OK) {
String data = formatStreamToString(conn);
showLog("result is " + data);
return data;
}
return null;
}
/**
* 根据url获取网络链接
*
* @param path
* @param requestType
* 请求方式,post或者get
* @return
* @throws IOException
*/
private HttpURLConnection getConn(String path, String requestType)
throws IOException {
URL url = new URL(path);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setDoOutput(true);
conn.setDoInput(true);
conn.setRequestMethod(requestType);
conn.setConnectTimeout(TIME_OUT);
conn.setReadTimeout(TIME_OUT);
conn.connect();
return conn;
}
/**
* 将网络连接中的输入流转换成string字符串
*
* @param conn
* @return
* @throws IOException
*/
private String formatStreamToString(HttpURLConnection conn)
throws IOException {
StringBuffer out = new StringBuffer();
BufferedReader input = new BufferedReader(new InputStreamReader(
conn.getInputStream()));
String line = null;
while ((line = input.readLine()) != null) {
out.append(line);
}
input.close();
return out.toString();
}
class Complete implements Runnable {
@Override
public void run() {
if (pd != null) {
pd.cancel();
}
requestThread.interrupt();
}
}
/**
* 判断网络连接
*/
private boolean isNetworkConnect() {
ConnectivityManager cm = (ConnectivityManager) activity
.getSystemService(Context.CONNECTIVITY_SERVICE);
cm.getActiveNetworkInfo();
if (cm.getActiveNetworkInfo() != null) {
return cm.getActiveNetworkInfo().isAvailable();
}
return false;
}
/**
* 打开网络对话框
*/
private void whetherOpenNet() {
if (dialog != null) {
dialog.cancel();
dialog = null;
}
AlertDialog.Builder builder = new AlertDialog.Builder(activity);
builder.setTitle("网络木有连接");
builder.setMessage("是否打开网络连接");
builder.setPositiveButton("确定", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
activity.startActivityForResult(new Intent(
Settings.ACTION_WIRELESS_SETTINGS), OPEN_NETWORK);
}
});
builder.setNegativeButton("取消", null);
dialog = builder.create();
dialog.show();
}
/**
* 打印日志
*
* @param log
*/
private void showLog(String log) {
Log.d("example", log);
}
/**
* 获取当前NetApi绑定的activity
*
* @return
*/
public Activity getActivity() {
return this.activity;
}
/**
* 请求string的监听
*/
public interface RequestStringListener {
/** 返回字符串 */
public void onComplete(String result);
}
}