學(xué)習(xí)資料：

Android 開發(fā)藝術(shù)探索

其實就是完完全全摘抄，讀書筆記 : )

LruCache和DiskLruCache是采用了LRU(Least Recently Used)近期最少使用算法的兩種緩存。LruCache內(nèi)存緩存，DiskLruCache存儲設(shè)備緩存

1.LruCache 內(nèi)存緩存

LruCache是一個泛型類，內(nèi)部是一個LinkedHashMap以強引用的方式存儲緩存對象，提供了get和put方法進行對緩存對象的操作。當(dāng)緩存滿時，移除近期最少使用的緩存對象，添加新的緩存對象

強引用：直接的對象引用
軟引用：當(dāng)一個對象只有軟引用存在時，系統(tǒng)內(nèi)存不足時，會被gc回收
弱引用：當(dāng)一個對象只有弱引用存在時，該對象會隨時被gc回收

LruCache是線程安全的

LruCache典型的初始化，重寫sizeOf()方法

int MaxMemory = (int)(Runtime.getRuntime().maxMemory() / 1024);// kB
int cacheSize = maxMemory / 8;
mMemoryCache = new LruCache<String,Bitmap>(cacheSize){
    @Override
    protected int sizeOf(String key,Bitmap bitmap){
        //bitmap.getByteCount() = bitmap.getRowBytes() * bitmap.getHeight(); 
        return bitmap.getRowBytes() * bitmap.getHeight() / 1024;// KB
    } 
}

計算緩存對象大小的單位和總?cè)萘康膯挝灰３忠恢?/p>

一些特殊時候，還需要重寫entryRemoved()方法。LruCache移除舊緩存對象時會調(diào)用這個方法，根據(jù)需求可以在這個方法中完成一些資源回收工作

獲取一個緩存對象，mMemoryCache.get(key)
添加一個緩存對象，mMemoryCache.put(key,bitmap)

2.DiskLruCache 磁盤緩存

DiskLruCache并不是Android SDK中的類。不明白為啥，官方只進行推薦，為何不加入SDK中

2.1創(chuàng)建

private static final long DISK_CACHE_SIZE = 1024 * 1024 * 50;// 50MB

File diskCacheDir = new File(mContext,"bitmap");
if(!diskCacheDir.exists()){
   diskCacheDir.mkdirs();
}
mDiskLruCache = DiskLruCache.open(diskCacheDir,1,1,DISK_CACHE_SIZE);

diskCacheDir 緩存文件夾，具體指sdcard/Android/data/package_name/cache
1 應(yīng)用版本號，一般寫為1
1 單個節(jié)點所對應(yīng)的數(shù)據(jù)的個數(shù)，一般寫1
DISK_CACHE_SIZE 緩存大小

2.2添加

DishLruCache緩存添加的操作通過Eidtor完成，Editor為一個緩存對象的編輯對象。

首先需要獲取圖片的url所對應(yīng)的key，根據(jù)key利用edit()來獲取Editor對象。若此時，這個緩存正在被編輯，edit()會返回null。DiskLruCache不允許同時編輯同一個緩存對象。之所以把url轉(zhuǎn)換成key，因為圖片的url中可能存在特殊字符，會影響使用，一般將url的md5值作為key

private String hashKeyFromUrl(String url){
    String cacheKey;
    try {
        final MessageDigest  mDigest = MessageDigest.getInstance("MD5");
        mDigest.update(url.getBytes());
        cacheKey = byteToHexString(mDigest.digest());
    } catch (NoSuchAlgorithmException e) {
        cacheKey = String.valueOf(url.hashCode());
    }
     return  cacheKey;
}

private String byteToHexString(byte[] bytes) {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < bytes.length; i ++){
          String hex = Integer.toHexString(0xFF & bytes[i]);//得到十六進制字符串
          if (hex.length() == 1){
             sb.append('0');
          }
          sb.append(hex);
    }
    return  sb.toString();
}

將url轉(zhuǎn)成key，利用這key值獲取Editor對象。若這個key的Editor對象不存在，edit()方法就創(chuàng)建一個新的出來。通過Editor對象可以獲取一個輸出流對象。DiskLruCache的open()方法中，一個節(jié)點只能有一個數(shù)據(jù)，edit.newOutputStream(DISK_CACHE_INDEX)參數(shù)設(shè)置為0

String key = hashKeyFromUrl(url);
DiskLruCache.Editor editor =mDiskLruCache.edit(key);
if (editor != null){
    OutputStream outputStream = editor.newOutputStream(DISK_CACHE_INDEX);
}

有了這個文件輸出流，從網(wǎng)絡(luò)加載一個圖片后，通過這個OutputStream outputStream寫入文件系統(tǒng)

private boolean downLoadUrlToStream(String urlString, OutputStream outputStream) {
        HttpURLConnection urlConnection = null;
        BufferedOutputStream bos = null;
        BufferedInputStream bis = null;
        try {
            final URL url   = new URL(urlString);
            urlConnection = (HttpURLConnection) url.openConnection();
            bis = new BufferedInputStream(urlConnection.getInputStream(),8 * 1024);
            bos = new BufferedOutputStream(outputStream,8 * 1024);
            int b ;
            while((b = bis.read())!= -1){
                bos.write(b);
            }
            return  true;
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (urlConnection != null){
                urlConnection.disconnect();
            }
            closeIn(bis) ;
            closeOut(bos);
        }
        return   false;
}

上面的代碼并沒有將圖片寫入文件系統(tǒng)，還需要通過Editor.commit()提交寫入操作，若寫入失敗，調(diào)用abort()方法，進行回退整個操作

if (downLoadUrlToStream(url,outputStream)){
    editor.commit();//提交
}else {
    editor.abort();//重復(fù)操作
}

這時，圖片已經(jīng)正確寫入文件系統(tǒng)，接下來的圖片獲取就不需要請求網(wǎng)絡(luò)

2.3 緩存查找

查找過程，也需要將url轉(zhuǎn)換為key，然后通過DiskLruCache的get方法得到一個Snapshot對象，再通過Snapshot對象可得到緩存的文件輸入流，有了輸入流就可以得到Bitmap對象

為了避免oom，會使用ImageResizer進行縮放。若直接對FileInputStream進行操作，縮放會出現(xiàn)問題。FileInputStream是有序的文件流，兩次decodeStream調(diào)用會影響文件流的位置屬性。可以通過文件流得到其所對應(yīng)的文件描述符，利用BitmapFactory.decodeFileDescriptor()方法進行縮放

Bitmap bitmap = null;
String key = hashKeyFromUrl(url);
DiskLruCache.Snapshot snapshot = mDiskLruCache.get(key);
if (snapshot != null){
    FileInputStream fis = (FileInputStream) snapshot.getInputStream(DISK_CACHE_INDEX);
    FileDescriptor fileDescriptor = fis.getFD();
    bitmap = imageResizer.decodeBitmapFromFileDescriptor(fileDescriptor,targetWidth,targetHeight);
    if (bitmap != null){
        addBitmapToMemoryCache(key,bitmap);
    }
}

在查找得到Bitmap后，把key,bitmap添加到內(nèi)存緩存中

3.ImageLoader的實現(xiàn)

主要思路：

拿到圖片請求地址url后，先把url變作對應(yīng)的key；
利用key在內(nèi)存緩存中查找，查找到了就進行加載顯示圖片；若沒有查到就進行3
在磁盤緩存中查找，在若查到了，就加載到內(nèi)存緩存，后加載顯示圖片；若沒有查找到，進行4
進行網(wǎng)絡(luò)求，拿到數(shù)據(jù)圖片，把圖片寫進磁盤緩存成功后，再加入到內(nèi)存緩存中，并根據(jù)實際所需顯示大小進行合理縮放顯示

類比較長，查看順序：構(gòu)造方法->bindBitmap(),之后順著方法內(nèi)的方法，結(jié)合4個步驟，并不難理解

public class ImageLoader {
    private static final long DISK_CACHE_SIZE = 1024 * 1024 * 50;// 50MB
    private Context mContext;
    private LruCache<String, Bitmap> mMemoryCache;
    private DiskLruCache mDiskLruCache;
    private boolean mIsDiskLruCacheCreated = false;//用來標(biāo)記mDiskLruCache是否創(chuàng)建成功
    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
    private static final int CORE_POOL_SIZE = CPU_COUNT+ 1;
    private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
    private static final long KEEP_ALIVE = 10;
    private final int DISK_CACHE_INDEX = 0;

    private static final int MESSAGE_POST_RESULT = 101;

    private ImageResizer imageResizer = new ImageResizer();

    private static final ThreadFactory mThreadFactory = new ThreadFactory() {
        private final AtomicInteger mCount = new AtomicInteger(1);
        @Override
        public Thread newThread(Runnable r) {
            return new Thread(r,"ImageLoader#"+mCount.getAndIncrement());
        }
    };
    /**
     * 創(chuàng)建線程池
     */
    public static final Executor THREAD_POOL_EXECUTOR = new ThreadPoolExecutor(
            CORE_POOL_SIZE,MAXIMUM_POOL_SIZE,KEEP_ALIVE, TimeUnit.SECONDS,
            new LinkedBlockingDeque<Runnable>(),mThreadFactory
    );

    /**
     * 創(chuàng)建Handler
     */
    private Handler mHandler = new Handler(Looper.getMainLooper()){
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            if (msg.what == MESSAGE_POST_RESULT){
                LoaderResult loadResult = (LoaderResult) msg.obj;
                ImageView iv = loadResult.iv;
                String url = (String) iv.getTag();
                if (url.equals(loadResult.uri)){//防止加載列表形式時，滑動復(fù)用的錯位
                    iv.setImageBitmap(loadResult.bitmap);
                }
            }
        }
    };

    private ImageLoader(Context mContext) {
        this.mContext = mContext.getApplicationContext();
        init();
    }
   /**
     * 創(chuàng)建一個ImageLoader
     */
    public static ImageLoader build(Context context) {
        return new ImageLoader(context);
    }

    
   /**
     * 初始化
     * LruCache<String,Bitmap> mMemoryCache
     * DiskLruCache mDiskLruCache
     */
    private void init() {
        // LruCache<String,Bitmap> mMemoryCache
        int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
        int cacheSize = maxMemory / 8;
        mMemoryCache = new LruCache<String, Bitmap>(cacheSize) {
            @Override
            protected int sizeOf(String key, Bitmap bitmap) {
                 //return bitmap.getRowBytes() * bitmap.getHeight() / 1024;
                return bitmap.getByteCount() / 1024;
            }
        };
        // DiskLruCache mDiskLruCache
        File diskCacheDir = getDiskCacheDir(mContext, "bitmap");
        if (!diskCacheDir.exists()) {
            diskCacheDir.mkdirs();
        }
        if (getUsableSpace(diskCacheDir) > DISK_CACHE_SIZE) {
            try {
                mDiskLruCache = DiskLruCache.open(diskCacheDir, 1, 1, DISK_CACHE_SIZE);
                mIsDiskLruCacheCreated = true;
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

   
    /**
     *  加載原始大小的圖
     */
    public  void bindBitmap(String uri,ImageView iv){
        bindBitmap(uri,iv,0,0);
    }

    /**
     * 異步加載網(wǎng)絡(luò)圖片 指定大小
     */
    public void bindBitmap(final String uri, final ImageView iv, final int targetWidth, final int targetHeight){
         iv.setTag(uri);
         Bitmap bitmap = loadBitmapFormMemCache(uri);
        if (bitmap != null){
            iv.setImageBitmap(bitmap);
            return;
        }
        Runnable loadBitmapTask = new Runnable() {
            @Override
            public void run() {
                Bitmap bitmap = loadBitmap(uri,targetWidth,targetHeight);
                if (bitmap != null){
                    LoaderResult result = new LoaderResult(iv,uri,bitmap);
                    Message message = mHandler.obtainMessage();
                    message.obj = result;
                    message.what = MESSAGE_POST_RESULT;
                    mHandler.sendMessage(message);
                }
            }
        };
        THREAD_POOL_EXECUTOR.execute(loadBitmapTask);
    }

    /**
     * 同步加載網(wǎng)絡(luò)圖片
     */
    private Bitmap loadBitmap(String url, int targetWidth, int targetHeight) {
        Bitmap bitmap = loadBitmapFormMemCache(url);
        if (bitmap != null) {
            return bitmap;
        }
        try {
            bitmap = loadBitmapFromDiskCache(url, targetWidth, targetHeight);
            if (bitmap != null) {
                return bitmap;
            }
            bitmap = loadBitmapFromHttp(url, targetWidth, targetHeight);
        } catch (IOException e) {
            e.printStackTrace();
        }
        if (bitmap == null && !mIsDiskLruCacheCreated) {//緩存文件夾創(chuàng)建失敗
            bitmap = downLoadFromUrl(url);
        }
        return bitmap;
    }
    
    /**
     * 向緩存中添加Bitmap
     */
    private void addBitmapToMemoryCache(String key, Bitmap bitmap) {
        if (getBitmapFromMemoryCache(key) == null) {
            mMemoryCache.put(key, bitmap);
        }
    }

    /**
     * 通過key拿到bitmap
     */
    private Bitmap getBitmapFromMemoryCache(String key) {
        return mMemoryCache.get(key);
    }

    private Bitmap loadBitmapFormMemCache(String url) {
        final String key = hashKeyFromUrl(url);
        return getBitmapFromMemoryCache(key);
    }

    /**
     * 從網(wǎng)絡(luò)進行請求
     */
    private Bitmap loadBitmapFromHttp(String url, int targetWidth, int targetHeight) throws IOException {
        if (Looper.myLooper() == Looper.getMainLooper()) {
            throw new RuntimeException("UI 線程不能進行網(wǎng)絡(luò)訪問");
        }
        if (mDiskLruCache == null) {
            return null;
        }
        String key = hashKeyFromUrl(url);
        DiskLruCache.Editor editor = mDiskLruCache.edit(key);
        if (editor != null) {
            OutputStream outputStream = editor.newOutputStream(DISK_CACHE_INDEX);
            if (downLoadUrlToStream(url, outputStream)) {
                editor.commit();
            } else {
                editor.abort();//重復(fù)操作
            }
            mDiskLruCache.flush();//刷新
        }
        return loadBitmapFromDiskCache(url, targetWidth, targetHeight);
    }

    /**
     * 從硬盤緩存中讀取Bitmap
     */
    private Bitmap loadBitmapFromDiskCache(String url, int targetWidth, int targetHeight) throws IOException {
        if (Looper.myLooper() == Looper.getMainLooper()) {
            throw new RuntimeException("硬盤讀取Bitmap在UI線程，UI 線程不進行耗時操作");
        }
        if (mDiskLruCache == null) {
            return null;
        }
        Bitmap bitmap = null;
        String key = hashKeyFromUrl(url);
        DiskLruCache.Snapshot snapshot = mDiskLruCache.get(key);
        if (snapshot != null) {
            FileInputStream fis = (FileInputStream) snapshot.getInputStream(DISK_CACHE_INDEX);
            FileDescriptor fileDescriptor = fis.getFD();
            bitmap = imageResizer.decodeBitmapFromFileDescriptor(fileDescriptor, targetWidth, targetHeight);
            if (bitmap != null) {
                addBitmapToMemoryCache(key, bitmap);
            }
        }
        return bitmap;
    }

    /**
     * 將數(shù)據(jù)請求到流之中
     */
    private boolean downLoadUrlToStream(String urlString, OutputStream outputStream) {
        HttpURLConnection urlConnection = null;
        BufferedOutputStream bos = null;
        BufferedInputStream bis = null;
        try {
            final URL url = new URL(urlString);
            urlConnection = (HttpURLConnection) url.openConnection();
            bis = new BufferedInputStream(urlConnection.getInputStream(), 8 * 1024);
            bos = new BufferedOutputStream(outputStream, 8 * 1024);
            int b;
            while ((b = bis.read()) != -1) {
                bos.write(b);
            }
            return true;
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (urlConnection != null) {
                urlConnection.disconnect();
            }
            closeIn(bis);
            closeOut(bos);
        }
        return false;
    }

    /**
     * 直接通過網(wǎng)絡(luò)請求圖片 也不做任何的縮放處理
     */
    private Bitmap downLoadFromUrl(String urlString) {
        Bitmap bitmap = null;
        HttpURLConnection urlConnection = null;
        BufferedInputStream bis = null;
        try {
            final URL url = new URL(urlString);
            urlConnection = (HttpURLConnection) url.openConnection();
            bis = new BufferedInputStream(urlConnection.getInputStream());
            bitmap = BitmapFactory.decodeStream(bis);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (urlConnection != null) {
                urlConnection.disconnect();
            }
            closeIn(bis);
        }
        return bitmap;
    }


    /**
     * 得到MD5值key
     */
    private String hashKeyFromUrl(String url) {
        String cacheKey;
        try {
            final MessageDigest mDigest = MessageDigest.getInstance("MD5");
            mDigest.update(url.getBytes());
            cacheKey = byteToHexString(mDigest.digest());
        } catch (NoSuchAlgorithmException e) {
            cacheKey = String.valueOf(url.hashCode());
        }
        return cacheKey;
    }

    /**
     * 將byte轉(zhuǎn)換成16進制字符串
     */
    private String byteToHexString(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < bytes.length; i++) {
            String hex = Integer.toHexString(0xFF & bytes[i]);//得到十六進制字符串
            if (hex.length() == 1) {
                sb.append('0');
            }
            sb.append(hex);
        }
        return sb.toString();
    }


    /**
     * 得到緩存文件夾
     */
    private File getDiskCacheDir(Context mContext, String uniqueName) {
        //判斷儲存卡是否可以用
        boolean externalStorageAvailable = Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED);
        final String cachePath;
        if (externalStorageAvailable) {
            cachePath = mContext.getExternalCacheDir().getPath();//儲存卡
        } else {
            cachePath = mContext.getCacheDir().getPath();//手機自身內(nèi)存
        }
        return new File(cachePath + File.separator + uniqueName);
    }

    /**
     * 得到可用空間大小
     */
    private long getUsableSpace(File file) {
        return file.getUsableSpace();
    }

    /**
     * 關(guān)閉輸入流
     */
    private void closeIn(BufferedInputStream in) {
        if (in != null) {
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                in = null;
            }
        }
    }

    /**
     * 關(guān)閉輸輸出流
     */
    private void closeOut(BufferedOutputStream out) {
        if (out != null) {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                out = null;
            }
        }
    }

    private static class LoaderResult {
        public ImageView iv ;
        public String uri;
        public Bitmap bitmap;

        public LoaderResult(ImageView iv, String uri, Bitmap bitmap) {
            this.iv = iv;
            this.uri = uri;
            this.bitmap = bitmap;
        }
    }
}

經(jīng)過測試，是可以正常加載出圖片的,緩存文件也正常，主要是學(xué)習(xí)過程思路

3.1補充 Closeable接口

在ImageLoader中，代碼最后寫了closeIn(),closeOut()方法，完全沒必要這樣寫。在jdk1.6之后，所有的流都實現(xiàn)了Closeable接口，可以用這個接口來關(guān)閉所有的流

/**
 * 關(guān)閉流
 */
 private void closeStream(Closeable closeable){
    if (closeable != null){
        try {
            closeable.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在downLoadFromUrl()和downLoadUrlToStream()方法中需要關(guān)閉流，就可以直接closeStream(bis),closeStream(bos)來進行關(guān)閉流操作

4.最后

這個ImgageLoader還非常簡陋，和Glide和Picasso根本無法相比。并不會在實際工作開發(fā)中使用，還是使用Glide或者Picasso。主要是學(xué)習(xí)基礎(chǔ)實現(xiàn)原理，學(xué)習(xí)了下Android中緩存的部分知識。之前面試時，被問到過ImageLoader原理。

最近的學(xué)習(xí)，感覺不會的東西太多了，得理一理學(xué)習(xí)的順序。

注意多鍛煉身體。共勉：）

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

Android 緩存策略LruCache和DiskLruCache學(xué)習(xí)

Android 緩存策略LruCache和DiskLruCache學(xué)習(xí)

1.LruCache 內(nèi)存緩存

2.DiskLruCache 磁盤緩存

2.1創(chuàng)建

2.2添加

2.3 緩存查找

3.ImageLoader的實現(xiàn)

3.1補充 Closeable接口

4.最后

推薦閱讀更多精彩內(nèi)容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

Android 緩存策略LruCache和DiskLruCache學(xué)習(xí)

1.LruCache 內(nèi)存緩存

2.DiskLruCache 磁盤緩存

2.1創(chuàng)建

2.2添加

2.3 緩存查找

3.ImageLoader的實現(xiàn)

3.1補充 Closeable接口

4.最后

推薦閱讀更多精彩內(nèi)容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频