android面向对象的六大原则之 —— 开闭原则

2017-01-13 15:17:21来源:http://www.jianshu.com/p/c423c6d50b05作者:马哥_人点击

第七城市

版权声明:本文为博主原创文章,未经博主允许不得转载。


学习了何红辉、关爱民写的《Android设计模式》,对于面向对象的六大原则有进一步的理解,特此根据自己的理解记录总结一下
什么是开闭原则
一个类、模块、函数等应该对于扩展是开放的,但是对于修改是封闭的,简单说就是当你的系统要升级维护需要对原有的代码进行修改时,可能会将错误引入到了原来的旧代码中,因此,在软件升级维护时,应该尽可能的通过扩展的方式而不是修改原有的代码,虽然在实际开发中,修改原本的代码跟扩展代码都是同时存在的,但是为了程序的可扩展性,在制作初期,应该遵循开闭原则。
以上一篇《面向对象的六大原则之 —— 单一原则》的例子为例继续讲解


在ImageCache类中,使用了内存缓存,可是内存缓存很有限,而且还容易丢失,比如应用关闭后,原来缓存在内存的图片会丢失,再打开需要重新加载,所以我们考虑加入SD卡缓存。


加入DiskCache类,缓存图片到SD卡中


importandroid.graphics.Bitmap;
importandroid.graphics.BitmapFactory;
importjava.io.FileNotFoundException;
importjava.io.FileOutputStream;
importjava.io.IOException;
/**
*CreatedbyAdministratoron2016/3/1.
*/
publicclassDiskCache{
publicstaticfinalStringcacheDir="sdcard/cache/";
/**
*获取sd卡的图片缓存
*@paramurl图片url
*@return返回bitmap
*/
publicBitmapget(Stringurl){
Bitmapbitmap=null;
bitmap=BitmapFactory.decodeFile(cacheDir+url);
returnbitmap;
}
/**
*缓存到sd卡
*@paramurl图片的url
*@parambitmapbitmap对象
*/
privatevoidput(Stringurl,Bitmapbitmap){
FileOutputStreamoutput=null;
try{
output=newFileOutputStream(cacheDir+url);
bitmap.compress(Bitmap.CompressFormat.PNG,100,output);
}catch(FileNotFoundExceptione){
e.printStackTrace();
}finally{
//无论是否有异常,都要关闭流
try{
if(output!=null){
output.close();
}
}catch(IOExceptione){
e.printStackTrace();
}
}
}
}

因为加入了sd卡的缓存方式,所以要修改ImageLoader类


importandroid.graphics.Bitmap;
importandroid.graphics.BitmapFactory;
importandroid.widget.ImageView;
importjava.io.IOException;
importjava.net.HttpURLConnection;
importjava.net.MalformedURLException;
importjava.net.URL;
importjava.util.concurrent.ExecutorService;
importjava.util.concurrent.Executors;
/**
*CreatedbyAdministratoron2016/3/1.
*/
publicclassImageLoader{
publicImageLoader(){
}
//内存缓存类
ImageCacheimageCache=newImageCache();
//sd卡缓存类
DiskCachediskCache=newDiskCache();
//是否使用sd卡缓存
booleanisUseDiskCache=false;
//线程池,线城数量为cpu的数量
ExecutorServicemExecutorService=Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
/**
*显示图片
*@paramurl图片的url
*@paramimageView要显示的view
*/
publicvoiddisplayImage(finalStringurl,finalImageViewimageView){
Bitmapbitmap=isUseDiskCache()?diskCache.get(url):imageCache.get(url);
if(bitmap!=null){
imageView.setImageBitmap(bitmap);
return;
}
imageView.setTag(url);
mExecutorService.submit(newRunnable(){
@Override
publicvoidrun(){
Bitmapbitmap=downloadImage(url);
if(bitmap==null){
return;
}
if(imageView.getTag().equals(url)){
imageView.setImageBitmap(bitmap);
}
imageCache.put(url,bitmap);
diskCache.put(url,bitmap);
}
});
}
/**
*下载图片
*@paramimageUrl网络图片地址
*@return返回bitmap对象
*/
publicBitmapdownloadImage(StringimageUrl){
Bitmapbitmap=null;
try{
URLurl=newURL(imageUrl);
HttpURLConnectionconn=(HttpURLConnection)url.openConnection();
bitmap=BitmapFactory.decodeStream(conn.getInputStream());
conn.disconnect();
}catch(MalformedURLExceptione){
e.printStackTrace();
}catch(IOExceptione){
e.printStackTrace();
}
returnbitmap;
}
publicbooleanisUseDiskCache(){
returnisUseDiskCache;
}
publicvoidsetIsUseDiskCache(booleanisUseDiskCache){
this.isUseDiskCache=isUseDiskCache;
}
}

ImageLoader类中加入了少量代码就添加了sd卡缓存的功能,用户还能通过setIsUseDiskCache设置使用哪种缓存,但是以上还有个问题,使用内存缓存的时候,就没有sd卡缓存,用户要两种策略都用,首先缓存优先使用内存缓存, 如果内存没有就查找sd卡缓存,sd卡没有就从网络获取,,这才是最好的缓存策略,依照这种想法,修改代码,加入DoubleCache类,实现双缓存


importandroid.graphics.Bitmap;
/**
*CreatedbyAdministratoron2016/3/1.
*/
publicclassDoubleCache{
//内存缓存
ImageCachemImageCache=newImageCache();
//sd卡缓存
DiskCachemDiskCache=newDiskCache();
/**
*获取缓存图片
*@paramurl图片url
*@return返回bitmap对象
*/
publicBitmapget(Stringurl){
Bitmapbitmap=null;
bitmap=mImageCache.get(url);
if(bitmap==null){
bitmap=mDiskCache.get(url);
}
returnbitmap;
}
/**
*缓存图片
*@paramurl图片url
*@parambitmap
*/
publicvoidput(Stringurl,Bitmapbitmap){
mImageCache.put(url,bitmap);
mDiskCache.put(url,bitmap);
}
}

ImageLoader类修改如下


importandroid.graphics.Bitmap;
importandroid.graphics.BitmapFactory;
importandroid.widget.ImageView;
importjava.io.IOException;
importjava.net.HttpURLConnection;
importjava.net.MalformedURLException;
importjava.net.URL;
importjava.util.concurrent.ExecutorService;
importjava.util.concurrent.Executors;
/**
*CreatedbyAdministratoron2016/3/1.
*/
publicclassImageLoader{
publicImageLoader(){
}
//内存缓存类
ImageCacheimageCache=newImageCache();
//sd卡缓存类
DiskCachediskCache=newDiskCache();
//双缓存
DoubleCachedoubleCache=newDoubleCache();
//是否使用sd卡缓存
booleanisUseDiskCache=false;
//是否使用双缓存
booleanisUseDoubleCache=false;
//线程池,线城数量为cpu的数量
ExecutorServicemExecutorService=Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

/**
*显示图片
*@paramurl图片的url
*@paramimageView要显示的view
*/
publicvoiddisplayImage(finalStringurl,finalImageViewimageView){
Bitmapbitmap=null;
if(isUseDoubleCache()){
bitmap=doubleCache.get(url);
}elseif(isUseDiskCache()){
bitmap=diskCache.get(url);
}else{
bitmap=imageCache.get(url);
}
if(bitmap!=null){
imageView.setImageBitmap(bitmap);
return;
}
imageView.setTag(url);
mExecutorService.submit(newRunnable(){
@Override
publicvoidrun(){
Bitmapbitmap=downloadImage(url);
if(bitmap==null){
return;
}
if(imageView.getTag().equals(url)){
imageView.setImageBitmap(bitmap);
}
//缓存到内存跟sd卡中
doubleCache.put(url,bitmap);
}
});
}
/**
*下载图片
*@paramimageUrl网络图片地址
*@return返回bitmap对象
*/
publicBitmapdownloadImage(StringimageUrl){
Bitmapbitmap=null;
try{
URLurl=newURL(imageUrl);
HttpURLConnectionconn=(HttpURLConnection)url.openConnection();
bitmap=BitmapFactory.decodeStream(conn.getInputStream());
conn.disconnect();
}catch(MalformedURLExceptione){
e.printStackTrace();
}catch(IOExceptione){
e.printStackTrace();
}
returnbitmap;
}
publicbooleanisUseDiskCache(){
returnisUseDiskCache;
}
publicvoidsetIsUseDiskCache(booleanisUseDiskCache){
this.isUseDiskCache=isUseDiskCache;
}
publicbooleanisUseDoubleCache(){
returnisUseDoubleCache;
}
publicvoidsetIsUseDoubleCache(booleanisUseDoubleCache){
this.isUseDoubleCache=isUseDoubleCache;
}
}

经过修改之后,我们的图片加载器已经实现了双缓存的功能了,可是细心的你可能发现了,每次加入新的缓存方法都要修改原来的代码,而且还会让ImageLoader变的越来越复杂,一堆的if{}else{}判断,条件多了就容易造成错误,而且如果现在用户想要自己扩展一个缓存方式,都要动ImageLoader类里面的东西,本文最上面已经说了,开闭原则的目的就是为了让扩展是开发的,修改是封闭的,当软件需要变化时,我们应该尽可能的通过扩展的方式来实现变化,而不要通过修改已有的代码来实现,按照这个思维,我们来想想应该如何修改,首先,我们的ImageLoader的职责就是加载图片跟设置缓存的,而缓存的实现不由它管,我们的目的是让缓存的方式能让用户自己扩展,所以我们定义ImageCache接口,接口中有两个方法,一个是put(String url,Bitmap bitmap)用来添加到缓存,一个是get(String url);用来获取缓存,具体实现不管,而是由实现了这个接口的实现类来具体实现。


ImageCache类如下:


importandroid.graphics.Bitmap;
/**
*CreatedbyAdministratoron2016/3/1.
*/
publicinterfaceImageCache{
/**
*添加缓存
*@paramurl缓存的图片url作为缓存的key
*@parambitmap缓存的bitmap
*/
publicvoidput(Stringurl,Bitmapbitmap);
/**
*获取缓存的图片
*@paramurl
*@return
*/
publicBitmapget(Stringurl);
}

我们可以将接口当成是一个标准,比如电脑的usb接口,想要通过usb连接到电脑,就必须要按照usb这个插口的标准走,不然你想插也插不进去,我们的图片加载器也是一样,想要自己扩展一个缓存方式,就要按我的标准来。
所以,上面的内存缓存、sd卡缓存、双缓存三个类,我们全部修改实现ImageCache类


内存缓存类(MemoryCache)


importandroid.graphics.Bitmap;
importandroid.util.LruCache;
/**
*CreatedbyAdministratoron2016/3/1.
*/
publicclassMemoryCacheimplementsImageCache{
publicMemoryCache(){
//初始化图片缓存
initImageCache();
}
//图片缓存类
LruCache<String,Bitmap>memoryCache;
/**
*初始化缓存
*/
privatevoidinitImageCache(){
//计算可使用的最大内存
intmaxMemory=(int)(Runtime.getRuntime().maxMemory()/1024);
//只用最大内存的四分之一作为缓存大小
intcacheSize=maxMemory/4;
memoryCache=newLruCache<String,Bitmap>(cacheSize){
@Override
protectedintsizeOf(Stringkey,Bitmapvalue){
returnvalue.getRowBytes()*value.getHeight()/1024;
}
};
}
/**
*添加缓存
*
*@paramurl缓存的图片url作为缓存的key
*@parambitmap缓存的bitmap
*/
publicvoidput(Stringurl,Bitmapbitmap){
memoryCache.put(url,bitmap);
}
/**
*获取缓存的图片
*
*@paramurl
*@return
*/
publicBitmapget(Stringurl){
Bitmapbitmap=null;
bitmap=memoryCache.get(url);
returnbitmap;
}
}

SD卡缓存类(DiskCache)


importandroid.graphics.Bitmap;
importandroid.graphics.BitmapFactory;
importjava.io.FileNotFoundException;
importjava.io.FileOutputStream;
importjava.io.IOException;
/**
*CreatedbyAdministratoron2016/3/1.
*/
publicclassDiskCacheimplementsImageCache{
publicstaticfinalStringcacheDir="sdcard/cache/";
/**
*获取sd卡的图片缓存
*@paramurl图片url
*@return返回bitmap
*/
publicBitmapget(Stringurl){
Bitmapbitmap=null;
bitmap=BitmapFactory.decodeFile(cacheDir+url);
returnbitmap;
}
/**
*缓存到sd卡
*@paramurl图片的url
*@parambitmapbitmap对象
*/
publicvoidput(Stringurl,Bitmapbitmap){
FileOutputStreamoutput=null;
try{
output=newFileOutputStream(cacheDir+url);
bitmap.compress(Bitmap.CompressFormat.PNG,100,output);
}catch(FileNotFoundExceptione){
e.printStackTrace();
}finally{
//无论是否有异常,都要关闭流
try{
if(output!=null){
output.close();
}
}catch(IOExceptione){
e.printStackTrace();
}
}
}
}

双缓存类(DoubleCache)


importandroid.graphics.Bitmap;
/**
*CreatedbyAdministratoron2016/3/1.
*/
publicclassDoubleCacheimplementsImageCache{
//内存缓存
MemoryCachemMemoryCache=newMemoryCache();
//sd卡缓存
DiskCachemDiskCache=newDiskCache();
/**
*获取缓存图片
*@paramurl图片url
*@return返回bitmap对象
*/
publicBitmapget(Stringurl){
Bitmapbitmap=null;
bitmap=mMemoryCache.get(url);
if(bitmap==null){
bitmap=mDiskCache.get(url);
}
returnbitmap;
}
/**
*缓存图片
*@paramurl图片url
*@parambitmap
*/
publicvoidput(Stringurl,Bitmapbitmap){
mMemoryCache.put(url,bitmap);
mDiskCache.put(url,bitmap);
}
}

最后我们的ImageLoader类修改如下:


importandroid.graphics.Bitmap;
importandroid.graphics.BitmapFactory;
importandroid.widget.ImageView;
importjava.io.IOException;
importjava.net.HttpURLConnection;
importjava.net.MalformedURLException;
importjava.net.URL;
importjava.util.concurrent.ExecutorService;
importjava.util.concurrent.Executors;
/**
*CreatedbyAdministratoron2016/3/1.
*/
publicclassImageLoader{
publicImageLoader(){
}
//默认使用内存缓存
ImageCacheimageCache=newMemoryCache();
//线程池,线城数量为cpu的数量
ExecutorServicemExecutorService=Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
/**
*设置要使用哪种缓存
*@paramimageCache缓存类
*/
publicvoidsetImageCache(ImageCacheimageCache){
this.imageCache=imageCache;
}
/**
*显示图片
*@paramurl图片的url
*@paramimageView要显示的view
*/
publicvoiddisplayImage(finalStringurl,finalImageViewimageView){
Bitmapbitmap=imageCache.get(url);
if(bitmap!=null){
imageView.setImageBitmap(bitmap);
return;
}
imageView.setTag(url);
mExecutorService.submit(newRunnable(){
@Override
publicvoidrun(){
Bitmapbitmap=downloadImage(url);
if(bitmap==null){
return;
}
if(imageView.getTag().equals(url)){
imageView.setImageBitmap(bitmap);
}
//添加到缓存
imageCache.put(url,bitmap);
}
});
}
/**
*下载图片
*@paramimageUrl网络图片地址
*@return返回bitmap对象
*/
publicBitmapdownloadImage(StringimageUrl){
Bitmapbitmap=null;
try{
URLurl=newURL(imageUrl);
HttpURLConnectionconn=(HttpURLConnection)url.openConnection();
bitmap=BitmapFactory.decodeStream(conn.getInputStream());
conn.disconnect();
}catch(MalformedURLExceptione){
e.printStackTrace();
}catch(IOExceptione){
e.printStackTrace();
}
returnbitmap;
}
}

在ImageLoader中,我们去掉了其他的缓存类,只加入了ImageCache接口,而且还开放了一个设置缓存的方法,也就是通常说的依赖注入,经过以上修改之后,用户的使用方式如下:


ImageLoaderimageLoader=newImageLoader();
/**
*内存缓存方式
*/
imageLoader.setImageCache(newMemoryCache());
/**
*SD卡缓存方式
*/
imageLoader.setImageCache(newDiskCache());
/**
*双缓存方式
*/
imageLoader.setImageCache(newDoubleCache());
/**
*自定义缓存方式
*/
imageLoader.setImageCache(newImageCache(){
@Override
publicvoidput(Stringurl,Bitmapbitmap){
//用户自定义的缓存方式
}
@Override
publicBitmapget(Stringurl){
//从缓存中获取图片
returnnull;
}
});

通过以上的修改,发现现在的ImageLoader的可扩展性、灵活性变的很高,三种缓存方式各自的具体实现都不一样,但是他们都实现了ImageCache接口,即有了这个标准,而用户想要自定义缓存实现的时候,只需要实现ImageCache接口,将其setImageCache进去即可。
以上就是开闭原则,对于修改是封闭的,对于扩展是开发的,遵循开闭原则的重要手段应该是通过抽象,由于实际开发中,可能会不尽人意,但是我们在设计的时候,应该尽量通过扩展的方式,这里说尽量是因为,可能原本的代码就是有问题的,必须要修改。




第七城市

最新文章

123

最新摄影

微信扫一扫

第七城市微信公众平台