NoHttp源码 初解析 ~

原创 2016年08月29日 15:05:20

用了那么久的NoHttp这么强大的网络库,但是对里面的源码都是一知半解,只会去怎么去使用,但不了解这个流程是怎样的,俗话说的好,“授人以鱼 不如授如以渔”~单单就会使用,怎么能称的上是合格的程序猿,向着大神看起,学习他们的思想设计~
本人还是名小白,本文还有欠缺考虑的地方请见谅
如果不知道NoHttp的话,
请看严振杰的博客 http://blog.csdn.net/yanzhenjie1003
请看NoHttp github 链接:https://github.com/yanzhenjie/NoHttp

———————我是一条分割线———————–
先看下作者说的源码核心流程是怎样的
这是异步请求 也是大部分应用都是调用这个 版本号1.0.0
异步请求
异步
那我们就遵循上面流程 一步步看 作者是如何做到的
NoHttp.init(application) 这个初始化 就不用说了 传入上下文 和设置 默认的 CookieManger
当面我们每次构建 request对象 需要 传入到 RequestQueue 请求的线程池中,建议这里写成单例~

  public static RequestQueue newRequestQueue(Cache<CacheEntity> cache, int threadPoolSize) {
        return newRequestQueue(HttpRestConnection.getInstance(cache), threadPoolSize);
    }
     public static RequestQueue newRequestQueue(ImplRestConnection implRestConnection, int threadPoolSize) {
        return newRequestQueue(HttpRestParser.getInstance(implRestConnection), threadPoolSize);
    }
     public static RequestQueue newRequestQueue(ImplRestParser implRestParser, int threadPoolSize) {
        RequestQueue requestQueue = new RequestQueue(implRestParser, threadPoolSize);
        requestQueue.start();
        return requestQueue;
    }

上面一步步的单例的形式 都是为了 后面做铺垫的,下文 有解析~
这里构造的方法最终都是到达 newRequestQueue(ImplRestParser implRestParser, int threadPoolSize)
开启 线程池 requestQueue.start();

public void start() {
        stop();
        for (int i = 0; i < mDispatchers.length; i++) {
            RequestDispatcher networkDispatcher = new RequestDispatcher(mUnFinishQueue, mRequestQueue, mImplRestParser);
            mDispatchers[i] = networkDispatcher;
            networkDispatcher.start();
        }
    }

这里就是创建一个 RequestDispatcher 子线程 去轮训这个线程池,mImplRestParser这个 相应解析者同时子线程里,作者说这里面是真正的请求网络的线程咯。
那我们就仔细深入看看着个类里 是怎么做到的

public class RequestDispatcher extends Thread


@Override
    public void run() {
        Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
        while (!mQuit) {
            final Request<?> request;
            try {
                request = mRequestQueue.take();
            } catch (InterruptedException e) {
                if (!mQuit)
                    return;
                continue;
            }

            if (request.isCanceled()) {
                Logger.d(request.url() + " is canceled.");
                continue;
            }

            final int what = request.what();
            final OnResponseListener<?> responseListener = request.responseListener();

            request.start();
            // start
            final ThreadPoster startThread = new ThreadPoster(what, responseListener);
            startThread.onStart();
            PosterHandler.getInstance().post(startThread);

            // request
            Response<?> response = mImplRestParser.parserRequest(request);

            // remove it from queue
            mUnFinishQueue.remove(request);

            // finish
            final ThreadPoster finishThread = new ThreadPoster(what, responseListener);
            finishThread.onFinished();
            PosterHandler.getInstance().post(finishThread);
            request.finish();

            // response
            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);
            }
        }
    }

RequestDispatcher 其实就是一个线程,不断的从RequestQueue请求队列中take(),如果为空 也不阻塞主线程 因为这是在子线程里操作的~并且 未请求的消息 如果被取消 也会同时取消掉,不会发起请求的~
这个responseListener接口 回调里记录发起请求 开始 结束等状态,最后在未完成的线程池中 移除请求
mUnFinishQueue.remove(request);最终handler发送回主线程上 返回服务器请求结果。

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

IRestParser这个响应解析类是 很关键 还没到达网络请求 连接的部分,这个只是个接口,它的实现类 按Ctrl+T可以看到它的实现类,RestParser这个类是它的实现类,通过之前的构造获取到IRestParser的实例

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

这里可以理解为Nohttp的同步请求开始

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

同样类似IRestParser,IRestProtocol也只是一个接口,它的实现类是RestProtocol这个类,这里会根据Nohttp的缓存模式 来进行请求,具体还是看下demo.
这个类中 RestProtocol的
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);
}

Connection 这个接口类就实现了

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

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

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

    /**
     * 拿到请求过程中的异常。
     */
    Exception exception();
}

只要实现上述的方法 就可以替换成底层的类,Okhtttp也可以和Nohttp 具体看详细链接吧~
传送门在此 http://blog.csdn.net/yanzhenjie1003/article/details/52413226

在其中 HttpRestParser 和 HttpRestConnection 这里 应该是请求的过程核心之一,根据request 的缓存模式来进行网络请求,可以看得出来 底层是HttpURLConnection 和 OKHttp一样

 protected Connection getConnection(BasicServerRequest request) {
        Logger.d("--------------Request start--------------");
        Headers responseHeaders = new HttpHeaders();
        InputStream inputStream = null;
        Exception exception = null;
        HttpURLConnection urlConnection = null;
        String url = request.url();
        try {
            if (!NetUtil.isNetworkAvailable())
                throw new NetworkError("The network is not available, please check the network. The requested url is: " + url);

            // MalformedURLException, IOException, ProtocolException, UnknownHostException, SocketTimeoutException
            urlConnection = createHttpURLConnection(request);
            Logger.d("-------Response start-------");
            int responseCode = urlConnection.getResponseCode();
            responseHeaders = parseResponseHeaders(new URI(request.url()), responseCode, urlConnection.getResponseMessage(), urlConnection.getHeaderFields());

            // handle body
            if (responseCode == 301 || responseCode == 302 || responseCode == 303 || responseCode == 307) {
                Connection redirectConnectiont = handleRedirect(request, responseHeaders);
                responseHeaders = redirectConnectiont.responseHeaders();
                inputStream = redirectConnectiont.serverStream();
                exception = redirectConnectiont.exception();
            } else if (hasResponseBody(request.getRequestMethod(), responseCode)) {
                inputStream = getServerStream(responseCode, responseHeaders.getContentEncoding(), urlConnection);
            }
            Logger.d("-------Response end-------");
        } catch (MalformedURLException e) {
            exception = new URLError("The url is malformed: " + url + ".");
        } catch (UnknownHostException e) {
            exception = new UnKnownHostError("Hostname can not be resolved: " + url + ".");
        } catch (SocketTimeoutException e) {
            exception = new TimeoutError("Request time out: " + url + ".");
        } catch (Exception e) {
            exception = e;
        } finally {
            if (exception != null)
                Logger.e(exception);
        }
        Logger.d("--------------Request finish--------------");
        return new Connection(urlConnection, responseHeaders, inputStream, exception);
    }

看了一圈下来 最主要看到那个几个核心处理的类,要好好理解 为啥 这样分层次,如何解耦~ 我要好好膜拜作者去了~~~吃瓜群众路过~

版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

noHttp 简单实用

框架特性 比Retrofit使用更简单、更易用。 动态配置底层框架为OkHttp、HttpURLConnection与RxJava完美结合,支持异步请求、支持同步请求多文件上传,支持大文件...

Android网络请求框架NoHttp简介

转载请注明本文转自严振杰的博客: http://blog.csdn.net/yanzhenjie1003 目录(?)[+] NoHttp QQ技术交流1群...

Nohttp源码

  • 2016年07月21日 18:46
  • 12.25MB
  • 下载

Android NoHttp源码阅读指导

现在市场的Http框架很多,比如我们熟知的NoHttp、Retrofit、Volley、android-async-http等上层框架,HttpURLConnection、OkHttp、HttpCli...

NoHttp深度定制自定义请求

  • 2016年03月10日 13:33
  • 5KB
  • 下载

NoHttp的封装

零丶关于Nohttp的基本使用请见 大神严振杰的博客: http://blog.csdn.net/yanzhenjie1003 废话不多说,直接进入程序 代码结构 实现效果 ...

nohttp的使用 ecplise版

  • 2016年04月23日 18:53
  • 14.29MB
  • 下载

NoHttp深度自定义请求

  • 2016年03月13日 17:09
  • 753KB
  • 下载

NoHttp请求的使用

官方文档:http://doc.nohttp.net/222880   跟着官网集成了下nohttp 1.初始化 定义自己的Applicastion NoHttp.Config config...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:NoHttp源码 初解析 ~
举报原因:
原因补充:

(最多只允许输入30个字)