依赖倒置原则在我们的开发过程中，也是非常常见的一种设计原则。他有三层定义：
- 高层模块不应该依赖低层模块，两者都应该依赖其抽象
- 抽象不应该依赖细节
- 细节应该依赖抽象
在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。完美实现图片加载。
某天产品经理说，我怎么感觉图片每次加载都很慢啊，而且，我跟别的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));
}
}
哎？？？，有没有发现，这样违反了开闭原则，总不能每次需求变更，我都要修改调用吧。再说了，虽然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图了：
哈哈，这就是 依赖倒置原则，那么例子看完了，好处总结一下吧：
- 采用依赖倒置原则可以减少类间的耦合性。因为他们都依赖接口，不相互依赖。
- 提高系统的稳定性，降低并行开发引起的风险，提高代码的可读性和可维护性。新增加了缓存实现，出了问题影响界面少。而且可以根据出问题的界面直接定位哪种缓存方式。
写在最后：改变世界，先从改变自己开始。---我说的
你也可以关注我的公众号：码H.cam ， 随时随地学习设计模式
