使用Android的AsyncTask

一、以下内容摘自网络：

AsyncTask定义了三种泛型类型 Params，Progress和Result。

Params 启动任务执行的输入参数，比如HTTP请求的URL。
Progress 后台任务执行的百分比。
Result 后台执行任务最终返回的结果，比如String。
使用过AsyncTask 的同学都知道一个异步加载数据最少要重写以下这两个方法：

doInBackground(Params…) 后台执行，比较耗时的操作都可以放在这里。注意这里不能直接操作UI。此方法在后台线程执行，完成任务的主要工作，通常需要较长的时间。在执行过程中可以调用publicProgress(Progress…)来更新任务的进度。
onPostExecute(Result)  相当于Handler 处理UI的方式，在这里面可以使用在doInBackground 得到的结果处理操作UI。 此方法在主线程执行，任务执行的结果作为此方法的参数返回
有必要的话你还得重写以下这三个方法，但不是必须的：

onProgressUpdate(Progress…)   可以使用进度条增加用户体验度。 此方法在主线程执行，用于显示任务执行的进度。
onPreExecute()        这里是最终用户调用Excute时的接口，当任务执行之前开始调用此方法，可以在这里显示进度对话框。
onCancelled()             用户调用取消时，要做的操作
使用AsyncTask类，以下是几条必须遵守的准则：

Task的实例必须在UI thread中创建；
execute方法必须在UI thread中调用；
不要手动的调用onPreExecute(), onPostExecute(Result)，doInBackground(Params...), onProgressUpdate(Progress...)这几个方法；
该task只能被执行一次，否则多次调用时将会出现异常；

二、下面是自己写的异步处理代码：

1.定义一个结果集类HttpResult，用来存储获取到的数据结果

import org.apache.http.Header;

public class HttpResult {
private Header[] headers;
private String result;

public HttpResult(Header[] headers, String result) {
super();
this.headers = headers;
this.result = result;
}

public Header[] getHeaders() {
return headers;
}

public void setHeaders(Header[] headers) {
this.headers = headers;
}

public String getResult() {
return result;
}

public void setResult(String result) {
this.result = result;
}
}

2.定义AsyncTask子类实现异步处理，这里实现doInBackground, onPostExecute, onPreExecute三个方法，其他有需要可以自行实现

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.lang.reflect.Method;
import java.util.List;

import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;

import android.content.Context;
import android.os.AsyncTask;

public class HttpAsyncTask extends AsyncTask<Void, Void, HttpResult> {
private String url;	//查询链接
private List<NameValuePair> parameters;	//链接参数
private String sessionId;	//用于记录登录后的sessionId
private Context context;
private String preMethod;	//获取数据前的方法
private String callBackMethod;	//回调方法
private Object[] preMethodParam;	//preMethod对应参数
private Object[] callBackParam;	//callBackMethod对应参数

public HttpAsyncTask(Context context, String url, List<NameValuePair> parameters, String sessionId){
super();
this.context = context;
this.url = url;
this.parameters = parameters;
this.sessionId = sessionId;
}

//后台线程执行，获取数据。在执行过程中可以调用publicProgress(Progress…)来更新任务的进度
@Override
protected HttpResult doInBackground(Void... params) {
BufferedReader reader = null;
try {
HttpParams httpParams = new BasicHttpParams();
HttpConnectionParams.setConnectionTimeout(httpParams, 5000);	//设置超时时间
HttpClient client = new DefaultHttpClient(httpParams);
HttpPost httpPost = new HttpPost(url);
if (sessionId != null && !"".equals(sessionId)) {
httpPost.setHeader("Cookie", sessionId);
}
httpPost.setHeader("x-requested-with", "XMLHttpRequest");//模拟异步登录
if (parameters != null) {
UrlEncodedFormEntity entity = new UrlEncodedFormEntity(parameters, "UTF-8");
httpPost.setEntity(entity);
}
HttpResponse response = null;
response = client.execute(httpPost);
reader = new BufferedReader(new InputStreamReader(response.getEntity().getContent(), "UTF-8"));
StringBuffer sb = new StringBuffer();
if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
String content = reader.readLine();
while (content != null) {
sb.append(content);
content = reader.readLine();
}
} else {
sb.append("error");
}
return new HttpResult(response.getHeaders("set-cookie"), sb.toString());
} catch (Exception e) {
e.printStackTrace();
} finally {
if (reader != null) {
try {
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return null;
}

//在主线程执行，参数为doInBackground得到的结果，在这里执行回调函数
@Override
protected void onPostExecute(HttpResult result) {
super.onPostExecute(result);
if (getCallBackMethod() != null && !"".equals(getCallBackMethod())) {
try {
Class c = context.getClass();
Class[] classes;
int paramLength = 1;
if (getCallBackParam() != null) {
paramLength += getCallBackParam().length;
}
classes = new Class[paramLength];
classes[0] = HttpResult.class;
for (int i = 1; i < paramLength; i++) {
classes[i] = getCallBackParam()[i - 1].getClass();
}
Method method = c.getMethod(getCallBackMethod(), classes);

Object[] objects = new Object[paramLength];
objects[0] = result;
for (int i = 1; i < paramLength; i++) {
objects[i] = getCallBackParam()[i - 1];
}
method.invoke(context, objects);
} catch (Exception e) {
//如果任务执行之前显示了进度条，在执行出错时要在这里关闭进度条
e.printStackTrace();
}
}
}

//任务开始之前执行的方法，可用来显示进度条等
@Override
protected void onPreExecute() {
if (getPreMethod() != null && !"".equals(getPreMethod())) {
try {
Class c = context.getClass();
if (getPreMethodParam() == null) {
c.getMethod(getPreMethod()).invoke(context);
} else {
Class[] classes = new Class[getPreMethodParam().length];
for (int i = 0; i < getPreMethodParam().length; i++) {
classes[i] = getPreMethodParam()[i].getClass();
}
c.getMethod(getPreMethod(), classes).invoke(context, getPreMethodParam());
}
} catch (Exception e) {
e.printStackTrace();
}
}
super.onPreExecute();
}

public String getPreMethod() {
return preMethod;
}
public void setPreMethod(String preMethod) {
this.preMethod = preMethod;
}
public String getCallBackMethod() {
return callBackMethod;
}
public void setCallBackMethod(String callBackMethod) {
this.callBackMethod = callBackMethod;
}
public Object[] getPreMethodParam() {
return preMethodParam;
}
public void setPreMethodParam(Object[] preMethodParam) {
this.preMethodParam = preMethodParam;
}
public Object[] getCallBackParam() {
return callBackParam;
}
public void setCallBackParam(Object[] callBackParam) {
this.callBackParam = callBackParam;
}
}

3.使用AsyncTask获取站点的数据并进行回调函数的处理

HttpAsyncTask asyncTask = new HttpAsyncTask(this, "http://127.0.0.1:8080/...", new ArrayList<NameValuePair>(), "");
asyncTask.setCallBackMethod("doBack");
asyncTask.execute();

回调函数定义

public void doBack(HttpResult result){
System.out.println(result.getResult());
}

4.在后台可以通过下
4000
面的方式返回数据
response.getWriter().print(String s)