三级缓存的含义和如何实战使用？

2016-03-28 16:01 阅读 11,320 次 评论 5 条

一.摘要

Android项目开发经常需要使用到网络访问数据，将获取到的数据保存到本地，本地数据使用时写入到内存，再次访问的时候从内存获取数据，这就是平时说的三级缓存，三级缓存听起来很“高大上”，其实集合了网络访问数据/本地访问数据/缓存访问数据三个级别，按理说不是什么困难的事情，前提是你对数据操作的的三种方式都熟悉。
three-cache-demo

二.网络访问数据

Android提供网络访问数据的类是：HttpURLConnection（最基础的访问方式），在实际开发中，我一直使用的第三方的开发框架：android-async-http-0.4.5.jar，它的特点是：1. UI线程中调用，异步执行；2.实现接口AsyncHttpResponseHandler回调方法；3.涉及的类AsyncHttpClient/RequestParams/AsyncHttpResponseHandler，简单的例子：

  1. public class BaseAPI {  
  2.       
  3.     public static String BASE_URL = "http://122.76.77.16:8080";  
  4.     protected static AsyncHttpClient client;  
  5.   
  6.     static {  
  7.         client = new AsyncHttpClient();  
  8.     }  
  9.     /** 
  10.      * 设置http请求超时时间，默认为60s 
  11.      *  
  12.      * @param timeOut 
  13.      */  
  14.     protected static void setTimeOut(int timeOut) {  
  15.         client.setTimeout(timeOut);  
  16.     }  
  17.           
  18.     public static void getLoginState(String name,String psw,AsyncHttpResponseHandler responseHandler) {  
  19.         RequestParams params = new RequestParams();  
  20.                 params.put("name", name);  
  21.         params.put("psw", psw);  
  22.         client.post(BASE_URL, params, responseHandler);  
  23.     }  
  24. }  

更加详细的使用说明，可以参考《Android开发之数据存储的四种方式之一：Network存储》

三.本地访问数据

将数据保存到本地，可以文件流方式写入sdcard的文件中，也可以通过SharedPreferences方式保存键值对，SharedPreferences是一种比较简单的保存数据的方式，封装成了SharedPreferencesUtils类，更加详细的使用说明，可以参考《Android开发之数据存储的四种方式：SharedPreferences》，这里主要使用文件流的方式将新闻数据写入到sdcard的文件中。

  1. 封装FileManager工具类
  2. 封装HttURLConnection工具类
  3. 访问服务器，将新闻数据写入文件

FileManager工具类

FileManager工具类传入需要保存的文件路径/文件名和文件内容，开辟输出流FileOutputStream/输入流FileInputStream，写入到本地sdcard的文件中，涉及到File类的操作：1.创建多级目录使用mkdirs()，2.创建一级目录使用mkdir()，3.判断是否文件目录isDirectory()，更多使用说明可以参考官方文档：java.io.File。

  1. public class FileManager {  
  2.     private Context context;  
  3.   
  4.     public FileManager(Context context) {  
  5.         this.context = context;  
  6.     }  
  7.     /** 
  8.      * 存数据到sdcard 
  9.      *  
  10.      * @param filename 
  11.      *            ：文件名 
  12.      * @param body 
  13.      *            ： 文件内容 
  14.      */  
  15.     public void saveToSdcard(String filename, String body) throws Exception {  
  16.         /** 
  17.          * 存数据到sdcar的实现步骤： 1. 先检查sdcard状态 2. 指定存放的路径及开辟输出流，用于存数据 3. 把数据写入文件中 4. 
  18.          * 记得加权限 
  19.          *  
  20.          */  
  21.         if (Environment.getExternalStorageState().equals(  
  22.                 Environment.MEDIA_MOUNTED)) {  
  23.             File rootPath = context  
  24.                     .getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS);  
  25.             File file = new File(rootPath, filename);  
  26.   
  27.             // 开辟输出流  
  28.             FileOutputStream fos = new FileOutputStream(file);  
  29.             fos.write(body.getBytes());  
  30.             fos.close();  
  31.             Toast.makeText(context, "存入手机外部存储", 0).show();  
  32.   
  33.         }else{  
  34.                      Toast.makeText(context, "请插入SDcard!", 0).show();  
  35.         }  
  36.   
  37.     }  
  38.   
  39.     /** 
  40.      * 从手机sdcard读数据 
  41.      *  
  42.      * @param filename 
  43.      *            :文件名 
  44.      * @return ： FileInputStream :文件输入流 位置 
  45.      */  
  46.     public String getDataFromSDCard(String filename) throws Exception {  
  47.         if (Environment.getExternalStorageState().equals(  
  48.                 Environment.MEDIA_MOUNTED)) {  
  49.             File rootPath = context  
  50.                     .getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS);  
  51.   
  52.             FileInputStream openFileInput = new FileInputStream(rootPath + "/"  
  53.                     + filename);  
  54.             BufferedReader bufferedReader = new BufferedReader(  
  55.                     new InputStreamReader(openFileInput));  
  56.             String body = bufferedReader.readLine();// 取得一行  
  57.             openFileInput.close();  
  58.             return body;  
  59.         }  
  60.         return null;  
  61.     }  
  62.           
  63. }  

HttpURLConnection工具类

流分为：字节流/字符流/文件流/数组流/缓冲流等，字节流是流操作的最小单位，字符流以字符为单位，文件流是特定对文件操作的一种流，对于其他的流操作也是字节流/字符流的直接或间接子类，比如：DataInputStream/DataOutputStream是InputStream/OutputStream的子类，操作方法是对底层流的“包装”，代码如下：

  1. InputStream is=new InputSteam();  
  2. DataInputStream dis=new DataInputStream(is);  
  1. OutputStream os=new OutputStream();  
  2. DataOutputStream dos=new DataOutputStream(os);  
  1. /* 
  2.  @author postmaster@teachcourse.cn 
  3.  @date 创建于：2016-3-27 
  4.  */  
  5. public class HttpURLConn {  
  6.     private static HttpURLConnection mConnet;  
  7.   
  8.     /** 
  9.      * 单例模式创建HttpURLConnection 
  10.      *  
  11.      * @return 返回HttpURLConnection实例 
  12.      */  
  13.     public static HttpURLConnection newIntance(String url) {  
  14.         if (mConnet == null) {  
  15.             try {  
  16.                 mConnet = (HttpURLConnection) new URL(url).openConnection();  
  17.             } catch (MalformedURLException e) {  
  18.                 e.printStackTrace();  
  19.             } catch (IOException e) {  
  20.                 e.printStackTrace();  
  21.             }  
  22.         }  
  23.         return mConnet;  
  24.     }  
  25.   
  26.     /** 
  27.      * 访问数据 
  28.      *  
  29.      * @return 返回请求的数据 
  30.      */  
  31.     public String get() {  
  32.         try {  
  33.             mConnet.setRequestMethod("get");//设置请求的方式get  
  34.             InputStream is = mConnet.getInputStream();  
  35.             DataInputStream dis = new DataInputStream(is);  
  36.             byte[] bytes = new byte[1024];// 指定每次读取字节数  
  37.             int count = 0;// 记录每次读取的位置  
  38.             StringBuffer sb = new StringBuffer();// 保存每次字符  
  39.             String str = null;  
  40.             while ((count = dis.read(bytes)) != -1) {  
  41.                 str = new String(bytes, 0, count);  
  42.                 sb.append(str);  
  43.             }  
  44.             return sb.toString();  
  45.         } catch (IOException e) {  
  46.   
  47.             e.printStackTrace();  
  48.         }  
  49.         return null;  
  50.   
  51.     }  
  52. }  

MainActivity获取数据

调用HttpURLConn中的get方法访问服务器，获取返回的json数据，然后o把json写入本地sdcard文件，再从sdcard的文件中读取数据在ListView中展示，具体代码如下：

  1. public class MainActivity extends Activity {  
  2.     private static final String TAG = "MainActivity";  
  3.     private ListView mListView;// 展示新闻的ListView列表  
  4.     private List<NewsBean> mList = new ArrayList<NewsBean>();// 新闻实体  
  5.     private NewsBaseAdapter mAdapter = null;// 新闻适配器  
  6.     /** 
  7.      * 调用FileManager工具类保存数到sdcard 
  8.      */  
  9.     private FileManager manager = new FileManager(MainActivity.this);  
  10.     private static final int REFRESH_LISTVIEW = 0x110;  
  11.   
  12.     @Override  
  13.     protected void onCreate(Bundle savedInstanceState) {  
  14.         super.onCreate(savedInstanceState);  
  15.         setContentView(R.layout.activity_main);  
  16.         mListView = (ListView) findViewById(R.id.news_listview);  
  17.         /** 
  18.          * 获取服务器返回的json数据 
  19.          */  
  20.         String url[] = { "http://120.76.76.16:8080/smartpg-1.0/app/cms/listByCode?code=redian&rows=10" };  
  21.         new LoadJsonTask().execute(url);  
  22.   
  23.     }  
  24.   
  25.     @Override  
  26.     protected void onResume() {  
  27.         super.onResume();  
  28.         /** 
  29.          * 从sdcard文件读取新闻数据 
  30.          */  
  31.         try {  
  32.             String json = manager.getDataFromSDCard("json.der");  
  33.             JSONObject obj = new JSONObject(json);  
  34.             String data = obj.getString("data");  
  35.             mList = resolveJson(data);  
  36.             Log.d(TAG, "取出json= " + data);  
  37.         } catch (Exception e) {  
  38.   
  39.             e.printStackTrace();  
  40.         }  
  41.     }  
  42.   
  43.     @Override  
  44.     public boolean onCreateOptionsMenu(Menu menu) {  
  45.         getMenuInflater().inflate(R.menu.main, menu);  
  46.         return true;  
  47.     }  
  48.   
  49.     @Override  
  50.     public boolean onOptionsItemSelected(MenuItem item) {  
  51.         int id = item.getItemId();  
  52.         if (id == R.id.action_settings) {  
  53.             return true;  
  54.         }  
  55.         return super.onOptionsItemSelected(item);  
  56.     }  
  57.   
  58.     private class LoadJsonTask extends AsyncTask<String, Void, String> {  
  59.   
  60.         @Override  
  61.         protected String doInBackground(String... params) {  
  62.             String json = HttpURLConn.newIntance(params[0]).get();  
  63.             if (json == null) {  
  64.                 return "获取不到数据";  
  65.             }  
  66.             return json;  
  67.         }  
  68.   
  69.         @Override  
  70.         protected void onPostExecute(String result) {  
  71.             super.onPostExecute(result);  
  72.             Log.d(TAG, "result= " + result);  
  73.             /** 
  74.              * 保存新闻数据到sdcard 
  75.              */  
  76.             try {  
  77.                 manager.saveToSdcard("json.der", result);  
  78.             } catch (Exception e) {  
  79.                 e.printStackTrace();  
  80.             }             
  81.         }  
  82.   
  83.     }  
  84.   
  85.     private List<NewsBean> resolveJson(String json) {  
  86.         List<NewsBean> mList = new ArrayList<NewsBean>();  
  87.         try {  
  88.             JSONArray mArray = new JSONArray(json);  
  89.             int i = 0;  
  90.             int length = mArray.length();  
  91.             while (i < length) {  
  92.                 JSONObject obj = mArray.getJSONObject(i);  
  93.                 String title = obj.getString("title");  
  94.                 String description = obj.getString("description");  
  95.                 String images = obj.getString("imgUrl");  
  96.                 NewsBean bean = new NewsBean(title, description, images);  
  97.                 mList.add(bean);  
  98.                 i++;  
  99.             }  
  100.             mHandler.sendEmptyMessage(REFRESH_LISTVIEW);  
  101.             return mList;  
  102.         } catch (Exception e) {  
  103.             e.printStackTrace();  
  104.         }  
  105.         return null;  
  106.     }  
  107.   
  108.     Handler mHandler = new Handler() {  
  109.   
  110.         @Override  
  111.         public void handleMessage(Message msg) {  
  112.             // TODO Auto-generated method stub  
  113.             super.handleMessage(msg);  
  114.             switch (msg.what) {  
  115.             case REFRESH_LISTVIEW:  
  116.                 /** 
  117.                  * 刷新新闻列表 
  118.                  */  
  119.                 mAdapter = new NewsBaseAdapter(mList, MainActivity.this);  
  120.                 mListView.setAdapter(mAdapter);  
  121.                 break;  
  122.   
  123.             default:  
  124.                 break;  
  125.             }  
  126.         }  
  127.   
  128.     };  
  129. }  

返回的json类型格式（只罗列一条新闻数据）如下：

  1. {  
  2.   "code": "success",  
  3.   "result": "成功",  
  4.   "data": [  
  5.     {  
  6.       "id": "b78e95f8bb974955aa704496d8a577b2",  
  7.       "isNewRecord": false,  
  8.       "createDate": "2016-01-06 17:31:40",  
  9.       "updateDate": "2016-03-15 15:19:06",  
  10.       "title": "并希望项目负责人要积极抢抓项目施工的晴好天气",  
  11.       "link": "http://120.76.76.16:8080/smartpg-1.0/f/app/cdc4b9b87ac74a5a85806f48cc208890/b78e95f8bb974955aa704496d8a577b2.html",  
  12.       "color": "",  
  13.       "keywords": "",  
  14.       "description": "并希望项目负责人要积极抢抓项目施工的晴好天气，加大施工机械和人力组织，确保项目早日建成达产",  
  15.       "weight": 0,  
  16.       "hits": 13,  
  17.       "posid": ",1,",  
  18.       "categoryId": "cdc4b9b87ac74a5a85806f48cc208890",  
  19.       "imgUrl": "http://120.76.76.16:8080/smartpg-1.0/userfiles/1/_thumbs/images/cms/article/2016/03/112342amokqmsmpnskfnkm.jpg",  
  20.       "images": [  
  21.         "http://120.76.76.16:8080/smartpg-1.0/userfiles/1/_thumbs/images/cms/article/2016/03/1f1ce870bca48ba3a106b19d1cbce4bc.jpg"  
  22.       ],  
  23.       "offset": 106  
  24.     }  
  25.   ]  
  26. }  

解析JSON格式数据使用JSONArray和JSONObject，数学将：{}称为大括号，将：[]称为中括号，在返回的JSON字符串中，大括号使用JSONObject转换成对象，中括号使用JSONArray转换成对象，例如对面的字符串json，转换代码如下：

  1. JSONObject obj = new JSONObject(json);  
  2. String data = obj.getString("data");//取出data嵌套的json数组  
  3. mList = resolveJson(data);  

四.内存读写数据

内存读写数据的位置在：/data/data//file，相对本地文件存储/网络存储，内存存储数据的读写速度是最快的，在Android开发中，能够做到三级缓存的APP，使用起来更加顺畅，因为内存保存数据的位置与当前的包名相关，所以需要Context的openFileInput()/openFileOutput()方法获取输入/输出流，而sdcard读取数据使用的是FileInputStream/FileOutputStream类获取输入/输出流，这是他们两者之间的区别。具体代码，如下：

  1.  /**  
  2.      * 存数据到内存  
  3.      *   
  4.      * @param filename  
  5.      *            :文件名  
  6.      * @param body  
  7.      *            ：文件内容  
  8.      */  
  9. public void saveToPhone(String filename, String body) throws Exception {  
  10.         /**  
  11.          * 开辟一个输出流 filename： 文件名 ，有则打开，无则创建 Mode：文件的操作模式 ： private： 私有的覆盖模式 （默认）  
  12.          * 、append ： 私有的追加模式 return: FileOutputStream  
  13.          * 文件的路径：/data/data/<pachagename>/file  
  14.          *   
  15.          */  
  16.         FileOutputStream openFileOutput = context.openFileOutput(filename,  
  17.                 Context.MODE_APPEND);  
  18.         openFileOutput.write(body.getBytes());// 写字符串到文件输出流  
  19.         openFileOutput.close();// 关闭流  
  20. }  
  21.   
  22.         /**  
  23.      * 从内存读数据  
  24.      *   
  25.      * @param filename  
  26.      *            :文件名  
  27.      * @return ： FileInputStream :文件输入流 位置：/data/data/<pachagename>/file  
  28.      */  
  29. public String getDataFromPhone(String filename) throws Exception {  
  30.   
  31.         FileInputStream openFileInput = context.openFileInput(filename);  
  32.         BufferedReader bufferedReader = new BufferedReader(  
  33.                 new InputStreamReader(openFileInput));  
  34.         String body = bufferedReader.readLine();// 取得一行  
  35.         openFileInput.close();  
  36.         return body;  
  37. }  

可以将上面新闻中的数据同时保存到内存/sdcard，当启动APP时，首先从内存读取，如果内存的数据不存在，再从sdcard中读取，最后
从网络加载，这是三级缓存的开发思路，结合上面的Demo，完成新闻列表的展示。

五.下一篇文章将介绍《如何读写sqlite数据库中的新闻数据》

你可能感兴趣的文章

来源：TeachCourse， 每周一次，深入学习Android教程，关注（QQ158#9359$239或公众号TeachCourse）
转载请注明出处： https://www.teachcourse.cn/1620.html ，谢谢支持！

资源分享

分类：Android Studio, Java基础 标签：, , ,
拨打电话小应用Demo 拨打电话小应用Demo
WordPress文章分页插件：Multi-page Toolkit WordPress文章分页插件：Mult
Eclipse卸载已安装的Genymotion插件 Eclipse卸载已安装的Genymotio
AsyncTask==Handler+Thread对比使用说明 AsyncTask==Handler+Thread对