开闭原则定义：软件中的对象（类，模块，函数等）应该对于扩展是开放的，对于修改是关闭的。英文全称（Open Close Principle）,简称：OCP
在实际开发中常常会遇到这样的问题，从别人那里接手过来的代码，还没来的及熟悉代码，项目就催着赶紧升级，当你想使用一个功能的时候，你可能发现项目里有相关代码，但是你又不敢用，你怕改出来问题，所以一般可能都会采取新增一块功能一样的代码。其实这就是简单的遵循了开闭原则。
上面的场景相信大家都遇见过，你不想你写的代码，被别人诟病吧。所以掌握开闭原则要领很有必要性。
图片的加载相信大家是避免不了的一个功能。在图片的加载显示过程中，图片的缓存是必不可少的。首先我们定义一个图片缓存类：
//图片缓存类
class ImageCache{
//图片LRU缓存
LruCache<String,Bitmap> mImageCache;
public ImageCache(){
//初始化内存
}
//缓存图片
public void put(String url,Bitmap bitmap){
mImageCache.put(url,bitmap);
}
//缓存图片
public Bitmap get(String url){
mImageCache.get(url);
}
}
//将图片加载ImageView显示类
class ImageLoader{
//内存缓存
ImageCache mImageCache = new ImageCache();
//线程池
ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
//加载图片
public void displayImage(final String url,final ImageView imageView){
//先从内存获取
Bitmap bitmap = mImageCache.get(url);
if(bitmap != null){
imageView.setImageBitmap(bitmap);
return;
}
//如果内存没有则根据URL下载图片
imageView.setTag(url);//给imageview设置TAG
mExecutorService.submit(new Runnable(){
@Override
public void run(){
//下载图片
Bitmap bitmap = downloadImage(url);
if(bitmap == null) return;
if(imageView.getTag().equals(url)){
imageView.setImageBitmap(bitmap);
}
//缓存到内存
mImageCache.put(url,bitmap);
}
})
}
}
这样的实现过程，加载显示图片没什么问题。但是在实际使用过程中，一般会要求，图片不单要缓存在内存中，还要缓存在本地。这样即使关掉了应用下一次打开的时候，已经下载过的图片就不需要去耗费流量再次下载了，直接从本地读取，同时缓存到内存和显示图片。那接下来，我们就得新增一种图片缓存的方法：
//sd卡图片缓存类
public class DiskCache{
static String cacheDir = "sdcard/cache/";
//从本地缓存中获取图片
public Bitmap get(String localUri){...}
//将图片缓存到本地
public void put(String localUri, Bitmap bmp){...}
}
然后更新ImageLoader类中的代码：
//将图片加载ImageView显示类
class ImageLoader{
//内存缓存
ImageCache mImageCache = new ImageCache();
//新增代码 SD卡缓存
DiskCache mDiskCache = new DiskCache();
//线程池
ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
//加载图片
public void displayImage(final String url,final ImageView imageView){
//先从内存获取
Bitmap bitmap = mImageCache.get(url);
//新增代码
if(bitmap == null){
//内存没有，从SD卡获取
bitmap = mDiskCache.get(url);
}else{
//其他缓存方式
...
}
if(bitmap != null){
imageView.setImageBitmap(bitmap);
return;
}
//如果内存、SD卡均没有则根据URL下载图片
imageView.setTag(url);//给imageview设置TAG
mExecutorService.submit(new Runnable(){
@Override
public void run(){
//下载图片
Bitmap bitmap = downloadImage(url);
if(bitmap == null) return;
if(imageView.getTag().equals(url)){
imageView.setImageBitmap(bitmap);
}
//缓存到内存
mImageCache.put(url,bitmap);
//新增代码，缓存到SD卡
mDiskCache.put(url,bitmap);
}
})
}
}
这样就完成了新增缓存到SD卡。你会发现，每次新增缓存方式，都会修改原来的加载类代码。这样很可能会引入Bug，就会发生，之前用的好好的功能，可能就突然不好用了。
知道了开闭原则之后，我们可以这样想：对扩展开放，对修改关闭。那么首先你的加载类得支持可扩展，而且无需修改即可被别人拿来使用。
说到扩展，我们一般会使用接口来定义，所有的扩展都要实现接口里定义的功能。这里我们说的是扩展缓存方式，那自然要将缓存定义成为接口。
//图片缓存接口声明
public interface ImageCache{
/**
* 获取图片
*/
public Bitmap get(String url);
/**
* 缓存图片
*/
public void put(String url,Bitmap bitmap);
}
so easy ! 不过多说明。
定义好了接口，那么接下来，每一个扩展方式都要实现该接口，这也起到了一个约束的作用：
//扩展内存缓存类 实现 ImageCache 接口
public class MemoryCache implements ImageCache{
//图片LRU缓存
private LruCache<String,Bitmap> mMemoryCache;
public ImageCache(){
//初始化内存
}
//缓存图片
@Override
public void put(String url,Bitmap bitmap){
mImageCache.put(url,bitmap);
}
//缓存图片
@Override
public Bitmap get(String url){
mImageCache.get(url);
}
}
//扩展SD卡缓存类 实现 ImageCache 接口
public class DiskCache implements ImageCache{
//缓存图片
@Override
public void put(String url,Bitmap bitmap){
//将图片存入本地文件中
...
}
//缓存图片
@Override
public Bitmap get(String url){
//根据url从本地读取图片
...
}
}
我只实现了两种缓存方式，你也可以依葫芦画瓢，实现双缓存，就是我上面说的默认支持内存缓存和本地缓存。
那么接下来我们应该怎么修改ImageLoader类呢，很简单，首先你要明白，既然所有的缓存方式都扩展自ImageCache ,那么所有的扩展类又可以称之为一个ImageCache。明白这一点，那下面的代码就不难理解了。
//将图片加载ImageView显示类
class ImageLoader{
//如果不setImageCache 默认支持内存缓存
ImageCache mImageCache = new MemoryCache();
//线程池
ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
//通过set的方式注入自定义扩展的缓存
public void setImageCache(ImageCache cache){
mImageCache = cache;
}
//加载图片
public void displayImage(final String url,final ImageView imageView){
//先从内存获取
Bitmap bitmap = mImageCache.get(url);
if(bitmap != null){
imageView.setImageBitmap(bitmap);
return;
}
//如果内存没有则根据URL下载图片
imageView.setTag(url);//给imageview设置TAG
mExecutorService.submit(new Runnable(){
@Override
public void run(){
//下载图片
Bitmap bitmap = downloadImage(url);
if(bitmap == null) return;
if(imageView.getTag().equals(url)){
imageView.setImageBitmap(bitmap);
}
//缓存到内存
mImageCache.put(url,bitmap);
}
})
}
}
可以看到，ImageLoader中多了setImageCache()这个方法，这是让ImageLoader按照你自定义的扩展缓存方法进行工作的重要途径。因为有了这个入口，你就可以像下面这样，使用你扩展的缓存方式，而且不用修改已有的加载类。
ImageLoader imageloader = new ImageLoader();
//设置你自己扩展的内存缓存
imageloader.setImageCache(new MemoryCache);
//或者设置你自己扩展的本地存缓存
imageloader.setImageCache(new DiskCache);
//再或者设置你自己扩展的其他存缓存方式
imageloader.setImageCache(new OtherCache);
//再再或者，你可以直接在调用的时候，直接自定义缓存方式
imageloader.setImageCache(new ImageCache(){
@Override
public void put(String url,Bitmap bitmap)
...
}
@Override
public Bitmap get(String url)
...
}
);
接下里再看开闭原则的UML图是不是就能看懂了：
好了，开闭原则内容记录到此结束。特此发出来，与大家将我的理解分享，希望不会误导别人。
写在最后：改变世界，先从改变自己开始。---我说的
你也可以关注我的公众号：码H.cam ， 随时随地学习设计模式
