Android网络框架

从代码学习Android网络框架

代码开源地址： https://github.com/hehonghui/simple_net_framework
作者博客地址： http://blog.csdn.net/column/details/simple-net.html
SimpleNet网络框架 SimpleNet是一个简单的Android网络框架，该框架的结构类似Volley，该框架是为了让不太熟悉框架开发或者说不太了解Android网络编程的同学学习使用。
自己在这里学习一下大神的想法，稍作总结

1.Simple_Net_Framework基本结构

熟悉Volley的同学们发现很相似，没错作者也说了是按照Volley造的轮子。主要分为4部分

1.1 Request

各种请求类型。Request是个抽象，针对不同的请求数据有不同的实现类。例如返回的数据类型为json的对应为JsonRequest，返回数据字符串的为StringRequest，如果需要上传文件，那么你需要使用MultipartRequest，该请求只支持小文件的上传，如果上传的文件过大则会产生OOM

1.2 RequestQueue

第二部分为消息队列，消息队列维护了提交给网络框架的请求列表，并且根据相应的规则进行排序。默认情况下更具优先级和进入队列的顺序来执行，该队列使用的是线程安全的PriorityBlockingQueue，因为我们的队列会被并发的访问，因此需要保证访问的原子性。

1.3 NetWorkExecutors

第三部分是Executor，也就是网络的执行者。该Executor继承自Thread，在run方法中循环访问第二部分的请求队列，请求完成之后将结果投递给UI线程。为了更好的控制请求队列，例如请求排序、取消等操作，这里我们并没有使用线程池来操作，而是自行管理队列和Thread的形式，这样整个结构也变得更为灵活。

1.4 Response Delivery

第四部分则是Response投递类，在第三部分的Executor中执行网络请求，Executor是Thread，但是我们并不能在主线程中更新UI，因此我们使用ResponseDelivery来封装Response的投递，保证Response执行在UI线程。

2.Simple_Net_Framework的设计理论

Request是一个抽象的泛型类，泛型类型就是返回的Response类型，例如StringRequest就是继承自Request。第二部分的RequestQueue依赖于Request，Request是抽象的，因此任何Request的子类都可以传递到请求队列中来，它依赖的是抽象Request，而不是具体的某个实现，因此保证了可扩展性。你可以自己实现自己所需的Request，例如大文件的上传Request。同理，第三部分的NetworkExecutor也只是依赖于Request抽象，但这里又引入了一个类型HttpStack，这个网络请求的真正执行者，有HttpClientStack和HttpUrlConnStack，两者分别为Apache的HttpClient和java的HttpURLConnection，关于这两者的区别请参考:Android访问网络，使用HttpURLConnection还是HttpClient？。HttpStack也是一个抽象，具体使用HttpClient还是HttpURLConnection则由运行系统版本来定，HttpStackFactory会根据系统版本给框架返回对应的HttpStack。最后的ResponseDelivery比较简单了，只是通过Handler将结果投递给UI线程执行，也就是执行RequestListener的onComplete方法，此时网络执行完成，用户即可在该方法中更新UI或者相关的其他的操作。

3.代码阅读

在开始阅读源码前，先看一下如何使用这个Simple_Net_Framework网络框架，这样可以帮我们更好的去入手阅读代码

        //建立一个队列        RequestQueue requestQueue = SimpleNet.newRequestQueue();        //我们的网络请求            StringRequest request = new StringRequest(Request.HttpMethod.GET,                "https://www.baidu.com/", new Request.RequestListener<String>() {            @Override            public void onComplete(int stCode, String response, String errMsg) {                Log.e(TAG, "stCode: "+stCode );                Log.e(TAG, "response: "+response );                Log.e(TAG, "errMsg: "+errMsg );            }        });        //加入队列就ok了，因为队列有钩子函数        requestQueue.addRequest(request);

这里不逐行来分析代码了，根据上面的使用方法来进行分析

3.1 RequestQueue requestQueue = SimpleNet.newRequestQueue()

SimpleNet.java

public final class SimpleNet {    /**     * 创建一个请求队列,NetworkExecutor数量为默认的数量     */    public static RequestQueue newRequestQueue() {        return newRequestQueue(RequestQueue.DEFAULT_CORE_NUMS);    }    /**     * 创建一个请求队列,NetworkExecutor数量为coreNums     */    public static RequestQueue newRequestQueue(int coreNums) {        return newRequestQueue(coreNums, null);    }    /**     * 创建一个请求队列,NetworkExecutor数量为coreNums     * @param coreNums 线程数量     * @param httpStack 网络执行者     */    public static RequestQueue newRequestQueue(int coreNums, HttpStack httpStack) {        RequestQueue queue = new RequestQueue(Math.max(0, coreNums), httpStack);        queue.start();        return queue;    }}

RequestQueue.java

public final class RequestQueue {    /**     * 请求队列 [ Thread-safe ]     */    private BlockingQueue<Request<?>> mRequestQueue = new PriorityBlockingQueue<Request<?>>();    /**     * 请求的序列化生成器     */    private AtomicInteger mSerialNumGenerator = new AtomicInteger(0);    /**     * 默认的核心数     */    public static int DEFAULT_CORE_NUMS = Runtime.getRuntime().availableProcessors() + 1;    /**     * CPU核心数 + 1个分发线程数     */    private int mDispatcherNums = DEFAULT_CORE_NUMS;    /**     * NetworkExecutor,执行网络请求的线程     */    private NetworkExecutor[] mDispatchers = null;  //一个Thread，进行一次网络操作    /**     * Http请求的真正执行者     */    private HttpStack mHttpStack;    /**     * @param coreNums 线程核心数     * @param httpStack http执行器     */    protected RequestQueue(int coreNums, HttpStack httpStack) {        mDispatcherNums = coreNums;  //最终开启这么多线程来执行网络操作        mHttpStack = httpStack != null ? httpStack : HttpStackFactory.createHttpStack(); //网络请求操作的最终执行者，在现在android版本中是对应HttpUrlConnStack ，下面分析    }    /**     * 启动NetworkExecutor     */    private final void startNetworkExecutors() {        mDispatchers = new NetworkExecutor[mDispatcherNums];  //开几个线程        for (int i = 0; i < mDispatcherNums; i++) {            mDispatchers[i] = new NetworkExecutor(mRequestQueue, mHttpStack); //一个队列，一个HttpStack执行者，多个线程去执行            mDispatchers[i].start();        }    }    public void start() {        stop();  //防止多次start(),如果mDispatcherNums个线程开启了就先全部关闭        startNetworkExecutors(); //开启mDispatcherNums个线程    }    /**     * 停止NetworkExecutor     */    public void stop() {        if (mDispatchers != null && mDispatchers.length > 0) {            for (int i = 0; i < mDispatchers.length; i++) {                mDispatchers[i].quit();            }        }    }    /**     * 不能重复添加请求     * 很重要的方法，request加入后RequestQueue后就会被开启的多个线程获取request进而执行，     * 所以在使用中只要调用addRequest就完成了网络操作     * @param request     */    public void addRequest(Request<?> request) {           if (!mRequestQueue.contains(request)) {            request.setSerialNumber(this.generateSerialNumber());            mRequestQueue.add(request);        } else {            Log.d("", "### 请求队列中已经含有");        }    }    public void clear() {        mRequestQueue.clear();    }    public BlockingQueue<Request<?>> getAllRequests() {        return mRequestQueue;    }    /**     * 为每个请求生成一个系列号     *      * @return 序列号     */    private int generateSerialNumber() {        return mSerialNumGenerator.incrementAndGet();    }}

RequestQueue是一个重要的核心类，这里总结一下，有一个阻塞队列来存储Request，每次网络请求只需要把new好的Request加入到阻塞队列就好了；还有一个网络请求的真正执行者HttpStack根据版本的不同是HttpClient或HttlUrlConnection(就是这个)；多个死循环的线程（线程的数量在new RequestQueue可以控制），每个线程从阻塞队列获取Request然后交个HttpStack来执行网络请求，下面来看这些多线程的代码

NetworkExecutor.java

final class NetworkExecutor extends Thread { //就是一个线程    /**     * 网络请求队列     */    private BlockingQueue<Request<?>> mRequestQueue;    /**     * 网络请求栈，执行者     */    private HttpStack mHttpStack;    /**     * 结果分发器,将网络请求结果投递到主线程，后面分析     */    private static ResponseDelivery mResponseDelivery = new ResponseDelivery();    /**     * 请求缓存，这部分就是使用LruMemCache不做解释     */    private static Cache<String, Response> mReqCache = new LruMemCache();    /**     * 是否停止     */    private boolean isStop = false;    //每个线程拥有RequestQueue中的阻塞队列和网络执行者    public NetworkExecutor(BlockingQueue<Request<?>> queue, HttpStack httpStack) {        mRequestQueue = queue;        mHttpStack = httpStack;    }    @Override    public void run() {        try {            while (!isStop) { //死循环                final Request<?> request = mRequestQueue.take(); //没有请求会阻塞                if (request.isCanceled()) {                    Log.d("### ", "### 取消执行了");                    continue;                }                Response response = null;                if (isUseCache(request)) {  //request是否采用缓存                    // 从缓存中取                    response = mReqCache.get(request.getUrl());                } else {                    // 从网络上获取数据                    response = mHttpStack.performRequest(request);  //执行网络操作                    // 如果该请求需要缓存,那么请求成功则缓存到mResponseCache中                    if (request.shouldCache() && isSuccess(response)) {                        mReqCache.put(request.getUrl(), response);                    }                }                // 分发请求结果                mResponseDelivery.deliveryResponse(request, response);            }        } catch (InterruptedException e) {            Log.i("", "### 请求分发器退出");        }    }    private boolean isSuccess(Response response) {        return response != null && response.getStatusCode() == 200;    }    private boolean isUseCache(Request<?> request) {        return request.shouldCache() && mReqCache.get(request.getUrl()) != null;    }    public void quit() {        isStop = true;        interrupt();    }}

对缓存有兴趣可以参考http://blog.csdn.net/chenqianleo/article/details/75137994 ，使用了LruCache，DiskLruCache两级缓存

这部分代码也很简单，在Thread的run()方法获取一个request，使用HttpStack来进行操作然后处理返回结果，这里两个问题，一个是HttpStack是如何处理的？二是如何处理网络请求结果？第一个就是HttpUrlConnect的基本操作，我们下面先来看第二个

ResponseDelivery.java

class ResponseDelivery implements Executor {    /**     * 主线程的hander     */    Handler mResponseHandler = new Handler(Looper.getMainLooper());    /**     * 处理请求结果,将其执行在UI线程     * @param request     * @param response     */    public void deliveryResponse(final Request<?> request, final Response response) {        Runnable respRunnable = new Runnable() {            @Override            public void run() {                request.deliveryResponse(response); //调用了request的方法，下面来看这个方法            }        };        execute(respRunnable);    }    @Override    public void execute(Runnable command) {        mResponseHandler.post(command);  //这个Runable使用Handler放到了UI线程    }}

Request.java

    public abstract T parseResponse(Response response); //不同的request类型自己处理自己请求的数据    public final void deliveryResponse(Response response) {        T result = parseResponse(response); //返回不同的结果，比如json，string等        if (mRequestListener != null) {            int stCode = response != null ? response.getStatusCode() : -1;            String msg = response != null ? response.getMessage() : "unkown error";            Log.e("", "### 执行回调 : stCode = " + stCode + ", result : " + result + ", err : " + msg);            mRequestListener.onComplete(stCode, result, msg); //回调方法，我们在new一个Request时传入的参数        }    }

阅读到这里大致的流程租完了，我们先创建一个RequestQueue，然后里面会有多个线程等待Request任务的到来，当我们新建一个Request时会传入一个onComplete的钩子函数，最后当我们把Request加入到RequestQueue后就被线程执行得到结果，执行钩子函数。。over