Android 网络层的封装

因为项目需要封装了其网络层，主要对其原来的模式进行改进，使用的回调的方式来进行网络的访问和返回结果的处理，还有就是在View层和网络层之间加了一个中间层，用来分配各种网络请求，这样就可以方便的调度和管理。

我就不拿原项目的代码来演示，自己写了一个demo，首先是最底层，处理最基本的Http协议，里面包含一个execute方法，用来Post或者Get获取数据，这里为了方便我只写了一个Get，可以根据具体需要进行改成Post或者其他方法：

import java.util.Map;

import org.apache.http.HttpResponse;
import org.apache.http.HttpVersion;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.conn.params.ConnManagerParams;
import org.apache.http.conn.scheme.PlainSocketFactory;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;
import org.apache.http.params.HttpProtocolParams;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;

public class BaseService {

	private static final String DEFAULT_CHARSET = HTTP.UTF_8;
	private static HttpClient simpleHttpClient = null;

	// 连接超时设定
	public final static int CONNECT_TIME_OUT = 10 * 1000;
	// 连接池取连接超时设定
	public final static int WAIT_TIME_OUT = 10 * 1000;
	// 读超时设定
	public final static int READ_TIME_OUT = 40 * 1000;
	// 连接池容量设定
	public final static int MAX_CONNECTION = 10;

	private static void init() {
		if (null == simpleHttpClient) {
			HttpParams params = new BasicHttpParams();
			HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
			HttpProtocolParams.setContentCharset(params, DEFAULT_CHARSET);
			HttpProtocolParams.setUseExpectContinue(params, true);
			ConnManagerParams.setTimeout(params, WAIT_TIME_OUT);
			ConnManagerParams.setMaxTotalConnections(params, MAX_CONNECTION);
			// 通信读超时时间
			HttpConnectionParams.setSoTimeout(params, READ_TIME_OUT);
			// 通信连接超时时间
			HttpConnectionParams.setConnectionTimeout(params, CONNECT_TIME_OUT);
			SchemeRegistry schReg = new SchemeRegistry();
			schReg.register(new Scheme("http", PlainSocketFactory
					.getSocketFactory(), 80));
			// schReg.register(new Scheme("https",
			// SSLSocketFactory.getSocketFactory(), 443));
			ClientConnectionManager connectionManager = new ThreadSafeClientConnManager(
					params, schReg);
			simpleHttpClient = new DefaultHttpClient(connectionManager, params);
		}
	}

	protected static String execute(String url, Map
   
   
    
     map) {

		String json = "";
		try {
			init();
			HttpGet httpGet = new HttpGet(url);
			HttpResponse httpResponse;
			httpResponse = simpleHttpClient.execute(httpGet);
			if (httpResponse.getStatusLine().getStatusCode() == 200)
				json = EntityUtils.toString(httpResponse.getEntity());
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return json;
	}

}

   
   

可以看到这个execute方法的参数是String url和Map<String,String> map，这样我们就需要一个POJO来构造这些参数：

package com.example.callbacktest;

import java.util.HashMap;
import java.util.Map;

public class NetworkPOJO {
	private String url;
	private Map
   
   
    
     map;

	public String getUrl() {
		return url;
	}

	public void setUrl(String url) {
		this.url = url;
	}

	public Map
    
    
     
      getMap() {
		return map;
	}

	public void setMap(Map
     
     
      
       map) {
		this.map = map;
	}

}

     
     
    
    
   
   

接下来是一个工厂类，这里用到了简单工厂模式，可以根据不同的参数很方便的创造出POJO的实例：

import java.util.HashMap;
import java.util.Map;

public class NetworkFactory {

	private static final String preUtrl = "http://contests.acmicpc.info/contests.json";

	private static final String login = "/user/login.php";
	private static final String reg = "/user/reg.php";

	private static NetworkPOJO createMyRequest(Map
   
   
    
     map,
			String houzhui) {

		String s = preUtrl + houzhui;
		NetworkPOJO networkPOJO = new NetworkPOJO();
		networkPOJO.setUrl(s);
		networkPOJO.setMap(map);
		return networkPOJO;
	}

	public static NetworkPOJO createLogin(String name, String pwd) {
		Map
    
    
     
      map = new HashMap
     
     
      
      ();
		map.put("name", name);
		map.put("pwd", pwd);
		return createMyRequest(map, login);
	}

	public static NetworkPOJO creategao() {
		Map
      
      
       
        map = new HashMap
       
       
         (); return createMyRequest(map, ""); } } 
       
      
      
     
     
    
    
   
   

接下来是中间层，所有的网络方法都需要经过这里才能调用底层协议，在这里进行各种网络方法的调度和管理：

import android.os.AsyncTask;

public class Network {
	
	/**
	 *  这个方法运行在主线程中，在具体使用时需要自己将其运行在子线程中
	 * @param request
	 * @param callback
	 */
	public static void postOnUI(NetworkPOJO request, Callback callback) {
		String json = BaseService.execute(request.getUrl(), request.getMap());
		if (json == "")
			callback.onSuccess(json);
		else
			callback.onError();
	}
	
	/**
	 * 这个方法运行在子线程中，构造好回调函数，使用时只需要简单调用就可以
	 * @param request
	 * @param callback
	 */
	public static void postOnThread(NetworkPOJO request, Callback callback) {
		new myAsyncTask(request, callback).execute("");
	}
	
	/**
	 * 这个是不带回调的方法，使用时需要根据自己的需要进行判断返回值处理各种逻辑
	 * @param request
	 * @return
	 */
	public static String post(NetworkPOJO request) {
		String json = BaseService.execute(request.getUrl(), request.getMap());
		return json;
	}
	
	/**
	 * AsyncTask
	 * @author ukfire
	 *
	 */
	static class myAsyncTask extends AsyncTask
   
   
    
     {

		private NetworkPOJO request;
		private Callback callback;

		public myAsyncTask(NetworkPOJO request, Callback callback) {
			this.request = request;
			this.callback = callback;
		}

		@Override
		protected String doInBackground(String... arg0) {
			String json = "";
			json = BaseService.execute(request.getUrl(), request.getMap());
			return json;
		}

		@Override
		protected void onPostExecute(String result) {
			super.onPostExecute(result);
			if (result == "")
				callback.onError();
			else
				callback.onSuccess(result);
		}
	}
	
	
	
}

   
   

自己定义回调接口，一般来说就是进行Success处理和Error处理，还可以进一步抽象：

public interface Callback {
	public void onError();

	public void onSuccess(String json);
}

最后就是在主函数中进行调用，这里调用的是运行在子线程中的方法，只需要构造好Callback回调函数，简单

调用即可：

		final NetworkPOJO request = NetworkFactory.creategao();	//构造POJO

		btn.setOnClickListener(new OnClickListener() {
			@Override
			public void onClick(View arg0) {
				Network.postOnThread(request, new Callback() {
					@Override
					public void onSuccess(String json) {
						text.setText(json);
					}
					@Override
					public void onError() {
						text.setText("Error");
					}
				});
			}
		});

这样View层和底层中间就多了一个中间层，提供运行在不同线程的各种调用方法，使用时对其回调方法进行实现就可以了，最大的有点就是方便调度和管理。