android中图片的三级缓存cache策略(内存/文件/网络)

在Android开发中，图片的加载和缓存是一个非常重要的问题。为了提高图片加载的效率和用户体验，通常会采用三级缓存的策略，即内存缓存、文件缓存和网络缓存。下面将详细讲解Android中图片的三级缓存cache策略。

内存缓存

内存缓存是指将图片缓存在内存中，以便快速加载和显示。内存缓存的优点是速度快，可以快速加载和显示图片，缺点是占用内存较大，容易导致内存溢出。在Android中，可以使用LruCache类来实现内存缓存。

示例一：使用LruCache实现内存缓存

下面是一个使用LruCache实现内存缓存的示例：

public class MemoryCache {
    private LruCache<String, Bitmap> mMemoryCache;

    public MemoryCache() {
        // 获取应用程序最大可用内存
        int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);

        // 设置缓存大小为最大可用内存的1/8
        int cacheSize = maxMemory / 8;

        mMemoryCache = new LruCache<String, Bitmap>(cacheSize) {
            @Override
            protected int sizeOf(String key, Bitmap bitmap) {
                // 重写此方法来衡量每张图片的大小，默认返回图片数量。
                return bitmap.getByteCount() / 1024;
            }
        };
    }

    public void put(String key, Bitmap bitmap) {
        mMemoryCache.put(key, bitmap);
    }

    public Bitmap get(String key) {
        return mMemoryCache.get(key);
    }

    public void clear() {
        mMemoryCache.evictAll();
    }
}

上述代码中，MemoryCache类用于实现内存缓存。在构造函数中，使用LruCache类创建了一个缓存对象。在put()方法中，将图片缓存到内存中。在get()方法中，从内存中获取缓存的图片。在clear()方法中，清空内存缓存。

文件缓存

文件缓存是指将图片缓存在文件中，以便在下次加载时快速读取。文件缓存的优点是占用内存较小，缺点是速度较慢，需要从文件中读取图片。在Android中，可以使用DiskLruCache类来实现文件缓存。

示例二：使用DiskLruCache实现文件缓存

下面是一个使用DiskLruCache实现文件缓存的示例：

public class DiskCache {
    private DiskLruCache mDiskLruCache;

    public DiskCache(Context context) {
        try {
            // 获取缓存目录
            File cacheDir = getDiskCacheDir(context, "image_cache");
            if (!cacheDir.exists()) {
                cacheDir.mkdirs();
            }

            // 创建DiskLruCache对象
            mDiskLruCache = DiskLruCache.open(cacheDir, getAppVersion(context), 1, 10 * 1024 * 1024);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void put(String key, Bitmap bitmap) {
        try {
            // 获取Editor对象
            DiskLruCache.Editor editor = mDiskLruCache.edit(key);
            if (editor != null) {
                OutputStream outputStream = editor.newOutputStream(0);
                bitmap.compress(Bitmap.CompressFormat.PNG, 100, outputStream);
                editor.commit();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public Bitmap get(String key) {
        try {
            // 获取Snapshot对象
            DiskLruCache.Snapshot snapshot = mDiskLruCache.get(key);
            if (snapshot != null) {
                InputStream inputStream = snapshot.getInputStream(0);
                Bitmap bitmap = BitmapFactory.decodeStream(inputStream);
                return bitmap;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    public void clear() {
        try {
            mDiskLruCache.delete();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private File getDiskCacheDir(Context context, String uniqueName) {
        String cachePath = context.getExternalCacheDir().getPath();
        return new File(cachePath + File.separator + uniqueName);
    }

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

上述代码中，DiskCache类用于实现文件缓存。在构造函数中，使用DiskLruCache类创建了一个缓存对象。在put()方法中，将图片缓存到文件中。在get()方法中，从文件中获取缓存的图片。在clear()方法中，清空文件缓存。

网络缓存

网络缓存是指将图片缓存在网络中，以便在下次加载时快速下载。网络缓存的优点是可以快速下载图片，缺点是需要联网。在Android中，可以使用Volley或OkHttp等网络框架来实现网络缓存。

示例三：使用Volley实现网络缓存

下面是一个使用Volley实现网络缓存的示例：

public class NetworkCache {
    private RequestQueue mRequestQueue;
    private ImageLoader mImageLoader;

    public NetworkCache(Context context) {
        mRequestQueue = Volley.newRequestQueue(context);
        mImageLoader = new ImageLoader(mRequestQueue, new ImageLoader.ImageCache() {
            private LruCache<String, Bitmap> mCache = new LruCache<String, Bitmap>(10 * 1024 * 1024) {
                @Override
                protected int sizeOf(String key, Bitmap bitmap) {
                    return bitmap.getByteCount();
                }
            };

            @Override
            public Bitmap getBitmap(String url) {
                return mCache.get(url);
            }

            @Override
            public void putBitmap(String url, Bitmap bitmap) {
                mCache.put(url, bitmap);
            }
        });
    }

    public void loadImage(String url, ImageView imageView) {
        mImageLoader.get(url, ImageLoader.getImageListener(imageView, R.mipmap.ic_launcher, R.mipmap.ic_launcher));
    }
}

上述代码中，NetworkCache类用于实现网络缓存。在构造函数中，使用Volley框架创建了一个请求队列和一个图片加载器。在loadImage()方法中，使用图片加载器加载图片。

总结

Android中图片的三级缓存cache策略包括内存缓存、文件缓存和网络缓存。内存缓存可以使用LruCache类实现，文件缓存可以使用DiskLruCache类实现，网络缓存可以使用Volley或OkHttp等网络框架实现。在实际开发中，可以根据具体需求选择合适的缓存策略。