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