Android数据加载及Json解析——框架版

方法调用

new ApiUser(this).initData(new ApiRequest() {

			@Override
			public void onResult(BeanRequest bean) {
			//如果接口调用不成功，给予提示
				if (!bean.isSuccess()) {
					UtilToast.show(Activitymain.this, bean.getErrInfo(), UtilToast.STYLE_ERROR);
				}
				//Json数据解析：BeanInitData 数据实体类
				BeanInitData data = (BeanInitData) ApiPublic.readJson((JSONObject) bean.getData(), BeanInitData.class);
				
			}
		});

接下来是方法过程：
1、创建实体类：

public class BeanInitData {
	private int jobApplicantCount;//":33,"
	private int employJobCount;//":21,"
	private int enterpriseCount;//":14,"
	private ArrayList<BeanAdv> ads;
	public int getJobApplicantCount() {
		return jobApplicantCount;
	}
	public void setJobApplicantCount(int jobApplicantCount) {
		this.jobApplicantCount = jobApplicantCount;
	}
	public int getEmployJobCount() {
		return employJobCount;
	}
	public void setEmployJobCount(int employJobCount) {
		this.employJobCount = employJobCount;
	}
	public int getEnterpriseCount() {
		return enterpriseCount;
	}
	public void setEnterpriseCount(int enterpriseCount) {
		this.enterpriseCount = enterpriseCount;
	}
	public ArrayList<BeanAdv> getAds() {
		return ads;
	}
	public void setAds(ArrayList<BeanAdv> ads) {
		this.ads = ads;
	}
	
}

2、所有接口调用统一写在一起，

public class ApiUser {

	private Context ctx;

	public ApiUser(Context ctx) {
		this.ctx = ctx;
	}
	
	public void initData(ApiRequest request) {
	// ApiPublic.SERERIP为接口url
		String url = ApiPublic.SERERIP + "initData.json";
		HttpParam param = new HttpParam();
		ApiPublic.startHttpPost(ctx, url, param, request);
	}
	//登陆
	//参数String account，String password,String loginFrom
	public void login(String account,String password,String loginFrom,ApiRequest request) {
		String url = ApiPublic.SERERIP + "login.html";
		HttpParam param = new HttpParam();
		param.addParams("account", account);
		param.addParams("password", password);
		param.addParams("loginFrom", loginFrom);
		ApiPublic.startHttpPost(ctx, url, param, request);
	}
}

3、ApiPublic包含分页，不分页Json解析

public class ApiPublic {

public final static String SERERIP = "http://write.blog.csdn.net/mdeditor/api/";

/**
 * 开始调用接口：POST方式
 * @param url
 * @param param
 * @param request
 */
public static void startHttpPost(Context ctx, String url, HttpParam param, ApiRequest request) {
	HttpRequest http = new HttpRequest(url, param, 0, request);
	http.execute();
}

public static void startHttpPost(String url, HttpParam param, ApiRequest request) {
	HttpRequest http = new HttpRequest(url, param, 0, request);
	http.execute();
}

/**
 * 开始调用接口：POST方式，传输文件
 * @param url
 * @param param
 * @param request
 */
public static void startHttpPostFile(Context ctx, String url, HttpParam param, ApiRequest request) {
	HttpRequest http = new HttpRequest(url, param, 1, request);
	http.execute();
}

public static void startHttpPostFile(String url, HttpParam param, ApiRequest request) {
	HttpRequest http = new HttpRequest(url, param, 1, request);
	http.execute();
}

/**
 * 取消接口调用
 */
public static void httpTaskCancel() {
	HttpRequest http = new HttpRequest();
	http.onCancelled();
}

/**
 * 通用的JSON解析
 * 
 * @param result 传入JSON字符串
 * @return String 成功返回为""，失败返回错误描述
 */
public static BeanRequest readJsonUtil(String result) {
	if (TextUtils.isEmpty(result)) {
		return new BeanRequest().setError("无响应数据");
	}

	try {
		JSONObject jsonObject = new JSONObject(result);
		if (jsonObject.isNull("status")) {
			return new BeanRequest().setError("受理失败");
		}

		// 0成功、1错误、2异常
		int Status = jsonObject.getInt("status");
		if (Status != 0) {
			String description = jsonObject.getString("desc");
			return new BeanRequest().setError(description);
		}

		BeanRequest bean = new BeanRequest();
		bean.setSuccess(true);
		bean.setResult(result);
		bean.setData(jsonObject.isNull("data") ? null : jsonObject.get("data"));
		return bean;

	} catch (JSONException e) {
		e.printStackTrace();
		return new BeanRequest().setError("数据异常");
	}
}

/**
 * 解析JSON对象，不含分页
 * 
 * @param result json数据
 * @param entityClass 实体类
 * @return
 */
public static <T> Object readJson(final JSONObject result, Class<T> entityClass) {
	if (null == result)
		return null;
	
	return new Gson().fromJson(result.toString(), entityClass);
}

/**
 * 解析JSON数组，含分页
 * 数据示例：{"total":xx,"rows":[]}
 * @param result json数据
 * @param entityClass 实体类
 * @return
 */
public static <T> List readJsonListPage(final JSONObject result, BeanPage page, Class<T> entityClass) {
	if (null == result)
		return null;
	
	try {
		int total = result.getInt("total");
		page.setTotal(total);

		JSONArray array = result.getJSONArray("rows");
		List<T> list = new ArrayList<T>();
		Gson gson = new Gson();

		int size = array.length();
		for (int i = 0; i < size; i++) {
			list.add(gson.fromJson(array.getString(i), entityClass));
		}

		return list;
	} catch (JSONException e) {
		return null;
	}
}

/**
 * 解析JSON数组，不含分页
 * 
 * @param result json数据
 * @param entityClass 实体类
 * @return
 */
public static <T> List readJsonList(final JSONArray result, Class<T> entityClass) {
	if (null == result)
		return null;
	
	List<T> list = new ArrayList<T>();
	Gson gson = new Gson();
	try {
		int size = result.length();
		for (int i = 0; i < size; i++) {
			list.add(gson.fromJson(result.getString(i), entityClass));
		}
	} catch (JSONException e) {
	}
	return list;
}

/**
 * 组成一个简单的json
 * @param id
 * @param name
 * @return
 */
public static JSONObject writeJsonSimple(int id, String name) {
	JSONObject json = new JSONObject();
	try {
		json.put("id", id);
		json.put("name", name);
	} catch (JSONException e) {
		e.printStackTrace();
	}

	return json;
}
public static JSONObject writeJson(int extendId, String tagValue,String tagText) {
	JSONObject json = new JSONObject();
	try {
		json.put("extendId", extendId);
		json.put("tagValue", tagValue);
		json.put("tagText", tagText);
	} catch (JSONException e) {
		e.printStackTrace();
	}

	return json;	

}

4、数据加载AsyncTask

public class HttpRequest extends AsyncTask<Void, Integer, Void> {

	private HttpParam params;
	private String url = null;
	private ApiRequest mCallBack = null;

	private String result = null;
	private String errInfo = null;

	/**
	 * //表单方式： 
	 * 0:application/x-www-form-urlencoded 
	 * 1:multipart/form-data
	 * 2:multipart/form-data，附件的ContentType传“image/jpeg”，含文件名
	 */
	private int _formFlag = 0;

	public HttpRequest() {

	}

	/**
	 * 构造方法
	 * @param url 调用的URL
	 * @param param 参数
	 * @param formFlag 表单方式：0:application/x-www-form-urlencoded、1:multipart/form-data
	 * @param request 接口回调
	 */
	public HttpRequest(String url, HttpParam param, int formFlag, ApiRequest request) {
		this.url = url;
		this.mCallBack = request;
		this.params = param;
		this._formFlag = formFlag;
		this.result = "";
		this.errInfo = "";
	}

	/**
	 * 执行POST调用
	 */
	private void runReqPost() {
		try {
			HttpParams httpParams = new BasicHttpParams();
			HttpConnectionParams.setConnectionTimeout(httpParams, 8000);
			HttpClient httpClient = new DefaultHttpClient(httpParams);

			HttpPost httpPost = new HttpPost(url);

			if (_formFlag == 0)
				httpPost.setEntity(params.getParamsPost());
			else if (_formFlag == 1) {
				httpPost.setEntity(params.getParamsPostFile());
				
				// 上传附件时，参数放在header里面！！！
				Map<String, Object> headers = params.getParams();
				if (null != headers && !headers.isEmpty()) {
					for (Map.Entry<String, Object> entry : headers.entrySet()) {
						String key = entry.getKey();
						Object values = entry.getValue();
						
						if (values instanceof String) {
							httpPost.addHeader(key, (String) values);
						}
					}	
				}
			}
			
			HttpResponse httpResponse = httpClient.execute(httpPost);
			int code = httpResponse.getStatusLine().getStatusCode();
			Log.i("getStatusCode()", "------->" + code);

			if (code == HttpStatus.SC_OK) {
				result = EntityUtils.toString(httpResponse.getEntity(), HTTP.UTF_8);
			} else {
				errInfo = "网络出错了";
			}
		} catch (ClientProtocolException e) {
			e.printStackTrace();
			errInfo = "客户端协议异常";
		} catch (IOException e) {
			e.printStackTrace();
			errInfo = "无法连接服务端";
		}
	}

	/**
	 * AsyncTask方法重载 预执行 
	 */
	@Override
	protected void onPreExecute() {
		super.onPreExecute();
	}

	/**
	 * AsyncTask方法重载 后台异步执行
	 * @return
	 */
	@Override
	protected Void doInBackground(Void... params) {
		try {
			this.runReqPost();
		} catch (Exception e) {
			e.printStackTrace();
			errInfo = "接口异常";
		}

		return null;
	}

	/**
	 * AsyncTask方法重载 在任务执行成功时回调
	 */
	@Override
	protected void onPostExecute(Void voids) {
		if (null == mCallBack || (null != errInfo && !errInfo.equals(""))) {
			Log.e("info", "失败--->errInfo:" + errInfo);
			mCallBack.onResult(new BeanRequest().setError(errInfo));
			return;
		}

		BeanRequest bean = ApiPublic.readJsonUtil(result);
		if (!bean.isSuccess())
			Log.w("info", "失败--->" + result);
		else
			Log.v("info", "成功--->" + result);

		mCallBack.onResult(bean);

	}

	/**
	 * AsyncTask方法重载 在任务成功取消时回调
	 */
	@Override
	protected void onCancelled() {
		if (mCallBack != null) {
			Log.w("info", "失败--->任务已取消");
			mCallBack.onResult(new BeanRequest().setError("已取消"));
		}
	}
}

5、接口调用返回参数的实体类

public class BeanRequest {

	private boolean success = true;// 接口调用是否成功
	private String errInfo;// 错误原因
	private Object Data;// 获取成功，业务数据
	private String result;// 接口返回的数据

	public BeanRequest setError(String errInfo) {
		this.success = false;
		this.errInfo = errInfo;
		return this;
	}

	public BeanRequest setSucc(String result) {
		this.success = true;
		this.result = result;
		return this;
	}

	public boolean isSuccess() {
		return success;
	}

	public void setSuccess(boolean success) {
		this.success = success;
	}

	public String getErrInfo() {
		return errInfo;
	}

	public void setErrInfo(String errInfo) {
		this.errInfo = errInfo;
	}

	public Object getData() {
		return Data;
	}

	public void setData(Object data) {
		Data = data;
	}

	public String getResult() {
		return result;
	}

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

}

6、网络请求参数储存类

/**
 * 网络请求参数存储类，以Map来存储
 */
public class HttpParam {
	private Map<String, Object> params = new HashMap<String, Object>();

	public Map<String, Object> getParams() {
		return params;
	}

	public void setParams(Map<String, Object> params) {
		this.params = params;
	}

	/**
	 * 普通的参数
	 * @param key
	 * @param values
	 */
	public void addParams(String key, Object values) {
		this.params.put(key, values);
	}

	/**
	 * 带有附件的参数，只传一个附件
	 * @param key
	 * @param values
	 */
	public void addParams(String key, File values) {
		this.params.put(key, values);
	}

	/**
	 * 带有附件的参数，传多个附件
	 * @param key
	 * @param values
	 */
	public void addParams(String key, Set<File> values) {
		this.params.put(key, values);
	}

	/**
	 * Post方法调用时，取出参数
	 * @return
	 * @throws UnsupportedEncodingException
	 */
	public HttpEntity getParamsPostFile() throws UnsupportedEncodingException {

		MultipartEntityBuilder multipartEntityBuilder = MultipartEntityBuilder.create();

		if (null == params || params.isEmpty()) {
			return multipartEntityBuilder.build();
		}

		for (Map.Entry<String, Object> entry : params.entrySet()) {
			String key = entry.getKey();
			Object values = entry.getValue();
			if (values instanceof File) {
				multipartEntityBuilder.addBinaryBody(key, (File) values);
			} else if (values instanceof Set) {
				for (File file : (Set<File>) values) {
					multipartEntityBuilder.addBinaryBody(key, (File) file);
				}
			}
		}

		return multipartEntityBuilder.build();
	}

	/**
	 * 使用application/x-www-form-urlencoded表单的方式传递参数
	 * @return
	 */
	public HttpEntity getParamsPost() {

		List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>();

		JSONObject jsonObj = new JSONObject();
		try {
			for (Map.Entry<String, Object> entry : params.entrySet()) {
				String key = entry.getKey();
				Object values = entry.getValue();
				if (values instanceof JSONArray) {
					jsonObj.put(key, (JSONArray) values);
				} else {
					jsonObj.put(key, values);
				}
			}

		} catch (JSONException e) {
			e.printStackTrace();
		}

		nameValuePairs.add(new BasicNameValuePair("param", jsonObj.toString()));
		Log.i("wocaonima", "参数的值为：" + jsonObj);

		HttpEntity entity = null;
		try {
			entity = new UrlEncodedFormEntity(nameValuePairs, HTTP.UTF_8);
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}

		return entity;
	}

}