android开发之就本地和网络图片的压缩以及缓存详解

最新推荐文章于 2023-05-13 19:30:55 发布
最新推荐文章于 2023-05-13 19:30:55 发布
阅读量402 收藏
点赞数
分类专栏： android 文章标签： android 压缩 图片 缓存

一、图片的压缩

1、本地图片的压缩

无论是本地亦或者是网络来源图片，加载都需要进行合适的压缩，然后通过控件显示出来。

第一步：获得ImageView控件想要显示的大小

/**
 * Created by ZaneLove on 2015/3/15.
 */
public class ImageSizeUtil {
    /**
     * a.根据ImageView获得适应的压缩的宽和高
     * @param imageView
     * @return
     */
    public static ImageSize getImageViewSize(ImageView imageView){
        ImageSize imageSize = new ImageSize();
        //获取ImageView控件的宽和高
        DisplayMetrics displayMetrics = imageView.getContext().getResources().getDisplayMetrics();
        ViewGroup.LayoutParams lp = imageView.getLayoutParams();

        // 获取imageview的实际宽度
        int width = imageView.getWidth();
        //首先企图通过getWidth获取显示的宽,如果返回0;那么再去看看它有没有在布局文件中声明宽
        if(width <= 0) {
            width = lp.width;
        }
        //如果布局文件中也没有精确值，那么我们再去看看它有没有设置最大值
        /**
         * 可以看到这里或者最大宽度，我们用的反射，而不是getMaxWidth()；为啥呢，因为getMaxWidth竟然要API 16，我也是醉了；为了兼容性，我们采用反射的方案。
         */
        if(width <= 0 ) {
            width = getImageViewFieldValue(imageView,"mMaxWidth");
        }
        //如果最大值也没设置，那么我们只有拿出我们的终极方案，使用我们的屏幕宽度
        if(width <=0) {
            width = displayMetrics.widthPixels;
        }

        // 获取imageview的实际高度
        int height = imageView.getHeight();
        if(height <= 0) {
            height = lp.height;
        }
        if(height <= 0) {
            height = getImageViewFieldValue(imageView,"mMaxHeight");
        }
        if(height <= 0) {
            height = displayMetrics.heightPixels;
        }
        imageSize.width = width;
        imageSize.height = height;
        return imageSize;
    }

    /**
     * 通过反射获取ImageView控件的某个属性值
     * @param object
     * @param fieldName
     * @return
     */
    private static int getImageViewFieldValue(Object object, String fieldName) {
        int value = 0;
        try{
            //Field：属性
            Field field = ImageView.class.getDeclaredField(fieldName);
            field.setAccessible(true);
            int fieldValue = field.getInt(object);
            if(fieldValue > 0 && fieldValue < Integer.MAX_VALUE) {
                value = fieldValue;
            }
        }catch (Exception e) {
            e.printStackTrace();
        }
        return value;
    }

    public static class ImageSize {
        public int width;
        public int height;
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76

第二步：设置合适的inSampleSize 
上面，我们获得了图片想要显示的宽和高，那么，接下来就是拿着宽和高与图片真正的宽和高做比较，得到一个合适的inSampleSize，再去对图片进行压缩。

①、拿到图片真正的宽和高，并存在options里面

//获的图片真正的宽和高，并不把图片加载到内存中
BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
BitmapFactory.decodeResource(getResources(),R.drawable.v,options);
//BitmapFactory.decodeFile(path, options);从sd卡中获取图片
 
 
  • 1
  • 2
  • 3
  • 4
  • 5

 
 
  • 1
  • 2
  • 3
  • 4
  • 5

②、获得inSampleSize

public class ImageSizeUtil {
    /**
     * b.根据需求的宽和高以及图片实际的宽和高计算SampleSize,为了对图片进行压缩
     * @param options
     * @param reqWidth
     * @param reqHeight
     * @return
     */
    public static int caculateInSampleSize(BitmapFactory.Options options,int reqWidth,int reqHeight) {
        /**
         * options里面存了实际的宽和高；reqWidth和reqHeight就是我们之前得到的想要显示的大小；经过比较，得到一个合适的inSampleSize
         */

        int width = options.outWidth;
        int height = options.outHeight;
        int inSampleSize = 1;
        if(width > reqWidth || height > reqHeight) {
            int widthRadio = Math.round(width * 1.0f / reqWidth);
            int heightRadio = Math.round(height * 1.0f / reqHeight);
            inSampleSize = Math.max(widthRadio,heightRadio);
        }
        return inSampleSize;
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

options里面存了实际的宽和高；reqWidth和reqHeight就是我们之前得到的想要显示的大小；经过比较，得到一个合适的inSampleSize。

③、对图片进行压缩

//根据ImageView获得适应的压缩的宽和高
ImageSizeUtil.ImageSize imageSize = ImageSizeUtil.getImageViewSize(iv);
//根据需求的宽和高以及图片实际的宽和高计算SampleSize,为了对图片进行压缩
options.inSampleSize = ImageSizeUtil.caculateInSampleSize(options,imageSize.width,imageSize.height);

//使用获得到的inSampleSize，再次解析图片并压缩图片
options.inJustDecodeBounds = false;
Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.v, options);
//BitmapFactory.decodeFile(path, options);从sd卡中获取图片
iv.setImageBitmap(bitmap);
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

2、网络图片的压缩

方案：

a、直接下载存到sd卡，然后采用本地的压缩方案。这种方式当前是在硬盘缓存开启的情况下，如果没有开启呢？

b、使用BitmapFactory.decodeStream(is, null, opts);

/**
 * Created by ZaneLove on 2015/3/15.
 */
public class DownloadImgUtil {
    /**
     * 根据url下载图片在指定的文件
     * @param urlStr
     * @param imageView
     * @return
     */
    public static Bitmap downloadImageByUrl(String urlStr,ImageView imageView) {
        InputStream is = null;

        try {
            //网络图片地址
            URL url = new URL(urlStr);
            //网络连接
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            //管道输入流
            is = new BufferedInputStream(conn.getInputStream());
            /**
             * BufferedInputStream类调用mark(int readlimit)方法后读取多少字节标记才失效，是取readlimit和BufferedInputStream类的缓冲区大小两者中的最大值，而并非完全由readlimit确定。这个在JAVA文档中是没有提到的。
             */
            is.mark(is.available());

            //图片压缩
            BitmapFactory.Options options = new BitmapFactory.Options();
            options.inJustDecodeBounds = true;
            Bitmap bitmap = BitmapFactory.decodeStream(is,null,options);

            //获得ImageView控件想要显示的宽和高
            ImageSizeUtil.ImageSize imageSize = ImageSizeUtil.getImageViewSize(imageView);
            options.inSampleSize = ImageSizeUtil.caculateInSampleSize(options,imageSize.width,imageSize.height);
            options.inJustDecodeBounds = false;
            is.reset();
            bitmap = BitmapFactory.decodeStream(is,null,options);

            conn.disconnect();
            return bitmap;
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            try{
                if(is != null) {
                    is.close();
                }
            }catch (Exception e) {

            }
        }
        return null;
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
/**
  * 下载网络图片，并将图片显示在控件上
  */
Bitmap bitmap1 =  DownloadImgUtil.downloadImageByUrl("https://img-my.csdn.net/uploads/201407/26/1406383299_1976.jpg", iv);
iv.setImageBitmap(bitmap1);
 
 
  • 1
  • 2
  • 3
  • 4
  • 5

 
 
  • 1
  • 2
  • 3
  • 4
  • 5

在此，图片压缩已结束，那么，就应该放入LruCache，然后再设置到我们的ImageView上 。

二、图片的缓存

基于此，我将带领大家一起打造一个从压缩到缓存的图片加载框架的架构。

打造一个从压缩到缓存的图片加载框架的架构

基本思路 
1、单例模式，包含一个LruCache用来管理缓存图片。

2、任务队列，每来一次加载图片的请求，就封装成Task存入到TaskQueue中。

3、包含一个后台线程，这个线程在第一次初始化实例的时候启动，然后会一直在后台运行，它用来干什么呢？大伙还记得我们有个任务队列么，有队列任务，得有人干活呀，所以，当每来一次加载图片请求的时候，我们同时发一个消息到后台线程，后台线程去使用线程池去TaskQueue去取一个任务来执行。

4、调度策略，在3中说过，后台线程去TaskQueue去取一个任务，这个任务不是随便取的，有策略可以选择，一个是FIFO(先进先出)，一个是LIFO(后进先出)，我更倾向于后者。

让我们一步两步分析代码如何实现吧！！

1、构造方法 – 使用单例模式
/**
 * 单例模式
 */
private static ImageLoader instance = null;

private ImageLoader(int threadCount,Type type){
    init(threadCount,type);
}

public static ImageLoader getInstance(int threadCount,Type type) {
    if(instance == null) {
        synchronized (ImageLoader.class) {
            if(instance == null) {
                instance = new ImageLoader(threadCount, type);
                return  instance;
            }
        }
    }
    return instance;
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

接下来， 让我们一起来看构造函数当中init()方法：(附带全局变量)

1、初始化后台轮询线程 
2、获得应用最大可用内存的1/8，分配给LruCache 
3、创建线程池

//线程数量
private int threadCount;
//队列调度方式，默认为LOFI(后进先出)
private Type mType = Type.LIFO;
//图片缓存的核心对象
private LruCache<String,Bitmap> mLruCache;
//线程池
private ExecutorService mThreadPool;
private static final int DEAFULT_THREAD_COUNT = 1;
//任务队列
private LinkedList<Runnable> mTaskQueue;

private Semaphore mSemaphorePoolThreadHandler = new Semaphore(0);
private Semaphore mSemaphoreThreadPool;

//后台轮询线程
private Thread mPoolThread;
private Handler mPoolThreadHandler;

private Runnable task;

//UI线程中的Handler
private Handler mUIHandler;
//是否开启硬盘缓存
private boolean isDiskCacheEnable = true;

public enum Type {
    FIFO, //先进先出
    LIFO  //后进先出
}

/**
 * 初始化
 * @param threadCount 线程数量
 * @param type 队列调度方式
 */
private void init(int threadCount, Type type) {
    //初始化后台轮询线程
    initBackThread();
    //获得应用最大可用内存的1/8，分配给LruCache
    int maxMemory = (int) Runtime.getRuntime().maxMemory();
    int cacheMemory = maxMemory / 8;
    mLruCache = new LruCache<String, Bitmap>(cacheMemory) {
        @Override
        protected int sizeOf(String key, Bitmap value) {
            return value.getRowBytes() * value.getHeight();
        }
    };

    //创建线程池
    mThreadPool = Executors.newFixedThreadPool(threadCount);
    mTaskQueue = new LinkedList<Runnable>();
    mType = type;
    mSemaphoreThreadPool = new Semaphore(threadCount);
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
private void initBackThread() {
    mPoolThread = new Thread(){
        @Override
        public void run() {
            //创建轮询器也会创建消息队列
            Looper.prepare();
            //创建消息处理器
            mPoolThreadHandler = new Handler(){
                @Override
                public void handleMessage(Message msg) {
                    //去线程池取出一个任务进行执行
                    mThreadPool.execute(getTask());
                    try{
                        mSemaphoreThreadPool.acquire();
                    }catch (Exception e) {
                    }
                }
            };
            //释放一个信号量
            mSemaphorePoolThreadHandler.release();
            //开启轮询器
            Looper.loop();
        }
    };
    //开启线程
    mPoolThread.start();
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
/**
 * 从任务队列取出一个任务
 * @return
 */
public Runnable getTask() {
    if(mType == Type.FIFO) {
        return mTaskQueue.removeFirst();
    }else if(mType == Type.LIFO) {
        return mTaskQueue.removeLast();
    }
    return null;
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

让我们在好好的分析分析一下以上代码，它到底做了什么？

  1. 在构造方法中我们调用init()方法

  2. 在init()方法中：

    1. 开启后台加载图片线程 – initBackThread()，实际上是让Looper轮询器不断的loop，随时往消息队列中拿消息进行处理
    2. 初始化mPoolThreadHandler用于发送消息到此线程
    3. 初始化LruCache缓存机制，并分配了缓存空间
    4. 创建线程池、初始化任务队列(TaskQueue)，使用线程池去TaskQueue中去取一个任务执行

目前为止，我们轮询器开启了、消息队列有了、处理消息的Handler处理器也有了、LruCache缓存机制又随时待命中、最后连线程池都有了，简直就是万事俱备，只欠东风。

2、加载图片（本地 + 网络）
/**
 * 根据path为ImageView设置图片
 */
public void loadImage(final String path,final ImageView imageView,final boolean isFromNet) {
    imageView.setTag(path);
    if(mUIHandler == null) {
        mUIHandler = new Handler(){
            @Override
            public void handleMessage(Message msg) {
                //获取得到图片，为ImageView回调设置图片
                ImgBeanHolder holder = (ImgBeanHolder) msg.obj;
                Bitmap bm = holder.bitmap;
                ImageView imageView = holder.imageView;
                String path = holder.path;
                //将path与getTag存储路径进行比较,防止图片混乱
                if(imageView.getTag().toString().equals(path)) {
                    imageView.setImageBitmap(bm);
                }
            }
        };
    }
    //根据path从缓存当中获取bitmap
    Bitmap bm = getBitmapFromLruCache(path);
    if(bm != null) {
        //找到了图片
        refreashBitmap(path,imageView,bm);
    }else {
        //没有找到图片
        //通过buildTask去新建一个任务，再addTask到任务队列
        addTask(buildTask(path,imageView,isFromNet));
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
/**
* 根据path从缓存当中获取bitmap
* @param key
* @return
*/
private Bitmap getBitmapFromLruCache(String key) {
   return mLruCache.get(key);
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
/**
* 去设置图片显示在控件上
* @param path
* @param imageView
* @param bm
*/
private void refreashBitmap(String path, ImageView imageView, Bitmap bm) {
   Message message = Message.obtain();
   ImgBeanHolder holder = new ImgBeanHolder();
   holder.bitmap = bm;
   holder.path = path;
   holder.imageView = imageView;
   message.obj = holder;
   mUIHandler.sendMessage(message);
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
/**
 * 新建一个任务
 * @param path
 * @param imageView
 * @param isFromNet
 * @return
 */
private Runnable buildTask(final String path, final ImageView imageView, final boolean isFromNet) {
    return new Runnable() {
        @Override
        public void run() {
            Bitmap bm = null;
            if (isFromNet) {
                File file = getDiskCacheDir(imageView.getContext(), md5(path));
                // 如果在缓存文件中发现
                if (file.exists()) {
                    bm = loadImageFromLocal(file.getAbsolutePath(), imageView);
                } else {
                    // 检测是否开启硬盘缓存
                    if (isDiskCacheEnable) {
                        boolean downloadState = DownloadImgUtil.downloadImgByUrl(path, file);
                        // 如果下载成功
                        if (downloadState) {
                            bm = loadImageFromLocal(file.getAbsolutePath(), imageView);
                        }
                    } else {// 直接从网络加载
                        bm = DownloadImgUtil.downloadImageByUrl(path,imageView);
                    }
                }
            } else {
                bm = loadImageFromLocal(path, imageView);
            }
            // 把图片加入到缓存
            addBitmapToLruCache(path, bm);
            refreashBitmap(path, imageView, bm);
            mSemaphoreThreadPool.release();
        }
    };
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
/**
 * 添加任务到队列
 * @param runnable
 */
private synchronized void addTask(Runnable runnable) {
    mTaskQueue.add(runnable);
    try{
        if(mPoolThreadHandler == null) {
            mSemaphorePoolThreadHandler.acquire();
        }
    }catch (Exception e) {

    }
    mPoolThreadHandler.sendEmptyMessage(0x110);
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
/**
 * 获得缓存图片的地址
 * @param context
 * @param mdStr
 * @return
 */
private File getDiskCacheDir(Context context, String mdStr) {
    String cachePath;
    if(Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())) {
        cachePath = context.getExternalCacheDir().getPath();
        isDiskCacheEnable = true;
    }else {
        cachePath = context.getCacheDir().getPath();
        isDiskCacheEnable = false;
    }
    return new File(cachePath + File.separator + mdStr);
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
/**
* 从本地缓存文件中加载图片
* @param path
* @param imageView
* @return
*/
private Bitmap loadImageFromLocal(String path, ImageView imageView) {
   Bitmap bm;
   //加载图片
   //图片压缩
   //1、获得图片需要显示的大小
   ImageSizeUtil.ImageSize imageSize = ImageSizeUtil.getImageViewSize(imageView);
   //2、压缩图片
   bm = decodeSampledBitmapFromPath(path,imageSize.width,imageSize.height);
   return bm;
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
/**
* 将图片加入LruCache
* @param path
* @param bm
*/
private void addBitmapToLruCache(String path, Bitmap bm) {
   if(getBitmapFromLruCache(path) == null) {
       if(bm != null) {
           mLruCache.put(path,bm);
       }
   }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

分析以上代码：

  1. 在外界调用loadImage()方法时，传入路径、展示控件(ImageView)和是否是来自于网络
  2. 在loadImage()方法中： 
    1. 为ImageView.setTag
    2. 初始化一个mUIHandler，用于用户更新ImageView控件，因此这个方法肯定是主线程调用的
    3. 首先根据path从缓存当中获取bitmap 
      1. 如果缓存当中找到了该图片，调用refreshBitmap()–设置图片显示在控件上
      2. 如果缓存当中没有找到该图片，通过buildTask()去新建一个任务，再addTask()到任务队列当中 
        1. buildTask()方法中： 
          1. 判断是否来自网络 
            1. 如果来自网络 
              1. 获得缓存图片的地址
              2. 如果在缓存文件中发现，那就说明还在本地，就调用loadImageFromLocal()方法，从本地缓存文件当中加载图片
              3. 如果没有发现 
                1. 检测是否开启硬盘缓存 
                  1. 如果开启了硬盘缓存，从网络下载图片，并存储到硬盘当中，这样的话又是本地缓存了，然后调用localImageFromLocal()从缓存文件中加载图片
                  2. 否则，直接从网络加载
            2. 如果来自本地，那么就直接调用loadImageFromLocal()从本地缓存文件中加载图片即可
          2. 将新加载过来的图片加入到缓存机制当中
          3. 设置图片显示在控件上

PS：就是在代码中，你会看到一些信号量的身影：

第一个：mSemaphorePoolThreadHandler = new Semaphore(0); 用于控制我们的mPoolThreadHandler的初始化完成，我们在使用mPoolThreadHandler会进行判空，如果为null，会通过mSemaphorePoolThreadHandler.acquire()进行阻塞；当mPoolThreadHandler初始化结束，我们会调用.release();解除阻塞。

第二个：mSemaphoreThreadPool = new Semaphore(threadCount);这个信号量的数量和我们加载图片的线程个数一致；每取一个任务去执行，我们会让信号量减一；每完成一个任务，会让信号量+1，再去取任务；目的是什么呢？为什么当我们的任务到来时，如果此时在没有空闲线程，任务则一直添加到TaskQueue中，当线程完成任务，可以根据策略去TaskQueue中去取任务，只有这样，我们的LIFO才有意义。

到此为止，布局我就buCopy了，大伙需要的话就去下载源码吧！嘎嘎，好坏好坏滴那种！

示例代码戳Here



转自：http://blog.csdn.net/zanelove/article/details/44278783

土豆片子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Android 使用Glide加载网络图片等比例缩放的实现方法
08-27
主要介绍了Android 使用Glide加载网络图片等比例缩放的实现方法,需要的朋友可以参考下
Android在ImageView上直接显示网络图片
u010227042的博客
11-19 3274
在原生的ImageView中，没有一个方法是可以直接显示网络的图片的，当我们经常需要显示网络图片时，每次都有一大堆的操作，这会很麻烦，今天就教大家在ImageView上轻松显示网络图片。 自定义ImageView方法 写一个类让它继承ImageView，并增加一个setImageURL(path)方法 import android.content.Context; import android.graphics.Bitmap; import android....
android 图片处理（压缩与缓存）
MrPeng的博客
09-27 1868
一、压缩 android程序经常用到许多图片，图片有不同的大小，形状。在大多数情况下，这些图片都会大于我们程序所需要的的大小。比如图片库展示的图片大都是手机摄像头拍出来的，图片分辨率比我们手机分辨率高得多。app都是有一定内存限制的，程序占用过高的内存就容易出现OOM，获取每个应用程序最高可用内存，因手机型号而有所不同，可用代码获取，大部分32M。 int maxMemory = (int...
Android中图片压缩方式总结
IT从业者，生活精致一点，工作认真一点！
08-31 4994
bitmap图片压缩方式总结
Android异步下载图片并且缓存图片到本地DEMO详解
06-01
主要介绍了Android异步下载图片并且缓存图片到本地DEMO详解,需要的朋友可以参考下
详解Android 图片的三级缓存及图片压缩
01-04
Android默认给每个应用只分配16M的内存，所以如果加载过多的图片，为了防止内存溢出，应该将图片缓存起来。图片的三级缓存分别是： 内存缓存 本地缓存 网络缓存 其中，内存缓存应优先加载，它速度最快；本地缓存...
Android图片三级缓存策略(网络、本地、内存缓存)
01-05
通常情况下，Android应用程序中图片的缓存策略采用“内存-本地-网络”三级缓存策略，首先应用程序访问网络拉取图片，分别将加载的图片保存在本地SD卡中和内存中，当程序再一次需要加载图片的时候，先判断内存中是否...
Android开发之ImageLoader本地缓存
01-04
ImageLoader是一个图片缓存的开源库，提供了强大的图片缓存机制，很多开发者都在使用，今天给大家介绍Android开发之ImageLoader本地缓存，具体内容如下所示： 本地缓存在缓存文件时对文件名称的修改提供了两种方式...
Android 图片压缩最常用的几种方法
muranfei的博客
02-23 6337
在android开发中图片是非常容易造成OOM异常的，大部分情况下，都需要对图片进行压缩展示，本文主要是记录下在开发中常见的几种图片压缩方法 一、质量压缩 保持像素的前提下改变图片的位深及透明度（即：通过算法抹掉(同化)图片中的一些某点附近 相近的像素）达到降低质量压缩文件的目的。 使用场景：将图片压缩后将图片上传到服务器，或者保存到本地，根据实际需求 /** * 质量压缩 * 设置bitmap options属性，降低图片的质量，像素不会减少 * 第一个参数为需要压缩
android图片压缩的完整的解决方案
04-23
NULL 博文链接：https://xuhangjiekvkk.iteye.com/blog/2259837
android压缩照片到指定大小100%可靠
热门推荐
我的专栏
04-23 1万+
android压缩照片到指定大小100%可靠，不会出现baos.toByteArray().length取到的照片大小与实际保存的大小不符，测试百分百准确
在安卓中如何对照片进行压缩后再加载到内存中
weixin_55020138的博客
05-13 570
为什么我们要对照片进行压缩处理后再加载到内存中，原因是某些照片即使经过裁剪后体积仍然很大，直接加载到内存中有可能会导致程序崩溃。需要注意的是，压缩照片会降低图像质量，所以需要根据具体需求进行权衡。2.压缩照片尺寸：根据需要，可以通过缩小照片的尺寸来减少内存占用。3.压缩照片质量：可以通过降低照片的质量来减少内存占用。该方法返回一个解码后的Bitmap对象，如果解码失败，则返回null。4.加载压缩后的照片到内存中：使用BitmapFactory类的。方法将压缩后的照片数据加载到内存中的Bitmap对象中。
图片瀑布流，so easy！
前端队长Daotin
11-08 423
什么是图片瀑布流 用一张花瓣网页的图片布局可以很清楚看出图片瀑布流的样子： 简单来说，就是有很多图片平铺在页面上，每张图片的宽度相同，但是高度不同，这样错落有致的排列出 n 列的样子很像瀑布，于是就有了瀑布流图片一说。 实现原理 1、第一种方式 第一种方式前提是：图片的宽度固定，但是列可变(根据屏幕大小) 通过上面的介绍，我们知道要实现瀑布流的前提是宽度一致(假如为100px)，高...
安卓中关于图片从网络获取，压缩，上传，下载，缩略图，缓存的一些处理总结（四）
Able
11-26 1020
这里根绝网上的一些文章写了一个工具类 pictureSize 一般写成1080*1920 这个数值越大图片越清晰 加载需要的内存越多 请大家根据情况自行设定 这里2个方法 一个是针对网上URL 一个是本地path public static Bitmap downloadImgByUrl(String imgUrl, int pictureSize) { B
Android如何优雅的缓存网络图片
Smile浅唱
12-06 1003
Android如何优雅的缓存网络图片在Android开发中，基本上都会有与网络握手，如果没实现这个功能，那也就只能是在开发一个“单机游戏”咯。既然从网络获取数据，那就避免不了加载网络数据，那么问题来了，流量怎么办？大家都知道，加载网络图片比加载网络文本耗费的流量多得多。不用担心，今天来分享以下如何缓存网络图片到本地来： 根据图片的url去加载，本地有就加载本地，没有则请求网络 图片压缩，降低内存使用
android缓存图片,Android 图片缓存
weixin_34766430的博客
05-27 463
前言本篇主要包含两个方面的内容：图片的加载和优化图片的加载LruCache，DisLruCache的使用与图片的三级缓存图片的加载和优化我们在编写Android程序的时候经常要用到很多的图片，在大多数情况下，这些图片都会大于我们程序所需要的大小。我们编写的应用程序都是有一定的内存限制，程序占用了过高的内存就容易出现OOM(Out Of Memory)异常。如下代码可以看出每个应用程序最高可用内存：...
Wiki_Android_获取ImageView的最大最小宽度和高度
GitHubClub
08-08 2869
一、通过ImageView对象直接获取，需考虑API的兼容问题，因为getMaxWidth()方法要API 16以上才可以使用 /* 获取ImageView的实际宽度* */ int width = imageView.getWidth(); int height = imageView.getHeight(); 二、通过反射获取，这种方法不用考虑兼容API的问题 /**
okHttp日常使用笔记
Androidcaobo
09-21 305
网络框架有很多，Okhttp是比较出名的一个，参考宏洋大神博客，写下自己的笔记，供参考 1.首先gradle，没什么好说的，就是依赖这几个，因为用的是别人封装过的okhttp compile ‘com.squareup.okhttp:okhttp:2.4.0’ compile ‘com.squareup.okio:okio:1.5.0’ compile ‘com.go
nginx如何对前端项目请求来的网络图片进行缓存和压缩
最新发布
06-01
Nginx可以通过配置HTTP头来对前端项目请求的网络图片进行缓存和压缩。 首先，对于需要缓存的网络图片，可以通过设置Expires或Cache-Control头来指定缓存时间。例如： ``` location /images/ { expires 1d; proxy_cache_valid 200 1d; proxy_cache_bypass $http_pragma; proxy_cache_revalidate on; proxy_cache_min_uses 1; proxy_cache_use_stale error timeout invalid_header updating http_500 http_502 http_503 http_504; proxy_cache_lock on; proxy_cache_lock_timeout 5s; proxy_cache_path /var/cache/nginx levels=1:2 keys_zone=my_cache:10m inactive=60m; add_header X-Cache-Status $upstream_cache_status; proxy_pass http://backend/; } ``` 这样，所有以/images/开头的请求都会被缓存一天。 其次，对于需要压缩的网络图片，可以使用ngx_http_gzip_module模块来开启gzip压缩。例如： ``` location /images/ { proxy_set_header Accept-Encoding ""; gzip on; gzip_types image/jpeg image/png; proxy_pass http://backend/; } ``` 这样，所有请求的jpeg和png图片都会被gzip压缩。同时，通过设置proxy_set_header Accept-Encoding ""，避免后端服务器再次压缩已经被Nginx压缩过的数据。 需要注意的是，开启gzip压缩会增加CPU负担，因此要根据服务器的性能来进行配置。同时，使用nginx做缓存需要安装ngx_http_proxy_module模块和ngx_http_cache_module模块。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值