镜中1人
镜中1人

Android NoHttp源码阅读指导

版权声明：转载必须注明本文转自严振杰的博客: http://blog.csdn.net/yanzhenjie1003

目录(?)[+]

Android NoHttp源码阅读指导

版权声明：转载必须注明本文转自严振杰的博客: http://blog.csdn.net/yanzhenjie1003

现在市场的Http框架很多，比如我们熟知的NoHttp、Retrofit、Volley、Android-async-http等上层框架，HttpURLConnection、OkHttp、HttpClient等底层框架，今天不说孰好孰坏，今天我带大家来分析NoHttp的源码，教大家如何来看NoHttp的源码。

今天的源码是以NoHttp1.0.5版及以上版本为基础的，今天我们由浅到深，深入浅出的分析第一个模块：请求模块。

NoHttp开源地址：https://github.com/yanzhenjie/NoHttp，。

更多NoHttp相关文章请看NoHttp博客专栏：http://blog.csdn.net/column/details/nohttp.html。

OkHttp做为NoHttp底层的博客详解：http://blog.csdn.net/yanzhenjie1003/article/details/52439317。

NoHttp 源码该如何入手

想要看一个框架的源码，首先就要学会怎么用，最起码基础用法要会，也不必深入或者精通。那么我们先来看下NoHttp的异步请求和同步请求的简单用法。

切入NoHttp

作为一个优秀的网络框架，必定时提供了异步请求、同步请求两种方式给开发者的。

NoHttp的异步，我们先来看一个最简单实践：

RequestQueue queue = NoHttp.newRequestQueue();
Request sReq = new StringRequest(url, POST);
...
queue.add(what sReq, new OnResponseListener() {
    public void onStart(int what){}
    public void onFinish(int what){}
    public void onSucceed(int what, Response response){}
    public void onFailed(int what, Response response){}
});
     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    • 
      
      
      
      
  • 3
    • 
      
      
      
      
  • 4
    • 
      
      
      
      
  • 5
    • 
      
      
      
      
  • 6
    • 
      
      
      
      
  • 7
    • 
      
      
      
      
  • 8
    • 
      
      
      
      
  • 9
    • 
     
     
     
     

     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    • 
      
      
      
      
  • 3
    • 
      
      
      
      
  • 4
    • 
      
      
      
      
  • 5
    • 
      
      
      
      
  • 6
    • 
      
      
      
      
  • 7
    • 
      
      
      
      
  • 8
    • 
      
      
      
      
  • 9
    •

来做个简单的分析，首先是new了一个队列，然后创建了一个String的Request，之后把这个请求添加到队列，等待请求网络后响应，完事儿，就是这么简单。

NoHttp同步请求，再来看一个最简单实例：

Request request = new StringRequest(url, GET);
Response response = NoHttp.startRequestSync(request);
     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    • 
     
     
     
     

     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    •

这个更简单了，创建了一个请求，然后调用NoHttp同步请求的方法拿到请求结果。

从哪里开始看起

看了异步请求和同步请求后我们来分析一下，应该从哪里开始看NoHttp的源码。

从上面的代码中看到，异步请求和同步请求最大的区别是：异步请求需要用队列发送，用Listener接受请求结果，而同步请求是直接请求到结果，那么最大的可能就是异步请求是建立在同步请求这个基础上的。所以我们直接看异步请求，在开始之前我已经画好了几个图。

NoHttp流程图

Android NoHttp源码阅读指导_第1张图片

这个图是NoHttp异步请求时，从主线程调用网络到拿到结果的流程图，这里非常有必要对这些类做个说明。

名称 类型 默认实现类 说明
RequestQueue 类 - 请求队列
RequestDispatcher 类 - 轮训队列的线程
IRestParser 接口 RestParser 解析网络结果，针对IParserRequest
IRestProtocol 接口 RestProtocol 按照Http协议请求网络处理请求结果，针对IProtocolRequest
IRestConnection 接口 RestConnection 访问网络，针对IBaseRequst，更改底层为OkHttp时只需要实现它
IBaseRequst 接口 BaseRequest 提供通用的网络设置、参数设置、Cookie、重试机制，下载和请求模块通用
IProtocolRequest 接口 ProtocolRequest 请求模块的协议，例如缓存机制
IParserRequest 接口 ParserRequest 泛型，提供解析请求结果ByteArray为泛型
Request 接口 RestRequest 提供异步请求的参数记录功能，如what、Listener等

注意：其中IRestConnection是网络访问的接口类，所以替换底层为OkHttp时，仅仅需要实现它就Ok了。

NoHttp动态流程图

如果上面的图还是不够显然，我们可以结合下面的图再看一边动态流程图就更加显而易懂了：

Android NoHttp源码阅读指导_第2张图片

从上面的两张图可以看到，任何一个请求都是从主线程开始发起，先把Request添加到RequestQueue（队列）中，队列此时会启动子线程，再由ReuqestDispatcher（请求分发者）把队列中请求按照一定的顺序分发给子线程去执行网络操作，ReuqestDispatcher拿到结果后，用Handler发送到主线程，这个过程就是NoHttp的整个异步请求的过程。

撸源码

上面是大致的逻辑说明，接着上面的分析，我们来个总分总，现在我们现在开始撸源码，把各个环节的细节给拆开了，那么先入手的入手的就是RequestQueue了。

RequestQueue

我们先来看看NoHttp怎么创建RequestQueue：

public static RequestQueue newRequestQueue() {
    return newRequestQueue(DEFAULT_REQUEST_THREAD_SIZE);
}

public static RequestQueue newRequestQueue(int threadPoolSize) {
    return newRequestQueue(DiskCacheStore.INSTANCE, RestConnection.getInstance(), threadPoolSize);
}

public static RequestQueue newRequestQueue(Cache cache, IRestConnection connection, int threadPoolSize) {
    return newRequestQueue(RestProtocol.getInstance(cache, connection), threadPoolSize);
}

public static RequestQueue newRequestQueue(IRestProtocol iRestProtocol, int threadPoolSize) {
    return newRequestQueue(RestParser.getInstance(iRestProtocol), threadPoolSize);
}

public static RequestQueue newRequestQueue(IRestParser implRestParser, int threadPoolSize) {
    RequestQueue requestQueue = new RequestQueue(implRestParser, threadPoolSize);
    requestQueue.start();
    return requestQueue;
}
     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    • 
      
      
      
      
  • 3
    • 
      
      
      
      
  • 4
    • 
      
      
      
      
  • 5
    • 
      
      
      
      
  • 6
    • 
      
      
      
      
  • 7
    • 
      
      
      
      
  • 8
    • 
      
      
      
      
  • 9
    • 
      
      
      
      
  • 10
    • 
      
      
      
      
  • 11
    • 
      
      
      
      
  • 12
    • 
      
      
      
      
  • 13
    • 
      
      
      
      
  • 14
    • 
      
      
      
      
  • 15
    • 
      
      
      
      
  • 16
    • 
      
      
      
      
  • 17
    • 
      
      
      
      
  • 18
    • 
      
      
      
      
  • 19
    • 
      
      
      
      
  • 20
    • 
      
      
      
      
  • 21
    • 
     
     
     
     

     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    • 
      
      
      
      
  • 3
    • 
      
      
      
      
  • 4
    • 
      
      
      
      
  • 5
    • 
      
      
      
      
  • 6
    • 
      
      
      
      
  • 7
    • 
      
      
      
      
  • 8
    • 
      
      
      
      
  • 9
    • 
      
      
      
      
  • 10
    • 
      
      
      
      
  • 11
    • 
      
      
      
      
  • 12
    • 
      
      
      
      
  • 13
    • 
      
      
      
      
  • 14
    • 
      
      
      
      
  • 15
    • 
      
      
      
      
  • 16
    • 
      
      
      
      
  • 17
    • 
      
      
      
      
  • 18
    • 
      
      
      
      
  • 19
    • 
      
      
      
      
  • 20
    • 
      
      
      
      
  • 21
    •

这里有5个方法可以创建ReuqestQueue，但是每个方法最终都会来到最后方法，最后一个方法需要两个参数，第一个参数是IRestParser，也就是响应解析者，第二个参数是threadPoolSize，也就是队列中启动的线程的数量，创建好ReuqestQueue后，调用start()方法启动队列，这时就可以往队列中添加请求了。

那么ReuqestQueue中究竟是怎么处理Request的呢？到这里我们就必须去看看ReuqestQueue的源码了，我已经把原文中的英文注释改为中文了，方便大家理解：

public class RequestQueue {

    /**
     * 保存没有完成的请求，包括正在执行的请求。
     */
    private final BlockingQueue> mUnFinishQueue;
    /**
     * 保存没有执行的请求，不包括正在执行的请求。
     */
    private final BlockingQueue> mRequestQueue;
    /**
     * Http 请求结果解析器。
     */
    private final IRestParser mImplRestParser;

    /**
     * 线程池。
     */
    private RequestDispatcher[] mDispatchers;

    public RequestQueue(IRestParser implRestParser, int threadPoolSize) {
        mImplRestParser = implRestParser;
        mDispatchers = new RequestDispatcher[threadPoolSize];
    }

    /**
     * 启动线程池，轮训请求队列。
     */
    public void start() {
        stop();
        for (int i = 0; i < mDispatchers.length; i++) {
            RequestDispatcher networkDispatcher = new RequestDispatcher(..., mImplRestParser);
            mDispatchers[i] = networkDispatcher;
            networkDispatcher.start();
        }
    }

    /**
     * 1. 添加一个请求到队列，如果队列中请求数没有满，则会立即执行，否则等待前面的请求执行完成后再执行。
     * 2. 在真正添加到队列前检查当前要添加的请求是否在队列中，如果重复添加则无任何操作。
     */
    public  void add(int what, Request request, OnResponseListener responseListener) {
        ...
    }

    /**
     * 没有开始执行的请求数量。
     */
    public int unStartSize() {}

    /**
     * 没有完成的请求数量，包括正在执行的请求。
     */
    public int unFinishSize() {}

    /**
     * 停止队列，使三个线程停止，不进行轮训队列。
     */
    public void stop() {}

    /**
     * 根绝sign取消所有用sign打标的请求。
     */
    public void cancelBySign(Object sign) {}

    /**
     * 取消队列中所有请求。
     */
    public void cancelAll() {}
}
     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    • 
      
      
      
      
  • 3
    • 
      
      
      
      
  • 4
    • 
      
      
      
      
  • 5
    • 
      
      
      
      
  • 6
    • 
      
      
      
      
  • 7
    • 
      
      
      
      
  • 8
    • 
      
      
      
      
  • 9
    • 
      
      
      
      
  • 10
    • 
      
      
      
      
  • 11
    • 
      
      
      
      
  • 12
    • 
      
      
      
      
  • 13
    • 
      
      
      
      
  • 14
    • 
      
      
      
      
  • 15
    • 
      
      
      
      
  • 16
    • 
      
      
      
      
  • 17
    • 
      
      
      
      
  • 18
    • 
      
      
      
      
  • 19
    • 
      
      
      
      
  • 20
    • 
      
      
      
      
  • 21
    • 
      
      
      
      
  • 22
    • 
      
      
      
      
  • 23
    • 
      
      
      
      
  • 24
    • 
      
      
      
      
  • 25
    • 
      
      
      
      
  • 26
    • 
      
      
      
      
  • 27
    • 
      
      
      
      
  • 28
    • 
      
      
      
      
  • 29
    • 
      
      
      
      
  • 30
    • 
      
      
      
      
  • 31
    • 
      
      
      
      
  • 32
    • 
      
      
      
      
  • 33
    • 
      
      
      
      
  • 34
    • 
      
      
      
      
  • 35
    • 
      
      
      
      
  • 36
    • 
      
      
      
      
  • 37
    • 
      
      
      
      
  • 38
    • 
      
      
      
      
  • 39
    • 
      
      
      
      
  • 40
    • 
      
      
      
      
  • 41
    • 
      
      
      
      
  • 42
    • 
      
      
      
      
  • 43
    • 
      
      
      
      
  • 44
    • 
      
      
      
      
  • 45
    • 
      
      
      
      
  • 46
    • 
      
      
      
      
  • 47
    • 
      
      
      
      
  • 48
    • 
      
      
      
      
  • 49
    • 
      
      
      
      
  • 50
    • 
      
      
      
      
  • 51
    • 
      
      
      
      
  • 52
    • 
      
      
      
      
  • 53
    • 
      
      
      
      
  • 54
    • 
      
      
      
      
  • 55
    • 
      
      
      
      
  • 56
    • 
      
      
      
      
  • 57
    • 
      
      
      
      
  • 58
    • 
      
      
      
      
  • 59
    • 
      
      
      
      
  • 60
    • 
      
      
      
      
  • 61
    • 
      
      
      
      
  • 62
    • 
      
      
      
      
  • 63
    • 
      
      
      
      
  • 64
    • 
      
      
      
      
  • 65
    • 
      
      
      
      
  • 66
    • 
      
      
      
      
  • 67
    • 
      
      
      
      
  • 68
    • 
      
      
      
      
  • 69
    • 
      
      
      
      
  • 70
    • 
     
     
     
     

     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    • 
      
      
      
      
  • 3
    • 
      
      
      
      
  • 4
    • 
      
      
      
      
  • 5
    • 
      
      
      
      
  • 6
    • 
      
      
      
      
  • 7
    • 
      
      
      
      
  • 8
    • 
      
      
      
      
  • 9
    • 
      
      
      
      
  • 10
    • 
      
      
      
      
  • 11
    • 
      
      
      
      
  • 12
    • 
      
      
      
      
  • 13
    • 
      
      
      
      
  • 14
    • 
      
      
      
      
  • 15
    • 
      
      
      
      
  • 16
    • 
      
      
      
      
  • 17
    • 
      
      
      
      
  • 18
    • 
      
      
      
      
  • 19
    • 
      
      
      
      
  • 20
    • 
      
      
      
      
  • 21
    • 
      
      
      
      
  • 22
    • 
      
      
      
      
  • 23
    • 
      
      
      
      
  • 24
    • 
      
      
      
      
  • 25
    • 
      
      
      
      
  • 26
    • 
      
      
      
      
  • 27
    • 
      
      
      
      
  • 28
    • 
      
      
      
      
  • 29
    • 
      
      
      
      
  • 30
    • 
      
      
      
      
  • 31
    • 
      
      
      
      
  • 32
    • 
      
      
      
      
  • 33
    • 
      
      
      
      
  • 34
    • 
      
      
      
      
  • 35
    • 
      
      
      
      
  • 36
    • 
      
      
      
      
  • 37
    • 
      
      
      
      
  • 38
    • 
      
      
      
      
  • 39
    • 
      
      
      
      
  • 40
    • 
      
      
      
      
  • 41
    • 
      
      
      
      
  • 42
    • 
      
      
      
      
  • 43
    • 
      
      
      
      
  • 44
    • 
      
      
      
      
  • 45
    • 
      
      
      
      
  • 46
    • 
      
      
      
      
  • 47
    • 
      
      
      
      
  • 48
    • 
      
      
      
      
  • 49
    • 
      
      
      
      
  • 50
    • 
      
      
      
      
  • 51
    • 
      
      
      
      
  • 52
    • 
      
      
      
      
  • 53
    • 
      
      
      
      
  • 54
    • 
      
      
      
      
  • 55
    • 
      
      
      
      
  • 56
    • 
      
      
      
      
  • 57
    • 
      
      
      
      
  • 58
    • 
      
      
      
      
  • 59
    • 
      
      
      
      
  • 60
    • 
      
      
      
      
  • 61
    • 
      
      
      
      
  • 62
    • 
      
      
      
      
  • 63
    • 
      
      
      
      
  • 64
    • 
      
      
      
      
  • 65
    • 
      
      
      
      
  • 66
    • 
      
      
      
      
  • 67
    • 
      
      
      
      
  • 68
    • 
      
      
      
      
  • 69
    • 
      
      
      
      
  • 70
    •

结合上文所说的，这里贴出了所有方法和最重要的实现。在构造方法中，创建了一个threadPoolSize大小的RequestDispatcher数组，调用start()的时候为数组的每一个index赋值一个真正的RequestDispatcher线程，并启动这个线程去轮训Queue，同时在创建RequestDispatcher的时候把我们创建队列的时候的IRestParser穿进去了，说明真正的调用网络还是在RequestDispatcher这个子线程中，具体怎么调用并处理接着看下文。

关于队列和线程的知识点这里不讲太多，只讲NoHttp在这里的设计，关于更多多线程、队列和任务优先级顺序的知识，请看严振杰的视频讲解。

RequestDispatcher

我们上面说到RequestDispatcher是一个线程，而且它在轮训队列里面的请求，根绝开始的流程图它也负责发送请求结果到主线程，所以它应该NoHttp异步请求中最重要的类之一了，我们不能放过它：

public class RequestDispatcher extends Thread {
    // 线程轮训是否停止。
    private boolean mQuit = false;

    // 停止线程轮训。
    public void stop() {
        mQuit = true;
    }

    ...

    @Override
    public void run() {
        while (!mQuit) { // 线程轮训没有停止则无限循环。
            final Request request;
            try {
                // 轮训请求，如果队列中请求为空则阻塞。
                request = mRequestQueue.take();
            } catch (InterruptedException e) {
                continue;
            }

            if (request.isCanceled()) {// 如果请求已经被取消则进行下一个请求。
                continue;
            }

            // 记录下what和listener，等待结果回调。
            final int what = request.what();
            final OnResponseListener responseListener = request.responseListener();

            request.start(); // 标志请求开始。
            // 发送请求开始回调到主线程。
            final ThreadPoster startThread = new ThreadPoster(what, responseListener);
            startThread.onStart();
            PosterHandler.getInstance().post(startThread);

            // 用IRestParser发送请求，并解析结果，这就是上文中说过的。
            Response response = mIRestParser.parserRequest(request);

            // 执行完请求，从队列移除。
            mUnFinishQueue.remove(request);

            // 发送请求完成回调到主线程。
            final ThreadPoster finishThread = new ThreadPoster(what, responseListener);
            finishThread.onFinished();
            PosterHandler.getInstance().post(finishThread);
            request.finish();// 标志网络请求已经完成。

            // 发送请求结果到主线程，如果请求在请求过程中被取消，则不发送。
            if (request.isCanceled())
                Logger.d(request.url() + " finish, but it's canceled.");
            else {
                final ThreadPoster responseThread = new ThreadPoster(what, responseListener);
                responseThread.onResponse(response);
                PosterHandler.getInstance().post(responseThread);
            }
        }
    }

    private class ThreadPoster implements Runnable {

        public static final int COMMAND_START = 0;
        public static final int COMMAND_RESPONSE = 1;
        public static final int COMMAND_FINISH = 2;

        private final int what;
        private final OnResponseListener responseListener;

        private int command;
        private Response response;

        public ThreadPoster(int what, OnResponseListener responseListener) {
            this.what = what;
            this.responseListener = responseListener;
        }

        public void onStart() {
            this.command = COMMAND_START;
        }

        public void onResponse(Response response) {
            this.command = COMMAND_RESPONSE;
            this.response = response;
        }

        public void onFinished() {
            this.command = COMMAND_FINISH;
        }

        @Override
        public void run() {
            if (responseListener != null) {
                if (command == COMMAND_START) // 开始回调。
                    responseListener.onStart(what);
                else if (command == COMMAND_FINISH) // 结束回调。
                    responseListener.onFinish(what);
                else if (command == COMMAND_RESPONSE) {// 请求结果回调。
                    if (response.isSucceed()) {// 如果成功，回调成功方法。
                        responseListener.onSucceed(what, response);
                    } else { // 如果失败，回调失败方法。
                        responseListener.onFailed(what, response);
                    }
                }
            }
        }
    }
}
     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    • 
      
      
      
      
  • 3
    • 
      
      
      
      
  • 4
    • 
      
      
      
      
  • 5
    • 
      
      
      
      
  • 6
    • 
      
      
      
      
  • 7
    • 
      
      
      
      
  • 8
    • 
      
      
      
      
  • 9
    • 
      
      
      
      
  • 10
    • 
      
      
      
      
  • 11
    • 
      
      
      
      
  • 12
    • 
      
      
      
      
  • 13
    • 
      
      
      
      
  • 14
    • 
      
      
      
      
  • 15
    • 
      
      
      
      
  • 16
    • 
      
      
      
      
  • 17
    • 
      
      
      
      
  • 18
    • 
      
      
      
      
  • 19
    • 
      
      
      
      
  • 20
    • 
      
      
      
      
  • 21
    • 
      
      
      
      
  • 22
    • 
      
      
      
      
  • 23
    • 
      
      
      
      
  • 24
    • 
      
      
      
      
  • 25
    • 
      
      
      
      
  • 26
    • 
      
      
      
      
  • 27
    • 
      
      
      
      
  • 28
    • 
      
      
      
      
  • 29
    • 
      
      
      
      
  • 30
    • 
      
      
      
      
  • 31
    • 
      
      
      
      
  • 32
    • 
      
      
      
      
  • 33
    • 
      
      
      
      
  • 34
    • 
      
      
      
      
  • 35
    • 
      
      
      
      
  • 36
    • 
      
      
      
      
  • 37
    • 
      
      
      
      
  • 38
    • 
      
      
      
      
  • 39
    • 
      
      
      
      
  • 40
    • 
      
      
      
      
  • 41
    • 
      
      
      
      
  • 42
    • 
      
      
      
      
  • 43
    • 
      
      
      
      
  • 44
    • 
      
      
      
      
  • 45
    • 
      
      
      
      
  • 46
    • 
      
      
      
      
  • 47
    • 
      
      
      
      
  • 48
    • 
      
      
      
      
  • 49
    • 
      
      
      
      
  • 50
    • 
      
      
      
      
  • 51
    • 
      
      
      
      
  • 52
    • 
      
      
      
      
  • 53
    • 
      
      
      
      
  • 54
    • 
      
      
      
      
  • 55
    • 
      
      
      
      
  • 56
    • 
      
      
      
      
  • 57
    • 
      
      
      
      
  • 58
    • 
      
      
      
      
  • 59
    • 
      
      
      
      
  • 60
    • 
      
      
      
      
  • 61
    • 
      
      
      
      
  • 62
    • 
      
      
      
      
  • 63
    • 
      
      
      
      
  • 64
    • 
      
      
      
      
  • 65
    • 
      
      
      
      
  • 66
    • 
      
      
      
      
  • 67
    • 
      
      
      
      
  • 68
    • 
      
      
      
      
  • 69
    • 
      
      
      
      
  • 70
    • 
      
      
      
      
  • 71
    • 
      
      
      
      
  • 72
    • 
      
      
      
      
  • 73
    • 
      
      
      
      
  • 74
    • 
      
      
      
      
  • 75
    • 
      
      
      
      
  • 76
    • 
      
      
      
      
  • 77
    • 
      
      
      
      
  • 78
    • 
      
      
      
      
  • 79
    • 
      
      
      
      
  • 80
    • 
      
      
      
      
  • 81
    • 
      
      
      
      
  • 82
    • 
      
      
      
      
  • 83
    • 
      
      
      
      
  • 84
    • 
      
      
      
      
  • 85
    • 
      
      
      
      
  • 86
    • 
      
      
      
      
  • 87
    • 
      
      
      
      
  • 88
    • 
      
      
      
      
  • 89
    • 
      
      
      
      
  • 90
    • 
      
      
      
      
  • 91
    • 
      
      
      
      
  • 92
    • 
      
      
      
      
  • 93
    • 
      
      
      
      
  • 94
    • 
      
      
      
      
  • 95
    • 
      
      
      
      
  • 96
    • 
      
      
      
      
  • 97
    • 
      
      
      
      
  • 98
    • 
      
      
      
      
  • 99
    • 
      
      
      
      
  • 100
    • 
      
      
      
      
  • 101
    • 
      
      
      
      
  • 102
    • 
      
      
      
      
  • 103
    • 
      
      
      
      
  • 104
    • 
      
      
      
      
  • 105
    • 
      
      
      
      
  • 106
    • 
      
      
      
      
  • 107
    • 
     
     
     
     

     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    • 
      
      
      
      
  • 3
    • 
      
      
      
      
  • 4
    • 
      
      
      
      
  • 5
    • 
      
      
      
      
  • 6
    • 
      
      
      
      
  • 7
    • 
      
      
      
      
  • 8
    • 
      
      
      
      
  • 9
    • 
      
      
      
      
  • 10
    • 
      
      
      
      
  • 11
    • 
      
      
      
      
  • 12
    • 
      
      
      
      
  • 13
    • 
      
      
      
      
  • 14
    • 
      
      
      
      
  • 15
    • 
      
      
      
      
  • 16
    • 
      
      
      
      
  • 17
    • 
      
      
      
      
  • 18
    • 
      
      
      
      
  • 19
    • 
      
      
      
      
  • 20
    • 
      
      
      
      
  • 21
    • 
      
      
      
      
  • 22
    • 
      
      
      
      
  • 23
    • 
      
      
      
      
  • 24
    • 
      
      
      
      
  • 25
    • 
      
      
      
      
  • 26
    • 
      
      
      
      
  • 27
    • 
      
      
      
      
  • 28
    • 
      
      
      
      
  • 29
    • 
      
      
      
      
  • 30
    • 
      
      
      
      
  • 31
    • 
      
      
      
      
  • 32
    • 
      
      
      
      
  • 33
    • 
      
      
      
      
  • 34
    • 
      
      
      
      
  • 35
    • 
      
      
      
      
  • 36
    • 
      
      
      
      
  • 37
    • 
      
      
      
      
  • 38
    • 
      
      
      
      
  • 39
    • 
      
      
      
      
  • 40
    • 
      
      
      
      
  • 41
    • 
      
      
      
      
  • 42
    • 
      
      
      
      
  • 43
    • 
      
      
      
      
  • 44
    • 
      
      
      
      
  • 45
    • 
      
      
      
      
  • 46
    • 
      
      
      
      
  • 47
    • 
      
      
      
      
  • 48
    • 
      
      
      
      
  • 49
    • 
      
      
      
      
  • 50
    • 
      
      
      
      
  • 51
    • 
      
      
      
      
  • 52
    • 
      
      
      
      
  • 53
    • 
      
      
      
      
  • 54
    • 
      
      
      
      
  • 55
    • 
      
      
      
      
  • 56
    • 
      
      
      
      
  • 57
    • 
      
      
      
      
  • 58
    • 
      
      
      
      
  • 59
    • 
      
      
      
      
  • 60
    • 
      
      
      
      
  • 61
    • 
      
      
      
      
  • 62
    • 
      
      
      
      
  • 63
    • 
      
      
      
      
  • 64
    • 
      
      
      
      
  • 65
    • 
      
      
      
      
  • 66
    • 
      
      
      
      
  • 67
    • 
      
      
      
      
  • 68
    • 
      
      
      
      
  • 69
    • 
      
      
      
      
  • 70
    • 
      
      
      
      
  • 71
    • 
      
      
      
      
  • 72
    • 
      
      
      
      
  • 73
    • 
      
      
      
      
  • 74
    • 
      
      
      
      
  • 75
    • 
      
      
      
      
  • 76
    • 
      
      
      
      
  • 77
    • 
      
      
      
      
  • 78
    • 
      
      
      
      
  • 79
    • 
      
      
      
      
  • 80
    • 
      
      
      
      
  • 81
    • 
      
      
      
      
  • 82
    • 
      
      
      
      
  • 83
    • 
      
      
      
      
  • 84
    • 
      
      
      
      
  • 85
    • 
      
      
      
      
  • 86
    • 
      
      
      
      
  • 87
    • 
      
      
      
      
  • 88
    • 
      
      
      
      
  • 89
    • 
      
      
      
      
  • 90
    • 
      
      
      
      
  • 91
    • 
      
      
      
      
  • 92
    • 
      
      
      
      
  • 93
    • 
      
      
      
      
  • 94
    • 
      
      
      
      
  • 95
    • 
      
      
      
      
  • 96
    • 
      
      
      
      
  • 97
    • 
      
      
      
      
  • 98
    • 
      
      
      
      
  • 99
    • 
      
      
      
      
  • 100
    • 
      
      
      
      
  • 101
    • 
      
      
      
      
  • 102
    • 
      
      
      
      
  • 103
    • 
      
      
      
      
  • 104
    • 
      
      
      
      
  • 105
    • 
      
      
      
      
  • 106
    • 
      
      
      
      
  • 107
    •

如果你认真看了我的注释结合我的解释也许就会明白很多了。

RequestDispatcher在线程没有被标志停止的情况下会一直循环调用Queue.take()轮训队列中的请求，如果线程中没有请求，由于Queue.take()的特性，这个子线程会处于阻塞状态，当然这不会使APP卡顿，因为它在子线程。当它每拿到一个Request先会判断请求是否被取消，如果是取消了的则去轮训下一个请求，如果没有取消会利用Handler发送一个Runnable回调Listener.onStart()方法通知主线程请求开始了，接着去执行Request，其中最重要的一句就是调用IRestParse的地方，这里正好印证了我们最开始讲的，在子线程中利用IRestParse去发送请求并解析结果成泛型：

// 用IRestParser发送请求，并解析结果，这就是上文中说过的。
Response response = mIRestParser.parserRequest(request);
     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    • 
     
     
     
     

     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    •

执行完请求后再次利用Handler发送一个Runnable回调Listener.onFinish()方法通知主线程网络请求执行完了：

// 发送请求完成回调到主线程。
final ThreadPoster finishThread = new ThreadPoster(what, responseListener);
finishThread.onFinished();
PosterHandler.getInstance().post(finishThread);
request.finish();

// 发送请求结果到主线程，如果请求在请求过程中被取消，则不发送。
if (request.isCanceled())
    Logger.d(request.url() + " finish, but it's canceled.");
else {
    final ThreadPoster responseThread = new ThreadPoster(what, responseListener);
    responseThread.onResponse(response);
    PosterHandler.getInstance().post(responseThread);
}
     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    • 
      
      
      
      
  • 3
    • 
      
      
      
      
  • 4
    • 
      
      
      
      
  • 5
    • 
      
      
      
      
  • 6
    • 
      
      
      
      
  • 7
    • 
      
      
      
      
  • 8
    • 
      
      
      
      
  • 9
    • 
      
      
      
      
  • 10
    • 
      
      
      
      
  • 11
    • 
      
      
      
      
  • 12
    • 
      
      
      
      
  • 13
    • 
      
      
      
      
  • 14
    • 
     
     
     
     

     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    • 
      
      
      
      
  • 3
    • 
      
      
      
      
  • 4
    • 
      
      
      
      
  • 5
    • 
      
      
      
      
  • 6
    • 
      
      
      
      
  • 7
    • 
      
      
      
      
  • 8
    • 
      
      
      
      
  • 9
    • 
      
      
      
      
  • 10
    • 
      
      
      
      
  • 11
    • 
      
      
      
      
  • 12
    • 
      
      
      
      
  • 13
    • 
      
      
      
      
  • 14
    •

可以看到如果回调了onStart()则一定会回调onFinish()，所以我们在OnResponseListener的onStart和onFinish非常适合做一个Dilaog的显示和关闭。

因为请求网络可能耗时比较长或者网络不好超时等因素，用户可能会取消这个请求，所以我们看到在回调了onFinish()后在发送结果到主线程前NoHttp又做了一个请求是否被取消的判断，综上所述我们得出一系列结论：

  1. 我们可以在onStart()时显示了一个Dialog，那么我们可以在onFinish()关闭Dialog。
  2. 如果请求开始之前就取消了，那这个请求不会被执行。
  3. 如果请求已经开始了，但是被中途取消，onFinish()还是会被回调，所以在这里关闭Dialog是非常合适的；同时请求若是被中途取消，那么也一定不会回调onSucceed()和onFailed()了，这里就涉及到取消请求了，用户退出当前页面会不会发生内存泄漏的问题，答案自然是不会。

IRestParser和它的实现类RestParser

看完了RequestQueue和RequestDispatcher后发现，里面除了和主线程的交互外，就是和网络的交互和结果如果解析了。

由上可以看到在创建队列、启动子线程到真正的执行请求，最终都需要响应解析者IRestParser，我们来看下它的源代码：

public interface IRestParser {
    /**
     * 请求网络并且解析结果。
     */
     Response parserRequest(IParserRequest request);
}
     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    • 
      
      
      
      
  • 3
    • 
      
      
      
      
  • 4
    • 
      
      
      
      
  • 5
    • 
      
      
      
      
  • 6
    • 
     
     
     
     

     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    • 
      
      
      
      
  • 3
    • 
      
      
      
      
  • 4
    • 
      
      
      
      
  • 5
    • 
      
      
      
      
  • 6
    •

根据源码和流程图的结构来看，它负责针对IRestRequest解析出数据并返回Response，数据肯定是来自网络，因此它也怎么从网络拿到数据并解析成我们想要的泛型结果就是重点了。但它只是一个接口，想知道它是如何实现的，就得看NoHttp为它提供的默认实现类怎么请求网络并返回数据了。

我们选中IRestParser，键盘上按下Ctrl + T（也许你的快捷键跟我不一样）就看到了接口的实现类，同时NoHttp为它提供的默认实现在创建队列的时候可以看到RestProtocol

public static RequestQueue newRequestQueue(IRestProtocol iRestProtocol, int threadPoolSize) {
    return newRequestQueue(RestParser.getInstance(iRestProtocol), threadPoolSize);
}
     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    • 
      
      
      
      
  • 3
    • 
     
     
     
     

     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    • 
      
      
      
      
  • 3
    •

我们可以看到源码是用RestParser.getInstance(iRestProtocol)单例模式从RestParser获取IRestParser的实例，因此下面接着就要撸RestParser的源码了：

public class RestParser implements IRestParser {

    private static RestParser _INSTANCE;

    private final IRestProtocol mIRestProtocol;

    public static IRestParser getInstance(IRestProtocol implRestConnection) {
        synchronized (RestParser.class) {
            if (_INSTANCE == null)
                _INSTANCE = new RestParser(implRestConnection);
            return _INSTANCE;
        }
    }

    private RestParser(IRestProtocol iRestProtocol) {
        this.mIRestProtocol = iRestProtocol;
    }

    @Override
    public  Response parserRequest(IParserRequest request) {
        long startTime = SystemClock.elapsedRealtime(); // 记录请求开始的时间。

        // 调用Http协议处理器IRestProtocol分析Request并完成网络请求拿到Response结果。
        ProtocolResult httpResponse = mIRestProtocol.requestNetwork(request);

        boolean isFromCache = httpResponse.isFromCache(); // 是否来自缓存的结果。
        Headers responseHeaders = httpResponse.responseHeaders(); // 服务器相应头。
        Exception exception = httpResponse.exception(); // 请求时是否发生异常。

        T result = null;
        byte[] responseBody = httpResponse.responseBody(); // 服务器响应内容。
        if (exception == null) {
            try {
                // 反调用IParserRequest去解析泛型结果。
                result = request.parseResponse(responseHeaders, responseBody);
            } catch (Throwable e) {
                exception = new ParseError("Parse data error: " + e.getMessage());
            }
        }
        return new RestResponse(request, isFromCache, responseHeaders,
            result, SystemClock.elapsedRealtime() - startTime, exception);
    }

}
     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    • 
      
      
      
      
  • 3
    • 
      
      
      
      
  • 4
    • 
      
      
      
      
  • 5
    • 
      
      
      
      
  • 6
    • 
      
      
      
      
  • 7
    • 
      
      
      
      
  • 8
    • 
      
      
      
      
  • 9
    • 
      
      
      
      
  • 10
    • 
      
      
      
      
  • 11
    • 
      
      
      
      
  • 12
    • 
      
      
      
      
  • 13
    • 
      
      
      
      
  • 14
    • 
      
      
      
      
  • 15
    • 
      
      
      
      
  • 16
    • 
      
      
      
      
  • 17
    • 
      
      
      
      
  • 18
    • 
      
      
      
      
  • 19
    • 
      
      
      
      
  • 20
    • 
      
      
      
      
  • 21
    • 
      
      
      
      
  • 22
    • 
      
      
      
      
  • 23
    • 
      
      
      
      
  • 24
    • 
      
      
      
      
  • 25
    • 
      
      
      
      
  • 26
    • 
      
      
      
      
  • 27
    • 
      
      
      
      
  • 28
    • 
      
      
      
      
  • 29
    • 
      
      
      
      
  • 30
    • 
      
      
      
      
  • 31
    • 
      
      
      
      
  • 32
    • 
      
      
      
      
  • 33
    • 
      
      
      
      
  • 34
    • 
      
      
      
      
  • 35
    • 
      
      
      
      
  • 36
    • 
      
      
      
      
  • 37
    • 
      
      
      
      
  • 38
    • 
      
      
      
      
  • 39
    • 
      
      
      
      
  • 40
    • 
      
      
      
      
  • 41
    • 
      
      
      
      
  • 42
    • 
      
      
      
      
  • 43
    • 
      
      
      
      
  • 44
    • 
     
     
     
     

     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    • 
      
      
      
      
  • 3
    • 
      
      
      
      
  • 4
    • 
      
      
      
      
  • 5
    • 
      
      
      
      
  • 6
    • 
      
      
      
      
  • 7
    • 
      
      
      
      
  • 8
    • 
      
      
      
      
  • 9
    • 
      
      
      
      
  • 10
    • 
      
      
      
      
  • 11
    • 
      
      
      
      
  • 12
    • 
      
      
      
      
  • 13
    • 
      
      
      
      
  • 14
    • 
      
      
      
      
  • 15
    • 
      
      
      
      
  • 16
    • 
      
      
      
      
  • 17
    • 
      
      
      
      
  • 18
    • 
      
      
      
      
  • 19
    • 
      
      
      
      
  • 20
    • 
      
      
      
      
  • 21
    • 
      
      
      
      
  • 22
    • 
      
      
      
      
  • 23
    • 
      
      
      
      
  • 24
    • 
      
      
      
      
  • 25
    • 
      
      
      
      
  • 26
    • 
      
      
      
      
  • 27
    • 
      
      
      
      
  • 28
    • 
      
      
      
      
  • 29
    • 
      
      
      
      
  • 30
    • 
      
      
      
      
  • 31
    • 
      
      
      
      
  • 32
    • 
      
      
      
      
  • 33
    • 
      
      
      
      
  • 34
    • 
      
      
      
      
  • 35
    • 
      
      
      
      
  • 36
    • 
      
      
      
      
  • 37
    • 
      
      
      
      
  • 38
    • 
      
      
      
      
  • 39
    • 
      
      
      
      
  • 40
    • 
      
      
      
      
  • 41
    • 
      
      
      
      
  • 42
    • 
      
      
      
      
  • 43
    • 
      
      
      
      
  • 44
    •

这里的单例和构造方法不多说，如果这都看不懂的话你可能不太适合做一枚程序猿，我们接着分析parserRequest()方法。

parserRequest()中是真正的请求网络，这里可以理解为同步请求的开始，所以看到这里不是有了灵感，NoHttp的同步请求一并看了，这也是NoHttp设计上的优点，同步请求更多的内容看本文最后。

这里要特别注意的一点是：生成IRestParser单例时需要传入一个IRestProtocol，而parserRequest()开始时记录了请求开始时间，然后立刻调用传入的IRestProtocol真正的执行网络请求：

// 调用Http协议处理器IRestProtocol分析Request并完成网络请求拿到Response结果。
ProtocolResult httpResponse = mIRestProtocol.requestNetwork(request);
     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    • 
     
     
     
     

     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    •

理论上讲IRestParser接口应该完全完成网络请求，解析出结果交给RequestDispatcher，但是实际上IRestParser的默认实现类RestParser把网络请求等繁琐的操作交给IRestProtocol接口去处理了，它只想负责拿到数据后的解析工作，这就叫做解耦。

完成网络协议请求后拿到ByteArray后调用IParserRequest.parseResponse()解析泛型结果，所以具体解析成什么结果是由IParserRequest决定的（题外话：因此我们在自定义请求时，继承RestRequest需要重写parseResponse解析结果），解析完ByteArray成泛型的结果后把异常、是否来自缓存和结果封装成RestResponse返回，剩下的事情就是上文中分析过的RequestDispatcher处理了，如果你忘记了RequestDispatcher的逻辑，可以回头去看看。

我们上面说到和Http相关的的网络请求是通过IRestProtoco这个接口发出的，so，接下来该撸IRestProtocol这个接口了。

IRestProtocol和它的实现类RestProtocol

IRestProtocol文章开头就说道了，它是一个接口，没啥好分析的，直接打开看源码：

public interface IRestProtocol {
    /**
     * 解析Http协议相关参数，完成网络请求。
     */
    ProtocolResult requestNetwork(IProtocolRequest request);
}
     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    • 
      
      
      
      
  • 3
    • 
      
      
      
      
  • 4
    • 
      
      
      
      
  • 5
    • 
      
      
      
      
  • 6
    • 
     
     
     
     

     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    • 
      
      
      
      
  • 3
    • 
      
      
      
      
  • 4
    • 
      
      
      
      
  • 5
    • 
      
      
      
      
  • 6
    •

根据源码和流程图的结构来看，它负责针对IProtocolRequest解析Http协议参数，并发起网络请求返回请求的结果。因此我们需要关心的地方是它如何处理Http协议的参数，so我们接着看NoHttp为它提供的默认实现类怎么请求网络并返回数据了。

选中IRestProtocol，键盘上按下Ctrl + T（也许你的快捷键跟我不一样）就看到了接口的实现类，或者回去看创建RequestQueue时，获取IRestParser的单例时：

public static RequestQueue newRequestQueue(Cache cache, IRestConnection connection, int threadPoolSize) {
    return newRequestQueue(RestProtocol.getInstance(cache, connection), threadPoolSize);
}

public static RequestQueue newRequestQueue(IRestProtocol iRestProtocol, int threadPoolSize) {
    return newRequestQueue(RestParser.getInstance(iRestProtocol), threadPoolSize);
}

public static RequestQueue newRequestQueue(IRestParser implRestParser, int threadPoolSize) {
    RequestQueue requestQueue = new RequestQueue(implRestParser, threadPoolSize);
    requestQueue.start();
    return requestQueue;
}
     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    • 
      
      
      
      
  • 3
    • 
      
      
      
      
  • 4
    • 
      
      
      
      
  • 5
    • 
      
      
      
      
  • 6
    • 
      
      
      
      
  • 7
    • 
      
      
      
      
  • 8
    • 
      
      
      
      
  • 9
    • 
      
      
      
      
  • 10
    • 
      
      
      
      
  • 11
    • 
      
      
      
      
  • 12
    • 
      
      
      
      
  • 13
    • 
     
     
     
     

     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    • 
      
      
      
      
  • 3
    • 
      
      
      
      
  • 4
    • 
      
      
      
      
  • 5
    • 
      
      
      
      
  • 6
    • 
      
      
      
      
  • 7
    • 
      
      
      
      
  • 8
    • 
      
      
      
      
  • 9
    • 
      
      
      
      
  • 10
    • 
      
      
      
      
  • 11
    • 
      
      
      
      
  • 12
    • 
      
      
      
      
  • 13
    •

这里可以看到最终创建队列时需要一个IRestParser，而在上一个方法获取IRestParser时需要一个IRestProtocol接口作为参数，在最上面的方法中看到IRestProtocol的是由RestProtocol.getInstance(cache)生成的，所以NoHttp为IRestProtocol提供的默认实现类是RestProtocol。

ProtocolResult requestNetwork(IProtocolRequest request);

由于这个类代码有点多，我们一点点的来分析，首先就是IRestProtocol必须要实现的方法requestNetwork()：

public class RestProtocol implements IRestProtocol {

  @Override
  public ProtocolResult requestNetwork(IProtocolRequest request) {
    // 处理Http缓存头。
    CacheMode cacheMode = request.getCacheMode();
    String cacheKey = request.getCacheKey();
    CacheEntity cEntity = mCache.get(cacheKey);

    ProtocolResult result;
    // 根据缓存模式处理。
    switch (cacheMode) {
        case ONLY_READ_CACHE:// 只读缓存.
            if (cEntity == null) {
                return new ProtocolResult(null, null, true, new NotFoundCacheError("没找到缓存"));
            } else {
                return new ProtocolResult(cEntity.getResponseHeaders(), cEntity.getData(), true, null);
            }
        case ONLY_REQUEST_NETWORK:// 仅仅请求网络.
            result = getHttpResponse(request);
            break;
        case NONE_CACHE_REQUEST_NETWORK:// 先读缓存，没缓存再请求网络。
            if (cEntity == null) {
                result = getHttpResponse(request);// 请求网络。
            } else {
                return new ProtocolResult(cEntity.getResponseHeaders(), cEntity.getData(), true, null);
            }
            break;
        case REQUEST_NETWORK_FAILED_READ_CACHE:// 请求网络失败后读缓存。
            if (cEntity != null)
                setRequestCacheHeader(request, cEntity); // 缓存存在时设置缓存头。
            result = getHttpResponse(request);// 请求网络。
            break;
        default:// 按照Http标准协议，304。
            if (cEntity != null) {
                // 缓存没失效直接返回。
                if (cEntity.getLocalExpire() > System.currentTimeMillis()) {
                    return new ProtocolResult(cEntity.getResponseHeaders(), cEntity.getData(), true, null);
                }
                // 缓存失败但存在，时设置缓存头。
                setRequestCacheHeader(request, cEntity);
            }
            result = getHttpResponse(request);// 请求网络。
            break;
    }
    return handleResponseCache(request, cEntity, result); // 处理响应数据，缓存协议等。
}
     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    • 
      
      
      
      
  • 3
    • 
      
      
      
      
  • 4
    • 
      
      
      
      
  • 5
    • 
      
      
      
      
  • 6
    • 
      
      
      
      
  • 7
    • 
      
      
      
      
  • 8
    • 
      
      
      
      
  • 9
    • 
      
      
      
      
  • 10
    • 
      
      
      
      
  • 11
    • 
      
      
      
      
  • 12
    • 
      
      
      
      
  • 13
    • 
      
      
      
      
  • 14
    • 
      
      
      
      
  • 15
    • 
      
      
      
      
  • 16
    • 
      
      
      
      
  • 17
    • 
      
      
      
      
  • 18
    • 
      
      
      
      
  • 19
    • 
      
      
      
      
  • 20
    • 
      
      
      
      
  • 21
    • 
      
      
      
      
  • 22
    • 
      
      
      
      
  • 23
    • 
      
      
      
      
  • 24
    • 
      
      
      
      
  • 25
    • 
      
      
      
      
  • 26
    • 
      
      
      
      
  • 27
    • 
      
      
      
      
  • 28
    • 
      
      
      
      
  • 29
    • 
      
      
      
      
  • 30
    • 
      
      
      
      
  • 31
    • 
      
      
      
      
  • 32
    • 
      
      
      
      
  • 33
    • 
      
      
      
      
  • 34
    • 
      
      
      
      
  • 35
    • 
      
      
      
      
  • 36
    • 
      
      
      
      
  • 37
    • 
      
      
      
      
  • 38
    • 
      
      
      
      
  • 39
    • 
      
      
      
      
  • 40
    • 
      
      
      
      
  • 41
    • 
      
      
      
      
  • 42
    • 
      
      
      
      
  • 43
    • 
      
      
      
      
  • 44
    • 
      
      
      
      
  • 45
    • 
      
      
      
      
  • 46
    • 
      
      
      
      
  • 47
    • 
     
     
     
     

     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    • 
      
      
      
      
  • 3
    • 
      
      
      
      
  • 4
    • 
      
      
      
      
  • 5
    • 
      
      
      
      
  • 6
    • 
      
      
      
      
  • 7
    • 
      
      
      
      
  • 8
    • 
      
      
      
      
  • 9
    • 
      
      
      
      
  • 10
    • 
      
      
      
      
  • 11
    • 
      
      
      
      
  • 12
    • 
      
      
      
      
  • 13
    • 
      
      
      
      
  • 14
    • 
      
      
      
      
  • 15
    • 
      
      
      
      
  • 16
    • 
      
      
      
      
  • 17
    • 
      
      
      
      
  • 18
    • 
      
      
      
      
  • 19
    • 
      
      
      
      
  • 20
    • 
      
      
      
      
  • 21
    • 
      
      
      
      
  • 22
    • 
      
      
      
      
  • 23
    • 
      
      
      
      
  • 24
    • 
      
      
      
      
  • 25
    • 
      
      
      
      
  • 26
    • 
      
      
      
      
  • 27
    • 
      
      
      
      
  • 28
    • 
      
      
      
      
  • 29
    • 
      
      
      
      
  • 30
    • 
      
      
      
      
  • 31
    • 
      
      
      
      
  • 32
    • 
      
      
      
      
  • 33
    • 
      
      
      
      
  • 34
    • 
      
      
      
      
  • 35
    • 
      
      
      
      
  • 36
    • 
      
      
      
      
  • 37
    • 
      
      
      
      
  • 38
    • 
      
      
      
      
  • 39
    • 
      
      
      
      
  • 40
    • 
      
      
      
      
  • 41
    • 
      
      
      
      
  • 42
    • 
      
      
      
      
  • 43
    • 
      
      
      
      
  • 44
    • 
      
      
      
      
  • 45
    • 
      
      
      
      
  • 46
    • 
      
      
      
      
  • 47
    •

要注意的两点： 
第一：NoHttp的几种缓存模式：

  • 只读缓存
  • 只请求缓存
  • 先读缓存，没有缓存再请求网络
  • 先请求网络，请求网络失败再读取缓存
  • 按照Http标准协议，重定向缓存机制

第二：此方法中出现的几个未知的方法：

  • setRequestCacheHeader(request, cacheEntity); // 为请求设置缓存头。
  • getHttpResponse(request); // 真正的请求网络。
  • handleResponseCache(request, cEntity, result); // 处理响应结果、缓存等。

setRequestCacheHeader(request, cacheEntity);

这个方法是在请求之前为Request添加和缓存协议有关的请求头，这是Http标准协议的内容，更多的协议讲解请看这篇博客：http://blog.csdn.net/yanzhenjie1003/article/details/50878323

private void setRequestCacheHeader(IProtocolRequest request, CacheEntity cacheEntity) {
    if (cacheEntity == null) { // 如果缓存为空，移除缓存相关请求头。
        request.headers().remove("If-None-Match");
        request.headers().remove("If-Modified-Since");
    } else { // 缓存不为空则添加相关请求头。
        Headers headers = cacheEntity.getResponseHeaders();
        String eTag = headers.getETag();
        if (eTag != null) {
            request.headers().set("If-None-Match", eTag);
        }
        long lastModified = headers.getLastModified();
        if (lastModified > 0) {
            request.headers().set("If-Modified-Since", HeaderUtil.formatMillisToGMT(lastModified));
        }
    }
}
     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    • 
      
      
      
      
  • 3
    • 
      
      
      
      
  • 4
    • 
      
      
      
      
  • 5
    • 
      
      
      
      
  • 6
    • 
      
      
      
      
  • 7
    • 
      
      
      
      
  • 8
    • 
      
      
      
      
  • 9
    • 
      
      
      
      
  • 10
    • 
      
      
      
      
  • 11
    • 
      
      
      
      
  • 12
    • 
      
      
      
      
  • 13
    • 
      
      
      
      
  • 14
    • 
      
      
      
      
  • 15
    • 
      
      
      
      
  • 16
    • 
     
     
     
     

     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    • 
      
      
      
      
  • 3
    • 
      
      
      
      
  • 4
    • 
      
      
      
      
  • 5
    • 
      
      
      
      
  • 6
    • 
      
      
      
      
  • 7
    • 
      
      
      
      
  • 8
    • 
      
      
      
      
  • 9
    • 
      
      
      
      
  • 10
    • 
      
      
      
      
  • 11
    • 
      
      
      
      
  • 12
    • 
      
      
      
      
  • 13
    • 
      
      
      
      
  • 14
    • 
      
      
      
      
  • 15
    • 
      
      
      
      
  • 16
    •

这里需要解释一下Http的缓存协议了。如果服务器支持http标准的缓存，当我们第一次请求服务器的时候，服务器会在响应头中添加Last-Modified头，这个头的含义是服务器最后一次修改响应body的时间，如果服务器支持设置缓存有效期，还会添加一个E-Tag的头，这个头是可以理解为响应body的一个tag。客户端接受到响应头到，会把这两个相应头保存起来，在第二次请求的时候会首先检查响应body是否过期，如果没有过期则直接使用上次的响应body，也就是我们在requestNetwork()方法中看到的：

default:// 按照Http标准协议，304。
    if (cEntity != null) {
        // 缓存没失效直接返回。
        if (cEntity.getLocalExpire() > System.currentTimeMillis()) {
            return new ProtocolResult(cEntity.getResponseHeaders(), cEntity.getData(), true, null);
        }
        // 缓存失败但存在，时设置缓存头。
        setRequestCacheHeader(request, cEntity);
    }
    result = getHttpResponse(request);// 请求网络。
    break;
     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    • 
      
      
      
      
  • 3
    • 
      
      
      
      
  • 4
    • 
      
      
      
      
  • 5
    • 
      
      
      
      
  • 6
    • 
      
      
      
      
  • 7
    • 
      
      
      
      
  • 8
    • 
      
      
      
      
  • 9
    • 
      
      
      
      
  • 10
    • 
      
      
      
      
  • 11
    • 
     
     
     
     

     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    • 
      
      
      
      
  • 3
    • 
      
      
      
      
  • 4
    • 
      
      
      
      
  • 5
    • 
      
      
      
      
  • 6
    • 
      
      
      
      
  • 7
    • 
      
      
      
      
  • 8
    • 
      
      
      
      
  • 9
    • 
      
      
      
      
  • 10
    • 
      
      
      
      
  • 11
    •

如果响应body过期，那么客户端应该重新请求服务器，并且在请求头中添加两个请求头，第一个是If-None-Match头，这个头的值应该是上次请求服务器时，服务器返回的E-Tag，第二个要添加的请求头是If-Modified-Since，这个头的值应该是上次服务器返回的Last-Modified的值。

服务器接受到请求后会用If-None-Match和If-Modified-Since和服务器现在E-Tag和Last-Modified做对比，判断客户端上次的缓存是否过期。如果没有过期则返回304响应码，并且不会向响应body中写入内容，客户端接受到这个响应后，判断响应码是304时应该从客户端拿上次的缓存数据；如果过期则返回200段的响应码，并且会向响应body中写入新的内容，客户端接受到这个响应后，判断响应码是200段，应该重新从响应body中读取内容。

这就是Http标准协议中的缓存协议内容，NoHttp做到了完美的支持。

getHttpResponse(request);

/**
 * 真正的请求网络。
 */
private ProtocolResult getHttpResponse(IProtocolRequest request) {
    byte[] responseBody = null;
    Connection connection = iRestConnection.getConnection(request); // 从IRestConnection拿到网络连接和响应内容。

    Headers responseHeaders = connection.responseHeaders();
    Exception exception = connection.exception();
    if (exception == null) {
        // 判断是否有响应内容，比如304响应码就没有body。
        if (hasResponseBody(request.getRequestMethod(), responseHeaders.getResponseCode()))
            try {
                // 把服务器响应body转为ByteArray。
                responseBody = IOUtils.toByteArray(connection.serverStream());
            } catch (IOException e) {// IOException.
                exception = e;
            }
    }
    IOUtils.closeQuietly(connection); // 关闭服务器流。
    // 返回响应内容。
    return new ProtocolResult(responseHeaders, responseBody, exception != null, exception);
}
     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    • 
      
      
      
      
  • 3
    • 
      
      
      
      
  • 4
    • 
      
      
      
      
  • 5
    • 
      
      
      
      
  • 6
    • 
      
      
      
      
  • 7
    • 
      
      
      
      
  • 8
    • 
      
      
      
      
  • 9
    • 
      
      
      
      
  • 10
    • 
      
      
      
      
  • 11
    • 
      
      
      
      
  • 12
    • 
      
      
      
      
  • 13
    • 
      
      
      
      
  • 14
    • 
      
      
      
      
  • 15
    • 
      
      
      
      
  • 16
    • 
      
      
      
      
  • 17
    • 
      
      
      
      
  • 18
    • 
      
      
      
      
  • 19
    • 
      
      
      
      
  • 20
    • 
      
      
      
      
  • 21
    • 
      
      
      
      
  • 22
    • 
      
      
      
      
  • 23
    • 
     
     
     
     

     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    • 
      
      
      
      
  • 3
    • 
      
      
      
      
  • 4
    • 
      
      
      
      
  • 5
    • 
      
      
      
      
  • 6
    • 
      
      
      
      
  • 7
    • 
      
      
      
      
  • 8
    • 
      
      
      
      
  • 9
    • 
      
      
      
      
  • 10
    • 
      
      
      
      
  • 11
    • 
      
      
      
      
  • 12
    • 
      
      
      
      
  • 13
    • 
      
      
      
      
  • 14
    • 
      
      
      
      
  • 15
    • 
      
      
      
      
  • 16
    • 
      
      
      
      
  • 17
    • 
      
      
      
      
  • 18
    • 
      
      
      
      
  • 19
    • 
      
      
      
      
  • 20
    • 
      
      
      
      
  • 21
    • 
      
      
      
      
  • 22
    • 
      
      
      
      
  • 23
    •

其中Connection connection = iRestConnection.getConnection(request); 。里面才是真正的建立网络请求，发送数据、上传文件等操作。

handleResponseCache(request, cEntity, result);

private ProtocolResult handleResponseCache(IProtocolRequest request, CacheEntity localCacheEntity, ProtocolResult httpResponse) {
    boolean isFromCache = false;
    Headers responseHeaders = httpResponse.responseHeaders();
    byte[] responseBody = httpResponse.responseBody();
    Exception exception = httpResponse.exception();

    CacheMode cacheMode = request.getCacheMode();
    int responseCode = responseHeaders.getResponseCode();
    if (exception == null) {// 没有发生异常，请求成功。
        if (responseCode == 304) {
            isFromCache = true;
            if (localCacheEntity == null) { // 服务器304，但本地没有缓存，兼容服务器bug。
                responseBody = new byte[0];
            } else {
                // 更新相应头信息。
                localCacheEntity.getResponseHeaders().setAll(responseHeaders);
                responseHeaders = localCacheEntity.getResponseHeaders();
                localCacheEntity.setLocalExpire(HeaderUtil.getLocalExpires(responseHeaders));

                // 读取本地缓存数据。
                responseBody = localCacheEntity.getData();
            }
        } else if (responseBody != null) {// 响应码非304，并且有响应内容。
            if (localCacheEntity == null) { // 如果本地没缓存，则根据http协议进行缓存。
                // 解析服务器缓存头。
                localCacheEntity = HeaderUtil.parseCacheHeaders(...);
                // 这里解析出来也许为空，因为服务器可能不允许缓存：no-cache，no-store。
            } else {
                // 如果本地已经有缓存，则更新数据。
                localCacheEntity.getResponseHeaders().setAll(responseHeaders);
                localCacheEntity.setLocalExpire(HeaderUtil.getLocalExpires(responseHeaders));
                localCacheEntity.setData(responseBody);
            }
        }
        if (localCacheEntity != null) { 
            // 解析响应头后服务区允许缓存或者已经有缓存，更新数据库缓存数据。
            mCache.replace(request.getCacheKey(), localCacheEntity);
        }
    } else if (cacheMode == CacheMode.REQUEST_NETWORK_FAILED_READ_CACHE
        && localCacheEntity != null) {
        // 如果请求失败，但是缓存模式是请求失败后读缓存，那么读缓存数据。
        exception = null;
        isFromCache = true;
        responseHeaders = localCacheEntity.getResponseHeaders();
        responseBody = localCacheEntity.getData();
    }
    return new ProtocolResult(responseHeaders, responseBody, isFromCache, exception);
}
     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    • 
      
      
      
      
  • 3
    • 
      
      
      
      
  • 4
    • 
      
      
      
      
  • 5
    • 
      
      
      
      
  • 6
    • 
      
      
      
      
  • 7
    • 
      
      
      
      
  • 8
    • 
      
      
      
      
  • 9
    • 
      
      
      
      
  • 10
    • 
      
      
      
      
  • 11
    • 
      
      
      
      
  • 12
    • 
      
      
      
      
  • 13
    • 
      
      
      
      
  • 14
    • 
      
      
      
      
  • 15
    • 
      
      
      
      
  • 16
    • 
      
      
      
      
  • 17
    • 
      
      
      
      
  • 18
    • 
      
      
      
      
  • 19
    • 
      
      
      
      
  • 20
    • 
      
      
      
      
  • 21
    • 
      
      
      
      
  • 22
    • 
      
      
      
      
  • 23
    • 
      
      
      
      
  • 24
    • 
      
      
      
      
  • 25
    • 
      
      
      
      
  • 26
    • 
      
      
      
      
  • 27
    • 
      
      
      
      
  • 28
    • 
      
      
      
      
  • 29
    • 
      
      
      
      
  • 30
    • 
      
      
      
      
  • 31
    • 
      
      
      
      
  • 32
    • 
      
      
      
      
  • 33
    • 
      
      
      
      
  • 34
    • 
      
      
      
      
  • 35
    • 
      
      
      
      
  • 36
    • 
      
      
      
      
  • 37
    • 
      
      
      
      
  • 38
    • 
      
      
      
      
  • 39
    • 
      
      
      
      
  • 40
    • 
      
      
      
      
  • 41
    • 
      
      
      
      
  • 42
    • 
      
      
      
      
  • 43
    • 
      
      
      
      
  • 44
    • 
      
      
      
      
  • 45
    • 
      
      
      
      
  • 46
    • 
      
      
      
      
  • 47
    • 
      
      
      
      
  • 48
    • 
     
     
     
     

     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    • 
      
      
      
      
  • 3
    • 
      
      
      
      
  • 4
    • 
      
      
      
      
  • 5
    • 
      
      
      
      
  • 6
    • 
      
      
      
      
  • 7
    • 
      
      
      
      
  • 8
    • 
      
      
      
      
  • 9
    • 
      
      
      
      
  • 10
    • 
      
      
      
      
  • 11
    • 
      
      
      
      
  • 12
    • 
      
      
      
      
  • 13
    • 
      
      
      
      
  • 14
    • 
      
      
      
      
  • 15
    • 
      
      
      
      
  • 16
    • 
      
      
      
      
  • 17
    • 
      
      
      
      
  • 18
    • 
      
      
      
      
  • 19
    • 
      
      
      
      
  • 20
    • 
      
      
      
      
  • 21
    • 
      
      
      
      
  • 22
    • 
      
      
      
      
  • 23
    • 
      
      
      
      
  • 24
    • 
      
      
      
      
  • 25
    • 
      
      
      
      
  • 26
    • 
      
      
      
      
  • 27
    • 
      
      
      
      
  • 28
    • 
      
      
      
      
  • 29
    • 
      
      
      
      
  • 30
    • 
      
      
      
      
  • 31
    • 
      
      
      
      
  • 32
    • 
      
      
      
      
  • 33
    • 
      
      
      
      
  • 34
    • 
      
      
      
      
  • 35
    • 
      
      
      
      
  • 36
    • 
      
      
      
      
  • 37
    • 
      
      
      
      
  • 38
    • 
      
      
      
      
  • 39
    • 
      
      
      
      
  • 40
    • 
      
      
      
      
  • 41
    • 
      
      
      
      
  • 42
    • 
      
      
      
      
  • 43
    • 
      
      
      
      
  • 44
    • 
      
      
      
      
  • 45
    • 
      
      
      
      
  • 46
    • 
      
      
      
      
  • 47
    • 
      
      
      
      
  • 48
    •

这个类的作用是根据服务器响应码、服务器响应头、本地数据等处理和缓存相关的逻辑，大家可以认真看下源码和逻辑。主要做的事情是，解析服务器响应码、响应内容，根据标准的http协议来决定是否缓存数据，或者更新上次的缓存数据。

RestProtocol小结

同样的理论上讲IRestProtocol接口应该完全完成网络请求，解析出结果交给IRestParser，但是实际上IRestProtocol的默认实现类RestProtocol把网络请求发送数据等繁琐的操作交给IRestConnection接口去处理了，它只负责处理与Http相关的协议等，这也叫做解耦。

看到这里的读者朋友现在最关心的应该是：Connection connection = iRestConnection.getConnection(request);中IRestConnection接口如何实现网络请求之类的，我们上面也提到了替换NoHttp的网络底层为OkHttp时需要只实现IRestConnection，那么下面我们就对IRestConnection一探究竟。

IRestConnection网络层：如何替换网络层为OkHttp

为什么说替换NoHttp底层库为OkHttp只需要实现一个简单的接口呢？其实细心的朋友已经看到了，我们在创建队列时需要一个IRestConnection：

public static RequestQueue newRequestQueue(int threadPoolSize) {
    // 调用下一个方法：这里传入RestConnection.getInstance()生成IRestConnection单例。
    return newRequestQueue(DiskCacheStore.INSTANCE, RestConnection.getInstance(), threadPoolSize);
}

// 这里需要一个IRestConnection参数。
public static RequestQueue newRequestQueue(Cache cache, IRestConnection connection, int threadPoolSize) {
    return newRequestQueue(RestProtocol.getInstance(cache, connection), threadPoolSize);
}

public static RequestQueue newRequestQueue(IRestProtocol iRestProtocol, int threadPoolSize) {
    return newRequestQueue(RestParser.getInstance(iRestProtocol), threadPoolSize);
}
     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    • 
      
      
      
      
  • 3
    • 
      
      
      
      
  • 4
    • 
      
      
      
      
  • 5
    • 
      
      
      
      
  • 6
    • 
      
      
      
      
  • 7
    • 
      
      
      
      
  • 8
    • 
      
      
      
      
  • 9
    • 
      
      
      
      
  • 10
    • 
      
      
      
      
  • 11
    • 
      
      
      
      
  • 12
    • 
      
      
      
      
  • 13
    • 
     
     
     
     

     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    • 
      
      
      
      
  • 3
    • 
      
      
      
      
  • 4
    • 
      
      
      
      
  • 5
    • 
      
      
      
      
  • 6
    • 
      
      
      
      
  • 7
    • 
      
      
      
      
  • 8
    • 
      
      
      
      
  • 9
    • 
      
      
      
      
  • 10
    • 
      
      
      
      
  • 11
    • 
      
      
      
      
  • 12
    • 
      
      
      
      
  • 13
    •

这里很明了，我们先看IRestConnection的源码：

public interface IRestConnection {

    /**
     * 拿到网络连接的各种属性、头、流。
     */
    Connection getConnection(IBasicRequest iBasicRequest);
}
     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    • 
      
      
      
      
  • 3
    • 
      
      
      
      
  • 4
    • 
      
      
      
      
  • 5
    • 
      
      
      
      
  • 6
    • 
      
      
      
      
  • 7
    • 
     
     
     
     

     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    • 
      
      
      
      
  • 3
    • 
      
      
      
      
  • 4
    • 
      
      
      
      
  • 5
    • 
      
      
      
      
  • 6
    • 
      
      
      
      
  • 7
    •

看到这里，有一个返回参数Connection，我们要想用OkHttp来实现这个方法，必须要看这个类是什么样的：

public interface Connection extends Closeable {
    /**
     * 拿到URL对象。
     */
    URL getURL();

    /**
     * 拿到相应头。
     */
    Headers responseHeaders();

    /**
     * 拿到服务器的输出流。
     */
    InputStream serverStream();

    /**
     * 拿到请求过程中的异常。
     */
    Exception exception();
}
     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    • 
      
      
      
      
  • 3
    • 
      
      
      
      
  • 4
    • 
      
      
      
      
  • 5
    • 
      
      
      
      
  • 6
    • 
      
      
      
      
  • 7
    • 
      
      
      
      
  • 8
    • 
      
      
      
      
  • 9
    • 
      
      
      
      
  • 10
    • 
      
      
      
      
  • 11
    • 
      
      
      
      
  • 12
    • 
      
      
      
      
  • 13
    • 
      
      
      
      
  • 14
    • 
      
      
      
      
  • 15
    • 
      
      
      
      
  • 16
    • 
      
      
      
      
  • 17
    • 
      
      
      
      
  • 18
    • 
      
      
      
      
  • 19
    • 
      
      
      
      
  • 20
    • 
      
      
      
      
  • 21
    • 
     
     
     
     

     
     
     
     
    
      
      
      
      
  • 1
    • 
      
      
      
      
  • 2
    • 
      
      
      
      
  • 3
    • 
      
      
      
      
  • 4
    • 
      
      
      
      
  • 5
    • 
      
      
      
      
  • 6
    • 
      
      
      
      
  • 7
    • 
      
      
      
      
  • 8
    • 
      
      
      
      
  • 9
    • 
      
      
      
      
  • 10
    • 
      
      
      
      
  • 11
    • 
      
      
      
      
  • 12
    • 
      
      
      
      
  • 13
    • 
      
      
      
      
  • 14
    • 
      
      
      
      
  • 15
    • 
      
      
      
      
  • 16
    • 
      
      
      
      
  • 17
    • 
      
      
      
      
  • 18
    • 
      
      
      
      
  • 19
    • 
      
      
      
      
  • 20
    • 
      
      
      
      
  • 21
    •

这个返回参数类是一个接口，也就说明了我们可以自定义这个类，NoHttp本身提供的类我们暂且不管，这里其实我们按照下面四个方法返回值即可：一URL、一个拿服务器的响应头、一个是服务器的输出流，一个是请求过程中是否发生异常。这样就非常好替换OkHttp了，我们底层用OkHttp请求网络，然后同样给IRestConnection返回这个对象，里面把服务器的相应头、输出流、请求过程中的异常塞进去就OK了。

更多细节请看替换NoHttp底层为OkHttp的教程： 
http://blog.csdn.net/yanzhenjie1003/article/details/52439317。

总结

今天我们的请求模块到这里就解析完了，看完文章的同学也许还会有不明白的地方，欢迎大家在博客下方留言。 
还剩下BasicConnection，因为它的能力请求网络、发送数据、上传文件、拿到服务器响应头、拿到服务器响应body、拿到服务器的流等内容较多，我会专门开一篇新的博客专门讲这个类。

  1. RequestQueue是请求队列，在主线程执行，主线程可以添加Request到请求队列中，等待子线程轮训读取Request去执行。

  2. RequestDispatcher是请求分发者，它是一个子线程，作用是轮训请求队列，拿到请求后调用IRestParser执行请求结果，负责发送开始请求、结束请求、把结果发送到主线程等重要任务。

    2.1 RequestQueue、RequestDispatcher可以接受的请求类是Request接口，Request接口继承自IParserRequest接口，Request接口负责记录响应监听器Listener和监听器的what对象。

  3. IRestParser是请求结果解析者，它在子线程中运行，负责把从网络请求回来的ByteArray解析成开发者想要的泛型对象。

    3.1 IRestParser接口带有泛型，可以接受到的请求类是IParserRequest接口，IParserRequest接口继承自IRestPtotocol接口，IParserRequest接口负责具体实现解析成开发者想要的泛型对象，由IRestParser具体调用。

  4. IRestProtocol是协议处理器，它在子线程中运行，负责从网络请求结果，包括Header、Body（ByteArray），并且在请求到结果前后处理缓存协议（其他协议待加）等。

    4.1 IRestProtocol接口可以接受的请求类是IProtocolRequest接口，IProtocolRequest接口继承自IBasicRequest接口，IProtocolRequest接口负责记录客户端自定义Http协议等，例如缓存模式，缓存Key等。

  5. IRestConnection是网络访问接口，它的能力：能力请求网络、发送数据、上传文件、拿到服务器响应头、拿到服务器响应body、拿到服务器的流等，是下载模块和请求模块的通用网络请求模块。

    5.1 IRestConnection接口的请求类是IBasicRequest接口，IBasicRequest接口记录了基础的请求属性、通用的网络设置、参数设置、Cookie、重试机制，下载和请求模块通用。

版权声明：转载必须注明本文转自严振杰的博客: http://blog.csdn.net/yanzhenjie1003

你可能感兴趣的:(Android)

  • android系统selinux中添加新属性property 辉色投像
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
  • 2.2.6 通知类控件 Toast、Menu 常思行
    本文例程下载：WillFlow_Toast、WillFlowMenu一、什么是Toast？Toast也被叫做吐司，是Android系统提供的一种非常好的提醒方式，在程序中可以使用它将一些短小的信息通知给用户，它有如下两个特点：Toast是没有焦点的Toast显示的时间有限过一定的时间就会自动消失所以一般来讲Toast的使用并不会影响我们的正常操作，并且它通常不会占用太大的屏幕空间，有着良好的用户体
  • mac 备份android 手机通讯录导入iphone,iphone如何导出通讯录（轻松教你iPhone备份通讯录的方法）... weixin_39762838 mac备份android手机通讯录导入iphone
    在日新月异的手机更替中，换手机已经成为一个非常稀松平常的事情，但将旧手机上面的通讯录导入到新手机还是让不少小伙伴为难，本篇将给大家详细讲解这方面的知识：“苹果手机通讯录怎么导入到新手机”及“安卓手机通讯录导入到新手机”的方法。一、苹果手机通讯录导入到新手机常用方法(SIM卡导入)在苹果手机主频幕上找到“设置”，单击进入设置菜单，下拉菜单列表，点击“邮件、通讯录、日历”，然后找到“导入SIM卡通讯录
  • android 更改窗口的层次,浮窗开发之窗口层级 Ms.Bu android更改窗口的层次
    最近在项目中遇到了这样的需求：需要在特定的其他应用之上悬浮自己的UI交互(拖动、输入等复杂的UI交互)，和九游的浮窗类似，不过我们的比九游的体验更好，我们越过了很多授权的限制。浮窗效果很多人都知道如何去实现一个简单的浮窗，但是却很少有人去深入的研究背后的流程机制，由于项目中浮窗交互比较复杂，遇到了些坑查看了很多资料，故总结浮窗涉及到的知识点：窗口层级关系(浮窗是如何“浮”的)？浮窗有哪些限制，如何
  • Android应用性能优化 轻口味 Android
    Android手机由于其本身的后台机制和硬件特点，性能上一直被诟病，所以软件开发者对软件本身的性能优化就显得尤为重要；本文将对Android开发过程中性能优化的各个方面做一个回顾与总结。Cache优化ListView缓存：ListView中有一个回收器，Item滑出界面的时候View会回收到这里，需要显示新的Item的时候，就尽量重用回收器里面的View；每次在getView函数中inflate新
  • Android实现监听事件的方法 Amy木婉清
    1.通过内部类实现2.通过匿名内部类实现3.通过事件源所在类实现4.通过外部类实现5.布局文件中onclick属性(针对点击事件)1.通过内部类实现代码:privateButtonmBtnEvent;//oncreate中mBtnEvent.setOnClickListener(newOnClick());//内部类实现监听classOnClickimplementsView.OnClickLis
  • 高级UI<第二十四篇>：Android中用到的矩阵常识 NoBugException
    （1）定义在数学中，矩阵（Matrix）是一个按照长方阵列排列的复数或实数集合。由m×n个数aij排成的m行n列的数表称为m行n列的矩阵，简称m×n矩阵。记作：图片.png这m×n个数称为矩阵A的元素，简称为元，数aij位于矩阵A的第i行第j列，称为矩阵A的(i,j)元，以数aij为(i,j)元的矩阵可记为(aij)或(aij)m×n，m×n矩阵A也记作Amn。元素是实数的矩阵称为实矩阵，元素是复
  • RK3229_Android9.0_Box 4G模块EC200A调试 suifen_ 网络
    0、kernel修改这部分完全可以参考Linux的移植：RK3588EC200A-CN【4G模块】调试_rkec200a-cn-CSDN博客1、修改device/rockchip/rk322xdiff--gita/device.mkb/device.mkindexec6bfaa..e7c32d1100755---a/device.mk+++b/device.mk@@-105,6+105,8@@en
  • kt文件和java文件_Java与Kotlin之间怎样进行互操作 铭空间 kt文件和java文件
    Java与Kotlin之间怎样进行互操作发布时间：2021-02-0210:50:43来源：亿速云阅读：98作者：小新这篇文章主要介绍了Java与Kotlin之间怎样进行互操作，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。前言目前kotlin是谷歌首推的开发Android的语言，但由于历史原因，我们绝大部分项目依旧还是以Java为主
  • Android shell 常用 debug 命令 晨春计 Audiodebugandroidlinux
    目录1、查看版本2、am命令3、pm命令4、dumpsys命令5、sed命令6、log定位查看APK进程号7、log定位使用场景1、查看版本1.1、Android串口终端执行getpropro.build.version.release#获取Android版本uname-a#查看linux内核版本信息uname-r#单独查看内核版本1.2、linux服务器执行lsb_release-a#查看Lin
  • 2024年最全Flutter如何和Native通信-Android视角，Electron开发Android界面 2401_84544531 程序员android面试学习
    总结【Android详细知识点思维脑图（技能树）】其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。虽然Android没有前几年火热了，已经过去了会四大组件就能找到高薪职位的时代了。这只能说明Android中级以下的岗位饱和了，现在高级工程师还是比较缺少的，很多高级职位给的薪
  • 分享一个基于python的电子书数据采集与可视化分析 hadoop电子书数据分析与推荐系统 spark大数据毕设项目（源码、调试、LW、开题、PPT) 计算机源码社 Python项目大数据大数据pythonhadoop计算机毕业设计选题计算机毕业设计源码数据分析spark毕设
    作者：计算机源码社个人简介：本人八年开发经验，擅长Java、Python、PHP、.NET、Node.js、Android、微信小程序、爬虫、大数据、机器学习等，大家有这一块的问题可以一起交流！学习资料、程序开发、技术解答、文档报告如需要源码，可以扫取文章下方二维码联系咨询Java项目微信小程序项目Android项目Python项目PHP项目ASP.NET项目Node.js项目选题推荐项目实战|p
  • android ndk 开发jni调用对象方法，数组参数 wulongkou 开发问题安卓的事ndkandroidstudiojni
    一、JNI和NDK关系JNI是Java语言提供的Java和C/C++相互沟通的机制，Java可以通过JNI调用本地的C/C++代码，本地的C/C++的代码也可以调用java代码。JNI是本地编程接口，Java和C/C++互相通过的接口。Java通过C/C++使用本地的代码的一个关键性原因在于C/C++代码的高效性。NDK是一系列工具的集合。它提供了一系列的工具，帮助开发者快速开发C（或C++）的动
  • Android jni中数组参数的传递方式 lokeyme Andriodandroid开发JNINDKjavac语言
    1、背景今天调试了一下Androidjni关于Java中调用C代码的程序，发现我的数组参数传递方式不对，导致值传递不正确，我的方法是：C代码，入口函数#include#includejintJava_sony_MedicalRecordDemo_MainActivity_decryptionSuccess(JNIEnv*env,jobjectthiz,jintAttr[]){returnAttr[
  • 1-1.Jetpack 之 Navigation 简单编码模板 我命由我12345 Android-Jetpack简化编程javajava-eeandroid-studioandroidstudio安卓androidjetpack
    一、Navigation1、Navigation概述Navigation是Jetpack中的一个重要成员，它主要是结合导航图（NavigationGraph）来控制和简化Fragment之间的导航，即往哪里走，该怎么走2、Navigate引入在模块级build.gradle中引入相关依赖implementation'androidx.navigation:navigation-fragment:2
  • Android JetPack架构——结合记事本Demo一篇打通对Sqlite的增删改查结合常用jetpack架构应用 erhtre 程序员androidjetpack架构sqlite
    为什么要用Jetpack?========================================================================关于为什么要用Jetpack，我参考了许多的博客和官方文档，开阔了我对Android生态圈的理解和认识，在Jetpack推出前出现的许许多多强大的第三方框架与语言，典型代表无疑是强大的RxJava在Jetpack仍然有许多粉丝在一
  • Android干净架构MVI模板使用指南 井美婵Toby
    Android干净架构MVI模板使用指南android-clean-architecture-mvi-boilerplateAforkofourcleanarchitectureboilerplateusingtheModel-View-Intentpattern项目地址:https://gitcode.com/gh_mirrors/an/android-clean-architecture-mv
  • ⭐Unity 安卓环境中正确地读取和处理 XML 文件 惊鸿醉 Unityunityandroidxml
    写了一个选择题Demo，电脑包和编辑器内无问题，但是打包安卓手机之后题目无法正常使用，想到的是安卓环境中正确地读取文件的问题改进方案：1.由于XmlDocument.Load方法在Android上的路径问题（由于文件位于APK内部，无法像在文件系统中那样直接访问），需要先使用UnityWebRequest来异步加载文件内容，然后再解析XML。2.异步处理：修改你的代码，以支持异步文件加载和处理，这
  • 《Android进阶之光》读书笔记 soleil雪寂 读书笔记#Android进阶之光
    文章目录第1章Android新特性1.1.Android5.0新特性1.2.RecyclerView1.1.4.3种Notification1.1.5.Toolbar与Palette1.1.6.Palette1.2.Android6.0新特性1.2.2.运行时权限机制1.3.Android7.0新特性第2章MaterialDesign2.2.DesignSupportLibrary常用控件详解第3
  • 《Android进阶之光》— Android 书籍 王睿丶 Android永无止境《Android进阶之光》Android书籍Androidphoenix移动开发
    文章目录第1章Android新特性1第2章MaterialDesign48第3章View体系与自定义View87第4章多线程编程165第5章网络编程与网络框架204第6章设计模式271第7章事件总线308第8章函数响应式编程333第9章注解与依赖注入框架382第10章应用架构设计422第11章系统架构与MediaPlayer框架460出版年:2017-7简介：《Android进阶之光》是一本And
  • 《android进阶之光》——多线程编程（上） TAING要一直努力 读书笔记
    今天了解了下多线程编程，知识点如下：进程与线程：进程是什么？线程是什么？进程可以看作是程序的实体，是线程的容器，是受操作系统管理的基本运行单元，例如exe文件就是一个进程。线程是进程运行的一些子任务，是操作系统调度的最小单元，各线程拥有自己的计数器，堆栈，局部变量等，也可以访问线程间共享的内存。线程的状态有哪些？新创建，可运行，等待，超时等待，阻塞，终止怎么创建一个线程？-三种方法第一种，MyTr
  • android进阶之光！Android面试必备的集合源码详解，系列篇 程序员Sunbu 程序员Android
    前言面试：如果不准备充分的面试，完全是浪费时间，更是对自己的不负责。文末会给大家分享下我整理的Android面试专题及答案其中大部分都是大企业面试常问的面试题，可以对照这查漏补缺，当然了，这里所列的肯定不可能覆盖全部方式，不过对大家找工作肯定是有帮助！本月飞机到达上海，到今天第6天了，四家大公司华为，小米，映客，抖音，还有二家中小型公司。有几家已经面了几轮，下周还要面，挂了几家，不过目前已经选择了
  • Android-悬浮窗功能的实现（附Java、KT实现源码）(1) egrhef 程序员androidjava开发语言
    //获取服务的操作对象valbinder=serviceasFloatWinfowServices.MyBinderbinder.service}overridefunonServiceDisconnected(name:ComponentName){}}overridefunonActivityResult(requestCode:Int,resultCode:Int,data:Intent){
  • Visual Studio中的Android模拟器使用详解 wurui8 androidandroidstudioandroidandroid应用
    关注微信号：javalearns随时随地学Java或扫一扫随时随地学JavaMicrosoft本周发布了VisualStudio2015预览版,里面包含Android开发工具.安装的时候,如果选Android开发,VisualStudio会把调试Android应用程序用的VisualStudio模拟器也装上.在介绍这个新模拟器之前,我们先来聊一聊,为什么需要一个新的Android模拟器–当然,你也
  • Unity 热更 之 【HybirdCLR】+【YooAsset】 [安卓 Android端] [代码 + 资源热更] 功能的 简单实现演示 仙魁XAN Unity进阶unityHybirdCLRYooAssetHotUpdate热更新
    Unity热更之【HybirdCLR】+【YooAsset】[安卓Android端][代码+资源热更]功能的简单实现演示目录Unity热更之【HybirdCLR】+【YooAsset】[安卓Android端][代码+资源热更]功能的简单实现演示一、简单介绍二、HybridCLR三、YooAsset四、HybirdCLR引入工程五、YooAsset引入工程六、Python服务器简单构建七、Hybir
  • Android 用线程池实现一个简单的任务队列(Kotlin) 深海呐 Android#Android进阶#Kotlinandroidkotlin线程池延时任务队列线程池延时任务
    关于线程池,Kotlin和java的使用方式一样在Android中,很多人喜欢用Handler的postDelayed()去实现延时任务.要使用postDelayed(),去实现延时任务队列,就不可避免要使用递归.但是这样做,代码的简洁性,和书写的简易,就远不如使用线程池.使用线程池的简单程度:privatevalmThreadPool=Executors.newSingleThreadSched
  • （小白入门）Windows环境下搭建React Native Android开发环境 码农老黑 前端ReactNative移动开发Androidstudio
    ReactNative(简称RN)是Facebook于2015年4月开源的跨平台移动应用开发框架，是Facebook早先开源的UI框架React在原生移动应用平台的衍生产物，目前支持iOS和Android两大平台。RN的环境搭建在RN的中文社区有所介绍，但是对于小白来说还是有些太过简略了。RN中文社区详见参考，本文不涉及的问题也许在其中能够有所解答。ReactNative思想底层引擎是JavaSc
  • Android Dialog圆角设置无效的问题 ly969434341 android
    一，参考AndroidDialog圆角设置无效的问题https://blog.csdn.net/woshi_awei/article/details/99664527Android自定义Dialog实现通用圆角对话框https://cloud.tencent.com/developer/article/1740956二，原因Diallog的默认背景是白色（直角背景），我自定义的Dialog背景也是
  • MultiSnapRecyclerView：让Android RecyclerView的滚动停靠更灵活 技术无疆 Androidandroiduiandroidstudioandroid-studiojavaandroidx
    在Android应用开发中，RecyclerView是一个强大且灵活的组件，用于展示大量数据集合。然而，标准的RecyclerView只支持单一的滚动停靠点，这在某些场景下可能不够灵活。为了解决这个问题，TakuSemba开发了一个名为MultiSnapRecyclerView的库，它允许开发者在RecyclerView中实现多个滚动停靠点。文章目录什么是MultiSnapRecyclerView
  • Android界面特效全汇总 小飞鹤 Android开发详解android
    （一）Activity页面切换的效果Android2.0之后有了overridePendingTransition（），其中里面两个参数，一个是前一个activity的退出两一个activity的进入，Java代码1.@OverridepublicvoidonCreate(BundlesavedInstanceState){2.super.onCreate(savedInstanceState);
  • 如何用ruby来写hadoop的mapreduce并生成jar包 wudixiaotie mapreduce
    ruby来写hadoop的mapreduce，我用的方法是rubydoop。怎么配置环境呢： 1.安装rvm：     不说了 网上有 2.安装ruby：     由于我以前是做ruby的，所以习惯性的先安装了ruby，起码调试起来比jruby快多了。 3.安装jruby：     rvm install jruby然后等待安
  • java编程思想 -- 访问控制权限 百合不是茶 java访问控制权限单例模式
    访问权限是java中一个比较中要的知识点,它规定者什么方法可以访问,什么不可以访问   一:包访问权限;   自定义包: package com.wj.control; //包 public class Demo { //定义一个无参的方法 public void DemoPackage(){ System.out.println("调用
  • [生物与医学]请审慎食用小龙虾 comsci 生物
         现在的餐馆里面出售的小龙虾,有一些是在野外捕捉的,这些小龙虾身体里面可能带有某些病毒和细菌,人食用以后可能会导致一些疾病,严重的甚至会死亡.....      所以,参加聚餐的时候,最好不要点小龙虾...就吃养殖的猪肉,牛肉,羊肉和鱼,等动物蛋白质     
  • org.apache.jasper.JasperException: Unable to compile class for JSP: 商人shang maven2.2jdk1.8
    环境： jdk1.8    maven  tomcat7-maven-plugin  2.0 原因： tomcat7-maven-plugin  2.0 不知吃 jdk 1.8，换成 tomcat7-maven-plugin  2.2就行，即     <plugin>
  • 你的垃圾你处理掉了吗?GC oloz GC
    前序:本人菜鸟，此文研究学习来自网络，各位牛牛多指教　 1.垃圾收集算法的核心思想 　　Java语言建立了垃圾收集机制，用以跟踪正在使用的对象和发现并回收不再使用(引用)的对象。该机制可以有效防范动态内存分配中可能发生的两个危险：因内存垃圾过多而引发的内存耗尽，以及不恰当的内存释放所造成的内存非法引用。 　　垃圾收集算法的核心思想是：对虚拟机可用内存空间，即堆空间中的对象进行识别
  • shiro 和 SESSSION 杨白白 shiro
    shiro 在web项目里默认使用的是web容器提供的session，也就是说shiro使用的session是web容器产生的，并不是自己产生的，在用于非web环境时可用其他来源代替。在web工程启动的时候它就和容器绑定在了一起，这是通过web.xml里面的shiroFilter实现的。通过session.getSession()方法会在浏览器cokkice产生JESSIONID，当关闭浏览器，此
  • 移动互联网终端 淘宝客如何实现盈利 小桔子 移動客戶端淘客淘寶App
           2012年淘宝联盟平台为站长和淘宝客带来的分成收入突破30亿元，同比增长100%。而来自移动端的分成达1亿元，其中美丽说、蘑菇街、果库、口袋购物等App运营商分成近5000万元。 可以看出，虽然目前阶段PC端对于淘客而言仍旧是盈利的大头，但移动端已经呈现出爆发之势。而且这个势头将随着智能终端(手机，平板)的加速普及而更加迅猛
  • wordpress小工具制作 aichenglong wordpress小工具
    wordpress 使用侧边栏的小工具，很方便调整页面结构 小工具的制作过程 1 在自己的主题文件中新建一个文件夹(如widget)，在文件夹中创建一个php(AWP_posts-category.php) 小工具是一个类,想侧边栏一样，还得使用代码注册，他才可以再后台使用，基本的代码一层不变 <?php class AWP_Post_Category extends WP_Wi
  • JS微信分享 AILIKES js
    // 所有功能必须包含在 WeixinApi.ready 中进行    WeixinApi.ready(function(Api) {        // 微信分享的数据            var wxData = {       &nb
  • 封装探讨 百合不是茶 JAVA面向对象 封装
    //封装   属性 方法 将某些东西包装在一起，通过创建对象或使用静态的方法来调用，称为封装；封装其实就是有选择性地公开或隐藏某些信息，它解决了数据的安全性问题，增加代码的可读性和可维护性   在 Aname类中申明三个属性，将其封装在一个类中：通过对象来调用   例如   1： //属性 将其设为私有 姓名 name 可以公开
  • jquery radio/checkbox change事件不能触发的问题 bijian1013 JavaScriptjquery
    我想让radio来控制当前我选择的是机动车还是特种车，如下所示：  <html> <head> <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js" type="text/javascript"><
  • AngularJS中安全性措施 bijian1013 JavaScriptAngularJS安全性XSRFJSON漏洞
            在使用web应用中，安全性是应该首要考虑的一个问题。AngularJS提供了一些辅助机制，用来防护来自两个常见攻击方向的网络攻击。 一.JSON漏洞         当使用一个GET请求获取JSON数组信息的时候（尤其是当这一信息非常敏感，
  • [Maven学习笔记九]Maven发布web项目 bit1129 maven
    基于Maven的web项目的标准项目结构 user-project     user-core     user-service     user-web        src      
  • 【Hive七】Hive用户自定义聚合函数(UDAF) bit1129 hive
    用户自定义聚合函数，用户提供的多个入参通过聚合计算(求和、求最大值、求最小值)得到一个聚合计算结果的函数。 问题：UDF也可以提供输入多个参数然后输出一个结果的运算，比如加法运算add(3，5)，add这个UDF需要实现UDF的evaluate方法,那么UDF和UDAF的实质分别究竟是什么？   Double evaluate(Double a, Double b)  
  • 通过 nginx-lua 给 Nginx 增加 OAuth 支持 ronin47
    前言：我们使用Nginx的Lua中间件建立了OAuth2认证和授权层。如果你也有此打算，阅读下面的文档，实现自动化并获得收益。SeatGeek 在过去几年中取得了发展，我们已经积累了不少针对各种任务的不同管理接口。我们通常为新的展示需求创建新模块，比如我们自己的博客、图表等。我们还定期开发内部工具来处理诸如部署、可视化操作及事件处理等事务。在处理这些事务中，我们使用了几个不同的接口来认证： &n
  • 利用tomcat-redis-session-manager做session同步时自定义类对象属性保存不上的解决方法 bsr1983 session
    在利用tomcat-redis-session-manager做session同步时，遇到了在session保存一个自定义对象时，修改该对象中的某个属性，session未进行序列化，属性没有被存储到redis中。 在 tomcat-redis-session-manager的github上有如下说明： Session Change Tracking As noted in the &qu
  • 《代码大全》表驱动法-Table Driven Approach-1 bylijinnan java算法
    关于Table Driven Approach的一篇非常好的文章： http://www.codeproject.com/Articles/42732/Table-driven-Approach package com.ljn.base; import java.util.Random; public class TableDriven { public
  • Sybase封锁原理 chicony Sybase
           昨天在操作Sybase IQ12.7时意外操作造成了数据库表锁定，不能删除被锁定表数据也不能往其中写入数据。由于着急往该表抽入数据，因此立马着手解决该表的解锁问题。     无奈此前没有接触过Sybase IQ12.7这套数据库产品，加之当时已属于下班时间无法求助于支持人员支持，因此只有借助搜索引擎强大的
  • java异常处理机制 CrazyMizzz java
    java异常关键字有以下几个，分别为 try catch final throw throws 他们的定义分别为 try：    Opening exception-handling statement. catch：  Captures the exception. finally： Runs its code before terminating
  • hive 数据插入DML语法汇总 daizj hiveDML数据插入
    Hive的数据插入DML语法汇总1、Loading files into tables语法：1) LOAD DATA [LOCAL] INPATH 'filepath' [OVERWRITE] INTO TABLE tablename [PARTITION (partcol1=val1, partcol2=val2 ...)]解释：1)、上面命令执行环境为hive客户端环境下： hive>l
  • 工厂设计模式 dcj3sjt126com 设计模式
      使用设计模式是促进最佳实践和良好设计的好办法。设计模式可以提供针对常见的编程问题的灵活的解决方案。 工厂模式 工厂模式（Factory）允许你在代码执行时实例化对象。它之所以被称为工厂模式是因为它负责“生产”对象。工厂方法的参数是你要生成的对象对应的类名称。 Example #1 调用工厂方法（带参数） <?phpclass Example{ 
  • mysql字符串查找函数 dcj3sjt126com mysql
      FIND_IN_SET(str,strlist) 假如字符串str 在由N 子链组成的字符串列表strlist 中，则返回值的范围在1到 N 之间。一个字符串列表就是一个由一些被‘,’符号分开的自链组成的字符串。如果第一个参数是一个常数字符串，而第二个是type SET列，则   FIND_IN_SET() 函数被优化，使用比特计算。如果str不在strlist 或st
  • jvm内存管理 easterfly jvm
    一、JVM堆内存的划分 分为年轻代和年老代。年轻代又分为三部分：一个eden,两个survivor。 工作过程是这样的：e区空间满了后，执行minor gc，存活下来的对象放入s0, 对s0仍会进行minor gc，存活下来的的对象放入s1中，对s1同样执行minor gc，依旧存活的对象就放入年老代中； 年老代满了之后会执行major gc，这个是stop the word模式，执行
  • CentOS-6.3安装配置JDK-8 gengzg centos
    JAVA_HOME=/usr/java/jdk1.8.0_45 JRE_HOME=/usr/java/jdk1.8.0_45/jre PATH=$PATH:$JAVA_HOME/bin:$JRE_HOME/bin CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_HOME/lib export JAVA_HOME
  • 【转】关于web路径的获取方法 huangyc1210 Web路径
    假定你的web application 名称为news,你在浏览器中输入请求路径：  http://localhost:8080/news/main/list.jsp  则执行下面向行代码后打印出如下结果：  1、 System.out.println(request.getContextPath()); //可返回站点的根路径。也就是项
  • php里获取第一个中文首字母并排序 远去的渡口 数据结构PHP
    很久没来更新博客了，还是觉得工作需要多总结的好。今天来更新一个自己认为比较有成就的问题吧。 最近在做储值结算，需求里结算首页需要按门店的首字母A-Z排序。我的数据结构原本是这样的： Array ( [0] => Array ( [sid] => 2885842 [recetcstoredpay] =&g
  • java内部类 hm4123660 java内部类匿名内部类成员内部类方法内部类
         　在Java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号。内部类可以间接解决多继承问题,可以使用内部类继承一个类，外部类继承一个类，实现多继承。      &nb
  • Caused by: java.lang.IncompatibleClassChangeError: class org.hibernate.cfg.Exten zhb8015
    maven pom.xml关于hibernate的配置和异常信息如下，查了好多资料，问题还是没有解决。只知道是包冲突，就是不知道是哪个包....遇到这个问题的分享下是怎么解决的。。   maven pom:   <dependency> <groupId>org.hibernate</groupId> <ar
  • Spark 性能相关参数配置详解－任务调度篇 Stark_Summer sparkcachecpu任务调度yarn
    随着Spark的逐渐成熟完善, 越来越多的可配置参数被添加到Spark中来, 本文试图通过阐述这其中部分参数的工作原理和配置思路, 和大家一起探讨一下如何根据实际场合对Spark进行配置优化。   由于篇幅较长，所以在这里分篇组织，如果要看最新完整的网页版内容，可以戳这里：http://spark-config.readthedocs.org/，主要是便
  • css3滤镜 wangkeheng htmlcss
    经常看到一些网站的底部有一些灰色的图标，鼠标移入的时候会变亮，开始以为是js操作src或者bg呢，搜索了一下，发现了一个更好的方法：通过css3的滤镜方法。 html代码： <a href='' class='icon'><img src='utv.jpg' /></a> css代码： .icon{-webkit-filter: graysc
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他