Android Asynchronous HTTPClient的实现和优化

大家知道Android对UI线程的反应时间要求很高，超过5秒钟直接ANR掉，根本不给你机会多等。

而Android应用与后端系统的交互是最基本的需求之一，如何实现高效的Asynchronous HTTPClient，确保UI线程在启动任务后交由后端异步处理与服务器端的通信，尤为关键。

Google过几个方案，要么太复杂要么不符合要求，基本都淘汰了，最后发现这一版本的实现不错，就拿来用了。

链接：Android Asynchronous HTTPClient tutorial

后来发现了几个严重的问题，罗列如下：

1. 启用单独的线程后，简直如脱缰的野马，难以驾驭。

现象是：在调试的时候经常发现某个线程死掉（比如在服务器down掉的时候，由于线程无法连接而挂掉）

后果是：只能关掉模拟器，甚至还要重启eclipse，否者两者通信出现问题，再也不能继续联机调试

2. 异常的处理非常弱，Activity层难以捕捉并加以处理。

这个问题跟实现的机制有一定的关系，此实现根本就没提供好的异常处理机制，以便捕捉、反馈、处理合理的可预见性的异常，诸如：

1）UnknownHostException – 谁能确保手机的网络连接一直正常，信号一直满格？

2）HttpResponseException – 后端500的错误，说不定就蹦出来了

3）SocketTimeoutException – 超时也是太正常不过了，如果人家在荒山野岭（no 3G）摆弄超大的通信请求

4）诸如此类吧

所以改造就再说难免了。下面我贴出相关代码（import就省了吧这里），并加以简单注释说明，方面大家的理解。

首先定义AsyncHttpClient.java。这里的重点是超时的设置。另外我加了个cancelRequest，用以在切换Activity后取消掉原有Activity发出的所有的异步请求，因为一般情况下，切换了Activity后是不能再更新那个UI了，否则会抛出异常，直接导致应用crash掉，不过话说回来，这个cancel我发现好像不是那么给力(any feedback?)。

Java代码

1. public class AsyncHttpClient {
2. private static DefaultHttpClient httpClient;
3. public static int CONNECTION_TIMEOUT = 2*60*1000;
4. public static int SOCKET_TIMEOUT = 2*60*1000;
5. private static ConcurrentHashMap<Activity,AsyncHttpSender> tasks = new ConcurrentHashMap<Activity,AsyncHttpSender>();
6. public static void sendRequest(
7. final Activity currentActitity,
8. final HttpRequest request,
9. AsyncResponseListener callback) {
10. sendRequest(currentActitity, request, callback, CONNECTION_TIMEOUT, SOCKET_TIMEOUT);
11. }
12. public static void sendRequest(
13. final Activity currentActitity,
14. final HttpRequest request,
15. AsyncResponseListener callback,
16. int timeoutConnection,
17. int timeoutSocket) {
18. InputHolder input = new InputHolder(request, callback);
19. AsyncHttpSender sender = new AsyncHttpSender();
20. sender.execute(input);
21. tasks.put(currentActitity, sender);
22. }
23. public static void cancelRequest(final Activity currentActitity){
24. if(tasks==null || tasks.size()==0) return;
25. for (Activity key : tasks.keySet()) {
26. if(currentActitity == key){
27. AsyncTask<?,?,?> task = tasks.get(key);
28. if(task.getStatus()!=null && task.getStatus()!=AsyncTask.Status.FINISHED){
29. Log.i(TAG, "AsyncTask of " + task + " cancelled.");
30. task.cancel(true);
31. }
32. tasks.remove(key);
33. }
34. }
35. }
36. public static synchronized HttpClient getClient() {
37. if (httpClient == null){
38. //use following code to solve Adapter is detached error
39. //refer: http://stackoverflow.com/questions/5317882/android-handling-back-button-during-asynctask
40. BasicHttpParams params = new BasicHttpParams();
41. SchemeRegistry schemeRegistry = new SchemeRegistry();
42. schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
43. final SSLSocketFactory sslSocketFactory = SSLSocketFactory.getSocketFactory();
44. schemeRegistry.register(new Scheme("https", sslSocketFactory, 443));
45. // Set the timeout in milliseconds until a connection is established.
46. HttpConnectionParams.setConnectionTimeout(params, CONNECTION_TIMEOUT);
47. // Set the default socket timeout (SO_TIMEOUT)
48. // in milliseconds which is the timeout for waiting for data.
49. HttpConnectionParams.setSoTimeout(params, SOCKET_TIMEOUT);
50. ClientConnectionManager cm = new ThreadSafeClientConnManager(params, schemeRegistry);
51. httpClient = new DefaultHttpClient(cm, params);
52. }
53. return httpClient;
54. }
55. }

public class AsyncHttpClient {	private static DefaultHttpClient httpClient;		public static int CONNECTION_TIMEOUT = 2*60*1000;	public static int SOCKET_TIMEOUT  = 2*60*1000;		private static ConcurrentHashMap<Activity,AsyncHttpSender> tasks = new ConcurrentHashMap<Activity,AsyncHttpSender>();			public static void sendRequest(			final Activity currentActitity,			final HttpRequest request,			AsyncResponseListener callback) {				sendRequest(currentActitity, request, callback, CONNECTION_TIMEOUT, SOCKET_TIMEOUT);	}		public static void sendRequest(			final Activity currentActitity,			final HttpRequest request,			AsyncResponseListener callback,			int timeoutConnection,			int timeoutSocket) {				InputHolder input = new InputHolder(request, callback);		AsyncHttpSender sender = new AsyncHttpSender();		sender.execute(input);		tasks.put(currentActitity, sender);	}		public static void cancelRequest(final Activity currentActitity){		if(tasks==null || tasks.size()==0) return;		for (Activity key : tasks.keySet()) {		    if(currentActitity == key){		    	AsyncTask<?,?,?> task = tasks.get(key);		    	if(task.getStatus()!=null && task.getStatus()!=AsyncTask.Status.FINISHED){			    	Log.i(TAG, "AsyncTask of " + task + " cancelled.");		    		task.cancel(true);		    	}		    	tasks.remove(key);		    }		}	} 	public static synchronized HttpClient getClient() {		if (httpClient == null){						//use following code to solve Adapter is detached error			//refer: http://stackoverflow.com/questions/5317882/android-handling-back-button-during-asynctask			BasicHttpParams params = new BasicHttpParams();						SchemeRegistry schemeRegistry = new SchemeRegistry();			schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));			final SSLSocketFactory sslSocketFactory = SSLSocketFactory.getSocketFactory();			schemeRegistry.register(new Scheme("https", sslSocketFactory, 443));						// Set the timeout in milliseconds until a connection is established.			HttpConnectionParams.setConnectionTimeout(params, CONNECTION_TIMEOUT);			// Set the default socket timeout (SO_TIMEOUT) 			// in milliseconds which is the timeout for waiting for data.			HttpConnectionParams.setSoTimeout(params, SOCKET_TIMEOUT);						ClientConnectionManager cm = new ThreadSafeClientConnManager(params, schemeRegistry);			httpClient = new DefaultHttpClient(cm, params);			}		return httpClient;	} }

然后是AsyncHttpSender。这里我用了InputHolder和OutputHolder来进行对象传递，简单包装了下：

Java代码

1. /**
2. * AsyncHttpSender is the AsyncTask implementation
3. *
4. * @author bright_zheng
5. *
6. */
7. public class AsyncHttpSender extends AsyncTask<InputHolder, Void, OutputHolder> {
8. @Override
9. protected OutputHolder doInBackground(InputHolder... params) {
10. HttpEntity entity = null;
11. InputHolder input = params[0];
12. try {
13. HttpResponse response = AsyncHttpClient.getClient().execute((HttpUriRequest) input.getRequest());
14. StatusLine status = response.getStatusLine();
15. if(status.getStatusCode() >= 300) {
16. return new OutputHolder(
17. new HttpResponseException(status.getStatusCode(), status.getReasonPhrase()),
18. input.getResponseListener());
19. }
20. entity = response.getEntity();
21. Log.i(TAG, "isChunked:" + entity.isChunked());
22. if(entity != null) {
23. try{
24. entity = new BufferedHttpEntity(entity);
25. }catch(Exception e){
26. Log.e(<span style="background-color: rgb(255, 255, 255);">TAG</span>, e.getMessage(), e);
27. //ignore?
28. }
29. }
30. } catch (ClientProtocolException e) {
31. Log.e(<span style="background-color: rgb(255, 255, 255);">TAG</span>, e.getMessage(), e);
32. return new OutputHolder(e, input.getResponseListener());
33. } catch (IOException e) {
34. Log.e(<span style="background-color: rgb(255, 255, 255);">TAG</span>, e.getMessage(), e);
35. return new OutputHolder(e, input.getResponseListener());
36. }
37. return new OutputHolder(entity, input.getResponseListener());
38. }
39. @Override
40. protected void onPreExecute(){
41. Log.i(<span style="background-color: rgb(255, 255, 255);">TAG</span>, "AsyncHttpSender.onPreExecute()");
42. super.onPreExecute();
43. }
44. @Override
45. protected void onPostExecute(OutputHolder result) {
46. Log.i(<span style="background-color: rgb(255, 255, 255);">TAG</span>, "AsyncHttpSender.onPostExecute()");
47. super.onPostExecute(result);
48. if(isCancelled()){
49. Log.i(<span style="background-color: rgb(255, 255, 255);">TAG</span>, "AsyncHttpSender.onPostExecute(): isCancelled() is true");
50. return; //Canceled, do nothing
51. }
52. AsyncResponseListener listener = result.getResponseListener();
53. HttpEntity response = result.getResponse();
54. Throwable exception = result.getException();
55. if(response!=null){
56. Log.i(<span style="background-color: rgb(255, 255, 255);">TAG</span>, "AsyncHttpSender.onResponseReceived(response)");
57. listener.onResponseReceived(response);
58. }else{
59. Log.i(<span style="background-color: rgb(255, 255, 255);">TAG</span>, "AsyncHttpSender.onResponseReceived(exception)");
60. listener.onResponseReceived(exception);
61. }
62. }
63. @Override
64. protected void onCancelled(){
65. Log.i(<span style="background-color: rgb(255, 255, 255);">TAG</span>, "AsyncHttpSender.onCancelled()");
66. super.onCancelled();
67. //this.isCancelled = true;
68. }
69. }

/** * AsyncHttpSender is the AsyncTask implementation *  * @author bright_zheng * */public class AsyncHttpSender extends AsyncTask<InputHolder, Void, OutputHolder> {	@Override	protected OutputHolder doInBackground(InputHolder... params) {		HttpEntity entity = null;		InputHolder input = params[0];		try {			HttpResponse response = AsyncHttpClient.getClient().execute((HttpUriRequest) input.getRequest());			StatusLine status = response.getStatusLine();				        if(status.getStatusCode() >= 300) {	        	return new OutputHolder(	        			new HttpResponseException(status.getStatusCode(), status.getReasonPhrase()),	        			input.getResponseListener());	        }	        			entity = response.getEntity();			Log.i(TAG, "isChunked:" + entity.isChunked());            if(entity != null) {            	try{            		entity = new BufferedHttpEntity(entity);            	}catch(Exception e){            		Log.e(TAG, e.getMessage(), e);            		//ignore?            	}            }					} catch (ClientProtocolException e) {			Log.e(TAG, e.getMessage(), e);			return new OutputHolder(e, input.getResponseListener());		} catch (IOException e) {			Log.e(TAG, e.getMessage(), e);			return new OutputHolder(e, input.getResponseListener());		}		return new OutputHolder(entity, input.getResponseListener());	}		@Override    protected void onPreExecute(){		Log.i(TAG, "AsyncHttpSender.onPreExecute()");		super.onPreExecute();	}		@Override	protected void onPostExecute(OutputHolder result) {		Log.i(TAG, "AsyncHttpSender.onPostExecute()");		super.onPostExecute(result);				if(isCancelled()){			Log.i(TAG, "AsyncHttpSender.onPostExecute(): isCancelled() is true");			return; //Canceled, do nothing		}				AsyncResponseListener listener = result.getResponseListener();		HttpEntity response = result.getResponse();		Throwable exception = result.getException();		if(response!=null){			Log.i(TAG, "AsyncHttpSender.onResponseReceived(response)");			listener.onResponseReceived(response);		}else{			Log.i(TAG, "AsyncHttpSender.onResponseReceived(exception)");			listener.onResponseReceived(exception);		}	}		@Override    protected void onCancelled(){		Log.i(TAG, "AsyncHttpSender.onCancelled()");		super.onCancelled();		//this.isCancelled = true;	}}

Java代码

1. /**
2. * Input holder
3. *
4. * @author bright_zheng
5. *
6. */
7. public class InputHolder{
8. private HttpRequest request;
9. private AsyncResponseListener responseListener;
10. public InputHolder(HttpRequest request, AsyncResponseListener responseListener){
11. this.request = request;
12. this.responseListener = responseListener;
13. }
14. public HttpRequest getRequest() {
15. return request;
16. }
17. public AsyncResponseListener getResponseListener() {
18. return responseListener;
19. }
20. }

/** * Input holder *  * @author bright_zheng * */public class InputHolder{	private HttpRequest request;	private AsyncResponseListener responseListener;		public InputHolder(HttpRequest request, AsyncResponseListener responseListener){		this.request = request;		this.responseListener = responseListener;	}			public HttpRequest getRequest() {		return request;	}	public AsyncResponseListener getResponseListener() {		return responseListener;	}}

Java代码

1. public class OutputHolder{
2. private HttpEntity response;
3. private Throwable exception;
4. private AsyncResponseListener responseListener;
5. public OutputHolder(HttpEntity response, AsyncResponseListener responseListener){
6. this.response = response;
7. this.responseListener = responseListener;
8. }
9. public OutputHolder(Throwable exception, AsyncResponseListener responseListener){
10. this.exception = exception;
11. this.responseListener = responseListener;
12. }
13. public HttpEntity getResponse() {
14. return response;
15. }
16. public Throwable getException() {
17. return exception;
18. }
19. public AsyncResponseListener getResponseListener() {
20. return responseListener;
21. }
22. }

public class OutputHolder{	private HttpEntity response;	private Throwable exception;	private AsyncResponseListener responseListener;		public OutputHolder(HttpEntity response, AsyncResponseListener responseListener){		this.response = response;		this.responseListener = responseListener;	}		public OutputHolder(Throwable exception, AsyncResponseListener responseListener){		this.exception = exception;		this.responseListener = responseListener;	}	public HttpEntity getResponse() {		return response;	}	public Throwable getException() {		return exception;	}		public AsyncResponseListener getResponseListener() {		return responseListener;	}	}

再来看看我们的Call back接口定义, AsyncResponseListener.java：

Java代码

1. /**
2. * The call back interface for
3. *
4. * @author bright_zheng
5. *
6. */
7. public interface AsyncResponseListener {
8. /** Handle successful response */
9. public void onResponseReceived(HttpEntity response);
10. /** Handle exception */
11. public void onResponseReceived(Throwable response);
12. }

/** * The call back interface for   *  * @author bright_zheng * */public interface AsyncResponseListener {	/** Handle successful response */	public void onResponseReceived(HttpEntity response);		/** Handle exception */	public void onResponseReceived(Throwable response);}

以及抽象Call back的实现，AbstractAsyncResponseListener.java：

Java代码

1. /**
2. * Abstract Async Response Listener implementation
3. *
4. * Subclass should implement at lease two methods.
5. * 1. onSuccess() to handle the corresponding successful response object
6. * 2. onFailure() to handle the exception if any
7. *
8. * @author bright_zheng
9. *
10. */
11. public abstract class AbstractAsyncResponseListener implements AsyncResponseListener{
12. public static final int RESPONSE_TYPE_STRING = 1;
13. public static final int RESPONSE_TYPE_JSON_ARRAY = 2;
14. public static final int RESPONSE_TYPE_JSON_OBJECT = 3;
15. public static final int RESPONSE_TYPE_STREAM = 4;
16. private int responseType;
17. public AbstractAsyncResponseListener(){
18. this.responseType = RESPONSE_TYPE_STRING; // default type
19. }
20. public AbstractAsyncResponseListener(int responseType){
21. this.responseType = responseType;
22. }
23. public void onResponseReceived(HttpEntity response){
24. try {
25. switch(this.responseType){
26. case RESPONSE_TYPE_JSON_ARRAY:{
27. String responseBody = EntityUtils.toString(response);
28. Log.i(<span style="background-color: rgb(255, 255, 255);">TAG</span>, "Return JSON String: " + responseBody);
29. JSONArray json = null;
30. if(responseBody!=null && responseBody.trim().length()>0){
31. json = (JSONArray) new JSONTokener(responseBody).nextValue();
32. }
33. onSuccess(json);
34. break;
35. }
36. case RESPONSE_TYPE_JSON_OBJECT:{
37. String responseBody = EntityUtils.toString(response);
38. Log.i(<span style="background-color: rgb(255, 255, 255);">TAG</span>, "Return JSON String: " + responseBody);
39. JSONObject json = null;
40. if(responseBody!=null && responseBody.trim().length()>0){
41. json = (JSONObject) new JSONTokener(responseBody).nextValue();
42. }
43. onSuccess(json);
44. break;
45. }
46. case RESPONSE_TYPE_STREAM:{
47. onSuccess(response.getContent());
48. break;
49. }
50. default:{
51. String responseBody = EntityUtils.toString(response);
52. onSuccess(responseBody);
53. }
54. }
55. } catch(IOException e) {
56. onFailure(e);
57. } catch (JSONException e) {
58. onFailure(e);
59. }
60. }
61. public void onResponseReceived(Throwable response){
62. onFailure(response);
63. }
64. protected void onSuccess(JSONArray response){}
65. protected void onSuccess(JSONObject response){}
66. protected void onSuccess(InputStream response){}
67. protected void onSuccess(String response) {}
68. protected void onFailure(Throwable e) {}
69. }

/** * Abstract Async Response Listener implementation *  * Subclass should implement at lease two methods. * 1. onSuccess() to handle the corresponding successful response object * 2. onFailure() to handle the exception if any *  * @author bright_zheng * */public abstract class AbstractAsyncResponseListener implements AsyncResponseListener{	public static final int RESPONSE_TYPE_STRING = 1;	public static final int RESPONSE_TYPE_JSON_ARRAY = 2;	public static final int RESPONSE_TYPE_JSON_OBJECT = 3;	public static final int RESPONSE_TYPE_STREAM = 4;	private int responseType;		public AbstractAsyncResponseListener(){		this.responseType = RESPONSE_TYPE_STRING; // default type	}		public AbstractAsyncResponseListener(int responseType){		this.responseType = responseType;	}		public void onResponseReceived(HttpEntity response){		try {			switch(this.responseType){		        case RESPONSE_TYPE_JSON_ARRAY:{		        	String responseBody = EntityUtils.toString(response);			        	Log.i(TAG, "Return JSON String: " + responseBody);		        	JSONArray json = null;		        	if(responseBody!=null && responseBody.trim().length()>0){		        		json = (JSONArray) new JSONTokener(responseBody).nextValue();		        	}		    		onSuccess(json);		        	break;		        }		        case RESPONSE_TYPE_JSON_OBJECT:{		        	String responseBody = EntityUtils.toString(response);			        	Log.i(TAG, "Return JSON String: " + responseBody);		        	JSONObject json = null;		        	if(responseBody!=null && responseBody.trim().length()>0){		        		json = (JSONObject) new JSONTokener(responseBody).nextValue();		        	}		    		onSuccess(json);			        	break;		        }		        case RESPONSE_TYPE_STREAM:{		        	onSuccess(response.getContent());		        	break;		        }		        default:{		        	String responseBody = EntityUtils.toString(response);		        	onSuccess(responseBody);		        }         			}	    } catch(IOException e) {	    	onFailure(e);	    } catch (JSONException e) {	    	onFailure(e);		}		}		public void onResponseReceived(Throwable response){		onFailure(response);	}		protected void onSuccess(JSONArray response){}		protected void onSuccess(JSONObject response){}		protected void onSuccess(InputStream response){}		protected void onSuccess(String response) {}	protected void onFailure(Throwable e) {}}

这样我们使用起来就非常清晰、简单了。

下面贴个简单的客户端用法代码片段：

1、这个是把服务器端响应当stream用的，用以诸如文件、图片下载之类的场景：

Java代码

1. AsyncHttpClient.sendRequest(this, request,
2. new AbstractAsyncResponseListener(AbstractAsyncResponseListener.RESPONSE_TYPE_STREAM){
3. @Override
4. protected void onSuccess(InputStream response){
5. Bitmap bmp = null;
6. try {
7. //bmp = decodeFile(response, _facial.getWidth());
8. bmp = BitmapFactory.decodeStream(response);
9. //resize to fit screen
10. bmp = resizeImage(bmp, _facial.getWidth(), true);
11. candidateCache.put(candidate_id, bmp);
12. ((ImageView) v).setImageBitmap(bmp);
13. dialog.dismiss();
14. } catch (Exception e) {
15. onFailure(e);
16. }
17. }
18. @Override
19. protected void onFailure(Throwable e) {
20. Log.i(TAG, "Error: " + e.getMessage(), e);
21. updateErrorMessage(e);
22. dialog.dismiss();
23. }
24. });

AsyncHttpClient.sendRequest(this, request,          		new AbstractAsyncResponseListener(AbstractAsyncResponseListener.RESPONSE_TYPE_STREAM){						@Override			protected void onSuccess(InputStream response){				Bitmap bmp = null;				try {					//bmp = decodeFile(response, _facial.getWidth());					bmp = BitmapFactory.decodeStream(response);										//resize to fit screen					bmp = resizeImage(bmp, _facial.getWidth(), true);	        							candidateCache.put(candidate_id, bmp);	        		((ImageView) v).setImageBitmap(bmp);	        			        		dialog.dismiss();				} catch (Exception e) {					onFailure(e);				}			}						@Override			protected void onFailure(Throwable e) {				Log.i(TAG, "Error: " + e.getMessage(), e);				updateErrorMessage(e);								dialog.dismiss();			}					});

2、这个是把服务器端响应当JSON用的，用以诸如获取基本文本信息之类的场景：

Java代码

1. // Async mode to get hit result
2. AsyncHttpClient.sendRequest(this, request,
3. new AbstractAsyncResponseListener(AbstractAsyncResponseListener.RESPONSE_TYPE_JSON_ARRAY){
4. @Override
5. protected void onSuccess(JSONArray response){
6. Log.i(TAG, "UploadAndMatch.onSuccess()...");
7. candidates = response;
8. if(candidates!=null && candidates.length()>0){
9. hit_count = candidates.length();
10. Log.i(TAG, "HIT: " + hit_count);
11. updateStatus(String.format(context.getString(R.string.msg_got_hit), hit_count));
12. //update UI
13. refreshCurrentUI(1);
14. }else{
15. Log.i(TAG, "No HIT!");
16. updateStatus(context.getString(R.string.msg_no_hit));
17. //update UI
18. refreshCurrentUI(0);
19. }
20. }
21. @Override
22. protected void onFailure(Throwable e) {
23. Log.e(TAG, "UploadAndMatch.onFailure(), error: " + e.getMessage(), e);
24. updateErrorMessage(e);
25. //update UI
26. refreshCurrentUI(-1);
27. }
28. });