五维思考

学习要加，骄傲要减，机会要乘，懒惰要除。 http://www.5dthink.cn
  博客园 :: 首页 :: 博问 :: 闪存 :: 新随笔 :: 联系 :: 订阅 订阅 :: 管理 ::
面向对象的六大原则之 —— 开闭原则

学习了何红辉、关爱民写的《Android设计模式》，对于面向对象的六大原则有进一步的理解，特此根据自己的理解记录总结一下

什么是开闭原则

一个类、模块、函数等应该对于扩展是开放的，但是对于修改是封闭的，简单说就是当你的系统要升级维护需要对原有的代码进行修改时，可能会将错误引入到了原来的旧代码中，因此，在软件升级维护时，应该尽可能的通过扩展的方式而不是修改原有的代码，虽然在实际开发中，修改原本的代码跟扩展代码都是同时存在的，但是为了程序的可扩展性，在制作初期，应该遵循开闭原则。

以上一篇《面向对象的六大原则之 —— 单一原则》的例子为例继续讲解

在ImageCache类中，使用了内存缓存，可是内存缓存很有限，而且还容易丢失，比如应用关闭后，原来缓存在内存的图片会丢失，再打开需要重新加载，所以我们考虑加入SD卡缓存。


加入DiskCache类，缓存图片到SD卡中

[java] view plain copy
  1. import android.graphics.Bitmap;  
  2. import android.graphics.BitmapFactory;  
  3.   
  4. import java.io.FileNotFoundException;  
  5. import java.io.FileOutputStream;  
  6. import java.io.IOException;  
  7.   
  8. /** 
  9.  * Created by Administrator on 2016/3/1. 
  10.  */  
  11. public class DiskCache {  
  12.     public static final String cacheDir="sdcard/cache/";  
  13.   
  14.     /** 
  15.      * 获取sd卡的图片缓存 
  16.      * @param url 图片url 
  17.      * @return 返回bitmap 
  18.      */  
  19.     public Bitmap get(String url){  
  20.         Bitmap bitmap=null;  
  21.         bitmap= BitmapFactory.decodeFile(cacheDir+url);  
  22.         return bitmap;  
  23.     }  
  24.   
  25.     /** 
  26.      * 缓存到sd卡 
  27.      * @param url 图片的url 
  28.      * @param bitmap bitmap对象 
  29.      */  
  30.     private void put(String url ,Bitmap bitmap){  
  31.         FileOutputStream output = null;  
  32.         try {  
  33.             output = new FileOutputStream(cacheDir+url);  
  34.             bitmap.compress(Bitmap.CompressFormat.PNG,100,output);  
  35.         } catch (FileNotFoundException e) {  
  36.             e.printStackTrace();  
  37.         }finally {  
  38.             //无论是否有异常，都要关闭流  
  39.             try {  
  40.                 if(output!=null){  
  41.                     output.close();  
  42.                 }  
  43.             } catch (IOException e) {  
  44.                 e.printStackTrace();  
  45.             }  
  46.         }  
  47.   
  48.     }  
  49. }  

因为加入了sd卡的缓存方式，所以要修改ImageLoader类

[java] view plain copy
  1. import android.graphics.Bitmap;  
  2. import android.graphics.BitmapFactory;  
  3. import android.widget.ImageView;  
  4.   
  5. import java.io.IOException;  
  6. import java.net.HttpURLConnection;  
  7. import java.net.MalformedURLException;  
  8. import java.net.URL;  
  9. import java.util.concurrent.ExecutorService;  
  10. import java.util.concurrent.Executors;  
  11.   
  12. /** 
  13.  * Created by Administrator on 2016/3/1. 
  14.  */  
  15. public class ImageLoader {  
  16.   
  17.     public ImageLoader() {  
  18.     }  
  19.     //内存缓存类  
  20.     ImageCache imageCache=new ImageCache();  
  21.     //sd卡缓存类  
  22.     DiskCache diskCache=new DiskCache();  
  23.     //是否使用sd卡缓存  
  24.     boolean isUseDiskCache=false;  
  25.     //线程池，线城数量为cpu的数量  
  26.     ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());  
  27.   
  28.     /** 
  29.      * 显示图片 
  30.      * @param url 图片的url 
  31.      * @param imageView 要显示的view 
  32.      */  
  33.     public void displayImage(final String url, final ImageView imageView) {  
  34.         Bitmap bitmap=isUseDiskCache()?diskCache.get(url):imageCache.get(url);  
  35.         if(bitmap!=null){  
  36.             imageView.setImageBitmap(bitmap);  
  37.             return;  
  38.         }  
  39.         imageView.setTag(url);  
  40.         mExecutorService.submit(new Runnable() {  
  41.             @Override  
  42.             public void run() {  
  43.                 Bitmap bitmap = downloadImage(url);  
  44.                 if (bitmap == null) {  
  45.                     return;  
  46.                 }  
  47.                 if (imageView.getTag().equals(url)) {  
  48.                     imageView.setImageBitmap(bitmap);  
  49.                 }  
  50.                 imageCache.put(url, bitmap);  
  51.         diskCache.put(url,bitmap);  
  52.             }  
  53.         });  
  54.     }  
  55.     /** 
  56.      * 下載圖片 
  57.      * @param imageUrl 网络图片地址 
  58.      * @return 返回bitmap对象 
  59.      */  
  60.     public Bitmap downloadImage(String imageUrl) {  
  61.         Bitmap bitmap = null;  
  62.         try {  
  63.             URL url = new URL(imageUrl);  
  64.             HttpURLConnection conn = (HttpURLConnection) url.openConnection();  
  65.             bitmap = BitmapFactory.decodeStream(conn.getInputStream());  
  66.             conn.disconnect();  
  67.         } catch (MalformedURLException e) {  
  68.             e.printStackTrace();  
  69.         } catch (IOException e) {  
  70.             e.printStackTrace();  
  71.         }  
  72.         return bitmap;  
  73.     }  
  74.   
  75.     public boolean isUseDiskCache() {  
  76.         return isUseDiskCache;  
  77.     }  
  78.   
  79.     public void setIsUseDiskCache(boolean isUseDiskCache) {  
  80.         this.isUseDiskCache = isUseDiskCache;  
  81.     }  
  82. }  


ImageLoader类中加入了少量代码就添加了sd卡缓存的功能，用户还能通过setIsUseDiskCache设置使用哪种缓存，但是以上还有个问题，使用内存缓存的时候，就没有sd卡缓存，用户要两种策略都用，首先缓存优先使用内存缓存， 如果内存没有就查找sd卡缓存，sd卡没有就从网络获取，，这才是最好的缓存策略，依照这种想法，修改代码，加入DoubleCache类，实现双缓存

[java] view plain copy
  1. import android.graphics.Bitmap;  
  2.   
  3. /** 
  4.  * Created by Administrator on 2016/3/1. 
  5.  */  
  6. public class DoubleCache {  
  7.     //内存缓存  
  8.     ImageCache mImageCache=new ImageCache();  
  9.     //sd卡缓存  
  10.     DiskCache mDiskCache=new DiskCache();  
  11.   
  12.     /** 
  13.      * 获取缓存图片 
  14.      * @param url 图片url 
  15.      * @return 返回bitmap对象 
  16.      */  
  17.     public Bitmap get(String url){  
  18.         Bitmap bitmap=null;  
  19.         bitmap=mImageCache.get(url);  
  20.         if(bitmap==null){  
  21.             bitmap=mDiskCache.get(url);  
  22.         }  
  23.         return bitmap;  
  24.     }  
  25.   
  26.     /** 
  27.      * 缓存图片 
  28.      * @param url 图片url 
  29.      * @param bitmap  
  30.      */  
  31.     public void put(String url,Bitmap bitmap){  
  32.         mImageCache.put(url,bitmap);  
  33.         mDiskCache.put(url,bitmap);  
  34.     }  
  35. }  

ImageLoader类修改如下

[java] view plain copy
  1. import android.graphics.Bitmap;  
  2. import android.graphics.BitmapFactory;  
  3. import android.widget.ImageView;  
  4.   
  5. import java.io.IOException;  
  6. import java.net.HttpURLConnection;  
  7. import java.net.MalformedURLException;  
  8. import java.net.URL;  
  9. import java.util.concurrent.ExecutorService;  
  10. import java.util.concurrent.Executors;  
  11.   
  12. /** 
  13.  * Created by Administrator on 2016/3/1. 
  14.  */  
  15. public class ImageLoader {  
  16.   
  17.     public ImageLoader() {  
  18.     }  
  19.   
  20.     //内存缓存类  
  21.     ImageCache imageCache=new ImageCache();  
  22.     //sd卡缓存类  
  23.     DiskCache diskCache=new DiskCache();  
  24.     //双缓存  
  25.     DoubleCache doubleCache=new DoubleCache();  
  26.     //是否使用sd卡缓存  
  27.     boolean isUseDiskCache=false;  
  28.     //是否使用双缓存  
  29.     boolean isUseDoubleCache=false;  
  30.     //线程池，线城数量为cpu的数量  
  31.     ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());  
  32.   
  33.   
  34.   
  35.     /** 
  36.      * 显示图片 
  37.      * @param url 图片的url 
  38.      * @param imageView 要显示的view 
  39.      */  
  40.     public void displayImage(final String url, final ImageView imageView) {  
  41.         Bitmap bitmap=null;  
  42.         if(isUseDoubleCache()){  
  43.             bitmap=doubleCache.get(url);  
  44.         }else if(isUseDiskCache()){  
  45.             bitmap=diskCache.get(url);  
  46.         }else{  
  47.             bitmap=imageCache.get(url);  
  48.         }  
  49.         if(bitmap!=null){  
  50.             imageView.setImageBitmap(bitmap);  
  51.             return;  
  52.         }  
  53.         imageView.setTag(url);  
  54.         mExecutorService.submit(new Runnable() {  
  55.             @Override  
  56.             public void run() {  
  57.                 Bitmap bitmap = downloadImage(url);  
  58.                 if (bitmap == null) {  
  59.                     return;  
  60.                 }  
  61.                 if (imageView.getTag().equals(url)) {  
  62.                     imageView.setImageBitmap(bitmap);  
  63.                 }  
  64.                 //缓存到内存跟sd卡中  
  65.                 doubleCache.put(url, bitmap);  
  66.             }  
  67.         });  
  68.     }  
  69.     /** 
  70.      * 下載圖片 
  71.      * @param imageUrl 网络图片地址 
  72.      * @return 返回bitmap对象 
  73.      */  
  74.     public Bitmap downloadImage(String imageUrl) {  
  75.         Bitmap bitmap = null;  
  76.         try {  
  77.             URL url = new URL(imageUrl);  
  78.             HttpURLConnection conn = (HttpURLConnection) url.openConnection();  
  79.             bitmap = BitmapFactory.decodeStream(conn.getInputStream());  
  80.             conn.disconnect();  
  81.         } catch (MalformedURLException e) {  
  82.             e.printStackTrace();  
  83.         } catch (IOException e) {  
  84.             e.printStackTrace();  
  85.         }  
  86.         return bitmap;  
  87.     }  
  88.   
  89.     public boolean isUseDiskCache() {  
  90.         return isUseDiskCache;  
  91.     }  
  92.   
  93.     public void setIsUseDiskCache(boolean isUseDiskCache) {  
  94.         this.isUseDiskCache = isUseDiskCache;  
  95.     }  
  96.   
  97.     public boolean isUseDoubleCache() {  
  98.         return isUseDoubleCache;  
  99.     }  
  100.   
  101.     public void setIsUseDoubleCache(boolean isUseDoubleCache) {  
  102.         this.isUseDoubleCache = isUseDoubleCache;  
  103.     }  
  104. }  

经过修改之后，我们的图片加载器已经实现了双缓存的功能了，可是细心的你可能发现了，每次加入新的缓存方法都要修改原来的代码，而且还会让ImageLoader变的越来越复杂，一堆的if{}else{}判断，条件多了就容易造成错误，而且如果现在用户想要自己扩展一个缓存方式，都要动ImageLoader类里面的东西，本文最上面已经说了，开闭原则的目的就是为了让扩展是开发的，修改是封闭的，当软件需要变化时，我们应该尽可能的通过扩展的方式来实现变化，而不要通过修改已有的代码来实现，按照这个思维，我们来想想应该如何修改，首先，我们的ImageLoader的职责就是加载图片跟设置缓存的，而缓存的实现不由它管，我们的目的是让缓存的方式能让用户自己扩展，所以我们定义ImageCache接口，接口中有两个方法，一个是put(String url,Bitmap bitmap)用来添加到缓存，一个是get(String url);用来获取缓存，具体实现不管，而是由实现了这个接口的实现类来具体实现。

ImageCache类如下：

[java] view plain copy
  1. import android.graphics.Bitmap;  
  2.   
  3. /** 
  4.  * Created by Administrator on 2016/3/1. 
  5.  */  
  6. public interface ImageCache {  
  7.     /** 
  8.      * 添加缓存 
  9.      * @param url    缓存的图片url作为缓存的key 
  10.      * @param bitmap 缓存的bitmap 
  11.      */  
  12.     public void put(String url, Bitmap bitmap);  
  13.   
  14.     /** 
  15.      * 获取缓存的图片 
  16.      * @param url 
  17.      * @return 
  18.      */  
  19.     public Bitmap get(String url);  
  20. }  

我们可以将接口当成是一个标准，比如电脑的usb接口，想要通过usb连接到电脑，就必须要按照usb这个插口的标准走，不然你想插也插不进去，我们的图片加载器也是一样，想要自己扩展一个缓存方式，就要按我的标准来。

所以，上面的内存缓存、sd卡缓存、双缓存三个类，我们全部修改实现ImageCache类

内存缓存类（MemoryCache）

[java] view plain copy
  1. import android.graphics.Bitmap;  
  2. import android.util.LruCache;  
  3.   
  4. /** 
  5.  * Created by Administrator on 2016/3/1. 
  6.  */  
  7. public class MemoryCache implements ImageCache{  
  8.   
  9.     public MemoryCache() {  
  10.         //初始化图片缓存  
  11.         initImageCache();  
  12.     }  
  13.   
  14.     //图片缓存类  
  15.     LruCache<String, Bitmap> memoryCache;  
  16.   
  17.     /** 
  18.      * 初始化缓存 
  19.      */  
  20.     private void initImageCache() {  
  21.         //计算可使用的最大内存  
  22.         int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);  
  23.         //只用最大内存的四分之一作为缓存大小  
  24.         int cacheSize = maxMemory / 4;  
  25.         memoryCache = new LruCache<String, Bitmap>(cacheSize) {  
  26.             @Override  
  27.             protected int sizeOf(String key, Bitmap value) {  
  28.                 return value.getRowBytes() * value.getHeight() / 1024;  
  29.             }  
  30.         };  
  31.     }  
  32.   
  33.     /** 
  34.      * 添加缓存 
  35.      * 
  36.      * @param url    缓存的图片url作为缓存的key 
  37.      * @param bitmap 缓存的bitmap 
  38.      */  
  39.     public void put(String url, Bitmap bitmap) {  
  40.         memoryCache.put(url, bitmap);  
  41.     }  
  42.   
  43.     /** 
  44.      * 获取缓存的图片 
  45.      * 
  46.      * @param url 
  47.      * @return 
  48.      */  
  49.     public Bitmap get(String url) {  
  50.         Bitmap bitmap = null;  
  51.         bitmap = memoryCache.get(url);  
  52.         return bitmap;  
  53.     }  
  54. }  

SD卡缓存类（DiskCache）

[java] view plain copy
  1. import android.graphics.Bitmap;  
  2. import android.graphics.BitmapFactory;  
  3.   
  4. import java.io.FileNotFoundException;  
  5. import java.io.FileOutputStream;  
  6. import java.io.IOException;  
  7.   
  8. /** 
  9.  * Created by Administrator on 2016/3/1. 
  10.  */  
  11. public class DiskCache implements ImageCache{  
  12.     public static final String cacheDir="sdcard/cache/";  
  13.   
  14.     /** 
  15.      * 获取sd卡的图片缓存 
  16.      * @param url 图片url 
  17.      * @return 返回bitmap 
  18.      */  
  19.     public Bitmap get(String url){  
  20.         Bitmap bitmap=null;  
  21.         bitmap= BitmapFactory.decodeFile(cacheDir+url);  
  22.         return bitmap;  
  23.     }  
  24.   
  25.     /** 
  26.      * 缓存到sd卡 
  27.      * @param url 图片的url 
  28.      * @param bitmap bitmap对象 
  29.      */  
  30.     public void put(String url ,Bitmap bitmap){  
  31.         FileOutputStream output = null;  
  32.         try {  
  33.             output = new FileOutputStream(cacheDir+url);  
  34.             bitmap.compress(Bitmap.CompressFormat.PNG,100,output);  
  35.         } catch (FileNotFoundException e) {  
  36.             e.printStackTrace();  
  37.         }finally {  
  38.             //无论是否有异常，都要关闭流  
  39.             try {  
  40.                 if(output!=null){  
  41.                     output.close();  
  42.                 }  
  43.             } catch (IOException e) {  
  44.                 e.printStackTrace();  
  45.             }  
  46.         }  
  47.   
  48.     }  
  49. }  

双缓存类（DoubleCache）

[java] view plain copy
  1. import android.graphics.Bitmap;  
  2.   
  3. /** 
  4.  * Created by Administrator on 2016/3/1. 
  5.  */  
  6. public class DoubleCache implements ImageCache{  
  7.     //内存缓存  
  8.     MemoryCache mMemoryCache =new MemoryCache();  
  9.     //sd卡缓存  
  10.     DiskCache mDiskCache=new DiskCache();  
  11.   
  12.     /** 
  13.      * 获取缓存图片 
  14.      * @param url 图片url 
  15.      * @return 返回bitmap对象 
  16.      */  
  17.     public Bitmap get(String url){  
  18.         Bitmap bitmap=null;  
  19.         bitmap= mMemoryCache.get(url);  
  20.         if(bitmap==null){  
  21.             bitmap=mDiskCache.get(url);  
  22.         }  
  23.         return bitmap;  
  24.     }  
  25.   
  26.     /** 
  27.      * 缓存图片 
  28.      * @param url 图片url 
  29.      * @param bitmap 
  30.      */  
  31.     public void put(String url,Bitmap bitmap){  
  32.         mMemoryCache.put(url,bitmap);  
  33.         mDiskCache.put(url,bitmap);  
  34.     }  
  35. }  

最后我们的ImageLoader类修改如下：

[java] view plain copy
  1. import android.graphics.Bitmap;  
  2. import android.graphics.BitmapFactory;  
  3. import android.widget.ImageView;  
  4.   
  5. import java.io.IOException;  
  6. import java.net.HttpURLConnection;  
  7. import java.net.MalformedURLException;  
  8. import java.net.URL;  
  9. import java.util.concurrent.ExecutorService;  
  10. import java.util.concurrent.Executors;  
  11.   
  12. /** 
  13.  * Created by Administrator on 2016/3/1. 
  14.  */  
  15. public class ImageLoader {  
  16.   
  17.     public ImageLoader() {  
  18.     }  
  19.   
  20.     //默认使用内存缓存  
  21.     ImageCache imageCache=new MemoryCache();  
  22.   
  23.     //线程池，线城数量为cpu的数量  
  24.     ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());  
  25.   
  26.     /** 
  27.      * 设置要使用哪种缓存 
  28.      * @param imageCache 缓存类 
  29.      */  
  30.     public void setImageCache(ImageCache imageCache) {  
  31.         this.imageCache = imageCache;  
  32.     }  
  33.   
  34.     /** 
  35.      * 显示图片 
  36.      * @param url 图片的url 
  37.      * @param imageView 要显示的view 
  38.      */  
  39.     public void displayImage(final String url, final ImageView imageView) {  
  40.         Bitmap bitmap=imageCache.get(url);  
  41.   
  42.         if(bitmap!=null){  
  43.             imageView.setImageBitmap(bitmap);  
  44.             return;  
  45.         }  
  46.         imageView.setTag(url);  
  47.         mExecutorService.submit(new Runnable() {  
  48.             @Override  
  49.             public void run() {  
  50.                 Bitmap bitmap = downloadImage(url);  
  51.                 if (bitmap == null) {  
  52.                     return;  
  53.                 }  
  54.                 if (imageView.getTag().equals(url)) {  
  55.                     imageView.setImageBitmap(bitmap);  
  56.                 }  
  57.                 //添加到缓存  
  58.                 imageCache.put(url, bitmap);  
  59.             }  
  60.         });  
  61.     }  
  62.   
  63.     /** 
  64.      * 下載圖片 
  65.      * @param imageUrl 网络图片地址 
  66.      * @return 返回bitmap对象 
  67.      */  
  68.     public Bitmap downloadImage(String imageUrl) {  
  69.         Bitmap bitmap = null;  
  70.         try {  
  71.             URL url = new URL(imageUrl);  
  72.             HttpURLConnection conn = (HttpURLConnection) url.openConnection();  
  73.             bitmap = BitmapFactory.decodeStream(conn.getInputStream());  
  74.             conn.disconnect();  
  75.         } catch (MalformedURLException e) {  
  76.             e.printStackTrace();  
  77.         } catch (IOException e) {  
  78.             e.printStackTrace();  
  79.         }  
  80.         return bitmap;  
  81.     }  
  82. }  

在ImageLoader中，我们去掉了其他的缓存类，只加入了ImageCache接口，而且还开放了一个设置缓存的方法，也就是通常说的依赖注入，经过以上修改之后，用户的使用方式如下：

[java] view plain copy
  1. <span style="white-space:pre">    </span>ImageLoader imageLoader=new ImageLoader();  
  2.         /** 
  3.          * 内存缓存方式 
  4.          */  
  5.         imageLoader.setImageCache(new MemoryCache());  
  6.         /** 
  7.          * SD卡缓存方式 
  8.          */  
  9.         imageLoader.setImageCache(new DiskCache());  
  10.         /** 
  11.          * 双缓存方式 
  12.          */  
  13.         imageLoader.setImageCache(new DoubleCache());  
  14.         /** 
  15.          * 自定义缓存方式 
  16.          */  
  17.         imageLoader.setImageCache(new ImageCache() {  
  18.             @Override  
  19.             public void put(String url, Bitmap bitmap) {  
  20.                 //用户自定义的缓存方式  
  21.             }  
  22.   
  23.             @Override  
  24.             public Bitmap get(String url) {  
  25.                 //从缓存中获取图片  
  26.                 return null;  
  27.             }  
  28.         });  
通过以上的修改，发现现在的ImageLoader的可扩展性、灵活性变的很高，三种缓存方式各自的具体实现都不一样，但是他们都实现了ImageCache接口，即有了这个标准，而用户想要自定义缓存实现的时候，只需要实现ImageCache接口，将其setImageCache进去即可。

以上就是开闭原则，对于修改是封闭的，对于扩展是开发的，遵循开闭原则的重要手段应该是通过抽象，由于实际开发中，可能会不尽人意，但是我们在设计的时候，应该尽量通过扩展的方式，这里说尽量是因为，可能原本的代码就是有问题的，必须要修改。

posted on 2018-02-02 22:14  五维思考  阅读(589)  评论(0)  编辑  收藏  举报

QQ群：1. 全栈码农【346906288】2. VBA/VSTO【2660245】