三级缓存_三级缓存中第三级放的是什么-优快云博客

本文链接：https://blog.youkuaiyun.com/xiaozhang0414/article/details/78472014

本文介绍了一个基于内存、文件和网络的三级缓存机制实现方案，通过LruCache管理内存缓存，利用SD卡进行文件缓存，并在网络层面对图片进行预加载及缓存。该方案能有效提升图片加载效率并节省流量。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

//权限

<uses-permission android:name="android.permission.INTERNET" />

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>

这里说的三级缓存，分别指的是：内存缓存、文件缓存和网络这三个层面。

一般来说，我们首次加载图片，内存和文件是没有缓存的，这样我们需要从网络加载，加载完成后，我们会存到内存和文件中去；当再次加载图片的时候，我们会先查找内存有没有，如果有就直接显示内存中的图片，如果没有，我们会接着查找文件中是否有，如果文件中有，我们会显示文件中的图片，并且把它存到内存中去，这样下次我们在内存中就能找到它了。

我们之所以要做缓存，主要是为了提高效率，节省流量。但是为什么要做三级呢？为什么不只存在内存或者只存在文件中呢？这是因为内存的读取速度快，但是容易被回收，容量小，文件的读取速度次之，不过容量大，不到不得已不会被回收

/**
 * author:Created by WangZhiQiang on 2017-09-04.
 * 处理三级缓存
 * 内存缓存(LruCache-->最近最少使用算法,当缓存慢的时候,自动把最近使用最少的删除,腾出来的空间添加新的缓存内容)
 * sd卡缓存
 * 网络
 */

//main方法

import android.graphics.Bitmap;
import android.os.Handler;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.GridView;
import android.widget.ImageView;

import com.bwei.Uilts.ulits;

public class MainActivity extends AppCompatActivity {

    private GridView rg;
    private ulits ulits;
    String[] imageUrls = new String[] {
            "https://img-my.youkuaiyun.com/uploads/201407/26/1406383299_1976.jpg",
            "https://img-my.youkuaiyun.com/uploads/201407/26/1406383299_1976.jpg",
            "https://img-my.youkuaiyun.com/uploads/201407/26/1406383299_1976.jpg",
            "https://img-my.youkuaiyun.com/uploads/201407/26/1406383299_1976.jpg",
            "https://img-my.youkuaiyun.com/uploads/201407/26/1406383299_1976.jpg",
            "https://img-my.youkuaiyun.com/uploads/201407/26/1406383299_1976.jpg",
            "https://img-my.youkuaiyun.com/uploads/201407/26/1406383299_1976.jpg",
            "https://img-my.youkuaiyun.com/uploads/201407/26/1406383299_1976.jpg",
            "https://img-my.youkuaiyun.com/uplds/201407/26/1406383299_1976.jpg",
            "https://img-my.youkuaiyun.com/uploads/201407/26/1406383299_1976.jpg",
            "https://img-my.youkuaiyun.com/uploads/201407/26/1406383299_1976.jpg",
            "https://img-my.youkuaiyun.com/uploads/201407/26/1406383299_1976.jpg",
            "https://img-my.youkuaiyun.com/uploads/201407/26/1406383299_1976.jpg",
            "https://img-my.youkuaiyun.com/uploads/201407/26/1406383299_1976.jpg",
            "https://img-my.youkuaiyun.com/uploads/201407/26/1406383299_1976.jpg",
            "https://img-my.youkuaiyun.com/uploads/201407/26/1406383299_1976.jpg",
            "https://img-my.youkuaiyun.com/uploads/201407/26/1406383299_1976.jpg",
            "https://img-my.youkuaiyun.com/uploads/201407/26/1406383299_1976.jpg",
            "https://img-my.youkuaiyun.com/uploads/201407/26/1406383299_1976.jpg",
            "https://img-my.youkuaiyun.com/uploads/201407/26/1406383299_1976.jpg",
            "https://img-my.youkuaiyun.com/uploads/201407/26/1406383299_1976.jpg",
            "https://img-my.youkuaiyun.com/uploads/201407/26/1406383299_1976.jpg",
            "https://img-my.youkuaiyun.com/uploads/201407/26/1406383299_1976.jpg",
            "https://img-my.youkuaiyun.com/uploads/201407/26/1406383291_6518.jpg",
            "https://img-my.youkuaiyun.com/uploads/201407/26/1406383291_8239.jpg",
            "https://img-my.youkuaiyun.com/uploads/201407/26/1406383290_9329.jpg",
            "https://img-my.youkuaiyun.com/uploads/201407/26/1406383290_1042.jpg",
            "https://img-my.youkuaiyun.com/uploads/201407/26/1406383275_3977.jpg",
            "https://img-my.youkuaiyun.com/uploads/201407/26/1406383265_8550.jpg",
            "https://img-my.youkuaiyun.com/uploads/201407/26/1406383264_3954.jpg",
            "https://img-my.youkuaiyun.com/uploads/201407/26/1406383264_4787.jpg",
    };
     private Handler handler=new Handler(){
         @Override
         public void handleMessage(Message msg) {
             super.handleMessage(msg);
         }
     };
    

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
       //实力化ulits类
        ulits = new ulits(this,handler);//传当前对象和handler机制
     //获取控件
        rg = (GridView) findViewById(R.id.rg);
         //获取适配器
       rg.setAdapter(new MyAdapter());
    }
 //适配器
    class MyAdapter extends BaseAdapter {

        @Override
        public int getCount() {
            // TODO Auto-generated method stub
            return imageUrls.length;
        }

        @Override
        public Object getItem(int position) {
            return null;
        }

        @Override
        public long getItemId(int position) {

            return position;
        }

        @Override
        public View getView(int position, View convertView, ViewGroup parent) {

            //获取ImageView控件
            ImageView iv = new ImageView(MainActivity.this);
            //赋值
            iv.setTag(imageUrls[position]);
            //ulits对象获取取图片的方法;
            Bitmap bit = ulits.bit(imageUrls[position]);

            // 从内存中或者缓存中
            if (bit != null) {
                iv.setImageBitmap(bit);
            }
            // 获取图片
            return iv;
        }
    }
}

//工具类

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.support.v4.util.LruCache;

import com.bwei.MainActivity;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * Created by lenovo on 2017/11/7.
 */

public class ulits {

    Handler handler;
    private  ExecutorService executorService;
    private LruCache<String, Bitmap> lruCache;
    private File cacheDir;
    //有餐构造
    public ulits(Context context, Handler handler) {

        //获取手机最大内存
        long maxMemory = Runtime.getRuntime().maxMemory();
        //最大内存除以8
        int maxSize = (int) (maxMemory / 8);
         //handler的当前对象等于handler
        this.handler = handler;
        //得到本app在sd上的缓存文件夹
        File cacheDir = context.getCacheDir();
        //// 初始化线程池;初始化5个现成,供程序使用
        executorService = Executors.newFixedThreadPool(5);

        //实力化 缓存
        lruCache = new LruCache<String, Bitmap>(maxSize) {
           //每次缓存图片都要调用这个方法
            @Override
            protected int sizeOf(String key, Bitmap value) {


                return value.getRowBytes() * value.getHeight();
            }
        };
    }
    /**
     * 取图片,
     *
     * @param path
     * @return
     */
    //获取取图片
    public Bitmap bit(String path){
         //缓存
        Bitmap bitmap = lruCache.get(path);
        //如果内存有图片走里面没有不进
      if(bitmap!=null){

          System.out.println("我走了内存");
          return bitmap;
      }
        //从本直去取，sd卡去取bitmap调用sd卡方法
        bitmap = getBitMapFromLocal(path);
        //如果本地有图片走里面没有不进
        if (bitmap != null) {
            System.out.println("我走了本地缓存");
            return bitmap;
        }

        // 从网络去取
        getBitmapFromNet(path);


      return  null;
    }
    /**
     * 从sd卡获取图片
     *
     * @param path
     * @return
     */
    //sd卡获取图片的方法
    private Bitmap getBitMapFromLocal(String path) {

        try {
            //调用EncoderUtils.encode方法编辑图片
            String encode = EncoderUtils.encode(path);
           //存储路径
            FileInputStream fileInputStream = new FileInputStream(cacheDir
                    + "/" + encode);
           //获取图片工厂
            Bitmap bitmap = BitmapFactory.decodeStream(fileInputStream);
            //存到内存
             lruCache.put(path,bitmap);

            return bitmap;

        } catch (Exception e) {
            e.printStackTrace();
        }

        return null;
    };
    /**
     * 从网络
     *
     * @param path
     */

    private void getBitmapFromNet(final String path) {
        //用线程池里的线程执行请求网络操作;
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    URL url=new URL(path);
                    HttpURLConnection connection  = (HttpURLConnection) url.openConnection();
                    connection.setConnectTimeout(5000);
                    connection.setReadTimeout(5000);
                    int code = connection.getResponseCode();
                    if(code==200){
                        InputStream inputStream = connection.getInputStream();
                        Bitmap bitmap = BitmapFactory.decodeStream(inputStream);
                        Message msg = new Message();
                        msg.what = 111;
                        msg.obj = bitmap;
                        Bundle data = new Bundle();
                        data.putString("tag", path);
                        msg.setData(data);
                        handler.sendMessage(msg);
                        //缓存到本地
                        saveBitmapToLocal(bitmap, path);
                        //缓存到内存
                        lruCache.put(path, bitmap);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

        });
    }

    private void saveBitmapToLocal(Bitmap bitmap, String path) {
        try {
            //获取编辑图片的类
            String encode = EncoderUtils.encode(path);
            //存储路径
            FileOutputStream fileOutputStream = new FileOutputStream(cacheDir + "/" + encode);
            //图片二次裁剪
            bitmap.compress(Bitmap.CompressFormat.JPEG, 80, fileOutputStream);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

//工具类

import java.security.MessageDigest;

/**
 * author:Created by WangZhiQiang on 2017-09-04.
 * 工具类,把对url进行md5加密,加密后以字符串的形式返回;
 * 缓存的时候用key(url加密后的字符串)对应value(bitmap)
 */


public class EncoderUtils {
    /**
     * Md5Encoder
     *
     * @param string
     * @return
     * @throws Exception
     */
    public static String encode(String string) throws Exception {
        byte[] hash = MessageDigest.getInstance("MD5").digest(
                string.getBytes("UTF-8"));
        StringBuilder hex = new StringBuilder(hash.length * 2);
        for (byte b : hash) {
            if ((b & 0xFF) < 0x10) {
                hex.append("0");
            }
            hex.append(Integer.toHexString(b & 0xFF));
        }
        return hex.toString();
    }




}






}
这里说的三级缓存，分别指的是：内存缓存、文件缓存和网络这三个层面。
一般来说，我们首次加载图片，内存和文件是没有缓存的，这样我们需要从网络加载，加载完成后，我们会存到内存和文件中去；当再次加载图片的时候，我们会先查找内存有没有，如果有就直接显示内存中的图片，如果没有，我们会接着查找文件中是否有，如果文件中有，我们会显示文件中的图片，并且把它存到内存中去，这样下次我们在内存中就能找到它了。
我们之所以要做缓存，主要是为了提高效率，节省流量。但是为什么要做三级呢？为什么不只存在内存或者只存在文件中呢？这是因为内存的读取速度快，但是容易被回收，容量小，文件的读取速度次之，不过容量大，不到不得已不会被回收