Android性能优化之缓存的代码实现

Hi，众猿们，昨天大概谈了一下三级缓存的原理，今天就说其代码实现吧，主要有：
1.随时获取全局Context（上下文对象）的方式
2.如何代码实现json的三级缓存
3.如何编写一个实现Lru算法的缓存类
4.编写一个用LruCache类实现图片的内存缓存的工具类

第一个问题：第一个问题貌似和后三个没啥关系，其实json缓存中获取SharedPreference对象是需要通过Context对象的，因此我们要先解决第一个问题。我们需要创建一个自定义的Application对象：MyApplication，该对象基础自系统的Application对象，其代码如下：

public class MyApplication extends Application {
//创建一个静态全局变量用于保存上下文对象
private static Context mContext;

@Override
public void onCreate() {
super.onCreate();
//创建应用时获取context对象并保存在全局变量中
mContext = getApplicationContext();
}
/**
* 静态方法，可直接由类名调用，用于获取上下文对象
* @return
*/
public static Context getContext(){
return mContext;
}
}

这样，当我们需要用到全局变量时，直接通过类名MyApplication调用getContext()方法即可，很简单吧，还不到20行代码，其实自定义Application对象有很多妙用，如在应用初始化时创建一些全局变量等，这个我看以后有木有机会再说吧。还要注意一点，我们自定义的Application对象需要在AndroidManifest文件中注册，记载application标签下添加下列属性即可：

android:name="lmz.threelevelcache.application.MyApplication"

public class JsonCacheUtil {
public static final int ERROR_NET_NUSED = 1;
public static final int ERROR_NO_RESULT = 0;
public static final String KEY_JSONCACHE = "JsonCache";

public static void loadJson(
String url,
SuccessCallback successCallback,
FailCallback failCallback){
String result = null;
//从本地缓存加载数据，
result = loadFromLocalCache(url);
if(TextUtils.isEmpty(result)){
loadFromNet(url, successCallback, failCallback);
}

}

/**
* 从网络加载json数据，
* @param url 请求数据的url，它会以get方式向服务器请求数据，且
*      请求参数已经添加到的url尾部
* @param successCallback
* @param failCallback
*/
private static void loadFromNet(
final String url,
final SuccessCallback successCallback,
final FailCallback failCallback) {

if(!isNetCanAccessable()){
if (failCallback != null) {
failCallback.onFail(ERROR_NET_NUSED);
}
return;
}

new AsyncTask<Void, Void, String>(){
@Override
protected String doInBackground(Void... params) {
URLConnection connection = null;
try {
connection = new URL(url).openConnection();
connection.setConnectTimeout(3000);
connection.setReadTimeout(3000);
connection.connect();
BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
StringBuffer buffer = new StringBuffer();
String line = null;
while((line = reader.readLine()) != null){
buffer.append(line);
}
return buffer.toString();
} catch (Exception e) {}
return null;
}
@Override
protected void onPostExecute(String result) {
if (result != null) {
//将json数据缓存在本地
cacheJsonToLocal(url, result);
if (successCallback != null) {
successCallback.onSuccess(result);
}
}else {
if (failCallback != null) {
failCallback.onFail(ERROR_NO_RESULT);
}
}
super.onPostExecute(result);
}
}.execute();
}

/**
* 缓存json数据至本地的方法
* @param url
* @param result
*/
protected static void cacheJsonToLocal(String url, String result) {
MyApplication.getContext()
.getSharedPreferences(KEY_JSONCACHE, Context.MODE_PRIVATE)
.edit().putString(url, result).commit();
}

/**
* 判断网络是否连接
* @return 网络已经连接则返回true
*/
private static boolean isNetCanAccessable() {
boolean flag = false;
ConnectivityManager manager = (ConnectivityManager) MyApplication.getContext().getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo info = manager.getActiveNetworkInfo();
if (info != null) {
flag = info.isAvailable();
}
return false;
}

/**
* 根据url从本地缓存中加载json数据
* @param url
* @return 若本地未缓存url对应的json数据则直接返回空字符串
*/
private static String loadFromLocalCache(String url) {
return MyApplication.getContext()
.getSharedPreferences(KEY_JSONCACHE, Context.MODE_PRIVATE)
.getString(url, "");
}

public interface SuccessCallback{ public void onSuccess(String result);}
public interface FailCallback{public void onFail(int error);}
}

代码上都有注释，本猿猿就不在多说了。

第三个问题，昨天的文章已经说过（戳这里看昨天文章），LRU算法有不同的实现方式，不同的方式在命中率、效率、时间空间复杂度等方面也不同，它们各有优缺点，这儿我就挑一个最简单的方式来实现吧（HashMap+链表，其实本猿猿也并不是什么老猿，算法功底也没那么好），其主要的思想为：建立一个链表，储存着HashMap中所有的键，当有值加入HashMap或从HashMap中取出时，将其对应的键移至表头，而每次移除对象时，总是优先移除链表尾的键所对应的值。其代码如下。其完整代码如下：

public abstract class MyLruCache<K, V> {
private int mMaxSize = 0;
private int currSize = 0;

private Map<K, V> mValues = new LinkedHashMap<K, V>();
private List<K> mPositions = new LinkedList<K>();

public MyLruCache(int maxSize){
//设置该所管理的空间的最大值
this.mMaxSize = maxSize;
}

/**
* 将指定的键和值放入集合中
* @param k
* @param v
*/
public void put(K k, V v){
if (mPositions.contains(k)) {
return;
}

int size = sizeof(v);
//若加入了值后该对象所占的空间大于最大空间，则不断移除对象直到不大于最大空间
while(currSize + size > mMaxSize){
removeFromTail();
}

mValues.put(k, v);
mPositions.add(k);

}

/**
* 根据指定的键得到值
* @param k
* @return
*/
public V get(K k){
if ( !mPositions.contains(k)) {
return null;
}

if (mPositions.remove(k)) {
mPositions.add(k);
}else{
return null;
}
return mValues.get(k);
}

/**
* 根据指定的键移除值
* @param k
*/
public void remove(K k){
if ( !mPositions.contains(k)) {
return;
}
mPositions.remove(k);
mValues.remove(k);
}

/**
* 从链表尾部移除值
*/
private void removeFromTail() {
K k = mPositions.remove(0);
V v = mValues.remove(k);
currSize =- sizeof(v);
}

/**
* 用于计算加入该空间的每一个值得大小，子类必须实现该方法
* @param v
* @return
*/
abstract protected int sizeof(V v);
}

Android系统的LruCache对象也是采用这种方式（微信搜索公众号：brooklee123，关注本猿猿的微信公众号“猿聚于此”，回复关键字“LruCache”，即可得到LruCache的源码），LRU算法不仅仅局限于处理图片的缓存，只要我们需要维护一定大小的某一空间（如内存），都可以使用Android为我们提供的LruCache对象。

好了，最后一个问题，不多说了，直接上源码：

public class BitmapMemoryCacheUtils {

private LruCache<String, Bitmap> mMemCache;

public BitmapMemoryCacheUtils() {
long maxMemory = Runtime.getRuntime().maxMemory();// 模拟器默认是16M内存
mMemCache = new LruCache<String, Bitmap>((int) (maxMemory / 8)) {
@Override
protected int sizeOf(String key, Bitmap value) {
return value.getRowBytes() * value.getHeight();// 返回图片大小
}
};
}

/**
* 从内存中取图片
*
* @param url
* @return
*/
public Bitmap getBitmapFromMem(String url) {
return mMemCache.get(url);
}

/**
* 向内存中存图片
*
* @param url
* @param bitmap
*/
public void putBitmapToMem(String url, Bitmap bitmap) {
mMemCache.put(url, bitmap);
}
}

对了，要想理解这一部分，你还有了解URLConnection及其子类HttpURLConnection对象、AsyncTask对象，有机会的话本猿会捯饬捯饬这两个对象的。
本猿还开了一个个人微信公众号：猿聚于此，本猿基本每天都会在该公众号上更新文章，如果大家像获得文章更新的最新信息的话，欢迎关注该微信公众号，微信搜索brooklee123即可关注，最后出个小题，就当娱乐一下吧，想不出来答案的猿猿们可要好好努力呀：
食堂有两个程序猿，一个吃完小心翼翼地把餐具送完才走，一个没送餐具就遛了，请问那个是C++程序猿？