(Android)之三級緩存(及封裝方法)

為什麼使用三級緩存？

在當今4G網路的時代中，浏覽網頁的越來越快，隨之而來的就是流量不夠用，那麼各種app都在往省流量的方向上走著，如果你的app沒有緩存，那麼用戶往回浏覽信息又會再刷新一次數據，這樣就背道而馳了。所以有了三級緩存的機制了。 安卓有一個解決的方法，就是使用LRUCache。 什麼是LRUCache？意思為最近最少使用算法的緩存

三級緩存幫助類及其詳解

1、首先得理解什麼是三級緩存？ 我們希望的程序打開一個app加載圖片的方法為： 內存--->磁盤-->網絡 存入內存的方法有，使用LruCache,而磁盤存儲安卓沒有專門的類可以使用，但是在github上，google公司也默認的可行的方法類，今天我們將用到這個類：DiskLruCache 我這裡有兩個鏈接：一個是源碼，一個是jar

2、前期准備工作已完成，那麼開始寫我們的幫助類吧

package com.sdp.panda.pictrueapp;

import android.app.ActivityManager;
import android.content.Context;
import android.content.pm.PackageManager;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.AsyncTask;
import android.os.Environment;
import android.util.LruCache;

import com.jakewharton.disklrucache.DiskLruCache;

import java.io.BufferedInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

/**
 * Created by 80926 on 2016/10/19.
 * 包涵內存和磁盤緩存
 */

public class LruCacheUtils {
    private static LruCacheUtils instance;//單例模式
    private LruCache lruCache;
    private Context context;
    private DiskLruCache diskLruCache;

    private LruCacheUtils() {}

    public static LruCacheUtils getInstance() {
        if (instance == null) {
            instance = new LruCacheUtils();
        }
        return instance;
    }

    //打開磁盤緩存
    public void open(Context context, String disk_cache_subdir, int dis_cache_size) {
        try {
            this.context = context;
            ActivityManager manager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
            int memoryClass = manager.getMemoryClass();
            lruCache = new LruCache<>((memoryClass / 8) * 1024 * 1024);//獲得內存緩存空間為給定的內存的1/8，
            /**
             * getAppVersion():獲取版本的時候，就會清除緩存
             *               1:為一個key存多少個類型的緩存,磁盤的大小
             *  dis_cache_size:自己存儲的大小，通常為10M
             */
            diskLruCache = DiskLruCache.open(getCacheDir(disk_cache_subdir), getAppVersion(), 1, dis_cache_size);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //緩存文件
    private File getCacheDir(String name) {
        //如果有sd卡，那麼創建在外部儲存mnt/android/data/packageame/cache/name ，
        // 否則創建在內部儲存dada/data/package/cache/name中（最好為1m）
        String cachePath = (Environment.getExternalStorageState() == Environment.MEDIA_MOUNTED || !Environment.isExternalStorageRemovable() ?
                context.getExternalCacheDir().getPath() : context.getCacheDir().getPath());
        return new File(cachePath + File.separator + name);
    }

    //版本信息
    private int getAppVersion() {
        try {
            return context.getPackageManager().getPackageInfo(context.getPackageName(), 0).versionCode;
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        }
        return 1;
    }
    //根據MD5計算出來的字符串,根據下載的地址轉換成MD5的新字符串
    public String hashKeyForDisk(String url){
        String cacheKey;
        try {
            MessageDigest digest = MessageDigest.getInstance("MD5");//計算摘要 16進制的符號
            digest.update(url.getBytes());
            cacheKey = bytesToHexString(digest.digest());
        }catch (NoSuchAlgorithmException e){
            cacheKey = String.valueOf(url.hashCode());
        }
        return cacheKey;
    }
    public String bytesToHexString(byte[] digests){
        StringBuilder sb = new StringBuilder();
        for(int i = 0 ; i < digests.length ; i ++){
            String hex = Integer.toHexString(0xFF&digests[i]);
            if (hex.length() ==1){
                sb.append("0");
            }
            sb.append(hex);
        }
        return sb.toString();
    }
    /**
     * 下載圖片到內存和磁盤
     * 使用到下載就需要異步任務完成
     */
    public void fromNetToCache(String url, final int reqWidth, final int reqHeight, final Callback callback){
        new AsyncTask(){

            @Override
            protected Bitmap doInBackground(String... params) {
                String key = hashKeyForDisk(params[0]);
                System.out.println("key:::::"+key);
                DiskLruCache.Editor editor = null;
                Bitmap bitmap = null;
                try {
                    URL url = new URL(params[0]);
                    HttpURLConnection conn = (HttpURLConnection) url.openConnection();
                    conn.setReadTimeout(1000*30);
                    conn.setConnectTimeout(1000*30);
                    ByteArrayOutputStream baos = null;
                    if (conn.getResponseCode()==HttpURLConnection.HTTP_OK&&conn!=null){
                        BufferedInputStream bis = new BufferedInputStream(conn.getInputStream());
                        baos = new ByteArrayOutputStream();
                        byte[] buffer = new byte[1024];
                        int len = -1;
                        while ((len = bis.read(buffer))!=-1){
                            baos.write(buffer,0,len);
                            baos.flush();
                        }
                        bis.close();
                        baos.close();
                        conn.disconnect();
                    }
                    if (baos!=null){
                        bitmap = decodeSampleBitmapFromStream(baos.toByteArray(),reqWidth,reqHeight);//縮小以後的位圖
                        addBitmapToCache(params[0],bitmap);//添加到緩存種
                        editor = diskLruCache.edit(key);//添加到磁盤
                        System.out.println(url.getFile());
                        //這個方法是將文件存在輸出流當中，並且可以壓縮,這裡只是操作一張圖片所以為 0
                        //這裡的100為不壓縮，70的話是壓縮30%
                        bitmap.compress(Bitmap.CompressFormat.JPEG,100,editor.newOutputStream(0));
                        editor.commit();
                    }
                }catch (IOException e){
                   try {
                       editor.abort();
                   }catch (IOException ie){
                       ie.printStackTrace();
                   }
                }
                return bitmap;
            }

            @Override
            protected void onPostExecute(Bitmap bitmap) {
                super.onPostExecute(bitmap);
                callback.response(bitmap);
            }
        }.execute(url);
    }
        //從磁盤中取
        public InputStream getDiskCache(final String url){
            String key = hashKeyForDisk(url);
            System.out.println("diskKey::::"+key);
            try {
                DiskLruCache.Snapshot snapshot = diskLruCache.get(key);
                if (snapshot!=null){
                    InputStream is = snapshot.getInputStream(0);
                    return snapshot.getInputStream(0);
                }
            }catch (IOException e){
                e.printStackTrace();
            }
            return null;
        }
    //關閉磁盤緩存的方法
    public void close(){
        if (diskLruCache!=null && !diskLruCache.isClosed()){
            try {
                diskLruCache.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    //刷新的磁盤緩存的方法
    public void flush()  {
        if (diskLruCache!=null){
            try {
                diskLruCache.flush();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    //回掉接口
    public interface Callback{
        void response(Bitmap entity);
    }

    /**
     * 以下的是往內存中存儲
     */
    //計算所有變換的比例，采樣率
    public  int calculateInSampleSize(BitmapFactory.Options options,int reqWidth,int reqHeight){
        int height = options.outHeight;
        int width = options.outWidth;
        int inSampleSize = 1;
        if (height>reqHeight||width>reqWidth){
            if (width>height){
                inSampleSize = Math.round((float)height/(float)reqHeight);
            }else {
                inSampleSize = Math.round((float)width/(float)reqWidth);
            }
        }
        return inSampleSize;
    }
    //從網路中得到的字節流,得到需求的bitmap
    public  Bitmap decodeSampleBitmapFromStream(byte[] bytes,int reqWidth, int reqHeight){
        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;//只是獲取它的屬性不顯示圖片
        BitmapFactory.decodeByteArray(bytes,0,bytes.length,options);
        options.inSampleSize = calculateInSampleSize(options,reqWidth,reqHeight);
        options.inJustDecodeBounds = false;//不獲取屬性，
        return BitmapFactory.decodeByteArray(bytes,0,bytes.length,options);
    }
    //從本地圖片中得到得到最新位圖
    public  Bitmap decodeSampleBitmapFromResource(Resources resources, int resId, int reqWidth, int reqHeight){
        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;//只是獲取它的屬性不顯示圖片
        BitmapFactory.decodeResource(resources,resId,options);
        options.inSampleSize = calculateInSampleSize(options,reqWidth,reqHeight);
        options.inJustDecodeBounds = false;//不獲取屬性，
        return BitmapFactory.decodeResource(resources,resId,options);
    }
    //LRU緩存,往內存中添加位圖
    public  void addBitmapToCache(String url,Bitmap bitmap){
        String key = hashKeyForDisk(url);
        if (getBitmapFromCache(key)==null){
            lruCache.put(key,bitmap);
        }
    }
    //從LRU內存中取出要用的key對應的bitmap
    public  Bitmap getBitmapFromCache(String url){
        String key = hashKeyForDisk(url);
        return lruCache.get(key);
    }
}

3.封裝類已完成，那麼接下來就是怎麼使用了
由於測試的界面簡單，就大概講一下，就是在布局文件中創建一個ImageView和一個Button；

private String url = "http://www.xxx.xxx.png";
LruCacheUtils instance = LruCacheUtils.getInstance();//獲取類
Button btn = (Button)findViewById(R.id.btn_test);
ImageView iv = (Button)findViewById(R.id.btn_test);
btn.setOnClickListener(new OnClickListener()){
    @override
    public void click(View v){
        //300，200為想要的圖片尺寸
        loadBitmap(url,300,200);
    }
};

private void  loadBitmap(String url,int reqWidth,int reqHeight){
    //1、先從內存中獲取
    Bitmap bitmap = instance.getBitmapFromCache();
    if(bitmap==null){
        //2、再從磁盤中獲取
        InputStream is = instance.getDiskCache(url);
        if(is==null){
            //3、最後從網路中下載並保存內存中
            instance.fromNetToCache(url,,reqWidth,reqHeight,new LruCacheUtils.Callback() {
                @Override
                public void response(Bitmap entity) {
                    iv.setImageBitmap(entity);
                }
            });)
        }else{
            bitmap = BitmapFactory.decodeStream(is);
            //需要將磁盤中保存的文件添加到內存中
            instance.addBitmapToCache(url,bitmap);
            iv.setImageBitmap(bitmap);
        }
    }else{
        iv.setImageBitmap(bitmap);
    }
}

結束了，自己一定要研究一下幫助類中的方法啊。