Android进阶之缓存机制与实现

1 问题描述

1.1 问题

　　在正常情况下进入app首页后，图片加载完成，接着退出app；然后断开网络，再进入app首页，页面显示空白。为什么？

1.1 问题

　　Android开发本质上就是手机和互联网中的web服务器之间进行通信，就必然需要从服务端获取数据，而反复通过网络获取数据是比较耗时的，特别是访问比较多的时候，会极大影响了性能；以及在断网情况下Android获取到的数据就为空。Android中可通过二级缓存来减少频繁的网络操作，减少流量、提升性能，缓存页面的json数据。

2 二级缓存工作机制

　　所谓二级缓存实际上并不复杂，当Android端需要获得数据时比如获取网络中的图片，我们首先从内存中查找（按键查找），内存中没有的再从磁盘文件或sqlite中去查找，若磁盘中也没有才通过网络获取；当获得来自网络的数据，就以key-value对的方式先缓存到内存（一级缓存），同时缓存到文件或sqlite中（二级缓存）。注意：内存缓存会造成堆内存泄露，所有一级缓存通常要严格控制缓存的大小，一般控制在系统内存的1/4。

　　理解了二级缓存大家可能会有个问题网络中的数据是变化的，数据一旦放入缓存中，再取该数据就是从缓存中获得，这样岂不是不能体现数据的变化？我们在缓存数据时会设置有效时间，比如说30分钟，若超过这个时间数据就失效并释放空间，然后重新请求网络中的数据。那么30分钟内咋办？就下拉刷新啦， 实际上这不是问题。 
　　

3 LruJsonCache介绍

3.1.1 LruJsonCache是一个为android制定的 轻量级的 开源缓存框架。轻量到只有一个java文件（由十几个类精简而来）。

3.1.2LruJsonCache可以缓存普通的字符串、JsonObject、JsonArray、Bitmap、Drawable、序列化的java对象，和 byte数据。

3.1.3LruJsonCache特色主要是：

1️⃣轻，轻到只有一个Java文件。 
2️⃣可配置，可以配置缓存路径，缓存大小，缓存数量等。 
3️⃣可以设置缓存超时时间，缓存超时自动失效，并被删除。 
4️⃣支持多进程

3.1.4LruJsonCache在android中可以用在哪些场景

1️⃣替换SharePreference当做配置文件 
2️⃣可以缓存网络请求数据，比如oschina的android客户端可以缓存http请求的新闻内容，缓存时间假设为1个小时，超时后自动失效，让客户端重新请求新的数据，减少客户端流量，同时减少服务器并发量。

4 LruJsonCache使用

public class NewsListActivity extends Activity {
  private List<News> list;
  private ListView listView;
  private LoadImageAdapter adapter;//适配器
  private LruJsonCache lruJsonCache;//缓存框架

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    super.setContentView(R.layout.load_img_listview_activity);

    //第1步：创建LruJsonCache组件
    lruJsonCache = LruJsonCache.get(this);

    initView();//初始化界面，代码不贴了
}

public void loadData(){
   //第3步：从缓存中取数据
   String cacheData = lruJsonCache.getAsString("newsList");//从缓存中取数据

   if(cacheData! = null){//如果缓存中有，就不访问网络
   List<News> newsList = gson.fromJson(cacheData, new TypeToken<List<News>>(){}.getType());//将json转为List
      list.addAll(newsList);
      adapter.notifyDataSetChanged();
      return;
   }

   new Thread(new Runnable() {
     @Override
     public void run() {
       SystemClock.sleep(2000);//模拟网络耗时
       String json=request();//模拟从网络中获取json数据

       //第2步：设置缓存数据，有效时间设置为1小时
       lruJsonCache.put("newslist", json, 60*60*1);

       List<News> newsList=gson.fromJson(json, new TypeToken<List<News>>(){}.getType());
       list.addAll(newsList);
       handler.sendEmptyMessage(1);
    }
  }).start();
}

    /**
     * 模拟网络请求方法
     */
private String request(){
   News news=null;
   for(int i=0;i<10;i++){
       news=new News();
       news.setId(i);
       news.setImgUrl("course/img/face_"+i+".png");
       news.setTitle("新闻标题"+i);
       news.setSummary("测试"+i);
       list.add(news);
   }
   Gson gson=new Gson();
   return gson.toJson(list);    
}

private Handler handler=new Handler()
   @Override
   public void handleMessage(Message msg) {
       switch(msg.what){
           case 1:
             notify_layout.setVisibility(View.GONE);
             adapter.notifyDataSetChanged();
           break;
       }
   }
}

• 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

• 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

5 主要代码解析

5.1 创建LruJsonCache组件

    LruJsonCache lruJsonCache = LruJsonCache.get(context)
    LruJsonCache lruJsonCache = LruJsonCache.get(context,max_size,max_count)
    //max_size:设置限制缓存大小，默认为50M
    //max_count:设置缓存数据的数量，默认不限制 

• 1
• 2
• 3
• 4

• 1
• 2
• 3
• 4

5.2 设置缓存数据

    //将数据同时上存入一级缓存（内存Map）和二级缓存（文件）中
    lruJsonCache.put(key,data,time)
    acache.put(key,data)

    //Key：为存入缓存的数据设置唯一标识，取数据时就根据key来获得的
    //Data：要存入的数据，acache支持的数据类型如图所示：

• 1
• 2
• 3
• 4
• 5
• 6

• 1
• 2
• 3
• 4
• 5
• 6

5.3 从缓存中取数据

提供一系列getAsXXX()方法，如图所示 

6 参考链接

Android 中的缓存机制与实现-本文版权归烟台杰瑞教育科技有限公司和博客园共有

7 LruJsonCache代码

package com.guesslive.caixiangji.util;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.PixelFormat;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;

import org.json.JSONArray;
import org.json.JSONObject;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.RandomAccessFile;
import java.io.Serializable;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;

/**
 * Json缓存工具
 * <p>
 * Created by chenliguan on 16/8/23.
 */
public class LruJsonCache {

    public static final int TIME_HOUR = 60 * 60;
    public static final int TIME_DAY = TIME_HOUR * 24;
    private static final int MAX_SIZE = 1000 * 1000 * 50; // 50 mb
    private static final int MAX_COUNT = Integer.MAX_VALUE; // 不限制存放数据的数量
    private static Map<String, LruJsonCache> mInstanceMap = new HashMap<String, LruJsonCache>();
    private ACacheManager mCache;

    public static LruJsonCache get(Context ctx) {
        return get(ctx, "LruJsonCache");
    }

    public static LruJsonCache get(Context ctx, String cacheName) {
        File f = new File(ctx.getCacheDir(), cacheName);
        return get(f, MAX_SIZE, MAX_COUNT);
    }

    public static LruJsonCache get(File cacheDir) {
        return get(cacheDir, MAX_SIZE, MAX_COUNT);
    }

    public static LruJsonCache get(Context ctx, long max_zise, int max_count) {
        File f = new File(ctx.getCacheDir(), "LruJsonCache");
        return get(f, max_zise, max_count);
    }

    public static LruJsonCache get(File cacheDir, long max_zise, int max_count) {
        LruJsonCache manager = mInstanceMap.get(cacheDir.getAbsoluteFile() + myPid());
        if (manager == null) {
            manager = new LruJsonCache(cacheDir, max_zise, max_count);
            mInstanceMap.put(cacheDir.getAbsolutePath() + myPid(), manager);
        }
        return manager;
    }

    private static String myPid() {
        return "_" + android.os.Process.myPid();
    }

    private LruJsonCache(File cacheDir, long max_size, int max_count) {
        if (!cacheDir.exists() && !cacheDir.mkdirs()) {
            throw new RuntimeException("can\'t make dirs in "
                    + cacheDir.getAbsolutePath());
        }
        mCache = new ACacheManager(cacheDir, max_size, max_count);
    }

    // =======================================
    // ============ String数据 读写 ==============
    // =======================================

    /**
     * 保存 String数据 到 缓存中
     *
     * @param key   保存的key
     * @param value 保存的String数据
     */
    public void put(String key, String value) {
        File file = mCache.newFile(key);
        BufferedWriter out = null;
        try {
            out = new BufferedWriter(new FileWriter(file), 1024);
            out.write(value);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (out != null) {
                try {
                    out.flush();
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            mCache.put(file);
        }
    }

    /**
     * 保存 String数据 到 缓存中
     *
     * @param key      保存的key
     * @param value    保存的String数据
     * @param saveTime 保存的时间，单位：秒
     */
    public void put(String key, String value, int saveTime) {
        put(key, Utils.newStringWithDateInfo(saveTime, value));
    }

    /**
     * 读取 String数据
     *
     * @param key
     * @return String 数据
     */
    public String getAsString(String key) {
        File file = mCache.get(key);
        if (!file.exists())
            return null;
        boolean removeFile = false;
        BufferedReader in = null;
        try {
            in = new BufferedReader(new FileReader(file));
            String readString = "";
            String currentLine;
            while ((currentLine = in.readLine()) != null) {
                readString += currentLine;
            }
            if (!Utils.isDue(readString)) {
                return Utils.clearDateInfo(readString);
            } else {
                removeFile = true;
                return null;
            }
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        } finally {
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (removeFile)
                remove(key);
        }
    }

    // =======================================
    // ============= JSONObject 数据 读写 ==============
    // =======================================

    /**
     * 保存 JSONObject数据 到 缓存中
     *
     * @param key   保存的key
     * @param value 保存的JSON数据
     */
    public void put(String key, JSONObject value) {
        put(key, value.toString());
    }

    /**
     * 保存 JSONObject数据 到 缓存中
     *
     * @param key      保存的key
     * @param value    保存的JSONObject数据
     * @param saveTime 保存的时间，单位：秒
     */
    public void put(String key, JSONObject value, int saveTime) {
        put(key, value.toString(), saveTime);
    }

    /**
     * 读取JSONObject数据
     *
     * @param key
     * @return JSONObject数据
     */
    public JSONObject getAsJSONObject(String key) {
        String JSONString = getAsString(key);
        try {
            JSONObject obj = new JSONObject(JSONString);
            return obj;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    // =======================================
    // ============ JSONArray 数据 读写 =============
    // =======================================

    /**
     * 保存 JSONArray数据 到 缓存中
     *
     * @param key   保存的key
     * @param value 保存的JSONArray数据
     */
    public void put(String key, JSONArray value) {
        put(key, value.toString());
    }

    /**
     * 保存 JSONArray数据 到 缓存中
     *
     * @param key      保存的key
     * @param value    保存的JSONArray数据
     * @param saveTime 保存的时间，单位：秒
     */
    public void put(String key, JSONArray value, int saveTime) {
        put(key, value.toString(), saveTime);
    }

    /**
     * 读取JSONArray数据
     *
     * @param key
     * @return JSONArray数据
     */
    public JSONArray getAsJSONArray(String key) {
        String JSONString = getAsString(key);
        try {
            JSONArray obj = new JSONArray(JSONString);
            return obj;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    // =======================================
    // ============== byte 数据 读写 =============
    // =======================================

    /**
     * 保存 byte数据 到 缓存中
     *
     * @param key   保存的key
     * @param value 保存的数据
     */
    public void put(String key, byte[] value) {
        File file = mCache.newFile(key);
        FileOutputStream out = null;
        try {
            out = new FileOutputStream(file);
            out.write(value);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (out != null) {
                try {
                    out.flush();
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            mCache.put(file);
        }
    }

    /**
     * 保存 byte数据 到 缓存中
     *
     * @param key      保存的key
     * @param value    保存的数据
     * @param saveTime 保存的时间，单位：秒
     */
    public void