开闭原则的英文全称是Open Close Principle,缩写是OCP,它是Java世界里最基础的设计原则,它指导我们如何建立一个稳定的、灵活的系统。开闭原则的定义是:软件中的对象(类、模块、函数等)应该对于扩展是开放的,但是对于修改是封闭的。
勃兰特-梅耶在1988年出版的《面向对象软件构造》一书中提出这一原则---开闭原则。这一想法认为,程序一旦开发完成,程序中一个类的实现只应该因错误而被修改,新的或者改变的特性应该通过新建不同的类实现,新建的类可以通过继承的方式来重用原类的代码。显然梅耶的定义提倡实现继承,已存在的实现类对于修改时封闭的,但是新的类可以通过覆写父类的接口应对变化。
引入其他缓存方式
说了这么多,下面还是以一个简单示例来说明开闭原则:
在对ImageLoader进行了一次重构之后的ImageLoader职责单一、结构清晰,算是个不错的开始。随着用户的增多,有些问题开始暴露出来:缓存系统是最让大家吐槽的地方,通过内存缓存解决了每次从网络加载图片的问题,但是,Android应用的内存很有限,且具有易失性,即当应用重新启动之后,原来已经加载过的图片将会丢失,这样重启之后及需要重新下载图片!而这又会导致加载缓慢、耗费用户流量的问题。针对以上问题考虑引入SD卡缓存,这样下载过的图片就会缓存到本地,即使重启应用也不需要重新下载了,接下来开始实现SD卡缓存。
DiskCache.java类,将图片缓存到SD卡中:
package com.deason.library.ocp;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* SD卡图片缓存
* Created by liuguoquan on 2016/3/17.
*/
public class DiskCache {
public static final String CACHE_DIR = "/sdcard/cache/";
/**
* 从缓存中获取图片
* @param url
* @return
*/
public Bitmap get(String url) {
return BitmapFactory.decodeFile(CACHE_DIR + url);
}
/**
* 将图片存入SD卡中
* @param url
* @param bitmap
*/
public void put(String url,Bitmap bitmap) {
FileOutputStream out = null;
try {
out = new FileOutputStream(CACHE_DIR + url);
bitmap.compress(Bitmap.CompressFormat.PNG,100,out);
} catch (Exception e) {
e.printStackTrace();
} finally {
if (out != null) {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
MemoryCache类,把图片缓存到内存中
package com.deason.library.ocp;
import android.graphics.Bitmap;
import android.util.LruCache;
/**
* 处理图片缓存
* Created by liuguoquan on 2016/3/14.
*/
public class MemoryCache {
/**
* 图片缓存
*/
LruCache mImageCache;
public MemoryCache() {
initImageCache();
}
private void initImageCache() {
//计算可使用的最大内存
final int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
//取内存的四分之一作为缓存
final int cacheSize = maxMemory / 4;
mImageCache = new LruCache(cacheSize) {
@Override
protected int sizeOf(String key, Bitmap value) {
return value.getRowBytes() * value.getHeight() / 1024;
}
};
}
/**
* 将图片存入缓存
* @param key
* @param bitmap
*/
public void put(String key,Bitmap bitmap) {
mImageCache.put(key,bitmap);
}
/**
* 取出缓存图片
* @param key
* @return
*/
public Bitmap get(String key) {
return mImageCache.get(key);
}
}
因为需要将图片缓存到SD卡中,所有ImageLoader代码有所更新,具体代码如下:
/**
* 图片加载类
* Created by liuguoquan on 2016/3/14.
*/
public class ImageLoader {
/**
* 图片缓存
*/
MemoryCache mMemoryCache = new MemoryCache();
/**
* SD卡缓存
*/
DiskCache mDiskCache = new DiskCache();
/**
* 是否使用SD卡缓存
*/
private boolean isUseDiskCache = false;
/**
* 线程池,线程数量未CPU的数量
*/
ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime()
.availableProcessors());
/**
* 显示图片
* @param url
* @param imageView
*/
public void displayImage(final String url, final ImageView imageView) {
//判断使用哪种缓存
Bitmap bitmap = isUseDiskCache ? mDiskCache.get(url) : mMemoryCache.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);
}
//将下载的图片存入内存
mMemoryCache.put(url,bitmap);
mDiskCache.put(url,bitmap);
}
});
}
/**
* 设置是否用SD卡缓存
* @param isUseDiskCache
*/
public void useDiskCache(boolean isUseDiskCache) {
this.isUseDiskCache = isUseDiskCache;
}
/**
* 下载图片
* @param url
* @return
*/
public Bitmap downloadImage(String imageUrl) {
Bitmap bitmap = null;
try {
URL url = new URL(imageUrl);
HttpURLConnection mConnection = (HttpURLConnection) url.openConnection();
int code = mConnection.getResponseCode();
if (200 == code) {
bitmap = BitmapFactory.decodeStream(mConnection.getInputStream());
}
mConnection.disconnect();
} catch (IOException e) {
e.printStackTrace();
}
return bitmap;
}
}
从上述的代码中可以看到,仅仅新增了一个DiskCache类和往ImageLoader类中加入了少量代码就添加了SD卡缓存的功能,用户可以通过useDiskCache方法来对使用哪种缓存进行设置,例如
ImageLoader mImageLoader = new ImageLoader();
//使用SD卡缓存
mImageLoader.useDiskCache(true);
//使用内存缓存
mImageLoader.useDisCache(false);
通过useDiskCache方法来让用户设置不同的缓存这个思路是对的,但是会有些明显的问题,就是使用内存缓存时用户不能使用SD卡缓存。类似地,使用SD卡缓存时用户就不能使用内存缓存。
实际上,用户需要这两种缓存的综合,首先缓存优先使用内存缓存,如果内存缓存没有图片再使用SD卡缓存,如果SD卡中也没有图片最后才从网络上获取,这才是最好的缓存策略。
接下来,我们继续重构,新建一个双缓冲类DoubleCache,具体代码如下:
package com.deason.library.ocp;
import android.graphics.Bitmap;
/**
* 双缓冲。获取图片时先从内存中获取,如果内存中没有缓存该图片,再从SD卡中获取
* Created by liuguoquan on 2016/3/17.
*/
public class DoubleCache {
MemoryCache mMemoryCache = new MemoryCache();
DiskCache mDiskCache = new DiskCache();
/**
* 先从内存获取图片,没有再从SD卡获取
* @param url
* @return
*/
public Bitmap get(String url) {
Bitmap bitmap = mMemoryCache.get(url);
if (bitmap == null) {
bitmap = mDiskCache.get(url);
}
return bitmap;
}
/**
* 将图片缓存到内存和SD卡中
* @param url
* @param bitmap
*/
public void put(String url, Bitmap bitmap) {
mMemoryCache.put(url, bitmap);
mDiskCache.put(url, bitmap);
}
}
我们再来看看最新的ImageLoader类,代码更新也不多:
/**
* 图片加载类
* Created by liuguoquan on 2016/3/14.
*/
public class ImageLoader {
/**
* 图片缓存
*/
MemoryCache mMemoryCache = new MemoryCache();
/**
* SD卡缓存
*/
DiskCache mDiskCache = new DiskCache();
//双缓存
DoubleCache mDoubleCache = new DoubleCache();
/**
* 是否使用SD卡缓存
*/
private boolean isUseDiskCache = false;
//使用双缓存
private boolean isUseDoubleCache = false;
/**
* 线程池,线程数量未CPU的数量
*/
ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime()
.availableProcessors());
/**
* 显示图片
* @param url
* @param imageView
*/
public void displayImage(final String url, final ImageView imageView) {
//判断使用哪种缓存
Bitmap bitmap = null;
if (isUseDoubleCache) {
bitmap = mDoubleCache.get(url);
} else if (isUseDiskCache) {
bitmap = mDiskCache.get(url);
} else {
bitmap = mMemoryCache.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);
}
//将下载的图片存入内存
mMemoryCache.put(url,bitmap);
mDiskCache.put(url,bitmap);
}
});
}
/**
* 设置是否用SD卡缓存
* @param isUseDiskCache
*/
public void useDiskCache(boolean isUseDiskCache) {
this.isUseDiskCache = isUseDiskCache;
}
/**
* 设置是否使用双缓存
* @param isUseDoubleCache
*/
public void useDoubleCache(boolean isUseDoubleCache) {
this.isUseDoubleCache = isUseDoubleCache;
}
/**
* 下载图片
* @param url
* @return
*/
public Bitmap downloadImage(String imageUrl) {
Bitmap bitmap = null;
try {
URL url = new URL(imageUrl);
HttpURLConnection mConnection = (HttpURLConnection) url.openConnection();
int code = mConnection.getResponseCode();
if (200 == code) {
bitmap = BitmapFactory.decodeStream(mConnection.getInputStream());
}
mConnection.disconnect();
} catch (IOException e) {
e.printStackTrace();
}
return bitmap;
}
}
此时程序越来越灵活了,通过增加短短几行代码就能够完成如此重要的功能。
人们总会把美好的事情讲在前面,最后给你来个“但是”,我们先来分析一下上面的程序:每次在程序中加入新的缓存实现都需要修改ImageLoader类,然后通过一个布尔类型的变量来让用户选择使用哪种缓存,因此,就使得ImageLoader中存在各种if-else判断语句,通过这些判断语句来确定使用哪种缓存。随着大量逻辑的引用,代码变得越来越复杂脆弱,如果一不小心写错某个if条件,势必会花费大量的时间去调试程序,整个ImageLoader类也会显得臃肿。最重要的是,用户不能自己实现缓存注入到ImageLoader类中,可扩展性较差,而可扩展性是框架的最重要的特性之一。
注入方式设置缓存方式
“软件中的对象(类、模块、函数等)应该对于扩展是开放的,但是对于修改则是封闭的,这就是开放-关闭原则。也就是说,我们应该尽量通过扩展的方式来实现变化,而不是通过修改已有的代码来实现”。现在,我们来实现终极解决方案,遵循开闭原则。
首先,我们先画出UML图,如下
开闭原则.png
然后,实现UML图上的类和接口,先重构ImageLoader类:
/**
* Created by liuguoquan on 2016/3/17.
*/
public interface ImageCache {
/**
* 获取图片
* @param url
* @return
*/
public Bitmap get(String url);
/**
* 缓存图片
* @param url
* @param bitmap
*/
public void put(String url, Bitmap bitmap);
}
经过重构后,少了if-else语句,没有了各种各样的缓存实现对象、布尔变量,代码确实清晰、简单了很多。需要注意的是,这次重构的ImageCache把它提取成一个图片缓存的接口,用来抽象图片缓存的功能,我们来看看该接口的声明:
/**
* 图片加载类
* Created by liuguoquan on 2016/3/14.
*/
public class ImageLoader {
/**
* 图片缓存
*/
ImageCache mImageCache = new MemoryCache();
/**
* 注入缓存实现
* @param cache
*/
public void setIamgeCache(ImageCache cache) {
mImageCache = cache;
}
/**
* 线程池,线程数量未CPU的数量
*/
ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime()
.availableProcessors());
/**
* 显示图片
* @param url
* @param imageView
*/
public void displayImage(final String url, final ImageView imageView) {
Bitmap bitmap = mImageCache.get(url);
if (bitmap != null) {
imageView.setImageBitmap(bitmap);
return ;
}
//没有缓存则提交线程池下载
submitLoadRequest(url, imageView);
}
private void submitLoadRequest(final String url, final ImageView imageView) {
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);
}
//将下载的图片存入内存
mImageCache.put(url,bitmap);
}
});
}
/**
* 下载图片
* @param url
* @return
*/
public Bitmap downloadImage(String imageUrl) {
Bitmap bitmap = null;
try {
URL url = new URL(imageUrl);
HttpURLConnection mConnection = (HttpURLConnection) url.openConnection();
int code = mConnection.getResponseCode();
if (200 == code) {
bitmap = BitmapFactory.decodeStream(mConnection.getInputStream());
}
mConnection.disconnect();
} catch (IOException e) {
e.printStackTrace();
}
return bitmap;
}
}
ImageCache接口简单定义了获取、缓存图片两个方法,缓存的可以是图片的url,值是图片的本身。内存缓存、SD卡缓存、爽缓存都实现该接口,我们看看几个缓存的实现:
MemoryCache.java
public class MemoryCache implements ImageCache {
/**
* 图片缓存
*/
LruCache mMemoryCache;
public MemoryCache() {
initImageCache();
}
/**
* 初始化LRU缓存
*/
private void initImageCache() {
//计算可使用的最大内存
final int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
//取内存的四分之一作为缓存
final int cacheSize = maxMemory / 4;
mMemoryCache = new LruCache(cacheSize) {
@Override
protected int sizeOf(String key, Bitmap value) {
return value.getRowBytes() * value.getHeight() / 1024;
}
};
}
@Override
public Bitmap get(String url) {
return mMemoryCache.get(url);
}
@Override
public void put(String url, Bitmap bitmap) {
mMemoryCache.put(url, bitmap);
}
}
DiskCache.java
/**
* Created by liuguoquan on 2016/3/17.
*/
public class DiskCache implements ImageCache {
public static final String CACHE_DIR = "/sdcard/cache/";
@Override
public Bitmap get(String url) {
return BitmapFactory.decodeFile(CACHE_DIR + url);
}
@Override
public void put(String url, Bitmap bitmap) {
FileOutputStream out = null;
try {
out = new FileOutputStream(CACHE_DIR + url);
bitmap.compress(Bitmap.CompressFormat.PNG,100,out);
} catch (Exception e) {
e.printStackTrace();
} finally {
if (out != null) {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
Double.java
/**
* Created by liuguoquan on 2016/3/17.
*/
public class DoubleCache implements ImageCache {
ImageCache mMemoryCache = new MemoryCache();
ImageCache mDiskCache = new DiskCache();
@Override
public Bitmap get(String url) {
Bitmap bitmap = mMemoryCache.get(url);
if (bitmap == null) {
bitmap = mDiskCache.get(url);
}
return bitmap;
}
@Override
public void put(String url, Bitmap bitmap) {
mMemoryCache.put(url, bitmap);
mDiskCache.put(url, bitmap);
}
}
上述重构后的ImageLoader类中增加了一个setImageCache(ImageCache cache)方法,用户可以通过该函数设置缓存实现,也就是通常所说的依赖注入。
下面看看用户如何通过使用ImageLoader来设置缓存实现的:
ImageLoader mImageLoader = new ImageLoader();
//使用内存缓存
mImageLoader.setIamgeCache(new MemoryCache());
//使用SD卡缓存
mImageLoader.setIamgeCache(new DiskCache());
//使用双缓存
mImageLoader.setIamgeCache(new DoubleCache());
//使用自定义的图片缓存实现
mImageLoader.setIamgeCache(new ImageCache() {
@Override
public Bitmap get(String url) {
return null;
}
@Override
public void put(String url, Bitmap bitmap) {
}
});
在上述代码中,通过setImageCache(ImageCache cache)方法注入不同的缓存实现,这样不仅能够使ImageLoader更简单、健壮,也使得ImageLoader可课扩展性、灵活性更高。
MemeryCache、DiskCache、DoubleCache缓存图片的具体实现完全不一样,但是,它们有一个特点是,都实现了ImageCache接口。当用户需要自定义缓存实现时,只需要新建一个实现ImageCache接口的类,然后构造该类的对象,并且通过setImageCache(ImageCache cache)注入到ImageLoader中就可以了,这样ImageLoader就实现了千变万化的缓存策略,且扩展这些缓存策略并不会导致ImageLoader类的修改。经过这次重构,ImageLoader在设计模式上基本已经合格了。
开闭原则指导我们,当软件需要变化时,应该尽量通过扩展的方式来实现变化,而不是通过修改已有的代码来实现。这里的“应该尽量”4个字说明OCP原则并不是说绝对不可以修改原始类的。当确定原来的代码已经“腐化”时,应该尽早的重构,以便让代码恢复带正常的状态,而不是通过继承等方式添加新的代码。因此,在开发过程中需要自己结合具体情况进行考量,是通过修改旧代码还是通过继承使得软件系统更稳当、更灵活,在保证去除“腐化代码”的同时,也保证原有模块的正确性。
优点
增加稳定性
可扩展性提高