网络请求处理与数据处理返回对象

一个网络请求工具类：

package com.android.whether.tools;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
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.BasicHttpParams;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;
import org.apache.http.util.EntityUtils;

import com.android.whether.R;
import com.android.whether.entity.RequestVo;

import android.content.Context;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.util.Log;
import android.widget.Toast;

	/**
	 * 网络工具类：
	 * 1.判断网络是否可用；
	 * 2.get请求；
	 * 3.post请求；
	 *
	 */
	public class NetUtil {
		private static BasicHeader[] headers = new BasicHeader[10];
		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", "");
		}
	
		   
		public static boolean hasNetwork(Context context){
			ConnectivityManager con = (ConnectivityManager)context.getSystemService(Context.CONNECTIVITY_SERVICE);
			NetworkInfo workinfo = con.getActiveNetworkInfo();
			if(workinfo == null || !workinfo.isAvailable())
			{
				Toast.makeText(context, R.string.net_error, Toast.LENGTH_SHORT).show();
				return false;
			}
			return true;
		}

		/**
		    * get请求
		    * @param RequestVo 网络请求参数对象
		    * @return object 数据返回object
		    */
     public static Object get(RequestVo vo){
			DefaultHttpClient client = new DefaultHttpClient();
			String paramString = null ;
			if(vo.requestDataMap!=null){
				StringBuffer params = new StringBuffer() ; 
				params.append("?") ;
				HashMap<String,String> map = vo.requestDataMap;
				for(Map.Entry<String,String> entry:map.entrySet()){
					params.append(entry.getKey()) ;
					params.append("=") ;
					params.append(entry.getValue()) ;
					params.append("&") ;
				}
				paramString = params.substring(0, params.lastIndexOf("&")) ; 
			}
			String getUrl = paramString == null ? vo.context.getString(R.string.app_host).concat(vo.requestUrl):
				vo.context.getString(R.string.app_host).concat(vo.requestUrl).concat(paramString) ;
			HttpGet get = new HttpGet(getUrl);
			get.setHeaders(headers);
			Object obj = null;
			try {
				HttpResponse response = client.execute(get);
				if(response.getStatusLine().getStatusCode()==HttpStatus.SC_OK){
					String result = EntityUtils.toString(response.getEntity(),"UTF-8");
					Log.e(NetUtil.class.getSimpleName(), result);
					obj = getObjectByResult(result) ;
					return obj;
				}
			} catch (ClientProtocolException e) {
				e.printStackTrace();
			} catch (IOException e) {
				e.printStackTrace();
			}
			return null;
		}
		/**
		    * post请求：通过RequestVo对象，可以获取到请求相关信息，并设置成HTTP协议的请求属性，并请求数据
		    * @param RequestVo 网络请求参数对象
		    * @return object 返回  数据返回的object
		    */
		public static Object post(RequestVo vo){
			DefaultHttpClient client = new DefaultHttpClient();
			Log.e("URL:", vo.context.getString(R.string.app_host).concat(vo.requestUrl));
			HttpParams params = new BasicHttpParams();// 
			
			//设置Conextion超时时间和Socket超时时间；
			HttpConnectionParams.setConnectionTimeout(params, 8000);   //连接超时
			HttpConnectionParams.setSoTimeout(params, 5000);   //响应超时
		   
			//拿到app_host,并追加requestUrl，组成请求对象HttpPost；
			HttpPost post = new HttpPost(vo.context.getString(R.string.app_host).concat(vo.requestUrl));
			//给HttpPost设置BasicHttpParams，和BasicHeader[];
			post.setParams(params);
			//post.setHeaders(headers);
		
			//准备一个Object对象引用；
			Object obj = null;
		
			try {
				/**
				 * 如果请求数据映射requestDataMap不为null，就从中获取条目Map.Entry,
				 * 并生成基本名值对BasicNameValueParir，并添加到数组集合中，以便创建HttpEntity；
				 */
				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);
					}
					//把BasicNameValuePair数组集合，以"UTF-8"编码，编码成Url HttpEntity；
					HttpEntity entity = new UrlEncodedFormEntity(pairList,"UTF-8");
					post.setEntity(entity);
					//StringEntity
				}
				//让DefaultHttpClient执行HttpPost,完成请求post；
				HttpResponse response = client.execute(post);//包含响应的状态和返回的结果==
				if(response.getStatusLine().getStatusCode()==HttpStatus.SC_OK){
					String result = EntityUtils.toString(response.getEntity(),"UTF-8");
					Log.e(NetUtil.class.getSimpleName(), result);
					obj = getObjectByResult(result) ;
					return obj;
				}
			} catch (ClientProtocolException e) {
				Log.e(NetUtil.class.getSimpleName(), e.getLocalizedMessage(),e);
			} catch (IOException e) {
				Log.e(NetUtil.class.getSimpleName(), e.getLocalizedMessage(),e);
			}
			return null;
		}
	
		private static Object getObjectByResult(String result){
			return FileUtils.weatherInfoXmlPullParser(result) ; 
		}
	}

网络参数对象类

package com.android.whether.entity;

import java.util.HashMap;

import android.content.Context;

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

文件操作工具类

public class FileUtils {
    public static WeatherInfo weatherInfoXmlPullParser(String buffer){  
        
        XmlPullParser xmlParser = Xml.newPullParser();//获得XmlPullParser解析器     
          
        ByteArrayInputStream tInputStringStream = null;  
        if (buffer != null && !buffer.trim().equals("")){  
           tInputStringStream = new ByteArrayInputStream(buffer.getBytes()); 
        }else {  
            return null;  
        }        
        try{  
            //得到文件流，并设置编码方式  
            //InputStream inputStream=mContext.getResources().getAssets().open(fileName);  
            //xmlParser.setInput(inputStream, "utf-8");  
            xmlParser.setInput(tInputStringStream, "UTF-8");                
            return parseXmlStream(xmlParser);  //通过xmlParser解析返回的xml文件得到对象
        } catch (XmlPullParserException e) {  
             // TODO Auto-generated catch block  
             e.printStackTrace();  
        } catch (IOException e1) {  
             // TODO Auto-generated catch block  
             e1.printStackTrace();  
        }   
        return null ;
        }
 }