[关闭]
@Tyhj 2018-07-13T00:55:54.000000Z 字数 5723 阅读 1498

Android设计模式二：开闭原则

设计模式

原文链接：https://www.zybuluo.com/Tyhj/note/1192305

定义

软件中的对象（类、模块、函数等）应该对于扩展是开放的，但是对于修改是封闭的

核心思想

尽量通过扩展软件实体来解决需求变化，而不是通过修改已有的代码来完成变化

一个软件产品在生命周期内，都会发生变化，既然变化是一个既定的事实，我们就应该在设计的时候尽量适应这些变化，以提高项目的稳定性和灵活性。

举个栗子

在之前的图片加载框架，新增本地缓存功能，tag 1.2

  1. public class DiskCache {
  3.     //保存位置
  4.     String cacheDir = "sdcard/cache/";
  6.     //获取图片
  7.     public Bitmap get(String url) {
  8.         return BitmapFactory.decodeFile(cacheDir + url);
  9.     }
  11.     //保存图片到本地
  12.     public void put(String url, Bitmap bitmap) {
  13.         FileOutputStream fileOutputStream = null;
  14.         fileOutputStream = new FileOutputStream(cacheDir + url);
  15.         bitmap.compress(Bitmap.CompressFormat.PNG, 100, fileOutputStream);
  16.     }
  18. }

新增了图片缓存到SD卡中，所以ImageLoad代码有更新

  1. public class ImageLoader {
  3.     //内存缓存
  4.     ImageCache mImageCache = new ImageCache();
  6.     //SD卡缓存
  7.     DiskCache mDiskCache = new DiskCache();
  9.     //是否使用本地缓存
  10.     boolean isUseDiskCache = false;
  12.     public void setUseDiskCache(boolean useDiskCache) {
  13.         isUseDiskCache = useDiskCache;
  14.     }
  16.     //线程池，线程数量为cpu的数量
  17.     private ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
  19.     public void displayImage(final String url, final ImageView imageView, final Activity context) {
  21.         final Bitmap bitmap = isUseDiskCache ? mDiskCache.get(url) : mImageCache.get(url);
  22.         if (bitmap != null) {
  23.             imageView.setImageBitmap(bitmap);
  24.             return;
  25.         }
  26.         imageView.setTag(url);
  28.         mExecutorService.submit(new Runnable() {
  29.             @Override
  30.             public void run() {
  31.                 final Bitmap bitmap = downLoadImage(url);
  32.                 if (isUseDiskCache) {
  33.                     mDiskCache.put(url, bitmap);
  34.                 } else {
  35.                     mImageCache.put(url, bitmap);
  36.                 }
  37.                imageView.setImageBitmap(bitmap);
  38.             }
  39.         });
  40.     }
  42.     public static Bitmap downLoadImage(String imageUrl) {
  43.         Bitmap bitmap = null;
  44.         URL url = new URL(imageUrl);
  45.         HttpURLConnection connection = (HttpURLConnection) url.openConnection();
  46.         bitmap = BitmapFactory.decodeStream(connection.getInputStream());
  47.         connection.disconnect();
  48.         return bitmap;
  49.     }
  51. }

代码完成，但是功能不是很合理，因为两种缓存不能同时使用，实际上，先从内存获取没有找到再从本地读取，本地也没有再从网络获取，才是最好的策略。

新增一个双重缓存的类

  1. public class DoubleCache {
  3.     ImageCache imageCache = new ImageCache();
  4.     DiskCache diskCache = new DiskCache();
  7.     /**
  8.      * 双缓存，获取图片的时候先从内存中读取，如果没有再从SD卡中读取
  9.      *
  10.      * @param url
  11.      * @return
  12.      */
  13.     public Bitmap get(String url) {
  14.         Bitmap bitmap = imageCache.get(url);
  15.         if (bitmap == null) {
  16.             bitmap = diskCache.get(url);
  17.             imageCache.put(url, bitmap);
  18.         }
  19.         return bitmap;
  20.     }
  22.     //将图片缓存到内存和SD卡中
  23.     public void put(String url, Bitmap bitmap) {
  24.         imageCache.put(url, bitmap);
  25.         diskCache.put(url, bitmap);
  26.     }
  28. }

再次修改ImageLoad代码

  1. public class ImageLoader {
  4.     //内存缓存
  5.     ImageCache mImageCache = new ImageCache();
  7.     //SD卡缓存
  8.     DiskCache mDiskCache = new DiskCache();
  10.     //双重缓存
  11.     DoubleCache mDoubleCache = new DoubleCache();
  13.     //是否使用本地缓存
  14.     boolean isUseDiskCache = false;
  16.     //双缓存
  17.     boolean isUseDoubleCache = false;
  19.     public void setUseDiskCache(boolean useDiskCache) {
  20.         isUseDiskCache = useDiskCache;
  21.     }
  23.     public void setUseDoubleCache(boolean useDoubleCache) {
  24.         isUseDoubleCache = useDoubleCache;
  25.     }
  27.     //线程池，线程数量为cpu的数量
  28.     private ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
  30.     public void displayImage(final String url, final ImageView imageView, final Activity context) {
  32.         Bitmap bitmap = null;
  34.         if (isUseDoubleCache) {
  35.             bitmap = mDoubleCache.get(url);
  36.         } else if (isUseDiskCache) {
  37.             bitmap = mDiskCache.get(url);
  38.         } else {
  39.             bitmap = mImageCache.get(url);
  40.         }
  42.         if (bitmap != null) {
  43.             final Bitmap finalBitmap = bitmap;
  44.             imageView.setImageBitmap(finalBitmap);
  45.             return;
  46.         }
  47.         imageView.setTag(url);
  49.         mExecutorService.submit(new Runnable() {
  50.             @Override
  51.             public void run() {
  52.                 final Bitmap bitmap = downLoadImage(url);
  53.                 if (isUseDoubleCache) {
  54.                     mDoubleCache.put(url, bitmap);
  55.                 } else if (isUseDiskCache) {
  56.                     mDiskCache.put(url, bitmap);
  57.                 } else {
  58.                     mImageCache.put(url, bitmap);
  59.                 }
  60.                 imageView.setImageBitmap(bitmap);
  61.             }
  62.         });
  63.     }
  65.     public static Bitmap downLoadImage(String imageUrl) {
  66.         Bitmap bitmap = null;
  67.         try {
  68.             URL url = new URL(imageUrl);
  69.             HttpURLConnection connection = (HttpURLConnection) url.openConnection();
  70.             bitmap = BitmapFactory.decodeStream(connection.getInputStream());
  71.             connection.disconnect();
  72.         } catch (Exception e) {
  73.             e.printStackTrace();
  74.         }
  75.         return bitmap;
  76.     }
  78. }

双缓存完成了，但是存在一些问题，每次添加新功能的时候都要去修改ImageLoader源码，很可能引入bug，而且使得原来的代码越来越复杂、脆弱，不小心写错一个if条件就需要花费时间来排查，而且用户使用我们的框架，不能自己实现缓存注入到ImageLoader中，可扩展性差

image_1cgr988tvpcp1lj2j3thlg1moo22.png-45.7kB

开闭原则重构代码，ImageLoader

  1. public class ImageLoader {
  4.     //内存缓存
  5.     ImageCache mImageCache = new MemoryCache();
  7.     public void setmImageCache(ImageCache mImageCache) {
  8.         this.mImageCache = mImageCache;
  9.     }
  12.     //线程池，线程数量为cpu的数量
  13.     private ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
  15.     public void displayImage(final String url, final ImageView imageView, final Activity context) {
  17.         Bitmap bitmap = mImageCache.get(url);
  19.         if (bitmap != null) {
  20.             final Bitmap finalBitmap = bitmap;
  21.             imageView.setImageBitmap(finalBitmap);
  22.             return;
  23.         }
  24.         imageView.setTag(url);
  26.         mExecutorService.submit(new Runnable() {
  27.             @Override
  28.             public void run() {
  29.                 final Bitmap bitmap = downLoadImage(url);
  30.                 mImageCache.put(url, bitmap);
  31.                 imageView.setImageBitmap(bitmap);
  32.             }
  33.         });
  34.     }
  37.     public static Bitmap downLoadImage(String imageUrl) {
  38.         Bitmap bitmap = null;
  39.         try {
  40.             URL url = new URL(imageUrl);
  41.             HttpURLConnection connection = (HttpURLConnection) url.openConnection();
  42.             bitmap = BitmapFactory.decodeStream(connection.getInputStream());
  43.             connection.disconnect();
  44.         } catch (Exception e) {
  45.             e.printStackTrace();
  46.         }
  47.         return bitmap;
  48.     }
  50. }

缓存继承ImageCache接口

  1. public interface ImageCache {
  2.     public Bitmap get(String url);
  4.     public void put(String url, Bitmap bmp);
  5. }

使用方法：

  1. //双重缓存
  2. imageLoader = new ImageLoader();
  3. imageLoader.setmImageCache(new DoubleCache());
  4. imageLoader.displayImage(url, iv_test1, this);
  7. //自定义缓存栗子
  8.  imageLoader.setmImageCache(new ImageCache() {
  9.             @Override
  10.             public Bitmap get(String url) {
  11.                 return null;
  12.             }
  14.             @Override
  15.             public void put(String url, Bitmap bmp) {
  17.             }
  18.         });

重构完成

通过setImageCache(IamgeCache iamgeCache)方法注入不同的缓存实现，这样不仅能够使ImageLoader更简单、健壮，也使得Imageloader的灵活性、可扩展性更高。只需要新建一个实现ImageCache接口的类，注入到ImageLoader中，ImageLoader就可以实现各种各样的缓存策略，而且这些缓存策略不会导致ImageLoader类的修改。

开闭原则的理解

用抽象构建框架，用实现扩展细节。因为抽象灵活性好，适应性广，只要抽象的合理，可以基本保持软件架构的稳定。而软件中易变的细节，我们用从抽象派生的实现类来进行扩展，当软件需要发生变化时，我们只需要根据需求重新派生一个实现类来扩展就可以了。当然前提是我们的抽象要合理，要对需求的变更有前瞻性和预见性才行。

该图片加载框架集成方法：

  1. //Step 1. Add the JitPack repository to your build file
  2.     allprojects {
  3.         repositories {
  4.             ...
  5.             maven { url 'https://jitpack.io' }
  6.         }
  7.     }
  1. //Step 2. Add the dependency
  2. dependencies {
  3.             implementation 'com.github.tyhjh:DesignMode:v1.3'
  4.     }

参考：《Android源码设计模式解析与实战》一书

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注