为什么需要“依赖注入”
Case 1
public class Foo {
private Bar bar;
public Foo() {
bar = new Bar();
}
public void doSomething(int key) {
String result = bar.getResult(key);
//swithch result
}
}
反模式 ，在构造函数中，初始化了合作类，导致：
• 外部使用者不知道 Foo 里面还依赖了 Bar
• 无法对Bar单元测试，体现在 bar.getResult() 返回真实值，如果和网络、数据库、IO 打交道的话，这是一个很耗时的动作
Case 2
public class Foo {
private Bar bar=new Bar();
public Foo(){
}
public void doSomething(int key){
String result = bar.getResult(key);
//swithch result
}
}
反模式，虽然没有在构造函数中初始化 Bar 对象，但在字段中直接初始化了 Bar 对象，问题和上面一样
Case 3 使用 Guice 来对依赖进行管理
public class Foo {
private Bar bar ;
@Inject
public Foo(Bar bar) {
this.bar = bar;
}
public String doSomething(int key) {
return bar.getResult(key);
}
}
对于使用 Foo 的用户而言，一眼就知道 Foo 内部需要 合作类 Bar, 明白了 Foo 的职责，同时 @Inject 将依赖对象注入，解耦的同时还方便测试
public class TestCase {
@Mock
private Bar bar;
@Before
public void before(){
MockitoAnnotations.initMocks(this);
}
@Test
public void test(){
//Arrange
when(bar.getResult(eq(1))).thenReturn("jack");
Foo foo=new Foo(bar);
//Action
String result = foo.doSomething(1);
//Assert
Assert.assertEquals("jack",result);
}
}
上面可以看到，Mock 了 Bar 对象，Bar 对象的 getResult() 可能是一个比较耗时的功能，所以对它进行了Stub，同时 Foo 不依赖真实的 Bar 对象。
