android 开发设计原则,Android开发设计模式六大原则之开闭原则

​开闭原则定义：软件中的对象(类，模块，函数等)应该对于扩展是开放的，对于修改是关闭的。英文全称(Open Close Principle),简称：OCP

在实际开发中常常会遇到这样的问题，从别人那里接手过来的代码，还没来的及熟悉代码，项目就催着赶紧升级，当你想使用一个功能的时候，你可能发现项目里有相关代码，但是你又不敢用，你怕改出来问题，所以一般可能都会采取新增一块功能一样的代码。其实这就是简单的遵循了开闭原则。

上面的场景相信大家都遇见过，你不想你写的代码，被别人诟病吧。所以掌握开闭原则要领很有必要性。

图片的加载相信大家是避免不了的一个功能。在图片的加载显示过程中，图片的缓存是必不可少的。首先我们定义一个图片缓存类：

//图片缓存类

class ImageCache{

//图片LRU缓存

LruCache 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 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 ， 随时随地学习设计模式