Android设计模式六大原则之依赖倒置原则

依赖倒置原则在我们的开发过程中，也是非常常见的一种设计原则。他有三层定义：

高层模块不应该依赖低层模块，两者都应该依赖其抽象
抽象不应该依赖细节
细节应该依赖抽象

在java中抽象就是接口或抽象类，而低层模块就是指实现接口或者继承抽象产生的细节的类。高层模块就是可以调用实现类的模块。也可以理解为 面向接口编程。按照惯例咱还是先不说好处，根据文章例子自己体会~~

我们先看一个没有按照依赖倒置原则的例子：

//内存缓存类 没有依赖抽象或接口的底层类
public class MemoryCache{
    //图片LRU缓存
    private LruCache<String,Bitmap> mMemoryCache;
    public ImageCache(){
       //初始化内存
    }

    //缓存图片
    public void put(String url,Bitmap bitmap){
      mImageCache.put(url,bitmap);
    } 
    //获取图片
    public Bitmap get(String url){
      return mImageCache.get(url);
    }  
}

//图片加载类 高层模块，调用类
class ImageLoader{
   //内存缓存
   MemoryCache mImageCache = new MemoryCache();

  //ImageView 显示图片
   public void display(String url,ImageView imageView){
       //加载图片的具体细节略去，那不是重点。。。
       imageView.setImageBitmap(mImageCache.get(url));
   }
}

看起来没毛病，定义了一个内存缓存类MemoryCache，定义了一个调用MemoryCache 的高层类 ImageLoader。完美实现图片加载。

Android设计模式六大原则之依赖倒置原则

某天产品经理说，我怎么感觉图片每次加载都很慢啊，而且，我跟别的app对比，同样的网络，发现咱比人家显示图片慢的多。然后你说：这个嘛，交给我来处理！你知道，这是人家利用了本地缓存，首次加载使用网络，之后就存到了本地，以后直接从本地读取然后再存到内存中，当然快了。于是乎，你增加了一个缓存类DoubleCache 用来满足以上需求。

//SD卡缓存类  没有依赖抽象或接口的底层类
public class DoubleCache{

    //缓存图片到SD卡，内存中
    public void put(String url,Bitmap bitmap){
     ...
    } 
    //从内存或Sd卡中获取图片
    public Bitmap get(String url){
      ...
    }    
}


//图片加载类 高层模块，调用类
class ImageLoader{
   //内存缓存
   DoubleCache mImageCache = new DoubleCache();

  //ImageView 显示图片
   public void display(String url,ImageView imageView){
       //加载图片的具体细节略去，那不是重点。。。
       imageView.setImageBitmap(mImageCache.get(url));
   }
}

Android设计模式六大原则之依赖倒置原则

哎？？？，有没有发现，这样违反了开闭原则，总不能每次需求变更，我都要修改调用吧。再说了，虽然DoubleCache 取代了 MemoryCache，但是 MemoryCache已经在线下线上经过了测试和用户的不计其数的检测，是稳定的。如果DoubleCache 由于测试机器的限制，和设备的多样化，有些问题前期测试没有测出来，上线之后，有数量不少的设备都出现异常，那岂不是非常糟糕。

于是乎，你了解到依赖倒置原则，知道了 高层模块不应该依赖低层模块，两者都应该依赖其抽象，抽象不应该依赖细节，细节应该依赖抽象（跟念经似的），那么接下来咱要重构一下代码。

//定义抽象 接口
public interface ImageCache{
   /**
    * 获取图片
    */
   public Bitmap get(String url);
   /**
    * 缓存图片
    */
   public void put(String url,Bitmap bitmap);
}

将缓存类的行为抽象出来，定义一种约束，然后由低层模块和高层模块依赖它。

//扩展内存缓存类 实现 ImageCache 接口
public class MemoryCache implements ImageCache{
    //图片LRU缓存
    private LruCache<String,Bitmap> mMemoryCache;
    public ImageCache(){
       //初始化内存
    }

    //缓存图片
    @Override
    public void put(String url,Bitmap bitmap){
      mImageCache.put(url,bitmap);
    } 
    //缓存图片
    @Override
    public Bitmap get(String url){
      mImageCache.get(url);
    }    
}

//扩展双缓存类 实现 ImageCache 接口
public class DoubleCache{

    //缓存图片到SD卡，内存中
    public void put(String url,Bitmap bitmap){
     ...
    } 
    //从内存或Sd卡中获取图片
    public Bitmap get(String url){
      ...
    }    
}


//将图片加载ImageView显示类  高层模块
class ImageLoader{
   //如果不setImageCache 默认支持内存缓存
   ImageCache mImageCache = new MemoryCache();

   //通过set的方式注入自定义扩展的缓存
   public void setImageCache(ImageCache cache){
     mImageCache = cache;
   }

    //ImageView 显示图片
   public void display(String url,ImageView imageView){
       //加载图片的具体细节略去，那不是重点。。。
       imageView.setImageBitmap(mImageCache.get(url));
   }
}

可以看到，都依赖了ImageCache ，即使更高的模块，在调用ImageLoader时，也只是通过setImageCache() 依赖注入不同的缓存实现方式，而不需要修改ImageLoader里面的任何地方。即使新添加缓存实现方式，出了问题，也很快能根据使用不同缓存的页面定位到哪种缓存方式。

该上UML图了：

Android设计模式六大原则之依赖倒置原则

哈哈，这就是依赖倒置原则，那么例子看完了，好处总结一下吧：

采用依赖倒置原则可以减少类间的耦合性。 因为他们都依赖接口，不相互依赖。
提高系统的稳定性，降低并行开发引起的风险，提高代码的可读性和可维护性。 新增加了缓存实现，出了问题影响界面少。而且可以根据出问题的界面直接定位哪种缓存方式。

写在最后：改变世界，先从改变自己开始。—我说的
你也可以关注我的公众号：码H.cam ，随时随地学习设计模式

秒客网

Android设计模式六大原则之依赖倒置原则

相关文章