Android图片缓存处理

最新推荐文章于 2024-07-07 21:33:02 发布
最新推荐文章于 2024-07-07 21:33:02 发布
阅读量3.8k 收藏 5
点赞数
分类专栏： 安卓基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/littlewhitetree/article/details/51958403
版权

Lrucache类 内存缓存

LruCache<Key,Values>以键-值对的形式存储（内部定义了一个LinkedHashMap<Key,Values>）数据，通过new LruCache(int size)实例化，参数使指定分配给LruCache的缓存大小。

LruCache缓存大小设置

对于分配给LruCache的缓存大小，可以直接指定固定的数值，但是更好的做法应该是通过获取最大内存(int)Runtime.getRuntime.maxMemory，然后通过返回的最大内存/int n的大小动态分配给LruCache。

LruCache的存储和读取

LruCache是以为键值对形式存储数据，所以它的读写方法都和HashMap<Key,Values>一样，都可以通过key操作。

存储

LruCache.put(Key,Values)

读取

LruCache.get(Key)

通过LruCache缓存从网络读取的图片资源

在开发中，经常会遇到请求网络，从网络读取图片资源的时候，如果每次都去请求读取，很浪费资源（都会开辟子线程进行耗时操作），这样也会影响用户的体验。那么我们应该想到的是，启动app后，只从网络中读取一次资源，之后如果还需要同样的操作，就直接通过缓存读取，这样就可以通过LruCache类来进行操作。

构造一个工具类，用来存储图片到缓存和从缓存中读取图片 
public class CustomLruCache {
    private LruCache<String, Bitmap> stringBitmapLruCache;
    int maxMemory = (int) Runtime.getRuntime().maxMemory();//获取最大内存
    int cacheSize = maxMemory / 16;//大小为最大内存的1/16
    private static CustomLruCache customLruCache;

    /**
     * 私有化构造方法
     */
    private CustomLruCache() {
        stringBitmapLruCache = new LruCache<String, Bitmap>(cacheSize) {
            @Override
            protected int sizeOf(String key, Bitmap value) {
                return value.getByteCount();
            }
        };
    }

    /**
     * 单例模式获取实例，保证只有一个CustomLruCache对象，同时保证只有一个CustomLruCache.stringBitmapLruCache
     *
     * @return
     */
    public static CustomLruCache getInstance() {
        if (customLruCache == null) {
            customLruCache = new CustomLruCache();
        }
        return customLruCache;
    }

    public void addBitmapToMemoryCache(String key, Bitmap bitmap) {
        if (getBitmapFromMemoryCache(key) != bitmap)//如果缓存中不存在bitmap,就存入缓存
            stringBitmapLruCache.put(key, bitmap);
    }

    public Bitmap getBitmapFromMemoryCache(String key) {
        return stringBitmapLruCache.get(key);
    }
}
从网络读取图片，存储到缓存用昨天学过的AsyncTask异步任务类来处理逻辑 
AsyncTask<String, Void, Bitmap> stringVoidBitmapAsyncTask = new AsyncTask<String, Void, Bitmap>() {
            @Override
            protected Bitmap doInBackground(String... params) {
                Bitmap bitmap = null;
                try {
                    CustomLruCache customLruCache = CustomLruCache.getInstance();
                    bitmap = customLruCache.getBitmapFromMemoryCache(params[0]);
                    //先从缓存中读取图片，如果缓存中不存在，再请求网络，从网络读取图片添加至LruCache中
                    //启动app后第一次bitmap为null,会先从网络中读取添加至LruCache,如果app没销毁,再执行读取图片操作时
                    //就会优先从缓存中读取
                    if (bitmap == null) {
                        //从网络中读取图片数据
                        URL url = new URL(params[0]);
                        bitmap = BitmapFactory.decodeStream(url.openStream());
                        //添加图片数据至LruCache
                        customLruCache.addBitmapToMemoryCache(params[0], bitmap);
                    }
                } catch (MalformedURLException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                return bitmap;
            }

            @Override
            protected void onPostExecute(Bitmap bitmap) {
                super.onPostExecute(bitmap);
                imageView.setImageBitmap(bitmap);
            }
        };
        stringVoidBitmapAsyncTask.execute(imageURL);


文件缓存-第三方类DiskLruCache

利用DiskLruCache从网络上获取到之后都会存入到本地缓存中，因此即使手机在没有网络的情况下依然能够加载显示图片数据。DiskLruCache存储的位置没有限制，但是一般选择存储在context.ExternolStorageCacheDir（），即这个手机的外部存储这个app的私有区域，即/sdcard/Android/data/应用包名/cache，因为是存储在外部存储私有区域，当app被卸载时，这部分的内容会被一起清除。


1、使用DiskLruCache

实例化DiskLruCache是通过 DiskLruCache.open(File directory, int appVersion, int valueCount, long maxSize)，四个参数分别：为directory缓存的路径；appVersion 应用版本；alueCount 指定同一个key可以对应多少个缓存文件，一般指定为1；maxSize 指定可以缓存多少字节的数据。

（1）directory 缓存路径

public File getDiskCacheDir(Context context, String uniqueName) {
        String cachePath;
        if (isExternalStorageWritable()) {
            cachePath = context.getExternalCacheDir().getPath();//如果挂载了sdcard，获取外部存储私有区域路径
        } else {
            cachePath = context.getCacheDir().getPath();//如果没有挂载sdcard，则获取内部存储缓存区域
        }
        return new File(cachePath + File.separator + uniqueName);
    }

其中isExternalStorageWritable（）是检测手机是否挂在sdcard。

private boolean isExternalStorageWritable() {
        String state = Environment.getExternalStorageState();
        if (state.equals(Environment.MEDIA_MOUNTED)) {
            return true;//挂载了sdcard，返回真
        } else {
            return false;//否则返回假
        }
    }

因为要对外部存储区域进行读写操作，所以要在androidManifest中添加相应的权限 

 <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />

（2）appVersion 应用版本

 public int getAppVersion(Context context) {
        try {
            PackageInfo info = context.getPackageManager().getPackageInfo(context.getPackageName(), 0);
            return info.versionCode;
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        }
        return 1;
    }

当版本号变更时，缓存路径下所有数据会被清除，因为DiskLruCache认为当版本更新时，所有数据应从网络重新获取

（3）alueCount Key对应的缓存文件个数

DiskLruCache从缓存读取文件和写入文件到缓存时是通过 key来识别的，所以一般是指定alueCountKey为1。

（4）maxSize 缓存存储内容的大小

可以自己指定


通过上面的方法可以，这下可以完整的实例化一个DiskLruCache

 private DiskLruCacheHelper(Context context) {
        try {
            File cacheDir = getDiskCacheDir(context, "bitmap");
            //如果文件不存在，则创建
            if (!cacheDir.exists()) {
                cacheDir.mkdirs();
            }
            mDiskLruCache = DiskLruCache.open(cacheDir, getAppVersion(context), 1, 10 * 1024 * 1024);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

2、通过DiskLruCache存储和读取图片


为了方便操作，我们可以封装一个类来进行操作

public class DiskLruCacheHelper {
    DiskLruCache mDiskLruCache = null;
    static DiskLruCacheHelper diskLruCacheHelper;

    private DiskLruCacheHelper(Context context) {
        try {
            File cacheDir = getDiskCacheDir(context, "bitmap");
            //如果文件不存在，则创建
            if (!cacheDir.exists()) {
                cacheDir.mkdirs();
            }
            mDiskLruCache = DiskLruCache.open(cacheDir, getAppVersion(context), 1, 10 * 1024 * 1024);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static DiskLruCacheHelper getInstance(Context context) {
        if (diskLruCacheHelper == null)
            diskLruCacheHelper = new DiskLruCacheHelper(context);
        return diskLruCacheHelper;
    }

    public File getDiskCacheDir(Context context, String uniqueName) {
        String cachePath;
        if (isExternalStorageWritable()) {
            cachePath = context.getExternalCacheDir().getPath();//如果挂载了sdcard，获取外部存储私有区域路径
        } else {
            cachePath = context.getCacheDir().getPath();//如果没有挂载sdcard，则获取内部存储缓存区域
        }
        return new File(cachePath + File.separator + uniqueName);
    }

    /**
     * 检查外部存储是否可用
     *
     * @return
     */
    private boolean isExternalStorageWritable() {
        String state = Environment.getExternalStorageState();
        if (state.equals(Environment.MEDIA_MOUNTED)) {
            return true;//挂载了sdcard，返回真
        } else {
            return false;//否则返回假
        }
    }

    /**
     * 获取应用版本号
     * 当版本号改变，缓存路径下存储的所有数据都会被清除掉，因为DiskLruCache认为
     * 当应用程序有版本更新的时候，所有的数据都应该从网上重新获取。
     *
     * @param context
     * @return
     */
    public int getAppVersion(Context context) {
        try {
            PackageInfo info = context.getPackageManager().getPackageInfo(context.getPackageName(), 0);
            return info.versionCode;
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        }
        return 1;
    }

    /**
     * 写入图片数据到文件缓存
     *
     * @param imageUrl
     * @param bitmap
     */
    public void writeToCache(String imageUrl, Bitmap bitmap) {
        try {
            String key = hashKeyForDisk(imageUrl);
            DiskLruCache.Editor editor = mDiskLruCache.edit(key);
            if (editor != null) {
                OutputStream outputStream = editor.newOutputStream(0);
                if (bitmap.compress(Bitmap.CompressFormat.PNG, 100, outputStream)) {
                    editor.commit();
                } else {
                    editor.abort();
                }

            }
            mDiskLruCache.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    /**
     * 从缓存读取数据
     *
     * @param imageUrl
     * @return
     */

    public Bitmap readFromCache(String imageUrl) {
        Bitmap bitmap = null;
        try {
            String key = hashKeyForDisk(imageUrl);
            DiskLruCache.Snapshot snapShot = mDiskLruCache.get(key);
            if (snapShot != null) {//如果文件存在,读取数据转换为Bitmap对象
                InputStream is = snapShot.getInputStream(0);
                bitmap = BitmapFactory.decodeStream(is);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return bitmap;
    }

    /**
     * 将文件名转换成"MD5"编码
     *
     * @param key
     * @return
     */
    public String hashKeyForDisk(String key) {
        String cacheKey;
        try {
            final MessageDigest mDigest = MessageDigest.getInstance("MD5");
            mDigest.update(key.getBytes());
            cacheKey = bytesToHexString(mDigest.digest());
        } catch (NoSuchAlgorithmException e) {
            cacheKey = String.valueOf(key.hashCode());
        }
        return cacheKey;
    }

    private String bytesToHexString(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < bytes.length; i++) {
            String hex = Integer.toHexString(0xFF & bytes[i]);
            if (hex.length() == 1) {
                sb.append('0');
            }
            sb.append(hex);
        }
        return sb.toString();
    }

}

下面是从网络获取一张图片显示到ImageView上，第一次进入app时从网络获取，并存储至外部存储私有区域，以后（即使没有网络的情况）进入若相同的缓存文件存在，则直接从缓存读取。

注:涉及到网络操作，需要添加网络操作的相关权限

 <uses-permission android:name="android.permission.INTERNET" />

 public class MainActivity extends AppCompatActivity {
        ImageView mImageView;

        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            mImageView = (ImageView) findViewById(R.id.get_image_from_network_img);
            new AsyncTask<String, Void, Bitmap>() {
                @Override
                protected Bitmap doInBackground(String... strings) {
                    Bitmap bitmap = DiskLruCacheHelper.getInstance(MainActivity.this).readFromCache(strings[0]);
                    if (bitmap == null) {
                        try {
                            URL url = new URL(strings[0]);
                            bitmap = BitmapFactory.decodeStream(url.openStream());
                            DiskLruCacheHelper.getInstance(MainActivity.this).writeToCache(strings[0], bitmap);
                            return bitmap;
                        } catch (MalformedURLException e) {
                            e.printStackTrace();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                    return bitmap;
                }

                @Override
                protected void onPostExecute(Bitmap bitmap) {
                    super.onPostExecute(bitmap);
                    mImageView.setImageBitmap(bitmap);
                }
            }.execute("http://file3.u148.net/2011/4/images/1302139153715.jpg");
        }
    }


运行过后，我们可以到相应的缓存区域查看是否有文件生成


多级缓存处理

上面提到了内存缓存和文件缓存，可以将这两者一起使用，形成二级缓存，第一层是内存缓存，如果内存缓存中没有，则从文件缓存中读取，之后如果本地也没有相关缓存文件，再从网络获取。



littlewhitetree
关注
专栏目录
Android中非常好图片缓存ImageCache
09-03
Android中非常好图片缓存ImageCache，是国外的大牛写的，比较完整系统，但是本人认为也有几个缺点，比如获取磁盘缓存目录的方法，不过，总体非常还是很好的，基本满足各种场景，希望对你有所帮助！
Android应用开发之（利用好图片缓存）
hao201011的专栏
09-20 737
Android Developer: 在用户界面（UI）加载一张图片时很简单，然而，如果你需要加载多张较大的图像，事情就会变得更加复杂，。在许多情况下（如与像的ListView GridView或ViewPager的组件），屏幕上的图片的总数伴随屏幕上滚动的骤然增加，且基本上是无限的。为使内存使用保持在稳定范围内，这些组件会在子view在屏幕中消失后，对其进行资源回收，垃圾回收机制会释放掉已
如何在Android应用程序中实现高效的图片加载和缓存机制。
最新发布
07-07 529
在Android应用程序中实现高效的图片加载和缓存机制是一个复杂但至关重要的任务，它直接关系到应用的性能、用户体验以及内存和流量的管理。下面从技术难点、面试官关注点、回答吸引力以及代码举例四个方面进行详细描述。
安卓图片缓存技术
weixin_33816946的博客
03-20 158
概述：随着手机硬件水平的提高及摩尔效应带来的成本的降低，用户手机上的图片的分辨率越来越高，而对于移动终端而言内存存在一定的限制的，如果程序占用过高的内存，也会抛出OOM异常，降低了APP的用户体验感。另外自己做的APP应该尽可能的减少安装包的体积。本博客主要讲述通过压缩图片来减少安装包体积和通过使用图片缓存技术来高效加载大图。 一 压缩图片： 在加载高分辨率图片的时候，最好先...
Android图片缓存管理
huli870715的专栏
10-02 4940
在一个app中，图片资源是处处存在的，加载图片的流程一般是： 1 先从缓存中读取 2 若缓存中不存在，从SD卡中读取 3 若SD卡中也不存在，则从服务器拉取 后两个步骤纯碎属于业务逻辑，暂且不表，这里来看一下手Q使用的图片缓存管理策略。 说到缓存管理，首先谈一下java中的强引用和弱引用 强引用：最普遍的引用，若一个对象具有强引用，那么GC绝不会回收它。如A a = new
android图片缓存
小志地盘
05-13 2517
博客分类：  android android Java代码   后来在外国佬的网站上发现了这个方法      // 从网络获取图片并缓存,缓存与浏览器共享   URL url = new URL(imageURL);   URLConnection connection = url.openConnection();   connectio
android 图片缓存处理
01-18
### Android 图片缓存处理详解 #### 概述 在Android开发中，图片缓存是一项重要的技术，尤其是在处理网络图片加载、浏览应用等场景时。合理的图片缓存机制不仅可以提高应用性能，减少流量消耗，还能提升用户体验。...
android 图片缓存处理，及异步加载类
12-17
"Android 图片缓存处理，及异步加载类"这个主题主要涵盖了两个关键知识点：图片缓存和异步加载。 首先，让我们深入了解一下图片缓存。在Android应用中，频繁地加载网络图片会导致用户体验下降，因为这会消耗大量的...
Android 图片缓存机制的深入理解
01-04
Android 图片缓存机制的深入理解 Android加载一张图片到用户界面是很简单的，但是当一次加载多张图片时，情况就变得复杂起来。很多情况下（像ListView、GridView或ViewPager等组件），屏幕上已显示的图片和即将滑动...
Android图片加载的缓存类
01-20
首先，Android中的图片缓存通常分为两层：内存缓存（一级缓存）和磁盘缓存（二级缓存）。内存缓存可以快速访问，但空间有限；磁盘缓存容量较大，但访问速度相对较慢。在Android的ImageLoaderEngine类中，我们看到...
android缓存图片,Android 图片缓存
weixin_34766430的博客
05-27 502
前言本篇主要包含两个方面的内容：图片的加载和优化图片的加载LruCache，DisLruCache的使用与图片的三级缓存图片的加载和优化我们在编写Android程序的时候经常要用到很多的图片，在大多数情况下，这些图片都会大于我们程序所需要的大小。我们编写的应用程序都是有一定的内存限制，程序占用了过高的内存就容易出现OOM(Out Of Memory)异常。如下代码可以看出每个应用程序最高可用内存：...
Android 图片缓存(文件+缓存+网络+线程池)
04-30 335
今天在项目中遇到了图片缓存的问题，自己尝试写了下： 1.正常的加载图片
Android 本地图片缓存
weixin_33810302的博客
09-19 199
2019独角兽企业重金招聘Python工程师标准>>> ...
android 图片缓存，记录一下
weixin_30757793的博客
05-21 70
文章来自：http://keegan-lee.diandian.com/post/2012-12-06/40047548955 多写了点注释而已，没有其他的变化，只有两级，硬引用和软引用，感觉已经够了吧，没用到弱引用 public class ImageFileCache { // 目录名称 private static final String CACHDIR = "...
Android图片缓存
w7822055的专栏
11-06 1845
1.内存缓存 //需要导入外部jar文件 android-support-v4.jar import android.support.v4.util.LruCache; //开辟8M硬缓存空间 private final int hardCachedSize = 8*1024*1024;   //hard cache private fina
android 图片缓存
renlei0109的专栏
06-30 1509
原理示意图     主体有三个，分别是UI，缓存模块和数据源（网络）。它们之间的关系如下： ① UI：请求数据，使用唯一的Key值索引Memory Cache中的Bitmap。 ② 内存缓存：缓存搜索，如果能找到Key值对应的Bitmap，则返回数据。否则执行第三步。 ③ 硬盘存储：使用唯一Key值对应的文件名，检索SDCard上的文件。 ④ 如果有对应文件，
Android 图片缓存策略详解
"Android图片缓存处理的实现方法和策略" 在Android开发中，图片缓存是提高应用性能和用户体验的关键技术。特别是在加载网络图片时，合理的缓存机制能避免不必要的网络请求，减少内存消耗，防止应用因频繁加载大图而...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值