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

最新推荐文章于 2021-05-26 10:56:12 发布
最新推荐文章于 2021-05-26 10:56:12 发布
阅读量718 收藏
点赞数
分类专栏： Android webview 文章标签： Android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/you_meng2/article/details/84826509
版权
本文探讨了Android WebView自带缓存机制的局限，并提出了一种自定义缓存策略的需求。通过创建继承WebViewClient的类并重写shouldInterceptRequest方法，实现了按需缓存特定内容和指定缓存更新策略。DVDUrlCache类的介绍和ThreadPoolManager的简单应用为优化WebView加载速度提供了方案。
摘要由CSDN通过智能技术生成
在现在的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;
    }


[color=red][b]完整的DVDURLCache代码，方便大家直接copy[/b][/color] 

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;
    }

}


[color=darkred][b]ThreadPoolManager很简单：[/b][/color] 
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();
//        }
//
//    }
}
you_meng2
关注
专栏目录
Android实现WebView图片缓存，替换加载前默认图片的样式
03-11
通过以上步骤，我们就成功地实现了在Android的WebView中进行图片缓存、替换加载前的默认图片样式以及图片点击事件的处理。这不仅提升了用户体验，还能有效地减少网络资源的消耗。同时，这些技术也可以作为基础，...
android webview 保存,将webview内容保存到android存储并加载它
weixin_39520979的博客
05-26 763
当页面加载完成时，您可以使用WebView的Javascript接口返回整个HTML源代码。为此，您需要将您自己的WebViewClient分配给WebView。要做到这一点，使用类似于你的Activity类以下的东西 - 确保您的活动实现观察员：public void onCreate(Bundle savedInstanceState) {// ...webView.setWebViewCli...
Android Webview HTML5 Application cache
学习记录
07-19 4093
经过几天的探索和反复的尝试，终于有了一点点进展了。
WebView系列之——读取本地文件
Ung8023
03-30 1万+
WebView读取本地文件前提条件 当加载的网页中存在 &lt;input type="file"&gt; 时，点击按钮需要读取本地文件。 需要添加读取权限&lt;uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/&gt; 原生中存在的问题 5.0 以前不存选择文件的公开API,只存在@...
Android Webview实现文件下载功能
冯立彬的博客
10-31 4万+
在做美图欣赏Android应用的时候，其中有涉及到Android应用下载的功能，这个应用本身其实也比较简单，就是通过WebView控制调用相应的WEB页面进行展示。刚开始以为和普通的文件下载实现，只需要一个链接，然后点击就可以实现下载了，可是放到手机上试的时候，点击下载链接一点反应都没有，在普通页面里面点击是好的，且点击其它的普通链接是可以正常工作的。原来是因为WebView默认没有开启文件下载的
android webview与H5混合开发，webview自定义缓存
飞在升级中
01-11 6459
公司开发的一个项目为Android+H5混合开发，虽然开发量对于原生来说不大，但是针对于H5与android结合的各种坑让初次接手这种开发模式的新手简直不可描述可怜，同样的功能在iOS上面运行的好好的，在Android上面各种问题，这种适配简直烦到极点，真的想竖起中指对着天空大喊一声   太阳你大爷。。。发火废话就不说了，下面记录开发中遇到的一些问题，新手第一次写博文，写的不好不对的地方敬请指教，...
Android中的WebView详细介绍
09-03
在Android开发中，WebView是一个非常重要的组件，它允许我们在应用程序内部加载和显示网页内容，而无需离开应用。WebView实质上就是一个轻量级的浏览器内核，基于WebKit引擎，能够解析和展示HTML、CSS以及JavaScript...
Android WebView 实现缓存网页数据
12-13
在Android开发中，`WebView` 是一个非常重要的组件，它允许开发者在应用程序内嵌入一个浏览器，用于显示网页内容。本篇文章将详细讲解如何利用 `WebView` 实现网页数据的缓存，使得在网络不稳定或者断开的情况下，...
Android 中ViewPager中使用WebView的注意事项
01-20
本文将详细讲解在Android中使用ViewPager与WebView结合时的注意事项。 首先，我们要了解WebView的基本用法。在XML布局文件中，WebView的`layout_width`通常设置为`match_parent`，`layout_height`设置为`wrap_...
Android开发中WebView的简单使用小结
09-01
在Android开发中，WebView是一个非常重要的组件，它允许我们在应用程序内部加载和显示网页内容，而无需离开应用。WebView使用WebKit渲染引擎，这使得它能够高效地解析和展示HTML、CSS和JavaScript。以下是对WebView...
Android WebView cache 缓存 在线 视频播放
09-08
WebView cache 缓存 在线 视频播放 离线阅读
android webview实现自身下载文件自动保存SDCARD
08-06
真正实现android webview自身下载文件，并自动保存到SDCARD上，静默下载哦。
WebView缓存机制
baidu_33512336的博客
02-10 748
如何复写WebView的缓存机制。 首先说一下webview的自带缓存机制的弊端： webview的自带缓存机制是无差别缓存，也就是说，不管是页面，样式还是图片，都会缓存到本地，刷新webview的缓存一般分为以下几种： LOAD_CACHE_ONLY: 不使用网络，只读取本地缓存数据 LOAD_DEFAULT: 根据cache-control决定是否从网络上取数据。 LOAD...
webView本地缓存
果酱大师的博客
06-13 865
用的aSampleCache做的缓存。但是webView页面怎么缓存以前并不知道，网上一查，居然webview自带缓存，才疏学浅，于是乎，做了一个简单的demopublic class MainActivity extends Activity { private WebView webView; private String url =" http://www.3dmgame.co
安卓WebView设置本地缓存和使用。
zhangyanqiu12的博客
05-25 5034
直接上源码吧，都有注解。private void initWebView() { //获取WebSetting对象 final WebSettings settings = webView.getSettings(); settings.setJavaScriptEnabled(true);//支持js脚本 settings.setRenderPriority(W...
Carson带你学Android：手把手构建WebView缓存机制及资源预加载方案
热门推荐
Carson带你学Android
05-08 5万+
前言 由于H5具备 开发周期短、灵活性好 的特点，所以现在 Android App大多嵌入了 Android Webview 组件进行 Hybrid 开发 但我知道你一定在烦恼 Android Webview 的性能问题，特别突出的是：加载速度慢 &amp; 消耗流量 今天，我将针对 Android Webview 的性能问题，提出一些有效解决方案。 目录 1. Andr...
android webview https缓存,FastWebView 自定义本地缓存策略和资源加载策略，突破原生 WebView 缓存限制，实现多种缓存模式，支持离线加载 @codeKK Andro...
weixin_42398055的博客
05-26 878
背景Android 原生 WebView 有磁盘缓存最大上限，在 4.4 之前只有 10M，在 4.4 及其之后虽然提升至 20M，但对频繁的 H5 业务场景来说，还是太小了。HTTP 的缓存部分采用 LRU 缓存算法实现，我们在使用 HTTP 缓存协议对资源缓存时，太小的缓存空间很容易导致页面缓存被清除，从而重新加载。不仅浪费用户的流量，也会造成不好的用户体验。如果服务器或者客户端的开发同学对 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值