首先给大家介绍Android使用缓存机制实现文件下载
在下载文件或者在线浏览文件时，或者为了保证文件下载的正确性，需要使用缓存机制，常使用SoftReference来实现。
SoftReference的特点是它的一个实例保存对一个Java对象的软引用，该软引用的存在不妨碍垃圾收集线程对该Java对象的回收。也就是说，一旦SoftReference保存了对一个Java对象的软引用后，在垃圾线程对这个Java对象回收前，SoftReference类所提供的get()方法返回Java对象的强引用。另外，一旦垃圾线程回收该Java对象之后，get()方法将返回null。软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收器回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。
一般的缓存策略是：
一级内存缓存、二级文件缓存（数据库也算作文件缓存）、三级网络数据
一、网络下载的缓存策略
关于网络下载文件（图片、音频、视频）的基本策略：
1.不要直接下载到目标文件，应使用temp文件作中转，以确保文件的正确性与完整性，流程如下：
a)以网络目标文件名 A 生成唯一的本地目标文件名 B
b)以本地目标文件名 B 生成唯一的本地临时文件名 T
c)下载文件到 T 中
d)下载完毕，校验文件 T 的正确性与完整性
e)若不正确或不完整则 delete 文件 T，并返回 false
f)校验完毕后，将文件 T 重命名 或 复制到 B 文件
g)最后的清理现场，删除临时文件 T，成功后，返回 true
2.尽力提供文件正确性与完整性的校验：
a)正确性：比如 MD5/Hash Code 比对、文件格式的比对。
b)完整性：比如 文件大小是否一致、图片的数据是否正确（图片文件头中提供了相关信息）
3.考虑对于下载到本地的文件是否需要再做二次加工，可以思考以下情况：
a)比如网络源始图片的大小为800*600，而我们需要作为缩略图的大小为160*145，所以考虑对下载后的文件进行裁剪，再保存，对于源始文件则直接删除。
二、文件缓存策略：
1.需要唯一的缓存文件的对应I/O key，一般可以使用 hashcode。
2.若是同一个文件，以不同的时间，可以考虑，先清本地缓存，再下载新的缓存到本地。
3.同一文件也可以加上时间戳后，再生成唯一hashcode。
4.生成文件缓时，也许需要作以下全面的考虑：
a)sdcard是否已经没有空间（这个需求是存在的，但几乎没有人会考虑到，一旦发生，必crash）。
b)缓存的清理策略。每日、每周定时清理？到达一个阀值后，自动清理？（若无清理策略，把垃圾数据一直当个宝一相存着，
是很SB的）。
c)缓存真正需要的数据。不要觉外存是无限的，所以就可以什么都存，要知道，多则繁，繁则乱。曾经有一同事，每天存几百MB的用户数据（所有用户的性别、 age、联系方式等等），而PM需要的只是一个每日数户的活跃数据报表，于是最后改为缓存每天的用户分析报表数据即可（才10几KB）。
d)给缓存文件加密。最简单就是去掉文件的扩展名，这也算加密，当然，你可以把服务端文件加密，然后在内存中解密。这就看项目的需求而定，我的经验也不足，一般就是改改扩展名之类的。
下面给大家介绍Android 异步请求图片加三级缓存
使用xUtils等框架是很方便,但今天要用代码实现bitmapUtils 的功能,很简单,
1 AsyncTask请求一张图片
####AsyncTask
#####AsyncTask是线程池+handler的封装 第一个泛型: 传参的参数类型类型(和doInBackground一致) 第二个泛型:
#####更新进度的参数类型(和onProgressUpdate一致) 第三个泛型: 返回结果的参数类型(和onPostExecute一致,
#####和doInBackground返回类型一致)
看AsyncTask源码:
|
1
2
3
4
5
6
7
8
9
10
11
|
public abstract class AsyncTask<Params, Progress, Result> {private static final String LOG_TAG = "AsyncTask";private static final int CORE_POOL_SIZE = 5;private static final int MAXIMUM_POOL_SIZE = 128;private static final int KEEP_ALIVE = 1;private static final ThreadFactory sThreadFactory = new ThreadFactory() {private final AtomicInteger mCount = new AtomicInteger(1);public Thread newThread(Runnable r) {return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());}}; |
核心线程5 最大线程128 这是AsyncTask的线程池 然后通过handler发送消息 , 它内部实例化了一个静态的自定义类 InternalHandler，这个类是继承自 Handler 的，在这个自定义类中绑定了一个叫做 AsyncTaskResult 的对象，每次子线程需要通知主线程，就调用 sendToTarget 发送消息给 handler自己。然后在 handler 的 handleMessage 中 AsyncTaskResult 根据消息的类型不同（例如 MESSAGE_POST_PROGRESS 会更新进度条，MESSAGE_POST_CANCEL 取消任务）而做不同的操作，值得一提的是，这些操作都是在UI线程进行的，意味着，从子线程一旦需要和 UI 线程交互，内部自动调用了 handler 对象把消息放在了主线程了。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
|
private static final InternalHandler sHandler = new InternalHandler(); mFuture = new FutureTask<Result>(mWorker) {@Overrideprotected void More ...done() {Message message;Result result = null;try {result = get();} catch (InterruptedException e) {android.util.Log.w(LOG_TAG, e);} catch (ExecutionException e) {throw new RuntimeException("An error occured while executing doInBackground()",e.getCause());} catch (CancellationException e) {message = sHandler.obtainMessage(MESSAGE_POST_CANCEL,new AsyncTaskResult<Result>(AsyncTask.this, (Result[]) null));message.sendToTarget();return;} catch (Throwable t) {throw new RuntimeException("An error occured while executing "+ "doInBackground()", t);}message = sHandler.obtainMessage(MESSAGE_POST_RESULT,new AsyncTaskResult<Result>(AsyncTask.this, result));message.sendToTarget();}};private static class InternalHandler extends Handler {@SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})@Overridepublic void More ...handleMessage(Message msg) {AsyncTaskResult result = (AsyncTaskResult) msg.obj;switch (msg.what) {case MESSAGE_POST_RESULT:// There is only one resultresult.mTask.finish(result.mData[0]);break;case MESSAGE_POST_PROGRESS:result.mTask.onProgressUpdate(result.mData);break;case MESSAGE_POST_CANCEL:result.mTask.onCancelled();break;}}} |
下面看代码 第一步我们先请求一张图片 并解析 注释写的很详细了.
NetCacheUtils.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
|
import java.io.InputStream;import java.net.HttpURLConnection;import java.net.URL;import android.graphics.Bitmap;import android.graphics.BitmapFactory;import android.os.AsyncTask;import android.widget.ImageView;/*** 网络缓存* * @author Ace* @date 2016-02-18*/public class NetCacheUtils {private LocalCacheUtils mLocalUtils;private MemoryCacheUtils mMemoryUtils;public NetCacheUtils(LocalCacheUtils localUtils,MemoryCacheUtils memoryUtils) {mLocalUtils = localUtils;mMemoryUtils = memoryUtils;}public void getBitmapFromNet(ImageView imageView, String url) {BitmapTask task = new BitmapTask();task.execute(imageView, url);}/*** AsyncTask是线程池+handler的封装 第一个泛型: 传参的参数类型类型(和doInBackground一致) 第二个泛型:* 更新进度的参数类型(和onProgressUpdate一致) 第三个泛型: 返回结果的参数类型(和onPostExecute一致,* 和doInBackground返回类型一致)*/class BitmapTask extends AsyncTask<Object, Integer, Bitmap> {private ImageView mImageView;private String url;// 主线程运行, 预加载@Overrideprotected void onPreExecute() {super.onPreExecute();}// 子线程运行, 异步加载逻辑在此方法中处理@Overrideprotected Bitmap doInBackground(Object... params) {mImageView = (ImageView) params[0];url = (String) params[1];mImageView.setTag(url);// 将imageView和url绑定在一起// publishProgress(values)//通知进度// 下载图片return download(url);}// 主线程运行, 更新进度@Overrideprotected void onProgressUpdate(Integer... values) {super.onProgressUpdate(values);}// 主线程运行, 更新主界面@Overrideprotected void onPostExecute(Bitmap result) {if (result != null) {// 判断当前图片是否就是imageView要的图片, 防止listview重用导致的图片错乱的情况出现String bindUrl = (String) mImageView.getTag();if (bindUrl.equals(url)) {// 给imageView设置图片mImageView.setImageBitmap(result);// 将图片保存在本地mLocalUtils.setBitmapToLocal(result, url);// 将图片保存在内存mMemoryUtils.setBitmapToMemory(url, result);}}}}/*** 下载图片* * @param url*/public Bitmap download(String url) {HttpURLConnection conn = null;try {conn = (HttpURLConnection) (new URL(url).openConnection());conn.setConnectTimeout(5000);conn.setReadTimeout(5000);conn.setRequestMethod("GET");conn.connect();int responseCode = conn.getResponseCode();if (responseCode == 200) {InputStream in = conn.getInputStream();// 将流转化为bitmap对象Bitmap bitmap = BitmapFactory.decodeStream(in);return bitmap;}} catch (Exception e) {e.printStackTrace();} finally {if (conn != null) {conn.disconnect();}}return null;}} |
MemoryCacheUtils.java 用到了LruCache 很简单我简单翻译下文档:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
* A cache that holds strong references to a limited number of values. Each time * a value is accessed, it is moved to the head of a queue. When a value is * added to a full cache, the value at the end of that queue is evicted and may * become eligible for garbage collection. * Cache保存一个强引用来限制内容数量，每当Item被访问的时候，此Item就会移动到队列的头部。* 当cache已满的时候加入新的item时，在队列尾部的item会被回收。 * <p>If your cached values hold resources that need to be explicitly released, * override {@link #entryRemoved}. * 如果你cache的某个值需要明确释放，重写entryRemoved()* <p>By default, the cache size is measured in the number of entries. Override * {@link #sizeOf} to size the cache in different units. For example, this cache * is limited to 4MiB of bitmaps: 默认cache大小是测量的item的数量，重写sizeof计算不同item的* 大小。 {@code * int cacheSize = 4 * 1024 * 1024; // 4MiB * LruCache<String, Bitmap> bitmapCache = new LruCache<String, Bitmap>(cacheSize) { * protected int sizeOf(String key, Bitmap value) { * return value.getByteCount(); * } * }}-------------------------------------------------------------------<p>This class is thread-safe. Perform multiple cache operations atomically by * synchronizing on the cache: <pre> {@code* synchronized (cache) { * if (cache.get(key) == null) { * cache.put(key, value); * } * }}</pre> * 他是线程安全的,自动地执行多个缓存操作并且加锁-------------------------<p>This class does not allow null to be used as a key or value. A return* value of null from {@link #get}, {@link #put} or {@link #remove} is * unambiguous: the key was not in the cache.* 不允许key或者value为null* 当get（），put（），remove（）返回值为null时，key相应的项不在cache中 |
最重要的大概就是以上几点: 使用很简单来看代码
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
|
import android.graphics.Bitmap;import android.support.v4.util.LruCache;/*** 内存缓存工具类* * @author Ace* @date 2016-02-19*/public class MemoryCacheUtils {// Android 2.3 (API Level// 9)开始，垃圾回收器会更倾向于回收持有软引用或弱引用的对象，这让软引用和弱引用变得不再可靠,建议用LruCache,它是强引用private LruCache<String, Bitmap> mCache;public MemoryCacheUtils() {int maxMemory = (int) Runtime.getRuntime().maxMemory();// 获取虚拟机分配的最大内存// 16M// LRU 最近最少使用, 通过控制内存不要超过最大值(由开发者指定), 来解决内存溢出,就像上面翻译的所说 如果cache满了会清理最近最少使用的缓存对象mCache = new LruCache<String, Bitmap>(maxMemory / 8) {@Overrideprotected int sizeOf(String key, Bitmap value) {// 计算一个bitmap的大小int size = value.getRowBytes() * value.getHeight();// 每一行的字节数乘以高度return size;}};}public Bitmap getBitmapFromMemory(String url) {return mCache.get(url);}public void setBitmapToMemory(String url, Bitmap bitmap) {mCache.put(url, bitmap);}} |
最后一级缓存 本地缓存 把网络下载的图片 文件名以MD5的形式保存到内存卡的制定目录
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
/*** 本地缓存工具类* * @author Ace* @date 2016-02-19*/public class LocalCacheUtils {// 图片缓存的文件夹public static final String DIR_PATH = Environment.getExternalStorageDirectory().getAbsolutePath()+ "/ace_bitmap_cache";public Bitmap getBitmapFromLocal(String url) {try {File file = new File(DIR_PATH, MD5Encoder.encode(url));if (file.exists()) {Bitmap bitmap = BitmapFactory.decodeStream(new FileInputStream(file));return bitmap;}} catch (Exception e) {e.printStackTrace();}return null;}public void setBitmapToLocal(Bitmap bitmap, String url) {File dirFile = new File(DIR_PATH);// 创建文件夹 文件夹不存在或者它不是文件夹 则创建一个文件夹.mkdirs,mkdir的区别在于假如文件夹有好几层路径的话,前者会创建缺失的父目录 后者不会创建这些父目录if (!dirFile.exists() || !dirFile.isDirectory()) {dirFile.mkdirs();}try {File file = new File(DIR_PATH, MD5Encoder.encode(url));// 将图片压缩保存在本地,参1:压缩格式;参2:压缩质量(0-100);参3:输出流bitmap.compress(CompressFormat.JPEG, 100,new FileOutputStream(file));} catch (Exception e) {e.printStackTrace();}}} |
MD5Encoder
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
import java.security.MessageDigest;public class MD5Encoder {public static String encode(String string) throws Exception {byte[] hash = MessageDigest.getInstance("MD5").digest(string.getBytes("UTF-8"));StringBuilder hex = new StringBuilder(hash.length * 2);for (byte b : hash) {if ((b & 0xFF) < 0x10) {hex.append("0");}hex.append(Integer.toHexString(b & 0xFF));}return hex.toString();}} |
最后新建一个工具类来使用我们上面的三个缓存工具类
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
|
/*** 三级缓存工具类* * @author Ace* @date 2016-02-19*/public class MyBitmapUtils {// 网络缓存工具类private NetCacheUtils mNetUtils;// 本地缓存工具类private LocalCacheUtils mLocalUtils;// 内存缓存工具类private MemoryCacheUtils mMemoryUtils;public MyBitmapUtils() {mMemoryUtils = new MemoryCacheUtils();mLocalUtils = new LocalCacheUtils();mNetUtils = new NetCacheUtils(mLocalUtils, mMemoryUtils);}public void display(ImageView imageView, String url) {// 设置默认加载图片imageView.setImageResource(R.drawable.news_pic_default);// 先从内存缓存加载Bitmap bitmap = mMemoryUtils.getBitmapFromMemory(url);if (bitmap != null) {imageView.setImageBitmap(bitmap);System.out.println("从内存读取图片啦...");return;}// 再从本地缓存加载bitmap = mLocalUtils.getBitmapFromLocal(url);if (bitmap != null) {imageView.setImageBitmap(bitmap);System.out.println("从本地读取图片啦...");// 给内存设置图片mMemoryUtils.setBitmapToMemory(url, bitmap);return;}// 从网络缓存加载mNetUtils.getBitmapFromNet(imageView, url);}} |
以上所述给大家介绍了Android 异步请求图片加三级缓存的相关知识，希望对大家有所帮助。
