依赖倒置原则，英文Dependence Inversion Principle,缩写–DIP。它具体指代了一种特定的解耦形式，使得高层次的模块不依赖于低层次模块的实现细节，依赖模块被颠倒了。总结它的概念有如下几点：
- 1，高层次模块不依赖于低层次模块，两者都应该依赖其抽象
- 2，抽象不应该依赖细节
- 3，细节应该依赖抽象
java中，抽象就是指接口类或者抽象类，他们都不能被实例化，细节就是实现类，实现接口或者继承抽象类类而new的类就是细节，其特点就是，可以直接被实例化。而高层模块就是指调用端，底层模块就是具体实现类。依赖倒置原则在Java中的表现是：模块间的依赖通过抽象发生，实现类之间不发生直接的依赖关系，其依赖关系是通过接口或抽象类实现的。这又是一个将理论抽象化的实例，一句话概括就是：面向接口编程，或者说面向抽象编程，这里的抽象当然指的是抽象类或接口，面向接口编程是面向对象精髓之一，也就是抽象。
如果类与类之间直接依赖于细节，那他们之间就有直接的耦合，当具体实现需要变化时，意味着要同时修改依赖者的代码，这限制系统的可扩展性。我们来看一个例子：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| public class ImageLoader {
//内存缓存
MemoryCache mMemoryCache = new MemoryCache();
//加载图片到ImageView中
public void displayImage(String url,ImageView imageView) {
Bitmap bitmap = mMemoryCache.get(url);
if (bitmap == null) {
downloaderImage(url,imageView);
} else {
imageView.setImageBitmap(bitmap);
}
}
public void setImageCache(MemoryCache cache) {
mCache = cache;
}
//代码省略
}
|
上述代码中，ImageLoader直接依赖于MemoryCache，这个MemoryCache是一个具体实现，而不是一个抽象类或者接口，这导致了ImageLoader直接依赖了细节，当MemoryCache不能满足ImageLoader而需要被其他缓存实现替换时，此时就必须修改ImageLoader的代码。随着产品的升级，MemoryCache不能满足要求，用户需要的ImageLoader可以将图片同时缓存到内存和SD卡中，或者让用户自己自定义实现缓存，这个时候MemoryCache就不能满足需求了。需要重构，如果将MemoryCache修改为DoubleCache，然后在DoubleCache中实现具体的缓存功能，代码修改如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| public class ImageLoader {
//双缓存，直接依赖于细节
DoubleCache mCache = new DoubleCache();
//加载图片到ImageView中
public void displayImage(String url,ImageView imageView) {
Bitmap bitmap = mMemoryCache.get(url);
if (bitmap == null) {
//异步下载图片
downloaderImageAsync(url,imageView);
} else {
imageView.setImageBitmap(bitmap);
}
}
public void setImageCache(DoubleCache cache) {
mCache = cache;
}
//代码省略
}
|
这样就好像满足了新的需求，我们将MemoryCache改成了DoubleCache，然后修改了ImageLoader中缓存类的具体实现，轻轻松松搞定了？不是，这还是依赖于具体的实现类(DoubleCache类)细节的，当用户需求再改变时呢？我们再修改源码吗？这违背了开放封闭原则。
解决问题的方法就是依赖于抽象，而不依赖于具体实现。针对图片缓存，建立ImageCache抽象，增加get和set方法用以实现图片的缓存，每种缓存都必须实现这个接口，并且实现自己的存取方法，当用户需要使用不同的缓存实现时，直接通过依赖注入即可，保证了系统的灵活性。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
| //抽象类
public interface ImageCache {
public Bitmap get(String url);
public Bitmap set(String urk);
}
//ImagerLoader类
public class ImageLoader {
//图片缓存类，依赖于抽象，并且有一个默认的实现
ImageCache mCache = new MemoryCache();
//加载图片到ImageView中
public void displayImage(String url,ImageView imageView) {
Bitmap bitmap = mMemoryCache.get(url);
if (bitmap == null) {
//异步下载图片
downloaderImageAsync(url,imageView);
} else {
imageView.setImageBitmap(bitmap);
}
}
public void setImageCache(DoubleCache cache) {
mCache = cache;
}
/**
设置缓存策略，依赖于抽象
*/
public void setImageCache (ImageCache cache) {
mCache = cache;
}
//代码省略
}
|
这里，我们建立了ImageCache抽象，ImageLoader依赖于抽象而不是细节。当需求发生变化时，我们只要实现ImageCache类或者继承其他已有的ImageCache子类完成相应的缓存功能，然后将具体的实现注入ImageLoader即可实现缓存功能的替换，这就保证了缓存系统的高可扩展性，有了拥抱变化的能力，这就依赖倒置原则。从上述的学习中，我们发现抽象几乎成为了让系统变得更灵活的唯一选择。