Android学习之 有关图片缓存问提的代码封装<一>

最新推荐文章于 2021-12-01 15:27:20 发布
最新推荐文章于 2021-12-01 15:27:20 发布
阅读量1.7k 收藏
点赞数
分类专栏： Android 文章标签： Android 图片缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/janice0529/article/details/25510833
版权

         背景：在做App应用时，特别是涉及到要大量获取网络图片在UI上展现，获取网络图片是非常要流量的，通常有效的解决方式就是充分的利用内存缓存和文件缓存<sdcard>，当然也可以将图片信息存储在SQLite本地数据库，这里我主要是通过对内存缓存和SD卡上的文件缓存进行代码封装。

         1、首先，定义一个 要显示图片的参数实体类：ImageParams.java ，他包含url<图片url> 和 updateTime<图片的更新时间>两个字段变量。  代码如下：

package com.ice.android.common.util.imagecache;
/**
 * 要显示图片的参数实体
 * @author ice
 *
 */
public class ImageParams {

	/** 图片的url */
	private String url;
	
	/** 图片的更新时间   */
	private String updateTime;

	/** 有参构造函数  */
	public ImageParams(String url, String updateTime) {
		this.url = url;
		this.updateTime = updateTime;
	}
	
	
	public String getUrl() {
		return url;
	}

	public void setUrl(String url) {
		this.url = url;
	}

	public String getUpdateTime() {
		return updateTime;
	}

	public void setUpdateTime(String updateTime) {
		this.updateTime = updateTime;
	}

	
	public String getImageKey(){
		return this.url + this.updateTime;
	}
	
}
        

         2、其次，就是关键的图片内存缓存类： ImageMemCache.java 

在该类中 我们会用到 硬缓存 和 软引用缓存 两者的相互配合来共同达到既有效的缓存图片又不会引起内存溢出的作用。详细代码如下：

package com.ice.android.common.util.imagecache;

import java.lang.ref.SoftReference;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.concurrent.ConcurrentHashMap;

import android.graphics.Bitmap;
import android.util.Log;


/**
 * 图片内存缓存 对象
 * @author ice
 *
 */
public class ImageMemCache {

	private static final String TAG = "ImageMemCache";
	/** 缓存容量  */
	private static final int CACHE_CAPACITY = 15;
	
	/** 存放图片的HashMap 对象 */
	private static HashMap<String, Bitmap> mHardBitmapCache;
	/** 使用软引用存放图片数据   放入ConcurrentHashMap对象    <这里是否使 WeakHashMap 会更好呢 ？> */
	private static ConcurrentHashMap<String, SoftReference<Bitmap>> mSoftBitmapCache = new ConcurrentHashMap<>(CACHE_CAPACITY);
	
	public ImageMemCache(){
		/* 这里之所以选用 LinkedHashMap，我想主要是因为第三个参数：排序模式  <true表示为访问顺序 |false表示为插入顺序 >
		 * 第二个参数 为加载因子
		 */
		mHardBitmapCache = new LinkedHashMap<String,Bitmap>(CACHE_CAPACITY * 2, 0.5f, true){
			
		     private static final long serialVersionUID = 1L;

			/**
			 * 从映射移除最旧的条目  返回 true,否则返回false 
			 */
			@Override
			protected boolean removeEldestEntry(Entry<String, Bitmap> eldest) {
				if(size() >= CACHE_CAPACITY){
					/*
					 * 将Bitmap从 mHardBitmapCache内存中 转移到  mSoftBitmapCache内存中
					 */
					mSoftBitmapCache.put(eldest.getKey(), new SoftReference<Bitmap>(eldest.getValue()));
					Log.d(TAG, "将数据从HardCache移到SoftCache，url="+eldest.getKey());
					return true;
				}
				return false;
			}
		};	
	}
	
	
	/**
	 * 从缓存中获取图片数据
	 * @param mImageParams
	 * @return
	 */
	public Bitmap getImageData(ImageParams mImageParams){
		String imageKey = mImageParams.getImageKey();
		// 先从 mHardBitmapCache 缓存中获取
		synchronized (mHardBitmapCache) {
			Bitmap bitmap = mHardBitmapCache.get(imageKey);
			if(bitmap != null){
				mHardBitmapCache.remove(imageKey);
				mHardBitmapCache.put(imageKey, bitmap);
				Log.d(TAG, "从HardCache中取到数据，url="+imageKey);
				return bitmap;
			}
		}
		// 如果mHardBitmapCache中找不到，到mSoftBitmapCache中找
		SoftReference<Bitmap> softReference = mSoftBitmapCache.get(imageKey);
		if(softReference != null){
			Bitmap bitmap = softReference.get();
			if(bitmap != null){
				// 将图片 移回硬缓存   从软缓存中移除
				mHardBitmapCache.put(imageKey, bitmap);
				mSoftBitmapCache.remove(imageKey);
				Log.d(TAG, "从SoftCache中取到数据，url="+ imageKey);
				return bitmap;
			}else{
				mSoftBitmapCache.remove(imageKey);
			}
		}
		
		return null;
	}
			
	/**
	 * 将图片添加到内存缓存		
	 * @param imageParams
	 * @param bitmap
	 */
	public void addBitmapToCache(ImageParams imageParams,Bitmap bitmap){
		if(bitmap != null){
			synchronized (mHardBitmapCache) {
				mHardBitmapCache.put(imageParams.getImageKey(), bitmap);
				Log.d(TAG, "将图片缓存到HardCache,url="+imageParams.getImageKey());
			}
		}
	}
	
}
     

          3、图片内存缓存类封装好啦，接着就是SD卡上的文件缓存类：ImageFileCache.java  

在该类中，我们就是把图片储存在SD卡上，当储存在SD卡上的图片临时缓存文件达到一定的大小时，会删除一定百分比的临时文件以达到手机内存的有效控制。

详细代码如下：

package com.ice.android.common.util.imagecache;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Arrays;
import java.util.Comparator;

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Environment;
import android.util.Log;

import com.ice.android.common.util.SdcardUtil;
import com.ice.android.common.util.encryption.MD5;

/**
 * 文件缓存对象  缓存在sdcard 上
 * @author ice
 *
 */
public class ImageFileCache {

	private static final String TAG = "ImageFileCache";
	
	/** 文件缓存存放目录  */
	private static final String CACHE_DIR = Environment.getExternalStorageDirectory().getPath()+"app package/cache/img/";
	
	/** 文件缓存后缀名    */
	private static final String CACHE_FILE_SUFFIX = ".cach";
	
	/** 允许最大缓存空间    30M */
	private static final long MAX_CHCHE_SPACE = 30 * 1024 * 1024;
	
	/** 最小SD卡 剩余空间（预留给用户做其它的事情） */
	private static final long MIN_SDCART_AVAILABLE_SPACE = 30 * 1024 * 1024;
	
	/** 每次清除缓存的百分比 */
	private static final float CACHE_REMOVE_FACTOR = 0.4f;
	
	public ImageFileCache(){
		// 根据sd卡内存情况 清理部分文件缓存
		removeCache();
	}

	
	/**
	 * 从sd卡上获取缓存图片
	 * @param imageParams
	 * @return
	 */
	public Bitmap getImageData(ImageParams imageParams){
		final String path = CACHE_DIR + convertUrlToFileName(imageParams.getImageKey());
		File file = new File(path);
		if(file.exists()){
			Bitmap bitmap = null;
			BitmapFactory.Options options = new BitmapFactory.Options();
			options.inJustDecodeBounds = true;
	        // 获取这个图片的宽和高
	        int beHeight = (int) (options.outHeight / (float) 200);
	        int beWidth = (int) (options.outWidth/ (float) 200);
	        int scale = beHeight>beWidth?beHeight:beWidth; 
	        options.inSampleSize=scale==0?1:scale;
	        options.inJustDecodeBounds = false;
	        
	        bitmap = BitmapFactory.decodeFile(path, options); 
			
	        if(bitmap == null){
	        	Log.w(TAG, "将文件转换成Bitmap失败，删除此文件，path = " + path);
	        	file.delete();
	        }else {
	        	Log.w(TAG, "将文件转换成Bitmap成功，path = " + path);
	        	// 修改 缓存文件的最后修改时间
	        	updateFileTime(path);
	        	return bitmap;
			}
		}
		
		return null;
	}
	

	

	/**
	 * 将图片数据保存到sd卡
	 * @param imageParams
	 * @param mBitmap
	 * @throws IOException 
	 */
	public void addBitmapToSdcard(ImageParams imageParams,Bitmap mBitmap) {
		String imageKey = imageParams.getImageKey();
		if(mBitmap == null){
			Log.w(TAG, "Bitmap为null，持久化存储失败，url = "+imageKey);
			return ; 
		}
		
		long sdcardAvailableSpace = SdcardUtil.getSdcardAvailableSpace();
		// 如果sd卡的可用空间 小于 SD卡最小预留空间
		if(sdcardAvailableSpace < MIN_SDCART_AVAILABLE_SPACE){
			Log.w(TAG, "SD卡空间不足，不做持持久化存储，sdcardAvailableSpace = " + sdcardAvailableSpace + ", url = "+imageParams.getUrl());
			return ;
		}
		
		File dir = new File(CACHE_DIR);
		if(!dir.exists()){
			dir.mkdirs();     // PS: 这里客串一下, 注意 mkdirs() 与  mkdir()方法的区别
		}
		
		String fileName = CACHE_DIR + convertUrlToFileName(imageKey);
		File file = new File(fileName);
		
		OutputStream os = null;
		try {
			os = new FileOutputStream(file);
			mBitmap.compress(Bitmap.CompressFormat.PNG, 100, os);
			os.flush();
			os.close();
			Log.d(TAG, "图片持久化存储成功，path = "+ fileName + ", url = " + imageKey);
		} catch (IOException e) {
			Log.d(TAG, "图片持久化存储失败:"+e.getMessage());
		}
		
	}
	
	
	
	/**
	 * 根据sd卡内存情况 清理部分文件缓存
	 * 1.计算存储目录下的文件大小
	 * 2.当文件总大小大于规定的最大缓存大小或者sdcard剩余空间小于最小SD卡可用空间的规定时，
	 *   删除特定数量的最近没有被使用的文件
	 */
	private boolean removeCache() {
		if(!SdcardUtil.isSdcardWritable()){
			Log.d(TAG, "SD卡不可写，清理缓存失败!");
			return false;
		}
		
		File dir = new File(CACHE_DIR);
		File[] files = dir.listFiles();
		if(files == null || files.length == 0){
			Log.d(TAG, "木有缓存，无需清理...");
			return true;
		}
		
		long dirSize = 0;
		for(int i = 0; i < files.length; i++){
			if(files[i].getName().endsWith(CACHE_FILE_SUFFIX)){
				dirSize += files[i].length();
			}
		}
		
		long sdcardAvailableSpace = SdcardUtil.getSdcardAvailableSpace();
		Log.d(TAG, "缓存文件的已有总大小为：" + dirSize + "，SD卡可用空间为：" + sdcardAvailableSpace);
		
		if(dirSize >= MAX_CHCHE_SPACE || sdcardAvailableSpace< MIN_SDCART_AVAILABLE_SPACE){
			// 计算出需要删除的文件数量
			int removeNum = (int)((files.length * CACHE_REMOVE_FACTOR) + 1);
			Log.d(TAG, "需要清除"+removeNum+"个缓存文件");
			
			// 根据文件的最后修改时间进行排序
			Arrays.sort(files, new FileLastModifiedComparator());
			
			for(int i = 0; i < removeNum; i++){
				if(files[i].getName().endsWith(CACHE_FILE_SUFFIX)){
					files[i].delete();
				}
			}
		}else{
			Log.d(TAG, "缓存情况还木有超出指定情况，无需清理...");
		}
		
		return true;
	}
	
	
	/**
	 * 根据文件的最后修改时间进行排序  
	 * 把最后修改时间 越长的排到越前面
	 * @author ice
	 *
	 */
	private class FileLastModifiedComparator implements Comparator<File>{

		@Override
		public int compare(File arg0, File arg1) {
			if(arg0.lastModified() > arg1.lastModified()){
				 return 1;
			}else if(arg0.lastModified() == arg1.lastModified()){
				return 0;
			}
			return -1;
		}
	}
	
	
	/**
	 * 根据图片url生成文件缓存的名字
	 * @param url
	 * @return
	 */
	private String convertUrlToFileName(String url){
		/**
		 * 将url进行MD5加密一下吧
		 */
		return MD5.getMD5Str(url)+CACHE_FILE_SUFFIX;
	}
	
	/**
	 * 修改 缓存文件的最后修改时间
	 * @param path  文件绝对路径
	 */
	private void updateFileTime(String path) {
		File file = new File(path);
		file.setLastModified(System.currentTimeMillis());
	}

}

 

PS：针对上面的ImageFileCache.java 和 ImageMemCache.java可以再一步改造，抽出一个 ImageCache 的接口，然后ImageFileCache,java 和 ImageMemCache.java 都实现该接口，这样是不是更好呢？哈哈 动手吧... ...


小吕、初学Android，正在努力的学习阶段，各位针对上面的代码如果有更好的建议和想法的，可以留言给我哈！ 多谢啦...  ... 





小吕-ICE
关注
专栏目录
Android开发笔记（一百七十一）使用Glide加载网络图片
aqi00的博客
05-25 2527
如何方便而又快速地显示网络图片，一直是安卓网络编程的热门课题，前些年图片缓存框架Picasso、Fresco等等大行其道，以至于谷歌按捺不住也开发了自己的Glide开源库。由于Android本身就是谷歌开发的，Glide与Android系出同门，因此Glide成为事实上的官方推荐图片缓存框架。不过Glide并未集成到Android的SDK当中，开发者需要另外给App工程导入Glide库，也就是修改模块的build.gradle，在dependencies节点内部添加如下一行依赖库配置： impl..
Android 超强图片工具类BitmapUtil
lovoo的博客
05-10 5194
说明：为了方便大家使用，本人把大家常用的图片处理代码集中到这个类里/** * 图片加载及转化工具 ----------------------------------------------------------------------- 延伸：一个Bitmap到底占用多大内存？系统给每个应用程序分配多大内存？ Bitmap占用的内存为：像素总数 * * 每个像素占用的内存。在Android中
Android学习之 有关图片缓存问提的代码封装<二>
小吕丶Code阶区
05-11 1228
在上一篇中，主要
强大的Android图片下载缓存库——Picasso<一>
jxq1994的博客
11-24 2247
概述 在Android开发中，常需要从远程获取图片并显示在客户端，当然我们可以使用原生HttpUrlConnection和AsyncTask等操作来完成，但并不推荐，因为这样不仅需要我们编写大量的代码，还需要处理缓存和下载管理等。 为什么要使用Picasso？ 它简化了从外部网址加载图片并在应用程序上显示的过程。例如，从服务器下载图像是任何应用程序中最常见的任务之一。它需要相当多的代码来实现这一
Android进阶之路 - 批量下载、缓存图片
Android、前端、小程序、后端
11-05 2203
在日常项目开发中，关于图片批量下载，数据缓存的相关功能比比皆是，这次也是去年在项目中需要在本地缓存商品数据，所以用到了批量下载的功能，特此记录 ~ 全局代码均使用的是伪代码 ，不能直接跑项目，更多的是提供解决思想和部分功能实现 单图下载：采用 Glide 框架为图片加载框架 批量下载：结合 Glide 框架与 递归 实现批量下载图片功能 Glide伪代码 public class GlideTool { /** * 主要用于监听Glide下载结果，成功或失败 ~.
Android获取图片缓存及清除
王志伟的博客
09-28 1638
封装一个类package com.jianong.xmtt.util;import android.content.Context; import android.os.Environment;import java.io.File; import java.math.BigDecimal;/** * Created by hgl on 2016/6/23. */ public class Da
Android进阶之路 - 批量下载、缓存图片、视频
Android、前端、小程序、后端
12-01 5849
之前已经记录过，批量下载图片和缓存本地的方式，此篇主要记录批量下载图片、视频，同时缓存在本地的功能实现 关联篇 Android进阶之路 - 批量下载、缓存图片 Android进阶之路 - 批量下载、缓存图片、视频 在此之前，我记录过一篇 主讲 - 批量下载、缓存图片，此篇可以作为上篇的进阶扩展，优化了调用场景和使用方式~ 基础配置图片下载视频下载完整封装使用方式 关于实现批量下载、缓存功能，主要使用了以下几方面的知识 通过Glide下载图片 通过okhttputils下载视频 greenDao数.
Android图片加载框架最全解析（三），深入探究Glide的缓存机制
热门推荐
郭霖的专栏
05-23 9万+
Glide的缓存设计可以说是非常先进的，考虑的场景也很周全。在缓存这一功能上，Glide又将它分成了两个模块，一个是内存缓存，一个是硬盘缓存。 这两个缓存模块的作用各不相同，内存缓存的主要作用是防止应用重复将图片数据读取到内存当中，而硬盘缓存的主要作用是防止应用重复从网络或其他地方重复下载和读取数据。 内存缓存和硬盘缓存的相互结合才构成了Glide极佳的图片缓存效果，那么接下来我们就分别来分析一下这两种缓存的使用
教你写Android ImageLoader框架之图片缓存 （完结篇）
Mr.Simple的专栏
03-10 9763
在教你写Android ImageLoader框架系列博文中，我们从基本架构到具体实现已经更新了大部分的内容。今天，我们来讲最后一个关键点，即图片的缓存。为了用户体验，通常情况下我们都会将已经下载的图片缓存起来，一般来说内存和本地都会有图片缓存。那既然是框架，必然需要有很好的定制性，这让我们又自然而然的想到了抽象。下面我们就一起来看看缓存的实现吧。
Android开发笔记之图片缓存、手势及OOM分析
09-02
在Android应用开发中，图片缓存、手势交互和内存管理（尤其是Out Of Memory，简称OOM）是开发者常常遇到的关键问题。这些元素对于提供流畅、高效且用户体验良好的应用程序至关重要。本篇开发笔记将深入探讨这三个...
实现一个快速简单的SimpleListDialog<T>
08-10
标题 "实现一个快速简单的SimpleListDialog<T>" 指向的是在编程中创建一个简易对话框，用于展示可选择的列表项。这个对话框可能是基于Android平台，因为通常在Android开发中，我们会用到类似`Dialog`的组件来与用户...
Android 图片缓存
11-18
在实现Android图片缓存时，我们可以使用开源库如Universal Image Loader、Glide、Picasso等，它们已经封装了完善的缓存机制。这些库通常会自动处理软硬引用、内存管理和磁盘操作，开发者只需要简单调用API即可实现...
android编程实现图片库的封装方法
09-03
在Android开发中，图片库的封装是一个常见的需求，主要用于高效管理和操作应用中的图片资源，包括下载、保存、获取以及缓存处理。以下是对标题和描述中提到的知识点的详细解释： 1. **图片库的封装**： 图片库封装...
Android-图片加载库的二次封装
08-13
例如，你可以创建一个`ImageLoaderManager`类，包含`displayImage()`和`downloadImage()`方法，将上述的Glide代码封装起来，提供更加简洁的接口给应用其他部分使用。 总的来说，Android图片加载库的二次封装旨在...
Android学习之 移动应用<App>微信支付集成小结
小吕丶Code阶区
07-22 2万+
微信支付现在主要集成在：1、移动应用开发  2、网站应用开发  3、公众账号开发        本篇主要
Android学习之 Manifest中meta-data扩展元素数据的配置与获取
小吕丶Code阶区
11-29 2万+
在AndroidManifest.xml清单文件中 我们有时会看到如下类似的元素开始的配置内容： <meta-data android:name="com.google.android.maps.v2.API_KEY" android:value="AIzaSyBhBFOgVQclaa8p1JJeqaZHiCo2nfiyBBo" /> <meta-data android
Android系统 小米/三星/索尼 应用启动图标未读消息数(BadgeNumber)动态提醒
小吕丶Code阶区
03-17 1万+
在Android手机上，如QQ、微信当有未读消息的时候、我们可以看到在应用的启动图标的右上角会有一个红色圈圈、且圈圈里会动态显示未读消息的数目，如下图显示： 那么该功能是怎么实现的呢？ 在万能的互联网搜索和翻阅了大量相关资料、也请教了一些技术群里的大咖们。从他们那里我获知、提取了一些关键词：第三方控件BadgeView（实现应用内的数字提醒）、快捷图标、Launcher、反射。 零零碎碎的花费
Android学习之 Activity堆栈管理与控制
小吕丶Code阶区
11-08 1万+
App程序中有很多Activity、你可以通俗的理解为把一个Activity看做是一个UI界面。在Andord系统中Activity是以堆栈的形式存在。堆栈中的根Activity就是应用程序的启动Activity。而堆栈中最上方的Activity则是当前运行的/用户正在操作的UI Activity。     也可以这样去理解：堆栈中保存的是Activity对象，如果一个应用中多次使用了一个Act
Android图片异步加载与三级缓存实现详解
"Android图片异步请求与三级缓存的实现" 在Android开发中，图片加载是一个常见的需求，尤其是在用户界面中。为了优化用户体验并减少网络请求的负担，开发者通常会采用图片异步请求的方式，并结合多级缓存策略。本文...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值