Android中数据提交工具类（参考）

NetUtil.java

package com.gzucm.volunteer.util;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicHeader;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.params.CoreConnectionPNames;
import org.apache.http.util.EntityUtils;
import org.json.JSONException;
import org.json.JSONObject;

import android.content.Context;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;

import com.gzucm.volunteer.R;
import com.gzucm.volunteer.vo.RequestVo;


public class NetUtil {
	private static final String NOT_LOGIN = "notlogin";
	private static final String TAG = "NetUtil";
	private static Header[] headers = new BasicHeader[11];   //传递时候的头信息
	static {
		headers[0] = new BasicHeader("Appkey", "");
		headers[1] = new BasicHeader("Udid", "");
		headers[2] = new BasicHeader("Os", "");
		headers[3] = new BasicHeader("Osversion", "");
		headers[4] = new BasicHeader("Appversion", "");
		headers[5] = new BasicHeader("Sourceid", "");
		headers[6] = new BasicHeader("Ver", "");
		headers[7] = new BasicHeader("Userid", "");
		headers[8] = new BasicHeader("Usersession", "");
		headers[9] = new BasicHeader("Unique", "");
		headers[10] = new BasicHeader("Cookie", "");
		
	}

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

	public static Object post(RequestVo vo) {
		DefaultHttpClient client = new DefaultHttpClient();
		client.getParams().setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, 10000);// 请求超时
		client.getParams().setParameter(CoreConnectionPNames.SO_TIMEOUT, 10000);  //读取超时
		String url = vo.context.getString(R.string.app_host).concat(vo.context.getString(vo.requestUrl));
		Logger.d(TAG, "Post " + url);
		HttpPost post = new HttpPost(url);
		post.setHeaders(headers);
		Object obj = null;
		try {
			if (vo.requestDataMap != null) {
				HashMap<String, String> map = vo.requestDataMap;
				ArrayList<BasicNameValuePair> pairList = new ArrayList<BasicNameValuePair>();
				for (Map.Entry<String, String> entry : map.entrySet()) {
					BasicNameValuePair pair = new BasicNameValuePair(entry.getKey(), entry.getValue());
					pairList.add(pair);
				}
				HttpEntity entity = new UrlEncodedFormEntity(pairList, "UTF-8");
				post.setEntity(entity);
			}
			HttpResponse response = client.execute(post);
			if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
				setCookie(response);
				String result = EntityUtils.toString(response.getEntity(), "UTF-8");
				try {
					if (invilidateLogin(result)) {  //验证是否登录成功
						return Status.Login;           //登录失败,需要重新登录
					}
					obj = vo.jsonParser.parseJSON(result);
				} catch (JSONException e) {
					Logger.e(TAG, e.getLocalizedMessage(), e);
				}
				return obj;
			}
		} catch (ClientProtocolException e) {
			Logger.e(TAG, e.getLocalizedMessage(), e);
		} catch (IOException e) {
			Logger.e(TAG, e.getLocalizedMessage(), e);
		}
 		return null;
	}


	/**
	 * 添加Cookie
	 * @param response
	 */
	public static void setCookie(HttpResponse response) {
		if (response.getHeaders("Set-Cookie").length > 0) {
			Logger.d(TAG, response.getHeaders("Set-Cookie")[0].getValue()) ;
			headers[10] = new BasicHeader("Cookie", response.getHeaders("Set-Cookie")[0].getValue());
		}
	}
	/**
	 * 验证是否需要登录
	 * @param result
	 * @return
	 * @throws JSONException
	 */
	public static boolean invilidateLogin(String result) throws JSONException {
		JSONObject jsonObject = new JSONObject(result);
		String responseCode = jsonObject.getString("response");
		if (NOT_LOGIN.equals(responseCode)) {
			return true;
		}
		return false;
	}
	
	/**
	 * 
	 * @param vo
	 * @return
	 */
	public static Object get(RequestVo vo) {
		DefaultHttpClient client = new DefaultHttpClient();
		client.getParams().setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, 10000);// 请求超时
		client.getParams().setParameter(CoreConnectionPNames.SO_TIMEOUT, 10000);  //读取超时
		String url = vo.context.getString(R.string.app_host).concat(vo.context.getString(vo.requestUrl));
		Logger.d(TAG, "Get " + url);
		HttpGet get = new HttpGet(url);
		get.setHeaders(headers);
		Object obj = null;
		try {

			HttpResponse response = client.execute(get);
			if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
				setCookie(response);
				String result = EntityUtils.toString(response.getEntity(), "UTF-8");
				Logger.d(TAG, result);
				try {
					if (invilidateLogin(result)) {
						return Status.Login;
					}
					obj = vo.jsonParser.parseJSON(result);
				} catch (JSONException e) {
					Logger.e(TAG, e.getLocalizedMessage(), e);
				}
				return obj;
			}
		} catch (ClientProtocolException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 获得网络连接是否可用
	 * 
	 * @param context
	 * @return
	 */
	public static boolean hasNetwork(Context context) {
		ConnectivityManager con = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
		NetworkInfo workinfo = con.getActiveNetworkInfo();
		if (workinfo == null || !workinfo.isAvailable()) {
			Logger.d(TAG, "网络不可用");
			return false;
		}
		return true;
	}
	
	public static enum Status {
		Login
	}
}

其中请求参数类

RequestVo.java

package com.gzucm.volunteer.vo;

import java.util.HashMap;

import com.gzucm.volunteer.parser.BaseParser;

import android.content.Context;

public class RequestVo {
	public int requestUrl;     //访问服务器的地址，除去主机地址之后
	public Context context;     //上下文
	public HashMap<String, String> requestDataMap;     //传递的参数
	public BaseParser<?> jsonParser;         //回调方法

	public RequestVo() {
	}

	public RequestVo(int requestUrl, Context context, HashMap<String, String> requestDataMap, BaseParser<?> jsonParser) {
		super();
		this.requestUrl = requestUrl;
		this.context = context;
		this.requestDataMap = requestDataMap;
		this.jsonParser = jsonParser;
	}
}

BaseParser.java

package com.gzucm.volunteer.parser;

import org.json.JSONException;
import org.json.JSONObject;
/*回调方法*/
public abstract class BaseParser<T> {

	/**
	 * 将返回的json数据转化为相应的对象
	 * @param paramString
	 * @throws JSONException
	 */
	public abstract T parseJSON(String paramString) throws JSONException;

	/**
	 * 检测服务器响应信息，并返回response中的内容-----处理的servlet名
	 * @param paramString
	 * @throws JSONException
	 */
	public String checkResponse(String paramString) throws JSONException {
		if (paramString == null) {
			return null;
		} else {
			JSONObject jsonObject = new JSONObject(paramString);
			String result = jsonObject.getString("response");
			if (result != null && !result.equals("error")) {
				return result;
			} else {
				return null;
			}

		}
	}
}

发请求的方法：

  RequestVo vo = new RequestVo();
  vo.requestUrl = R.string.login; //登录的servlet名称
  vo.jsonParser = new LoginParser();
  vo.context = this;
  HashMap map = new HashMap();
  map.put("username", userName);
  vo.requestDataMap = map;
  super.getDataFromServer(vo, new DataCallback<User>(){

	@Override
	public void processData(User paramObject,boolean paramBoolean) {
        }
});

其中要继承基类Activity

主要代码：

	/**
	 * 显示进度框
	 */
	protected void showProgressDialog() {
		if ((!isFinishing()) && (this.progressDialog == null)) {
			this.progressDialog = new ProgressDialog(this);
		}
		this.progressDialog.setTitle(getString(R.string.loadTitle));
		this.progressDialog.setMessage(getString(R.string.LoadContent));
		this.progressDialog.show();
	}

	/**
	 * 隐藏进度框
	 */
	protected void closeProgressDialog() {
		if (this.progressDialog != null)
			this.progressDialog.dismiss();
	}

	/* 回调方法处理请求 */
	@SuppressWarnings("unchecked")
	class BaseHandler extends Handler {
		private Context context;
		private DataCallback callBack;
		private RequestVo reqVo;

		public BaseHandler(Context context, DataCallback callBack,
				RequestVo reqVo) {
			this.context = context;
			this.callBack = callBack;
			this.reqVo = reqVo;
		}

		public void handleMessage(Message msg) {
			closeProgressDialog();
			if (msg.what == Constant.SUCCESS) {
				if (msg.obj == null) {
					Toast.makeText(context, getString(R.string.net_server_no_respone), Toast.LENGTH_SHORT).show();// 服务器未响应对话框
				} else {
					callBack.processData(msg.obj, true);
				}
			} else if (msg.what == Constant.NET_FAILED) {
				Toast.makeText(context, getString(R.string.net_error), Toast.LENGTH_SHORT).show();  //网络未连接
			}

			Logger.d(TAG, "recordSize:" + record.size());
		}
	}

	/* 处理登陆的子线程 */
	class BaseTask implements Runnable {
		private Context context;
		private RequestVo reqVo;
		private Handler handler;

		public BaseTask(Context context, RequestVo reqVo, Handler handler) {
			this.context = context;
			this.reqVo = reqVo;
			this.handler = handler;
		}

		@Override
		public void run() {
			Object obj = null;
			Message msg = Message.obtain();
			try {
				if (NetUtil.hasNetwork(context)) {
					obj = NetUtil.post(reqVo);
					if (obj instanceof Status) {
						Intent intent = new Intent(BaseWapperActivity.this,
								LoginActivity.class);
						intent.putExtra("notlogin", "notlogin");
						startActivityForResult(intent, NOT_LOGIN);
					} else {
						msg.what = Constant.SUCCESS;
						msg.obj = obj;
						handler.sendMessage(msg);
						record.remove(this);
					}
				} else {
					msg.what = Constant.NET_FAILED;
					msg.obj = obj;
					handler.sendMessage(msg);
					record.remove(this);
				}
			} catch (Exception e) {
				record.remove(this);
				throw new RuntimeException(e);
			}
		}

	}

	/**
	 * 回调函数，处理服务器返回的数据
	 * 
	 * @param paramObject
	 *            服务器返回的数据封装后的对象
	 * @param paramBoolean
	 *            服务器是否返回数据
	 */
	public abstract interface DataCallback<T> {

		public abstract void processData(T paramObject, boolean paramBoolean);
	}

	/**
	 * 向服务器发送请求
	 * 
	 * @param reqVo
	 * @param callBack
	 */
	protected void getDataFromServer(RequestVo reqVo, DataCallback callBack) {
		showProgressDialog();
		BaseHandler handler = new BaseHandler(this, callBack, reqVo);
		BaseTask taskThread = new BaseTask(this, reqVo, handler);
		this.threadPoolManager.addTask(taskThread);
	}

该源码框架取自红孩子应用程序