`

Android系统中WebView的本地缓存重写

Android 
阅读更多
在现在的app中，越来越多的公司开始使用webview来进行一些活动页面的展示，甚至一些公司开始使用webview做为主要显示组件，把所有的内容都使用H5来呈现，这样一来，就对WebView的加载速度开始有越来越高的要求，我们要讨论的是webview的原本缓存机制所存在的弊端和如何复写WebView的缓存机制。

首先说一下webview的自带缓存机制的弊端：
webview的自带缓存机制是无差别缓存，也就是说，不管是页面，样式还是图片，都会缓存到本地，刷新webview的缓存一般分为以下几种：

LOAD_CACHE_ONLY:  不使用网络，只读取本地缓存数据
LOAD_DEFAULT:  根据cache-control决定是否从网络上取数据。
LOAD_CACHE_NORMAL: API level 17中已经废弃, 从API level 11开始作用同LOAD_DEFAULT模式
LOAD_NO_CACHE: 不使用缓存，只从网络获取数据.
LOAD_CACHE_ELSE_NETWORK，只要本地有，无论是否过期，或者no-cache，都使用缓存中的数据。

反正不管以上几种具体情况如何，都肯定不是我们想要的。

我们想要的机制是：
1.缓存自己想要缓存的内容。
2.指定一个缓存策略，在需要的时候重新去服务器获取最新数据

于是我想到了以下方法
重写
WebViewClient.shouldInterceptRequest(WebView view,WebResourceRequest request)
方法
首先需要新建一个类，继承WebViewClient： 
public class DVDWebViewClient extends WebViewClient

然后实现 
public WebResourceResponse shouldInterceptRequest(WebView view,WebResourceRequest request)

方法
shouldInterceptRequest方法会将所有页面的资源URL都一一列举出来，这样一来就好办了，我们似乎只需要缓存自己想要缓存的url就可以了。
然后事实是不是这样的呢？ 
@Override
    public WebResourceResponse shouldInterceptRequest(WebView view,
                                                      WebResourceRequest request) {
        //获取本地的URL主域名
        String curDomain = request.getUrl().getHost();
        //这行LOG可以不看
        if (BuildConfig.DEBUG) {
            Log.d(LOG_TAG, "curDomain " + curDomain + " request headers " + request.getRequestHeaders());
            for (Map.Entry<String, String> entry : request.getRequestHeaders().entrySet()) {
                Log.d(LOG_TAG, "key=" + entry.getKey() + " #####value=" + entry.getValue() + "\n");
            }
        }
        //取不到domain就直接返回，把接下俩的动作交给webview自己处理
        if (curDomain == null || !isPicUrl(curDomain)) {
            return null;
        }
        if (BuildConfig.DEBUG) {
            Log.d(LOG_TAG, "shouldInterceptRequest url " + request.getUrl().toString());
        }
        //读取当前webview正准备加载URL资源
        String url = request.getUrl().toString();
        try {
           //根据资源url获取一个你要缓存到本地的文件名，一般是URL的MD5
            String resFileName = getResourcesFileName(url);
            if (resFileName == null || "".equals(resFileName)) {
                return null;
            }
           //这里是处理本地缓存的URL，缓存到本地，或者已经缓存过的就直接返回而不去网络进行加载
            this.dvdUrlCache.register(url, getResourcesFileName(url),
                    request.getRequestHeaders().get("Accept"), "UTF-8", DVDUrlCache.ONE_MONTH);
            return this.dvdUrlCache.load(url);
        } catch (Exception e) {
            Log.e(LOG_TAG, "", e);
        }
        return null;
    }

  接下来我们看下DVDUrlCache的实现：
DVDUrlCache主要做了这么几件事：
1.封装一个内部类CacheEntry，做一些基本信息存储 
private static class CacheEntry {
       //用作存储的URL
        public String url;
        //本地保存的文件名称
        public String fileName;
        //标记资源的头部，通过request参数取回
        String mimeType;
        //需要缓存的资源文件的编码
        public String encoding;
        //缓存最大有效时间
        long maxAgeMillis;

        private CacheEntry(String url, String fileName,
                           String mimeType, String encoding, long maxAgeMillis) {
            this.url = url;
            this.fileName = fileName;
            this.mimeType = mimeType;
            this.encoding = encoding;
            this.maxAgeMillis = maxAgeMillis;
        }
    }

接下来是类的构造放方法以及需要映射的map 
//Key 为URL
private Map<String, CacheEntry> cacheEntries = new HashMap<>();
//缓存路径的根目录
    private File rootDir = null;
    DVDUrlCache() {
//获取本地缓存路径，这个请在调试中自行修改
        this.rootDir = DiskUtil.getDiskCacheDir(DVDApplicationContext.getInstance().getApplicationContext());
    }
//资源注册，参考DVDWebViewClient的调用
public void register(String url, String cacheFileName,
                         String mimeType, String encoding,
                         long maxAgeMillis) {
        CacheEntry entry = new CacheEntry(url, cacheFileName, mimeType, encoding, maxAgeMillis);
        this.cacheEntries.put(url, entry);
    }

然后是核心内容 
public WebResourceResponse load(final String url) {
        try {
            final CacheEntry cacheEntry = this.cacheEntries.get(url);
            if (cacheEntry == null) {
                return null;
            }

            final File cachedFile = new File(this.rootDir.getPath() + File.separator + cacheEntry.fileName);
            if (BuildConfig.DEBUG) {
                Log.d(LOG_TAG, "cachedFile is " + cachedFile);
            }
            if (cachedFile.exists() && isReadFromCache(url)) {
                //还没有下载完,在快速切换URL的时候，可能会有很多task并没有及时完成，所以这里需要一个map用于存储正在下载的URL，下载完成后需要移除相应的task
                if (queueMap.containsKey(url)) {               
                    return null;
                }
//过期后直接删除本地缓存内容
                long cacheEntryAge = System.currentTimeMillis() - cachedFile.lastModified();
                if (cacheEntryAge > cacheEntry.maxAgeMillis) {
                    cachedFile.delete();
                    if (BuildConfig.DEBUG) {
                        Log.d(LOG_TAG, "Deleting from cache: " + url);
                    }
                    return null;
                }
                //cached file exists and is not too old. Return file.
                if (BuildConfig.DEBUG) {
                    Log.d(LOG_TAG, url + " ### cache file : " + cachedFile.getAbsolutePath());
                }
                return new WebResourceResponse(
                        cacheEntry.mimeType, cacheEntry.encoding, new FileInputStream(cachedFile));
            } else {
                if (!queueMap.containsKey(url)) {
                    queueMap.put(url, new Callable<Boolean>() {
                        @Override
                        public Boolean call() throws Exception {
                            return downloadAndStore(url, cacheEntry);
                        }
                    });
                    final FutureTask<Boolean> futureTask = ThreadPoolManager.getInstance().addTaskCallback(queueMap.get(url));
                    ThreadPoolManager.getInstance().addTask(new Runnable() {
                        @Override
                        public void run() {
                            try {
                                if (futureTask.get()) {
                                    if (BuildConfig.DEBUG) {
                                        Log.d(LOG_TAG, "remove " + url);
                                    }
                                    queueMap.remove(url);
                                }
                            } catch (InterruptedException | ExecutionException e) {
                                Log.d(LOG_TAG, "", e);
                            }
                        }
                    });
                }
            }
        } catch (Exception e) {
            Log.d(LOG_TAG, "Error reading file over network: ", e);
        }
        return null;
    }

//这个方法是资源下载
    private boolean downloadAndStore(final String url, final CacheEntry cacheEntry)
            throws IOException {
        FileOutputStream fileOutputStream = null;
        InputStream urlInput = null;
        try {
            URL urlObj = new URL(url);
            URLConnection urlConnection = urlObj.openConnection();
            urlInput = urlConnection.getInputStream();
            String tempFilePath = DVDUrlCache.this.rootDir.getPath() + File.separator + cacheEntry.fileName + ".temp";
            File tempFile = new File(tempFilePath);
            fileOutputStream = new FileOutputStream(tempFile);
            byte[] buffer = new byte[1024];
            int length;
            while ((length = urlInput.read(buffer)) > 0) {
                fileOutputStream.write(buffer, 0, length);
            }
            fileOutputStream.flush();
            File lastFile = new File(tempFilePath.replace(".temp", ""));
            boolean renameResult = tempFile.renameTo(lastFile);
            if (!renameResult) {
                Log.w(LOG_TAG, "rename file failed, " + tempFilePath);
            }
//            Log.d(LOG_TAG, "Cache file: " + cacheEntry.fileName + " stored. ");
            return true;
        } catch (Exception e) {
            Log.e(LOG_TAG, "", e);
        } finally {
            if (urlInput != null) {
                urlInput.close();
            }
            if (fileOutputStream != null) {
                fileOutputStream.close();
            }
        }
        return false;
    }

    private boolean isReadFromCache(String url) {
        return true;
    }


完整的DVDURLCache代码，方便大家直接copy 

package com.davdian.seller.util.WebUtil;

import android.util.Log;
import android.webkit.WebResourceResponse;
import com.davdian.seller.BuildConfig;
import com.davdian.seller.global.DVDApplicationContext;
import com.davdian.seller.util.DiskUtil;
import com.davdian.seller.util.ThreadPoolManager;

import java.io.*;
import java.net.URL;
import java.net.URLConnection;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * 只缓存图片的自定义接口
 * <p>
 * Created by hongminghuangfu on 16/9/3.
 */
public class DVDUrlCache {

    private static final String LOG_TAG = "DVDUrlCache";

    private static final long ONE_SECOND = 1000L;
    private static final long ONE_MINUTE = 60L * ONE_SECOND;
    static final long ONE_HOUR = 60 * ONE_MINUTE;
    static final long ONE_DAY = 24 * ONE_HOUR;
    static final long ONE_MONTH = 30 * ONE_DAY;


    private static final LinkedHashMap<String, Callable<Boolean>> queueMap = new LinkedHashMap<>();


    private static class CacheEntry {
        public String url;
        public String fileName;
        String mimeType;
        public String encoding;
        long maxAgeMillis;

        private CacheEntry(String url, String fileName,
                           String mimeType, String encoding, long maxAgeMillis) {
            this.url = url;
            this.fileName = fileName;
            this.mimeType = mimeType;
            this.encoding = encoding;
            this.maxAgeMillis = maxAgeMillis;
        }
    }

    private Map<String, CacheEntry> cacheEntries = new HashMap<>();
    private File rootDir = null;

    DVDUrlCache() {
//本地缓存路径，请在调试中自行修改
        this.rootDir = DiskUtil.getDiskCacheDir(DVDApplicationContext.getInstance().getApplicationContext());
    }

    public void register(String url, String cacheFileName,
                         String mimeType, String encoding,
                         long maxAgeMillis) {
        CacheEntry entry = new CacheEntry(url, cacheFileName, mimeType, encoding, maxAgeMillis);
        this.cacheEntries.put(url, entry);
    }

    public WebResourceResponse load(final String url) {
        try {
            final CacheEntry cacheEntry = this.cacheEntries.get(url);
            if (cacheEntry == null) {
                return null;
            }

            final File cachedFile = new File(this.rootDir.getPath() + File.separator + cacheEntry.fileName);
            if (BuildConfig.DEBUG) {
                Log.d(LOG_TAG, "cachedFile is " + cachedFile);
            }
            if (cachedFile.exists() && isReadFromCache(url)) {
                //还没有下载完
                if (queueMap.containsKey(url)) {                
                    return null;
                }
                long cacheEntryAge = System.currentTimeMillis() - cachedFile.lastModified();
                if (cacheEntryAge > cacheEntry.maxAgeMillis) {
                    cachedFile.delete();
                    if (BuildConfig.DEBUG) {
                        Log.d(LOG_TAG, "Deleting from cache: " + url);
                    }
                    return null;
                }
                //cached file exists and is not too old. Return file.
                if (BuildConfig.DEBUG) {
                    Log.d(LOG_TAG, url + " ### cache file : " + cachedFile.getAbsolutePath());
                }
                return new WebResourceResponse(
                        cacheEntry.mimeType, cacheEntry.encoding, new FileInputStream(cachedFile));
            } else {
                if (!queueMap.containsKey(url)) {
                    queueMap.put(url, new Callable<Boolean>() {
                        @Override
                        public Boolean call() throws Exception {
                            return downloadAndStore(url, cacheEntry);
                        }
                    });
                    final FutureTask<Boolean> futureTask = ThreadPoolManager.getInstance().addTaskCallback(queueMap.get(url));
                    ThreadPoolManager.getInstance().addTask(new Runnable() {
                        @Override
                        public void run() {
                            try {
                                if (futureTask.get()) {
                                    if (BuildConfig.DEBUG) {
                                        Log.d(LOG_TAG, "remove " + url);
                                    }
                                    queueMap.remove(url);
                                }
                            } catch (InterruptedException | ExecutionException e) {
                                Log.d(LOG_TAG, "", e);
                            }
                        }
                    });
                }
            }
        } catch (Exception e) {
            Log.d(LOG_TAG, "Error reading file over network: ", e);
        }
        return null;
    }

    private boolean downloadAndStore(final String url, final CacheEntry cacheEntry)
            throws IOException {
        FileOutputStream fileOutputStream = null;
        InputStream urlInput = null;
        try {
            URL urlObj = new URL(url);
            URLConnection urlConnection = urlObj.openConnection();
            urlInput = urlConnection.getInputStream();
            String tempFilePath = DVDUrlCache.this.rootDir.getPath() + File.separator + cacheEntry.fileName + ".temp";
            File tempFile = new File(tempFilePath);
            fileOutputStream = new FileOutputStream(tempFile);
            byte[] buffer = new byte[1024];
            int length;
            while ((length = urlInput.read(buffer)) > 0) {
                fileOutputStream.write(buffer, 0, length);
            }
            fileOutputStream.flush();
            File lastFile = new File(tempFilePath.replace(".temp", ""));
            boolean renameResult = tempFile.renameTo(lastFile);
            if (!renameResult) {
                Log.w(LOG_TAG, "rename file failed, " + tempFilePath);
            }
//            Log.d(LOG_TAG, "Cache file: " + cacheEntry.fileName + " stored. ");
            return true;
        } catch (Exception e) {
            Log.e(LOG_TAG, "", e);
        } finally {
            if (urlInput != null) {
                urlInput.close();
            }
            if (fileOutputStream != null) {
                fileOutputStream.close();
            }
        }
        return false;
    }

    private boolean isReadFromCache(String url) {
        return true;
    }

}


ThreadPoolManager很简单： 
package com.davdian.seller.util;

import android.util.Log;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

/**
 * 线程池
 * <p>
 * Created by hongminghuangfu on 16/9/9.
 */
public class ThreadPoolManager {

    private static final String LOG_TAG = "ThreadPoolManager";
    private static final ThreadPoolManager instance = new ThreadPoolManager();

    private ExecutorService threadPool = Executors.newFixedThreadPool(100);

    public static ThreadPoolManager getInstance() {
        return instance;
    }

    /**
     * @param runnable 不返回执行结果的异步任务
     */
    public void addTask(Runnable runnable) {
        try {
            if (runnable != null) {
                threadPool.execute(runnable);
            }
        } catch (Exception e) {
            Log.e(LOG_TAG, "", e);
        }
    }

    /**
     * @param callback 异步任务
     * @return 你可以获取相应的执行结果
     */
    public FutureTask addTaskCallback(Callable<Boolean> callback) {
        if (callback == null) {
            return null;
        } else {
            FutureTask futureTask = new FutureTask<>(callback);
            threadPool.submit(futureTask);
            return futureTask;
        }

    }
// 这是一个demo，如果你看不懂，可以打开跑一下
//    public static void main(String args[]) {
//        FutureTask ft = ThreadPoolManager.getInstance().addTaskCallback(new Callable<Object>() {
//            @Override
//            public Object call() throws Exception {
//                int sum = 0;
//                for (int i = 0; i < 1000; i++) {
//                    sum++;
//                }
//                return sum;
//            }
//        });
//        try {
//            System.out.println("执行结果是:" + ft.get());
//        } catch (InterruptedException | ExecutionException e) {
//            e.printStackTrace();
//        }
//
//    }
}
分享到：
| 编辑器还可以啊
评论
3 楼 you_meng 2016-12-01  
dangbochang 写道
你好，调试报错。DVDApplicationContext、DVDDebugToggle和DiskUtil这3个类能否共享一下。
我的邮箱78101787@qq.com

多谢


仔细看注释
2 楼 dangbochang 2016-11-18  
还有getResourcesFileName()和isPic()这两个方法能否也贴一下，谢谢
1 楼 dangbochang 2016-11-18  
你好，调试报错。DVDApplicationContext、DVDDebugToggle和DiskUtil这3个类能否共享一下。

我的邮箱78101787@qq.com

多谢
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Android WebView 实现缓存网页数据

    在Android开发中，`WebView` 是一个非常重要的组件，它允许开发者在应用程序内嵌入一个浏览器，用于显示网页内容。本篇文章将详细讲解如何利用 `WebView` 实现网页数据的缓存，使得在网络不稳定或者断开的情况下，...

    Android实现WebView图片缓存，替换加载前默认图片的样式

    通过以上步骤，我们就成功地实现了在Android的WebView中进行图片缓存、替换加载前的默认图片样式以及图片点击事件的处理。这不仅提升了用户体验，还能有效地减少网络资源的消耗。同时，这些技术也可以作为基础，...

    Android Webview滑动监听

    在Android开发中，Webview是一个非常重要的组件，它允许开发者在原生应用中嵌入网页内容，实现网页...在实际开发中，还可以结合其他API和技巧，如设置Webview缓存、禁用JavaScript、添加进度条等，来实现更复杂的功能。

    Android中的WebView详细介绍

    在Android开发中，WebView是一个非常重要的组件，它允许我们在应用程序内部加载和显示网页内容，而无需离开应用。WebView实质上就是一个轻量级的浏览器内核，基于WebKit引擎，能够解析和展示HTML、CSS以及JavaScript...

    安卓Android源码——webview重载使用&自定义网址.zip

    这份“安卓Android源码——webview重载使用&自定义网址.zip”资源包含了一系列的源码示例和相关图片，旨在帮助开发者理解如何在Android应用中自定义和优化WebView的使用。以下是关于WebView重载与自定义网址的一些...

    Android-android端通用WebView

    - 使用WebView缓存：开启缓存机制，如 `getSettings().setCacheMode(WebSettings.LOAD_CACHE_ELSE_NETWORK)`，在网络不稳定时加载本地缓存。 - 清理缓存：`clearCache()` 和 `clearHistory()` 方法用于清理浏览...

    Android中使用WebView显示网页

    本文将深入探讨如何在Android中使用WebView显示网页，并涉及如何打包本地网页、加载Web页面、设置启用JavaScript以及使用缓存等关键知识点。 1. **使用WebView组件** Android中的WebView是Android SDK提供的一种...

    android开发中WebView的使用

    这个简单的例子展示了WebView在Android开发中的基本使用，但实际应用中，开发者可能还需要实现更多的功能，例如添加网页拦截器（WebViewClient的`onReceivedError`或`onReceivedHttpError`方法），处理用户登录认证...

    Android 中的 WebView实现Html5标签使用

    同时，我们重写了`shouldOverrideUrlLoading`方法，确保点击网页中的链接时，仍在当前WebView内加载，而不是跳转到系统浏览器。 对于HTML5视频标签 `&lt;video&gt;`，我们需要提供至少一种视频格式，以适应不同的设备和...

    Android BTAndroidWebViewSelection（webview选择文字）.zip

    项目可能包含了对Webview缓存的配置，例如启用`WebSettings.setCacheMode()`来利用本地缓存，以及使用`setDomStorageEnabled()`、`setAppCacheEnabled()`等方法开启HTML5本地存储功能，提升加载速度。 7. **Webview...

    Android中WebView使用

    在Android开发中，WebView是一个非常重要的组件，它允许我们在应用程序中内嵌网页内容，实现与HTML、CSS和JavaScript的交互。随着HTML5技术的发展，WebView的使用愈发广泛，许多App都采用混合开发模式，利用WebView...

    Android webview加载网页.zip

    在Android开发中，WebView是一个非常重要的组件，它允许我们在应用程序内部加载和显示网页内容，无需跳转到外部浏览器。这个“Android webview加载网页.zip”文件可能包含了一个示例项目或者教程，帮助开发者理解...

    android中webview图片点击及图片手势操作

    在Android开发中，WebView是一个非常重要的组件，它允许我们在应用程序中内嵌网页内容，实现与网页的交互。本文将深入探讨如何在Android的WebView中处理图片点击事件以及实现图片的手势操作，同时介绍JavaScript交互...

    android 简单webview的使用

    以上就是Android中使用WebView的基本操作，通过这些基础，你可以根据需求进行更复杂的定制，例如实现离线缓存、注入JavaScript对象、处理网页中的图片和视频等。在实际开发中，WebView经常被用来构建混合应用，结合...

    android_中webView控件详解

    WebView是Android系统提供的一个重要的控件，主要用于在应用程序中展示Web内容。它不仅能够加载并显示HTML文档，还支持JavaScript脚本执行，允许开发者通过Java与JavaScript进行交互。本文将详细介绍WebView的一些...

    webview加载本地的html文件

    在WebViewLoadDemo这个示例项目中，可能包含了上述所有操作的完整代码，你可以参考该项目学习和实践如何在Android应用中有效地使用WebView加载本地HTML文件。总的来说，理解并熟练掌握WebView的使用对于Android...

    android 使用WebView浏览网页

    总结，WebView是Android开发中的重要工具，能够帮助我们构建混合型应用，结合本地和Web功能。理解并熟练使用WebView的相关设置、事件处理和JavaScript交互，对于提升Android应用的功能性和用户体验具有重要意义。

    实现缓存WebView中的图片的demo

    同时，我们启用了DOM存储、AppCache和数据库存储，这些都是WebView缓存机制的一部分。 2. **自定义缓存策略**： 如果需要更精细的控制，可以重写`shouldInterceptRequest`方法，该方法允许我们在网络请求发生之前...

    Android之WebView使用Demo

    在Android开发中，`WebView`是一个非常重要的组件，它允许我们在应用程序内部加载和显示网页内容，极大地扩展了Android应用的功能。本教程将详细讲解如何在Android应用中使用`WebView`，并结合提供的博客链接，帮助...

Magicbox
Global site tag (gtag.js) - Google Analytics