使用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.在后台可以通过下面的方式返回数据

response.getWriter().print(String s)