以前聽一個大神說過一句借用不知道哪位偉人的話：一個好的方法只有兩三行，每個方法只專注一件事。

本著這樣的精神，我們在拉取網路資料的時候希望能將拉取和解析分開，然而我們也希望有這樣一個方法，傳入UIL和表單資料後，能直接返回解析好的物件陣列。所以就有了這樣的一個在AsyncHttpClient框架基礎上定製的框架。由我的小夥伴lwz大神，和打下手的MoblieXu完成。

專案中用的伺服器地址，為自己的小專案中一處拉取JSon，請各位手下留情。

首先看一下，我們希望的結果一個方法傳入引數就能返回解析好的物件陣列：

public class MainActivity extends Activity {
	private TextView tv_showData;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		tv_showData =(TextView) findViewById(R.id.tv_showData);
		getWebData();
	}

	private void getWebData() {
		GetJournalRequest getJournalRequest = new GetJournalRequest(
				getApplicationContext());
		getJournalRequest.request(new ResponseParseHandler<List<Journal>>() {
					@Override
					public void onStart() {
						//mProgressBar.setVisibility(View.VISIBLE);
					}

					@Override
					public void onSuccess(List<Journal> result) {
//						
					}

					@Override
					public void onFailure(String error, String message) {
						AppContext.showToast(message + "--" + error);
					}
				});
		
	}
}
 

直接就能從onSuccess回撥中獲取資料，保證了方法的簡潔；

GetJournalRequest.java

public class GetJournalRequest extends
		AbsAsyncHttpRequest<JSONArray, List<Journal>> {

	public static final String KEY_PARAM_JOURNALS = "Journals";

	public GetJournalRequest(Context context) {
		super(context);
	}

	@Override
	public String getAPI() {
		return API.GETJOURNAL_URL;
	}

	@Override
	public HttpMethod getHttpMethod() {
		return HttpMethod.GET;
	}

	@Override
	protected List<Journal> parseEntity(String parseData) throws JSONException {
		List<Journal> data = new ArrayList<Journal>();
		JSONObject jsonObject = new JSONObject(parseData);
		JSONArray jsonArray = jsonObject.getJSONArray(KEY_PARAM_JOURNALS);
		GetJournalParser getJournalParser = new GetJournalParser();
		for (int i = 0; i < jsonArray.length(); i++) {
			data.add(getJournalParser.parse(jsonArray.getJSONObject(i)));
		}
		return CollectionsUtil.isNullOrEmpty(data) ? new ArrayList<Journal>()
				: data;
	}
}
 

繼承的時候設定了要返回的物件陣列，

public abstract class AbsAsyncHttpRequest<E, T> implements IAsyncHttpRequest<T>  因為都是用泛型所以可以完成上面的設定。

public abstract class AbsAsyncHttpRequest<E, T> implements IAsyncHttpRequest<T> {

	public static final String JSON = "json";
	private Context mContext;
	private HttpRequestParams mParams;
	private ResponseParseHandler<T> mHandler;
	private String mPrefName;
	private String mCacheKey;

	public AbsAsyncHttpRequest(Context context) {
		mContext = context;
	}

	public void setParams(HttpRequestParams params) {
		mParams = params;
	}

	public abstract String getAPI();

	public abstract HttpMethod getHttpMethod();

	public void request(final ResponseParseHandler<T> handler) {
		request(null, null, handler);
	}

	@Override
	public void request(String prefName, String cacheKey,
			final ResponseParseHandler<T> handler) {
		this.mPrefName = prefName;
		this.mCacheKey = cacheKey;
		mHandler = handler;
		mResponse.updatePreNames(mContext,mPrefName, mCacheKey);
		if (getHttpMethod() == HttpMethod.GET) {
			doGet();
		} else {
			doPost();
		}
	}

	private void doGet() {
		if (isParamsEmpty(mParams)) {
			RequestClient.get(getAPI(), mResponse);
		} else {
			RequestClient.get(getUrlWithParams(getAPI(), mParams), mResponse);
		}
	}

	private void doPost() {
		if (isParamsEmpty(mParams)) {
			RequestClient.post(getAPI(), mResponse);
		} else {
			RequestClient.post(getAPI(), mParams.toString(), mResponse);
		}
	}

	private boolean isParamsEmpty(HttpRequestParams params) {
		return params == null || params.isEmpty();
	}

	private String getUrlWithParams(String url, HttpRequestParams params) {
		Set<String> keySet = params.keySet();
		StringBuffer sb = new StringBuffer();
		sb.append("?");
		int i=0;
		for (String key : keySet) {
			i++;
			if(i==keySet.size()){
				sb.append(key + "=" + params.get(key));
			}else{
				sb.append(key + "=" + params.get(key)+"&");
			}
		}
		AppContext.showLog("GET方式URL" + url + sb.toString());
		return url + sb.toString();
	}

	private AsyncHttpResponse mResponse = new AsyncHttpResponse(mContext,
			mPrefName, mCacheKey, new LoadDataHandler() {

				@Override
				public void onStart() {
//					AppContext.showLog("onRequestStart");
					mHandler.onStart();
				}

				@Override
				public void onLoadCaches(String data) {
//					AppContext.showLog("onLoadCaches");
					mHandler.onLoadCaches(parse(data));
				}

				@Override
				public void onSuccess(String data) {
//					AppContext.showLog("成功獲得Json資料" + data);
					mHandler.onSuccess(parse(data));
				}

				@Override
				public void onFinished() {
//					AppContext.showLog("onFinished");
					mHandler.onFinished();
				}

				@Override
				public void onFailure(String error, String message) {
					AppContext.showLog(error + "   " + message);
					mHandler.onFailure(error, message);
				}

			});

	private T parse(String responseData) {
		JSONObject jsonData;
		try {
			jsonData = new JSONObject(responseData);
			BaseResponseParser<String> brp = new BaseResponseParser<String>(
					jsonData);
			if (brp.isSucceed()) {
				return parseEntity(brp.getData());
			} else {
				mHandler.onFailure(brp.getErrorCode(), brp.getErrorMessage());
			}
		} catch (JSONException e) {
			mHandler.onFailure("-1", e.getMessage());
		}
		return null;
	}

	protected abstract T parseEntity(String parseData) throws JSONException;
}
 

mHandler.onSuccess(parse(data));

private T parse(String responseData) {
		JSONObject jsonData;
		try {
			jsonData = new JSONObject(responseData);
			BaseResponseParser<String> brp = new BaseResponseParser<String>(
					jsonData);
			if (brp.isSucceed()) {
				return parseEntity(brp.getData());
			} else {
				mHandler.onFailure(brp.getErrorCode(), brp.getErrorMessage());
			}
		} catch (JSONException e) {
			mHandler.onFailure("-1", e.getMessage());
		}
		return null;
	}

protected abstract T parseEntity(String parseData) throws JSONException;

這是一個抽象方法，具體的實現是在繼承它的子類裡面實現，所以這樣也就實現了將解析和拉取分開，要解析成什麼物件，由繼承它的類決定，這個parseEntity就像一個鉤子，最後又把解析好的物件陣列返回回來，交給介面mHandler.onSuccess(parse(data));最有趣的是這個介面的實現也就是我們最外面呼叫的

	@Override
public void onSuccess(List<Journal> result) {
//

						}

github：https://github.com/xujinyang/AsyncHttpClientByLX

通過這樣一個框架作為屌絲程式猿的我也能領會到程式設計的美和快樂，何況是大神們尼？