为什么需要依赖注入

为什么需要“依赖注入”

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);
  }
}

上面可以看到,MockBar 对象,Bar 对象的 getResult() 可能是一个比较耗时的功能,所以对它进行了Stub,同时 Foo 不依赖真实的 Bar 对象。