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

一.摘要

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

二.网络访问数据

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@ 
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数据库中的新闻数据》