学习了何红辉、关爱民写的《Android设计模式》，对于面向对象的六大原则有进一步的理解，特此根据自己的理解记录总结一下
什么是开闭原则
一个类、模块、函数等应该对于扩展是开放的，但是对于修改是封闭的，简单说就是当你的系统要升级维护需要对原有的代码进行修改时，可能会将错误引入到了原来的旧代码中，因此，在软件升级维护时，应该尽可能的通过扩展的方式而不是修改原有的代码，虽然在实际开发中，修改原本的代码跟扩展代码都是同时存在的，但是为了程序的可扩展性，在制作初期，应该遵循开闭原则。
以上一篇《面向对象的六大原则之 —— 单一原则》的例子为例继续讲解
在ImageCache类中，使用了内存缓存，可是内存缓存很有限，而且还容易丢失，比如应用关闭后，原来缓存在内存的图片会丢失，再打开需要重新加载，所以我们考虑加入SD卡缓存。
加入DiskCache类，缓存图片到SD卡中
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* Created by Administrator on 2016/3/1.
*/
public class DiskCache {
public static final String cacheDir="sdcard/cache/";
/**
* 获取sd卡的图片缓存
* @param url 图片url
* @return 返回bitmap
*/
public Bitmap get(String url){
Bitmap bitmap=null;
bitmap= BitmapFactory.decodeFile(cacheDir+url);
return bitmap;
}
/**
* 缓存到sd卡
* @param url 图片的url
* @param bitmap bitmap对象
*/
private void put(String url ,Bitmap bitmap){
FileOutputStream output = null;
try {
output = new FileOutputStream(cacheDir+url);
bitmap.compress(Bitmap.CompressFormat.PNG,100,output);
} catch (FileNotFoundException e) {
e.printStackTrace();
}finally {
//无论是否有异常，都要关闭流
try {
if(output!=null){
output.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
因为加入了sd卡的缓存方式，所以要修改ImageLoader类
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.widget.ImageView;
import java.io.IOException;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* Created by Administrator on 2016/3/1.
*/
public class ImageLoader {
public ImageLoader() {
}
//内存缓存类
ImageCache imageCache=new ImageCache();
//sd卡缓存类
DiskCache diskCache=new DiskCache();
//是否使用sd卡缓存
boolean isUseDiskCache=false;
//线程池，线城数量为cpu的数量
ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
/**
* 显示图片
* @param url 图片的url
* @param imageView 要显示的view
*/
public void displayImage(final String url, final ImageView imageView) {
Bitmap bitmap=isUseDiskCache()?diskCache.get(url):imageCache.get(url);
if(bitmap!=null){
imageView.setImageBitmap(bitmap);
return;
}
imageView.setTag(url);
mExecutorService.submit(new Runnable() {
@Override
public void run() {
Bitmap bitmap = downloadImage(url);
if (bitmap == null) {
return;
}
if (imageView.getTag().equals(url)) {
imageView.setImageBitmap(bitmap);
}
imageCache.put(url, bitmap);
diskCache.put(url,bitmap);
}
});
}
/**
* 下載圖片
* @param imageUrl 网络图片地址
* @return 返回bitmap对象
*/
public Bitmap downloadImage(String imageUrl) {
Bitmap bitmap = null;
try {
URL url = new URL(imageUrl);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
bitmap = BitmapFactory.decodeStream(conn.getInputStream());
conn.disconnect();
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return bitmap;
}
public boolean isUseDiskCache() {
return isUseDiskCache;
}
public void setIsUseDiskCache(boolean isUseDiskCache) {
this.isUseDiskCache = isUseDiskCache;
}
}
ImageLoader类中加入了少量代码就添加了sd卡缓存的功能，用户还能通过setIsUseDiskCache设置使用哪种缓存，但是以上还有个问题，使用内存缓存的时候，就没有sd卡缓存，用户要两种策略都用，首先缓存优先使用内存缓存， 如果内存没有就查找sd卡缓存，sd卡没有就从网络获取，，这才是最好的缓存策略，依照这种想法，修改代码，加入DoubleCache类，实现双缓存
import android.graphics.Bitmap;
/**
* Created by Administrator on 2016/3/1.
*/
public class DoubleCache {
//内存缓存
ImageCache mImageCache=new ImageCache();
//sd卡缓存
DiskCache mDiskCache=new DiskCache();
/**
* 获取缓存图片
* @param url 图片url
* @return 返回bitmap对象
*/
public Bitmap get(String url){
Bitmap bitmap=null;
bitmap=mImageCache.get(url);
if(bitmap==null){
bitmap=mDiskCache.get(url);
}
return bitmap;
}
/**
* 缓存图片
* @param url 图片url
* @param bitmap
*/
public void put(String url,Bitmap bitmap){
mImageCache.put(url,bitmap);
mDiskCache.put(url,bitmap);
}
}
ImageLoader类修改如下
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.widget.ImageView;
import java.io.IOException;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* Created by Administrator on 2016/3/1.
*/
public class ImageLoader {
public ImageLoader() {
}
//内存缓存类
ImageCache imageCache=new ImageCache();
//sd卡缓存类
DiskCache diskCache=new DiskCache();
//双缓存
DoubleCache doubleCache=new DoubleCache();
//是否使用sd卡缓存
boolean isUseDiskCache=false;
//是否使用双缓存
boolean isUseDoubleCache=false;
//线程池，线城数量为cpu的数量
ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
/**
* 显示图片
* @param url 图片的url
* @param imageView 要显示的view
*/
public void displayImage(final String url, final ImageView imageView) {
Bitmap bitmap=null;
if(isUseDoubleCache()){
bitmap=doubleCache.get(url);
}else if(isUseDiskCache()){
bitmap=diskCache.get(url);
}else{
bitmap=imageCache.get(url);
}
if(bitmap!=null){
imageView.setImageBitmap(bitmap);
return;
}
imageView.setTag(url);
mExecutorService.submit(new Runnable() {
@Override
public void run() {
Bitmap bitmap = downloadImage(url);
if (bitmap == null) {
return;
}
if (imageView.getTag().equals(url)) {
imageView.setImageBitmap(bitmap);
}
//缓存到内存跟sd卡中
doubleCache.put(url, bitmap);
}
});
}
/**
* 下載圖片
* @param imageUrl 网络图片地址
* @return 返回bitmap对象
*/
public Bitmap downloadImage(String imageUrl) {
Bitmap bitmap = null;
try {
URL url = new URL(imageUrl);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
bitmap = BitmapFactory.decodeStream(conn.getInputStream());
conn.disconnect();
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return bitmap;
}
public boolean isUseDiskCache() {
return isUseDiskCache;
}
public void setIsUseDiskCache(boolean isUseDiskCache) {
this.isUseDiskCache = isUseDiskCache;
}
public boolean isUseDoubleCache() {
return isUseDoubleCache;
}
public void setIsUseDoubleCache(boolean isUseDoubleCache) {
this.isUseDoubleCache = isUseDoubleCache;
}
}
经过修改之后，我们的图片加载器已经实现了双缓存的功能了，可是细心的你可能发现了，每次加入新的缓存方法都要修改原来的代码，而且还会让ImageLoader变的越来越复杂，一堆的if{}else{}判断，条件多了就容易造成错误，而且如果现在用户想要自己扩展一个缓存方式，都要动ImageLoader类里面的东西，本文最上面已经说了，开闭原则的目的就是为了让扩展是开发的，修改是封闭的，当软件需要变化时，我们应该尽可能的通过扩展的方式来实现变化，而不要通过修改已有的代码来实现，按照这个思维，我们来想想应该如何修改，首先，我们的ImageLoader的职责就是加载图片跟设置缓存的，而缓存的实现不由它管，我们的目的是让缓存的方式能让用户自己扩展，所以我们定义ImageCache接口，接口中有两个方法，一个是put(String url,Bitmap bitmap)用来添加到缓存，一个是get(String url);用来获取缓存，具体实现不管，而是由实现了这个接口的实现类来具体实现。
ImageCache类如下：
import android.graphics.Bitmap;
/**
* Created by Administrator on 2016/3/1.
*/
public interface ImageCache {
/**
* 添加缓存
* @param url 缓存的图片url作为缓存的key
* @param bitmap 缓存的bitmap
*/
public void put(String url, Bitmap bitmap);
/**
* 获取缓存的图片
* @param url
* @return
*/
public Bitmap get(String url);
}
我们可以将接口当成是一个标准，比如电脑的usb接口，想要通过usb连接到电脑，就必须要按照usb这个插口的标准走，不然你想插也插不进去，我们的图片加载器也是一样，想要自己扩展一个缓存方式，就要按我的标准来。
所以，上面的内存缓存、sd卡缓存、双缓存三个类，我们全部修改实现ImageCache类
内存缓存类（MemoryCache）
import android.graphics.Bitmap;
import android.util.LruCache;
/**
* Created by Administrator on 2016/3/1.
*/
public class MemoryCache implements ImageCache{
public MemoryCache() {
//初始化图片缓存
initImageCache();
}
//图片缓存类
LruCache<String, Bitmap> memoryCache;
/**
* 初始化缓存
*/
private void initImageCache() {
//计算可使用的最大内存
int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
//只用最大内存的四分之一作为缓存大小
int cacheSize = maxMemory / 4;
memoryCache = new LruCache<String, Bitmap>(cacheSize) {
@Override
protected int sizeOf(String key, Bitmap value) {
return value.getRowBytes() * value.getHeight() / 1024;
}
};
}
/**
* 添加缓存
*
* @param url 缓存的图片url作为缓存的key
* @param bitmap 缓存的bitmap
*/
public void put(String url, Bitmap bitmap) {
memoryCache.put(url, bitmap);
}
/**
* 获取缓存的图片
*
* @param url
* @return
*/
public Bitmap get(String url) {
Bitmap bitmap = null;
bitmap = memoryCache.get(url);
return bitmap;
}
}
SD卡缓存类（DiskCache）
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* Created by Administrator on 2016/3/1.
*/
public class DiskCache implements ImageCache{
public static final String cacheDir="sdcard/cache/";
/**
* 获取sd卡的图片缓存
* @param url 图片url
* @return 返回bitmap
*/
public Bitmap get(String url){
Bitmap bitmap=null;
bitmap= BitmapFactory.decodeFile(cacheDir+url);
return bitmap;
}
/**
* 缓存到sd卡
* @param url 图片的url
* @param bitmap bitmap对象
*/
public void put(String url ,Bitmap bitmap){
FileOutputStream output = null;
try {
output = new FileOutputStream(cacheDir+url);
bitmap.compress(Bitmap.CompressFormat.PNG,100,output);
} catch (FileNotFoundException e) {
e.printStackTrace();
}finally {
//无论是否有异常，都要关闭流
try {
if(output!=null){
output.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
双缓存类（DoubleCache）
import android.graphics.Bitmap;
/**
* Created by Administrator on 2016/3/1.
*/
public class DoubleCache implements ImageCache{
//内存缓存
MemoryCache mMemoryCache =new MemoryCache();
//sd卡缓存
DiskCache mDiskCache=new DiskCache();
/**
* 获取缓存图片
* @param url 图片url
* @return 返回bitmap对象
*/
public Bitmap get(String url){
Bitmap bitmap=null;
bitmap= mMemoryCache.get(url);
if(bitmap==null){
bitmap=mDiskCache.get(url);
}
return bitmap;
}
/**
* 缓存图片
* @param url 图片url
* @param bitmap
*/
public void put(String url,Bitmap bitmap){
mMemoryCache.put(url,bitmap);
mDiskCache.put(url,bitmap);
}
}
最后我们的ImageLoader类修改如下：
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.widget.ImageView;
import java.io.IOException;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* Created by Administrator on 2016/3/1.
*/
public class ImageLoader {
public ImageLoader() {
}
//默认使用内存缓存
ImageCache imageCache=new MemoryCache();
//线程池，线城数量为cpu的数量
ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
/**
* 设置要使用哪种缓存
* @param imageCache 缓存类
*/
public void setImageCache(ImageCache imageCache) {
this.imageCache = imageCache;
}
/**
* 显示图片
* @param url 图片的url
* @param imageView 要显示的view
*/
public void displayImage(final String url, final ImageView imageView) {
Bitmap bitmap=imageCache.get(url);
if(bitmap!=null){
imageView.setImageBitmap(bitmap);
return;
}
imageView.setTag(url);
mExecutorService.submit(new Runnable() {
@Override
public void run() {
Bitmap bitmap = downloadImage(url);
if (bitmap == null) {
return;
}
if (imageView.getTag().equals(url)) {
imageView.setImageBitmap(bitmap);
}
//添加到缓存
imageCache.put(url, bitmap);
}
});
}
/**
* 下載圖片
* @param imageUrl 网络图片地址
* @return 返回bitmap对象
*/
public Bitmap downloadImage(String imageUrl) {
Bitmap bitmap = null;
try {
URL url = new URL(imageUrl);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
bitmap = BitmapFactory.decodeStream(conn.getInputStream());
conn.disconnect();
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return bitmap;
}
}
在ImageLoader中，我们去掉了其他的缓存类，只加入了ImageCache接口，而且还开放了一个设置缓存的方法，也就是通常说的依赖注入，经过以上修改之后，用户的使用方式如下：
<span style="white-space:pre"></span>ImageLoader imageLoader=new ImageLoader();通过以上的修改，发现现在的ImageLoader的可扩展性、灵活性变的很高，三种缓存方式各自的具体实现都不一样，但是他们都实现了ImageCache接口，即有了这个标准，而用户想要自定义缓存实现的时候，只需要实现ImageCache接口，将其setImageCache进去即可。
/**
* 内存缓存方式
*/
imageLoader.setImageCache(new MemoryCache());
/**
* SD卡缓存方式
*/
imageLoader.setImageCache(new DiskCache());
/**
* 双缓存方式
*/
imageLoader.setImageCache(new DoubleCache());
/**
* 自定义缓存方式
*/
imageLoader.setImageCache(new ImageCache() {
@Override
public void put(String url, Bitmap bitmap) {
//用户自定义的缓存方式
}
@Override
public Bitmap get(String url) {
//从缓存中获取图片
return null;
}
});
以上就是开闭原则，对于修改是封闭的，对于扩展是开发的，遵循开闭原则的重要手段应该是通过抽象，由于实际开发中，可能会不尽人意，但是我们在设计的时候，应该尽量通过扩展的方式，这里说尽量是因为，可能原本的代码就是有问题的，必须要修改。
下一篇：《面向对象的六大原则之 —— 里氏替换原则》