发布于 2016-02-29 05:26:36 | 97 次阅读 | 评论: 0 | 来源: 网友投递

这里有新鲜出炉的精品教程，程序狗速度看过来！

Android移动端操作系统

Android是一种基于Linux的自由及开放源代码的操作系统，主要使用于移动设备，如智能手机和平板电脑，由Google公司和开放手机联盟领导及开发。尚未有统一中文名称，中国大陆地区较多人使用“安卓”或“安致”。

---

实现图片缓存也不难，需要有相应的cache策略。这里我采用 内存-文件-网络 三层cache机制，其中内存缓存包括强引用缓存和软引用缓存（SoftReference），其实网络不算cache，这里姑且也把它划到缓存的层次结构中
1.简介
现在android应用中不可避免的要使用图片，有些图片是可以变化的，需要每次启动时从网络拉取，这种场景在有广告位的应用以及纯图片应用（比如百度美拍）中比较多。

现在有一个问题：假如每次启动的时候都从网络拉取图片的话，势必会消耗很多流量。在当前的状况下，对于非wifi用户来说，流量还是很贵的，一个很耗流量的应用，其用户数量级肯定要受到影响。当然，我想，向百度美拍这样的应用，必然也有其内部的图片缓存策略。总之，图片缓存是很重要而且是必须的。

2.图片缓存的原理
实现图片缓存也不难，需要有相应的cache策略。这里我采用 内存-文件-网络 三层cache机制，其中内存缓存包括强引用缓存和软引用缓存（SoftReference），其实网络不算cache，这里姑且也把它划到缓存的层次结构中。当根据url向网络拉取图片的时候，先从内存中找，如果内存中没有，再从缓存文件中查找，如果缓存文件中也没有，再从网络上通过http请求拉取图片。在键值对（key-value）中，这个图片缓存的key是图片url的hash值，value就是bitmap。所以，按照这个逻辑，只要一个url被下载过，其图片就被缓存起来了。

关于Java中对象的软引用（SoftReference），如果一个对象具有软引用，内存空间足够，垃 圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高 速缓存。使用软引用能防止内存泄露，增强程序的健壮性。

从代码上来说，采用一个ImageManager来负责图片的管理和缓存，函数接口为public void loadBitmap(String url, Handler handler) ；其中url为要下载的图片地址，handler为图片下载成功后的回调，在handler中处理message，而message中包含了图片的信息以及bitmap对象。ImageManager中使用的ImageMemoryCache（内存缓存）、ImageFileCache（文件缓存）以及LruCache（最近最久未使用缓存）会在后续文章中介绍。

3.代码ImageManager.java

 
/* 
* 图片管理 
* 异步获取图片，直接调用loadImage()函数，该函数自己判断是从缓存还是网络加载 
* 同步获取图片，直接调用getBitmap()函数，该函数自己判断是从缓存还是网络加载 
* 仅从本地获取图片，调用getBitmapFromNative() 
* 仅从网络加载图片，调用getBitmapFromHttp() 
* 
*/ 
public class ImageManager implements IManager 
{ 
private final static String TAG = "ImageManager"; 

private ImageMemoryCache imageMemoryCache; //内存缓存 

private ImageFileCache imageFileCache; //文件缓存 

//正在下载的image列表 
public static HashMap<String, Handler> ongoingTaskMap = new HashMap<String, Handler>(); 

//等待下载的image列表 
public static HashMap<String, Handler> waitingTaskMap = new HashMap<String, Handler>(); 

//同时下载图片的线程个数 
final static int MAX_DOWNLOAD_IMAGE_THREAD = 4; 

private final Handler downloadStatusHandler = new Handler(){ 
public void handleMessage(Message msg) 
{ 
startDownloadNext(); 
} 
}; 

public ImageManager() 
{ 
imageMemoryCache = new ImageMemoryCache(); 
imageFileCache = new ImageFileCache(); 
} 

/** 
* 获取图片，多线程的入口 
*/ 
public void loadBitmap(String url, Handler handler) 
{ 
//先从内存缓存中获取，取到直接加载 
Bitmap bitmap = getBitmapFromNative(url); 
if (bitmap != null) 
{ 
Logger.d(TAG, "loadBitmap:loaded from native"); 
Message msg = Message.obtain(); 
Bundle bundle = new Bundle(); 
bundle.putString("url", url); 
msg.obj = bitmap; 
msg.setData(bundle); 
handler.sendMessage(msg); 
} 
else 
{ 
Logger.d(TAG, "loadBitmap:will load by network"); 
downloadBmpOnNewThread(url, handler); 
} 
} 
/** 
* 新起线程下载图片 
*/ 
private void downloadBmpOnNewThread(final String url, final Handler handler) 
{ 
Logger.d(TAG, "ongoingTaskMap'size=" + ongoingTaskMap.size()); 

if (ongoingTaskMap.size() >= MAX_DOWNLOAD_IMAGE_THREAD) 
{ 
synchronized (waitingTaskMap) 
{ 
waitingTaskMap.put(url, handler); 
} 
} 
else 
{ 
synchronized (ongoingTaskMap) 
{ 
ongoingTaskMap.put(url, handler); 
} 
new Thread() 
{ 
public void run() 
{ 
Bitmap bmp = getBitmapFromHttp(url); 
// 不论下载是否成功，都从下载队列中移除,再由业务逻辑判断是否重新下载 
// 下载图片使用了httpClientRequest，本身已经带了重连机制 
synchronized (ongoingTaskMap) 
{ 
ongoingTaskMap.remove(url); 
} 

if(downloadStatusHandler != null) 
{ 
downloadStatusHandler.sendEmptyMessage(0); 

} 
Message msg = Message.obtain(); 
msg.obj = bmp; 
Bundle bundle = new Bundle(); 
bundle.putString("url", url); 
msg.setData(bundle); 

if(handler != null) 
{ 
handler.sendMessage(msg); 
} 
} 
}.start(); 
} 
} 
/** 
* 依次从内存，缓存文件，网络上加载单个bitmap,不考虑线程的问题 
*/ 
public Bitmap getBitmap(String url) 
{ 
// 从内存缓存中获取图片 
Bitmap bitmap = imageMemoryCache.getBitmapFromMemory(url); 
if (bitmap == null) 
{ 
// 文件缓存中获取 
bitmap = imageFileCache.getImageFromFile(url); 
if (bitmap != null) 
{ 
// 添加到内存缓存 
imageMemoryCache.addBitmapToMemory(url, bitmap); 
} 
else 
{ 
// 从网络获取 
bitmap = getBitmapFromHttp(url); 
} 
} 
return bitmap; 
} 

/** 
* 从内存或者缓存文件中获取bitmap 
*/ 
public Bitmap getBitmapFromNative(String url) 
{ 
Bitmap bitmap = null; 
bitmap = imageMemoryCache.getBitmapFromMemory(url); 

if(bitmap == null) 
{ 
bitmap = imageFileCache.getImageFromFile(url); 
if(bitmap != null) 
{ 
// 添加到内存缓存 
imageMemoryCache.addBitmapToMemory(url, bitmap); 
} 
} 
return bitmap; 
} 

/** 
* 通过网络下载图片,与线程无关 
*/ 
public Bitmap getBitmapFromHttp(String url) 
{ 
Bitmap bmp = null; 

try 
{ 
byte[] tmpPicByte = getImageBytes(url); 

if (tmpPicByte != null) 
{ 
bmp = BitmapFactory.decodeByteArray(tmpPicByte, 0, 
tmpPicByte.length); 
} 
tmpPicByte = null; 
} 
catch(Exception e) 
{ 
e.printStackTrace(); 
} 

if(bmp != null) 
{ 
// 添加到文件缓存 
imageFileCache.saveBitmapToFile(bmp, url); 
// 添加到内存缓存 
imageMemoryCache.addBitmapToMemory(url, bmp); 
} 
return bmp; 
} 

/** 
* 下载链接的图片资源 
* 
* @param url 
* 
* @return 图片 
*/ 
public byte[] getImageBytes(String url) 
{ 
byte[] pic = null; 
if (url != null && !"".equals(url)) 
{ 
Requester request = RequesterFactory.getRequester( 
Requester.REQUEST_REMOTE, RequesterFactory.IMPL_HC); 
// 执行请求 
MyResponse myResponse = null; 
MyRequest mMyRequest; 
mMyRequest = new MyRequest(); 
mMyRequest.setUrl(url); 
mMyRequest.addHeader(HttpHeader.REQ.ACCEPT_ENCODING, "identity"); 
InputStream is = null; 
ByteArrayOutputStream baos = null; 
try { 
myResponse = request.execute(mMyRequest); 
is = myResponse.getInputStream().getImpl(); 
baos = new ByteArrayOutputStream(); 
byte[] b = new byte[512]; 
int len = 0; 
while ((len = is.read(b)) != -1) 
{ 
baos.write(b, 0, len); 
baos.flush(); 
} 
pic = baos.toByteArray(); 
Logger.d(TAG, "icon bytes.length=" + pic.length); 
} 
catch (Exception e3) 
{ 
e3.printStackTrace(); 
try 
{ 
Logger.e(TAG, 
"download shortcut icon faild and responsecode=" 
+ myResponse.getStatusCode()); 
} 
catch (Exception e4) 
{ 
e4.printStackTrace(); 
} 
} 
finally 
{ 
try 
{ 
if (is != null) 
{ 
is.close(); 
is = null; 
} 
} 
catch (Exception e2) 
{ 
e2.printStackTrace(); 
} 
try 
{ 
if (baos != null) 
{ 
baos.close(); 
baos = null; 
} 
} 
catch (Exception e2) 
{ 
e2.printStackTrace(); 
} 
try 
{ 
request.close(); 
} 
catch (Exception e1) 
{ 
e1.printStackTrace(); 
} 
} 
} 
return pic; 
} 

/** 
* 取出等待队列第一个任务，开始下载 
*/ 
private void startDownloadNext() 
{ 
synchronized(waitingTaskMap) 
{ 
Logger.d(TAG, "begin start next"); 
Iterator iter = waitingTaskMap.entrySet().iterator(); 

while (iter.hasNext()) 
{ 

Map.Entry entry = (Map.Entry) iter.next(); 
Logger.d(TAG, "WaitingTaskMap isn't null,url=" + (String)entry.getKey()); 

if(entry != null) 
{ 
waitingTaskMap.remove(entry.getKey()); 
downloadBmpOnNewThread((String)entry.getKey(), (Handler)entry.getValue()); 
} 
break; 
} 
} 
} 

public String startDownloadNext_ForUnitTest() 
{ 
String urlString = null; 
synchronized(waitingTaskMap) 
{ 
Logger.d(TAG, "begin start next"); 
Iterator iter = waitingTaskMap.entrySet().iterator(); 

while (iter.hasNext()) 
{ 
Map.Entry entry = (Map.Entry) iter.next(); 
urlString = (String)entry.getKey(); 
waitingTaskMap.remove(entry.getKey()); 
break; 
} 
} 
return urlString; 
} 

/** 
* 图片变为圆角 
* @param bitmap:传入的bitmap 
* @param pixels：圆角的度数，值越大，圆角越大 
* @return bitmap:加入圆角的bitmap 
*/ 
public static Bitmap toRoundCorner(Bitmap bitmap, int pixels) 
{ 
if(bitmap == null) 
return null; 
Bitmap output = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(), Config.ARGB_8888); 
Canvas canvas = new Canvas(output); 
final int color = 0xff424242; 
final Paint paint = new Paint(); 
final Rect rect = new Rect(0, 0, bitmap.getWidth(), bitmap.getHeight()); 
final RectF rectF = new RectF(rect); 
final float roundPx = pixels; 
paint.setAntiAlias(true); 
canvas.drawARGB(0, 0, 0, 0); 
paint.setColor(color); 
canvas.drawRoundRect(rectF, roundPx, roundPx, paint); 
paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN)); 
canvas.drawBitmap(bitmap, rect, rect, paint); 
return output; 
} 

public byte managerId() 
{ 
return IMAGE_ID; 
} 
}