内容字号:默认大号超大号

段落设置:段首缩进取消段首缩进

字体设置:切换到微软雅黑切换到宋体

详解tencentSonic框架

2017-08-11 16:26 出处:清屏网 人气: 评论(0

这是Soinc 项目的地址 https://github.com/Tencent/VasSonic

这个框架做的事情是加速网页的加载速度

传统的WebView加载方式是WebView 初始化后, 然后去请求数据,是串行的操作由于初始化需要时间。所以这里做的事情是让WebView 初始化和请求 数据 并行处理,同时与服务器配合 做好缓存的处理,这里的缓存 分为全部缓存,局部缓存(数据,模板)。获取网络的方式 使用Http(s) 来请求数据 然后通过loadDataWithBaseURL,加载本地download下来的文件,或者是通过loadUrl 但是拦截其资源请求,使用桥节流(InputStream 读取)然后在拦截其资源后返回

android 的传统加载过程

enter image description here

这里是Sonic的流程

enter image description here

直接上图

这里写图片描述

基本的类结构

  • SonicSession::包括缓存数据的获取,服务器回包数据的处理,其中QuickSonicSession 和StandardSonicSession作为其两个子类
  • SonicUtils:作为其数据的重组
  • SonicSessionConnection:作为底层请求数据
  • SonicSessionStream:是Sonic的数据流,是个InputStream
  • SonciSessionClient:是Sonic与WevView的交互,loadUrl 这些
  • 。。。。

这里是 SonicSession 这个处理数据缓存对象的时候为重写的方法

//当本地有缓存的时候做的事情
 protected void handleLocalHtml(String localHtml) {

    }
//当服务器检查本地缓存是最新的时候不需要请求,这个304服务器响应码回复的
    protected void handleFlow_304() {

    }
    //第一次加载
    protected void handleFlow_FirstLoad() {

    }
    //数据更新
   protected void handleFlow_DataUpdate() {

    }
    //模板更新
    protected void handleFlow_TemplateChange() {

    }
对于QuickSonicSession来说,让WebView 调用的方式为webView.loadDataWithBaseURL(baseUrl, data, mimeType, encoding, historyUrl); 这里是加载本地文件
对于StandardSonicSession来说,让WebView 调用的方式为webView.loadUrl(url);这里是资源文件,但是拦截了资源文件,通过InputStream 来给WEbView 去渲染

两者去区别

  • QuickSonicSession这种方式加载速度比较快,但是由于不能带header(例如csp等),可能会有一些安全问题。
  • 是通过loadUrl,并且在资源拦截的时候返回数据。这种类型相比于QuickSonicSession速度上可能会慢一些(因为资源拦截需要内核底层派发,再到终端进行拦截)。但是这种方式支持在数据返回的时候添加header,所以不存在安全问题

对于SonicSession这个类 ,是多线程的所以采用原子操作

//当前的状态是否开始请求,请求数据中等
    protected final AtomicInteger sessionState = new AtomicInteger(STATE_NONE);

    //当前资源是否开始被拦截
    protected final AtomicBoolean wasInterceptInvoked = new AtomicBoolean(false);
    
    //是否webview加载网页ok
    protected final AtomicBoolean wasOnPageFinishInvoked = new AtomicBoolean(false);

首先

此处创建了一个SonicSession 同时一块开了一个线程在做请求数据的处理
 sonicSession = SonicEngine.getInstance().createSession(url, sessionConfigBuilder.build());
最终调用 
start()
//开个线程跑
runSonicFlow();


   private void runSonicFlow() {
          isWaitingForSessionThread.set(true);

        if (STATE_RUNNING != sessionState.get()) {
            return;
        }
         //查看本地有无缓冲(读取本地文件)
        String htmlString = SonicCacheInterceptor.getSonicCacheData(this);

        boolean hasHtmlCache = !TextUtils.isEmpty(htmlString);
        //加载缓存 如果存在缓存StandardSonicSession 做的是准备好InputStream 就是读取(String) 这里做的发送给handler CLIENT_CORE_MSG_PRE_LOAD看下面代码
        handleLocalHtml(htmlString);

  
        if (!runtime.isNetworkValid()) {
          
        } else {
            //对于本地是否存在完成后已经处理好,此时进行网络连接
            handleFlow_Connection(htmlString);
        }

        // Update session state
        switchState(STATE_RUNNING, STATE_READY, true);

        isWaitingForSessionThread.set(false);

    }
对于QuickSonicSession 做的逻辑是判断本地有无缓存, 有直接加载 没有直接loadurl
  protected void handleLocalHtml(String localHtml) {
        Message msg = mainHandler.obtainMessage(CLIENT_CORE_MSG_PRE_LOAD);
        if (!TextUtils.isEmpty(localHtml)) {
            msg.arg1 = PRE_LOAD_WITH_CACHE;
            msg.obj = localHtml;
        } else {
                    msg.arg1 = PRE_LOAD_NO_CACHE;
        }
        mainHandler.sendMessage(msg);
    }

 private void handleClientCoreMessage_PreLoad(Message msg) {
        switch (msg.arg1) {
            case PRE_LOAD_NO_CACHE: {
                   //是否第一次调用loadUrl
                if (wasLoadUrlInvoked.compareAndSet(false, true)) {
                  //直接加载网页但是另一个线程已经在获取数据 然后拦截资源后返回inputSteam
                    sessionClient.loadUrl(srcUrl, null);
                }
            }
            break;
            case PRE_LOAD_WITH_CACHE: {
                 //是否第一次调用loadDataWithBaseUrlAndHeader
                if (wasLoadDataInvoked.compareAndSet(false, true)) {
                    String html = (String) msg.obj;
                    sessionClient.loadDataWithBaseUrlAndHeader(currUrl, html, "text/html", "utf-8", currUrl, getHeaders());
                } 
            }
            break;
        }
    }

/////////////////////////////////////////////////////////////
对于StandardSonicSession  来说存在直接准备好流修改状态 
 @Override
    protected void handleLocalHtml(String localHtml) {
        if (!TextUtils.isEmpty(localHtml)) {
            synchronized (webResponseLock) {
                pendingWebResourceStream = new ByteArrayInputStream(localHtml.getBytes());
            }
            //修改当前状态
            switchState(STATE_RUNNING, STATE_READY, true);
        }
    }

WebView 的回调方法

webView.setWebViewClient(new WebViewClient() {
            @Override
            public void onPageFinished(WebView view, String url) {
                super.onPageFinished(view, url);
                if (sonicSession != null) {
                    sonicSession.getSessionClient().pageFinish(url);
                }
            }

            @TargetApi(21)
            @Override
            public WebResourceResponse shouldInterceptRequest(WebView view, WebResourceRequest request) {
                return shouldInterceptRequest(view, request.getUrl().toString());
            }

            @Override
            public WebResourceResponse shouldInterceptRequest(WebView view, String url) {
               //请求资源拦截,返回本地请求的inputSteam
                if (sonicSession != null) {
                    return (WebResourceResponse) sonicSession.getSessionClient().requestResource(url);
                }
                return null;
            }
        });
//此时进行连接
protected void handleFlow_Connection(String htmlString) {
        ....
        intent.putExtra(SonicSessionConnection.DNS_PREFETCH_ADDRESS, hostDirectAddress);
        //此处默认的实现类是SessionConnectionDefaultImpl ,可以自定义设置案例中提供了OfflinePkgSessionConnection 用来读取本地文件
        sessionConnection = SonicSessionConnectionInterceptor.getSonicSessionConnection(this, intent);

        //获取响应码
        int responseCode = sessionConnection.connect();
        if (SonicConstants.ERROR_CODE_SUCCESS == responseCode) {
            //成功设置一些cookie 连接时间等
        }
        if (isDestroyedOrWaitingForDestroy()) {
            return;
        }

        //此处是服务器返回304 采用全部缓存,QuickSonicSession和StandardSonicSession   是直接发送给js状态码304 不需要做操作
        if (HttpURLConnection.HTTP_NOT_MODIFIED == responseCode) {
            handleFlow_304();
            return;
        }

        if (HttpURLConnection.HTTP_OK != responseCode) {
           //失败操作
            return;
        }
         
      
        .....
          
        if (TextUtils.isEmpty(htmlString)) {
            //这是本地无缓存走的逻辑
            handleFlow_FirstLoad(); 
        } else {
         //模板文件是否改变
            String templateChange = sessionConnection.getResponseHeaderField(SonicSessionConnection.CUSTOM_HEAD_FILED_TEMPLATE_CHANGE);
            if (!TextUtils.isEmpty(templateChange)) {
                if ("false".equals(templateChange) || "0".equals(templateChange)) {
                   //数据更新
                    handleFlow_DataUpdate(); // data update
                } else {
                   //模板更新
                    handleFlow_TemplateChange(); // template change
                }
            } else {
               //模板文件的sha1值
                String templateTag = sessionConnection.getResponseHeaderField(SonicSessionConnection.CUSTOM_HEAD_FILED_TEMPLATE_TAG);
                //检查获取的sha1是否为空同时和本地的sha1比较
                if (!TextUtils.isEmpty(templateTag) && !templateTag.equals(sessionData.templateTag)) {
                    handleFlow_TemplateChange(); //fault tolerance
                } else { 
                   错误 移除...
                }
            }
        }

        saveHeaders(sessionConnection);
    }

这里以QuickSonicSession的部分实现为例

protected void handleFlow_FirstLoad() {
   // 获取服务器返回的数据,wasInterceptInvoked 判断是否发起请求资源如果发起直接发哦会
        SonicSessionConnection.ResponseDataTuple responseDataTuple = sessionConnection.getResponseData(wasInterceptInvoked, null);
        。。。
        pendingWebResourceStream = new SonicSessionStream(this, responseDataTuple.outputStream, responseDataTuple.responseStream);

        String htmlString = null;
        //如果当前读取完成 生成htmlString
        if (responseDataTuple.isComplete) {
            try {
                htmlString = responseDataTuple.outputStream.toString("UTF-8");
            } catch (Throwable e) {
                pendingWebResourceStream = null;
            }
        }

        boolean hasCacheData = !TextUtils.isEmpty(htmlString);

        //  //发送加载消息 如果htmlString 存在调用loadDataWithBaseUrlAndHeader
        mainHandler.removeMessages(CLIENT_CORE_MSG_PRE_LOAD);
        Message msg = mainHandler.obtainMessage(CLIENT_CORE_MSG_FIRST_LOAD);
        msg.obj = htmlString;
        msg.arg1 = hasCacheData ? FIRST_LOAD_WITH_CACHE : FIRST_LOAD_NO_CACHE;
        mainHandler.sendMessage(msg);
      
        String cacheOffline = sessionConnection.getResponseHeaderField(SonicSessionConnection.CUSTOM_HEAD_FILED_CACHE_OFFLINE);
        if (SonicUtils.needSaveData(cacheOffline)) {
            try {
                if (hasCacheData && !wasLoadUrlInvoked.get() && !wasInterceptInvoked.get()) {
                    switchState(STATE_RUNNING, STATE_READY, true);
                    Thread.sleep(1500);
                    //保存到本地 此处会如果是空就不保存,有则会sonic数据的模版分割
                    separateAndSaveCache(htmlString);
                }
            } catch (Throwable e) {
            }
        } 
    }


 //数据更新
 protected void handleFlow_DataUpdate() {
        ByteArrayOutputStream output = sessionConnection.getResponseData();
        if (output != null) {
         //服务器返回 json 是标签和键值对 然后替换
                JSONObject serverRspJson = new JSONObject(serverRsp);
                 final JSONObject serverDataJson = serverRspJson.optJSONObject("data");
                 //这里替换了本地的网页的内容同时返回更新的标签
                JSONObject diffDataJson = SonicUtils.getDiffData(id, serverDataJson);
                。。。。
              //  当前是否已经调用过了loadDataWithBaseUrlAndHeader 如果调用了 直接js给网页,让给他需要更新的json 让js 刷新不需要重新load
                   
                   boolean hasSentDataUpdateMessage = false;
                 if (wasLoadDataInvoked.get()) {
                    if (SonicUtils.shouldLog(Log.INFO)) {
                        SonicUtils.log(TAG, Log.INFO, "handleFlow_DataUpdate:loadData was invoked, quick notify web data update.");
                    }
                    Message msg = mainHandler.obtainMessage(CLIENT_CORE_MSG_DATA_UPDATE);
                    if (!OFFLINE_MODE_STORE.equals(cacheOffline)) {
                        msg.setData(diffDataBundle);
                    }
                    mainHandler.sendMessage(msg);
                    hasSentDataUpdateMessage = true;
                }
                //发送如果当前还未loadDataWithBaseUrlAndHeader成功,这里是直接返回本地保存的新的html内容重新调用loadDataWithBaseUrlAndHeader
                  if (!hasSentDataUpdateMessage) {
                    mainHandler.removeMessages(CLIENT_CORE_MSG_PRE_LOAD);
                    Message msg = mainHandler.obtainMessage(CLIENT_CORE_MSG_DATA_UPDATE);
                    msg.obj = htmlString;
                    mainHandler.sendMessage(msg);
                }
                。。。
        }
    }

//模板缓存
 protected void handleFlow_TemplateChange() {
        try {
          
            ByteArrayOutputStream output = new ByteArrayOutputStream();
            //检查当前是否已经加载网页成功
            SonicSessionConnection.ResponseDataTuple responseDataTuple = sessionConnection.getResponseData(wasOnPageFinishInvoked, output);
            ....

            String cacheOffline = sessionConnection.getResponseHeaderField(SonicSessionConnection.CUSTOM_HEAD_FILED_CACHE_OFFLINE);

            // send CLIENT_CORE_MSG_TEMPLATE_CHANGE message
            mainHandler.removeMessages(CLIENT_CORE_MSG_PRE_LOAD);
            Message msg = mainHandler.obtainMessage(CLIENT_CORE_MSG_TEMPLATE_CHANGE);
            String htmlString = "";
            if (responseDataTuple.isComplete) {
                htmlString = responseDataTuple.outputStream.toString("UTF-8");
                msg.obj = htmlString;
            }
            if (!OFFLINE_MODE_STORE.equals(cacheOffline)) {
                msg.arg1 = TEMPLATE_CHANGE_REFRESH;
            }
             //有无加载完成htmlString 有则调用loadDataWithBaseUrlAndHeader负责调用loadUrl 然后拦截资源和上述差不多
            mainHandler.sendMessage(msg);

            if (!responseDataTuple.isComplete) {
                responseDataTuple = sessionConnection.getResponseData(wasInterceptInvoked, output);
                if (responseDataTuple != null) {
                   //准备好桥节流如果当前为读取完 拦截资源后返回改流
                    pendingWebResourceStream = new SonicSessionStream(this, responseDataTuple.outputStream, responseDataTuple.responseStream);
                } else {
                    pendingWebResourceStream = null;
                    SonicUtils.log(TAG, Log.ERROR, "session(" + sId + ") handleFlow_TemplateChange error:resourceResponseTuple = null!");
                    return;
                }
            }
           ...// 保存文件
    }

参考资料 https://www.qcloud.com/community/article/164816001481011853

分享给小伙伴们:
本文标签: tencentSonic

相关文章

发表评论愿您的每句评论,都能给大家的生活添色彩,带来共鸣,带来思索,带来快乐。

CopyRight © 2015-2016 QingPingShan.com , All Rights Reserved.

清屏网 版权所有 豫ICP备15026204号