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