单一职责原则
- 读《Android源码设计模式》
- 单一职责的定义为:就一个类而言,应该仅有一个引起它变化的原因,简单来说,一个类中应该是一组相关性很高的函数,数据的封装
- 我们从最入门的方式入手
入手
- 假设现在要实现图片加载的功能,并且能将图片缓存,我们可能写出的代码是这样的
public class ImageLoader {
LruCache mImageCache;
ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
Handler mUIHandler = new Handler(Looper.getMainLooper());
public ImageLoader() {
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 bitmap) {
return bitmap.getRowBytes() * bitmap.getHeight() / 1024;
}
};
}
public void displayImage(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)){
updataImageView(imageView,bitmap);
}
mImageCache.put(url,bitmap);
}
});
}
private void updataImageView(final ImageView imageView,final Bitmap bmp){
mUIHandler.post(new Runnable() {
@Override
public void run() {
imageView.setImageBitmap(bmp);
}
});
}
public Bitmap downloadImage(String imageUrl){
Bitmap bitmap = null;
try{
URL url = new URL(imageUrl);
final 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类拆分一下,把各个功能独立出来
- 各个功能独立?我们原本的这个ImageLoader类有什么功能?图片加载和图片缓存?那好吧,就把图片缓存提出来吧?我们单独写一个图片缓存的类
public class ImageCache {
LruCache mImageCache;
public ImageCache() {
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 bitmap) {
return bitmap.getRowBytes() * bitmap.getHeight() / 1024;
}
};
}
public void put(String url , Bitmap bitmap){
mImageCache.put(url,bitmap);
}
public Bitmap get(String url){
return mImageCache.get(url);
}
}
- 可以看到,我们只是将缓存类的put和get方法抽出去而已,
- 然后看一下我们的图片加载类怎么改的
public class ImageLoader {
ImageCache mImageCache = new ImageCache();
ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
Handler mUIHandler = new Handler(Looper.getMainLooper());
public void displayImage(final String url, final ImageView imageView){
Bitmap bitmap = mImageCache.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)){
updataImageView(imageView,bitmap);
}
mImageCache.put(url,bitmap);
}
});
}
private void updataImageView(final ImageView imageView,final Bitmap bmp){
mUIHandler.post(new Runnable() {
@Override
public void run() {
imageView.setImageBitmap(bmp);
}
});
}
public Bitmap downloadImage(String imageUrl){
Bitmap bitmap = null;
try{
URL url = new URL(imageUrl);
final HttpURLConnection conn = (HttpURLConnection) url.openConnection();
bitmap = BitmapFactory.decodeStream(conn.getInputStream());
conn.disconnect();
} catch (Exception e) {
e.printStackTrace();
}
return bitmap;
}
}
- 具体也没什么大的改动,就是用到了缓存类的对象去调用相关方法
- 这样拆分之后,每个类的功能很明确,且代码量也得到了减少,虽然可扩展性还是没那么好,但是最起码思路,代码结构变得清晰许多
总结
- 其实上面的改进思想就是单一职责的思想:根据不同的功能,合理的划分一个类,或者一个函数的职责,关于这个划分倒是没有一个特别强制的概念,每个人都对功能的划分有自己的理解,具体项目中的代码就需要根据个人经验与具体逻辑而定,
开闭原则
- 开闭原则的定义:软件中的对象(类,模块,函数等)应该对于扩展是开放的,但是对于修改是封闭的,在软件的生命周期内,因为变化,升级和维护等原因需要对软件原有代码进行修改时,可能会将错误引入原本经过测试的旧代码中,破坏原有系统,因此,当软件需要变化时,我们应该尽量通过扩展的方式来实现变化,而不是通过破坏已有的代码来实现
- 当然,一定的不改变原有代码是不现实的,不过,我们在开发过程中,应尽量遵循这个开闭原则
入门
- 还是之前的那个例子,通过使用不难发现,我们虽然写的这个类具有缓存图片的功能,但是当程序重启的时候我们之前的缓存都会丢掉,因为我们的缓存全都是简单的缓存在运行内存中,这样不就会影响Android系统的性能,(因为Android手机的运行内存始终有限,我们无法让一个App占用手机太多运行内存),具有易失性,重启程序的时候又会重新下载,浪费用户流量,基于此,我们打算将缓存做成缓存在SD卡当中
- 先写缓存到SD卡中的类
public class DiskCache {
private static final String TAG = "DiskCache";
static String cacheDir = null;
public DiskCache() {
cacheDir = getSDPath() + "/sadsaf";
}
public String getSDPath(){
File sdDir = null;
boolean sdCardExist = Environment.getExternalStorageState()
.equals(android.os.Environment.MEDIA_MOUNTED);
if(sdCardExist) {
sdDir = Environment.getExternalStorageDirectory();
Log.d(TAG, "getSDPath: " + sdDir.toString());
}else {
sdDir = Environment.getDataDirectory();
Log.d(TAG, "getSDPath: " + sdDir.toString());
}
return sdDir.toString();
}
public Bitmap get(String url){
Log.d(TAG, "get: 在这里" + url);
String fileName = creatFileName(url);
return BitmapFactory.decodeFile(cacheDir + fileName);
}
public void put(String url, Bitmap bmp){
FileOutputStream fileOutputStream = null;
try{
File file = new File(cacheDir);
if(!file.exists()){
Log.d(TAG, "put: 文件夹不存在,先创建出文件夹");
if(!file.mkdirs()){
Log.d(TAG, "put: 文件夹创建失败");
}
if (file.exists()){
Log.d(TAG, "put: 文件夹已经存在");
}
}
String s = cacheDir + creatFileName(url);
Log.d(TAG, "put: 准备打开文件流 " + s);
fileOutputStream = new FileOutputStream(s);
bmp.compress(Bitmap.CompressFormat.PNG,100,fileOutputStream);
} catch (FileNotFoundException e) {
e.printStackTrace();
}finally {
if (fileOutputStream != null){
try{
fileOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
private String creatFileName(String url){
StringBuilder builder = new StringBuilder(url);
String s;
if(url.contains("/")){
int i = builder.lastIndexOf("/");
s = builder.substring(i, builder.length());
}else {
s = builder.toString();
}
return s;
}
- 那么接下来改一下我们ImageLoader,让他具有设置SD卡缓存的能力
- 注:这里的SD卡写入问题,以及权限问题,就不在这里细说了,如果在这里有问题的话,自行百度
- 看ImageLoader改动的内容
ImageCache mImageCache = new ImageCache();
DiskCache mDiskCache = new DiskCache();
boolean isUseDiskCache = false;
public void displayImage(final String url, final ImageView imageView){
Bitmap bitmap = isUseDiskCache ? mDiskCache.get(url) : mImageCache.get(url);
if(bitmap != null){
Log.d(TAG, "displayImage: 获取到缓存");
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)){
updataImageView(imageView,bitmap);
}
if(isUseDiskCache){
mDiskCache.put(url,bitmap);
}else {
mImageCache.put(url,bitmap);
}
}
});
}
public void useDiskCache(boolean useDiskCache){
isUseDiskCache = useDiskCache;
}
- 这里我们在Activity里面设置使用SD卡缓存就ok啦
String url = "http://img2.imgtn.bdimg.com/it/u=4060216298,1329589408&fm=27&gp=0.jpg";
mImageView = findViewById(R.id.main_IV);
ImageLoader loader = new ImageLoader();
loader.useDiskCache(true);
loader.displayImage(url,mImageView);
- 写成这样,我们就可以很方便的选择缓存方式,非常方便
- 但是不知道大家思考过没?如果我想两种缓存都使用呢?
- 如果这样的话,用目前的代码去达到这种要求是不是太过复杂?那怎么办?
- 我们可以提供这样一个思路,当要获取图片的时候,我们先看看内存缓存里面有没有,如果没有,再看看SD卡缓存里面有没有,如果都没有,再去网络上获取是不是更加人性化一些呢?
继续探索
- 这里有两种方案,一种是我们直接在原来代码上面改,一种是创建一个新的可以实现同时两种缓存都支持的类
- 那么想想看?我们刚才说的开闭原则?好吧,直接选择第二种方案
- 来看看我们这个双缓存类(DoubleCache)的实现
public class DoubleCache {
ImageCache mMemoryCache = new ImageCache();
DiskCache mDiskCache = new DiskCache();
public Bitmap get(String url){
Bitmap bitmap = mMemoryCache.get(url);
if(bitmap == null){
bitmap = mDiskCache.get(url);
}
return bitmap;
}
public void put(String url,Bitmap bitmap){
mMemoryCache.put(url,bitmap);
mDiskCache.put(url,bitmap);
}
}
- 代码没有任何难度,当提供了双缓存机制之后,我们就可以去修改下我们的加载类了(ImageLoader)
DoubleCache mDoubleCache = new DoubleCache();
boolean isUseDoubleCache = false;
public void displayImage(final String url, final ImageView imageView){
Bitmap bitmap;
if(isUseDoubleCache){
bitmap = mDoubleCache.get(url);
}else if(isUseDiskCache){
bitmap = mDiskCache.get(url);
}else {
bitmap = mImageCache.get(url);
}
if(bitmap != null){
Log.d(TAG, "displayImage: 获取到缓存");
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)){
updataImageView(imageView,bitmap);
}
if(isUseDiskCache){
mDiskCache.put(url,bitmap);
}else {
mImageCache.put(url,bitmap);
}
}
});
}
public void UseDoubleCache(boolean useDoubleCache) {
isUseDoubleCache = useDoubleCache;
}
- 貌似?蛮好的?好像是符合开闭原则来着?
- 来,回过头想一下,我们刚才为了添加双缓存机制,修改了几个类的代码?好像基本上都修改了吧
- 问题:每次加入新的缓存方法都要修改原来的代码,这样可能引来新的bug,而且,照这样的实现方法,用户是不能自己实现自定义缓存实现的
- 这里基于这个问题,我们再来看一下开闭原则的定义:软件中的对象(类,模块,函数等)应该对于扩展是开放的,但是对于修改是封闭的,也就是说,当软件需要变化时,我们应该尽量通过扩展的方式来实现变化,而不是通修改已有的代码来实现
- 如果要实现用户自定义缓存机制实现的话,我们是不是应该抽出一个缓存接口?
public interface IImageCache {
public Bitmap get(String url);
public void put(String url,Bitmap bitmap);
}
- 然后让我们之前写的三个缓存类实现这个接口,这里就不贴代码,接下来我们去看看图片加载类怎么做的(ImageLoader)
public class ImageLoader {
private final static String TAG = "ImageLoader";
IImageCache mImageCache = new MemeryCache();
ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
Handler mUIHandler = new Handler(Looper.getMainLooper());
public void setImageCache(IImageCache mImageCache){
this.mImageCache = mImageCache;
}
public void displayImage(final String url, final ImageView imageView){
Bitmap bitmap = mImageCache .get(url);
if(bitmap != null){
Log.d(TAG, "displayImage: 获取到缓存");
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){
Log.d(TAG, "run: 网络图片下载失败");
return;
}
if (imageView.getTag().equals(url)){
updataImageView(imageView,bitmap);
}
mImageCache.put(url,bitmap);
}
});
}
private void updataImageView(final ImageView imageView,final Bitmap bmp){
mUIHandler.post(new Runnable() {
@Override
public void run() {
imageView.setImageBitmap(bmp);
}
});
}
public Bitmap downloadImage(String imageUrl){
Bitmap bitmap = null;
try{
URL url = new URL(imageUrl);
final HttpURLConnection conn = (HttpURLConnection) url.openConnection();
bitmap = BitmapFactory.decodeStream(conn.getInputStream());
conn.disconnect();
} catch (Exception e) {
e.printStackTrace();
}
return bitmap;
}
}
- 从这个ImageLoader里面我们可以看出来,这个类已经相当成熟了,里面的东西我们基本不需要再去改变,想用哪种缓存,哪怕是我们自己的缓存方式,只要我们实现了那个接口,然后调用set方法将我们的缓存注入进去即可,
- 现在想想看?如果我们现在需要使用一种新的缓存方式该怎么做呢?只需实现我们自己的缓存逻辑,然后在调用一下set方法,即可完美使用,如下:
String url = "http://img2.imgtn.bdimg.com/it/u=4060216298,1329589408&fm=27&gp=0.jpg"
mImageView = findViewById(R.id.main_IV)
ImageLoader loader = new ImageLoader()
DoubleCache doubleCache = new DoubleCache()
loader.setImageCache(doubleCache)
loader.displayImage(url,mImageView)
- 这就是开闭原则,我们的图片加载机制对于扩展式开放的,我们可以任意去扩展我们的缓存机制,而不用去管一点点图片加载的细节,就可以实现代码的开闭原则
- 这就是六大原则的前两种,预知后面如何,且听下回分解