Google Guice 用户指南 - Ⅱ：愿景

译者：kefate
原文：https://github.com/google/guice/wiki/Motivation

将所有组件连接在一起是应用程序开发中繁琐的一部分。有多种方法可以将数据、服务和表示层类连接在一起。为了对比这些方法，我们将编写一个披萨订购网站的计费代码：

1. public interface BillingService {
3.   /**
4.    * 尝试使用信用卡对订单进行扣款。成功和失败的交易都将被记录
5.    *
6.    * @return 交易的收据。如果扣款成功，收据将显示成功信息；否则，收据将包含一份拒绝说明，描述为何扣款失败。
7.    */
8.   Receipt chargeOrder(PizzaOrder order, CreditCard creditCard);
9. }

复制代码

除了实现代码之外，我们还将为我们的代码编写单元测试。在测试中，我们需要一个FakeCreditCardProcessor来避免对真实信用卡进行扣款。
直接调用构造方法

当我们仅仅使用new来创建CreditCardProcessor 和 TransactionLog对象时，代码如下：

1. public class RealBillingService implements BillingService {
2.   public Receipt chargeOrder(PizzaOrder order, CreditCard creditCard) {
3.     CreditCardProcessor processor = new PaypalCreditCardProcessor();
4.     TransactionLog transactionLog = new DatabaseTransactionLog();
6.     try {
7.       ChargeResult result = processor.charge(creditCard, order.getAmount());
8.       transactionLog.logChargeResult(result);
10.       return result.wasSuccessful()
11.           ? Receipt.forSuccessfulCharge(order.getAmount())
12.           : Receipt.forDeclinedCharge(result.getDeclineMessage());
13.      } catch (UnreachableException e) {
14.       transactionLog.logConnectException(e);
15.       return Receipt.forSystemFailure(e.getMessage());
16.     }
17.   }
18. }

复制代码

这段代码带来了模块化和可测试性的问题。这种对真实的信用卡处理器PaypalCreditCardProcessor 的编译时的直接依赖，意味着测试这段代码时将会用真实的信用卡进行扣款！并且，当向PaypalCreditCardProcessor 扣款被拒绝或者其服务不可用时，测试代码也会变得困难。
工厂类

使用工厂类可以将客户端和实现类进行解耦。下面是一个简单的工厂类，它用static方法来获取实例对象/设置 mock 对象：

1. public class CreditCardProcessorFactory {
3.   private static CreditCardProcessor instance;
5.   public static void setInstance(CreditCardProcessor processor) {
6.     instance = processor;
7.   }
9.   public static CreditCardProcessor getInstance() {
10.     if (instance == null) {
11.       return new SquareCreditCardProcessor();
12.     }
14.     return instance;
15.   }
16. }

复制代码

在我们的客户端代码中，我们只需要用工厂类的getInstance方法替换掉原来通过new创建对象的逻辑即可：

1. public class RealBillingService implements BillingService {
2.   public Receipt chargeOrder(PizzaOrder order, CreditCard creditCard) {
3.     CreditCardProcessor processor = CreditCardProcessorFactory.getInstance();
4.     TransactionLog transactionLog = TransactionLogFactory.getInstance();
6.     try {
7.       ChargeResult result = processor.charge(creditCard, order.getAmount());
8.       transactionLog.logChargeResult(result);
10.       return result.wasSuccessful()
11.           ? Receipt.forSuccessfulCharge(order.getAmount())
12.           : Receipt.forDeclinedCharge(result.getDeclineMessage());
13.      } catch (UnreachableException e) {
14.       transactionLog.logConnectException(e);
15.       return Receipt.forSystemFailure(e.getMessage());
16.     }
17.   }
18. }

复制代码

这种工厂类的写法让我们有能力写出一个恰当的单元测试出来：

1. public class RealBillingServiceTest extends TestCase {
3.   private final PizzaOrder order = new PizzaOrder(100);
4.   private final CreditCard creditCard = new CreditCard("1234", 11, 2010);
6.   private final InMemoryTransactionLog transactionLog = new InMemoryTransactionLog();
7.   private final FakeCreditCardProcessor processor = new FakeCreditCardProcessor();
9.   @Override public void setUp() {
10.     TransactionLogFactory.setInstance(transactionLog);
11.     CreditCardProcessorFactory.setInstance(processor);
12.   }
14.   @Override public void tearDown() {
15.     TransactionLogFactory.setInstance(null);
16.     CreditCardProcessorFactory.setInstance(null);
17.   }
19.   public void testSuccessfulCharge() {
20.     RealBillingService billingService = new RealBillingService();
21.     Receipt receipt = billingService.chargeOrder(order, creditCard);
23.     assertTrue(receipt.hasSuccessfulCharge());
24.     assertEquals(100, receipt.getAmountOfCharge());
25.     assertEquals(creditCard, processor.getCardOfOnlyCharge());
26.     assertEquals(100, processor.getAmountOfOnlyCharge());
27.     assertTrue(transactionLog.wasSuccessLogged());
28.   }
29. }

复制代码

这种代码写起来就比较蠢。全局变量instance在这里被设置成了一个 mock 对象，所以我们需要很小心去设置它的值或者把它恢复为初始值null。如果tearDown方法执行失败了，这个全局变量就会一直是我们创建的 mock 对象。这样可能会给其他的测试带来问题，并且我们也无法并发运行多个测试。
但最大的问题其实是依赖关系被隐藏到了代码里。如果工厂类中增加了对CreditCardFraudTracker的依赖，我们必须要重新进行测试才能找出哪些测试会被破坏。如果测试类中忘记初始化一个工厂，那就只能在最后调用的时候才发现。随着应用程序规模的增长，时刻关注工厂类相关的代码就成了一件很折磨人的事情。
虽然QA会保证软件的质量，但我们身为研发，还是要尽可能地做得更好一些。
依赖注入

就像工厂模式一样，依赖注入其实也只是一种设计模式。其核心原则是将行为与依赖进行解耦。在我们的示例中，RealBillingService 不负责查找 TransactionLog 和 CreditCardProcessor对象，而是把他们作为构造函数参数传递进来：

1. public class RealBillingService implements BillingService {
2.   private final CreditCardProcessor processor;
3.   private final TransactionLog transactionLog;
5.   public RealBillingService(CreditCardProcessor processor,
6.       TransactionLog transactionLog) {
7.     this.processor = processor;
8.     this.transactionLog = transactionLog;
9.   }
11.   public Receipt chargeOrder(PizzaOrder order, CreditCard creditCard) {
12.     try {
13.       ChargeResult result = processor.charge(creditCard, order.getAmount());
14.       transactionLog.logChargeResult(result);
16.       return result.wasSuccessful()
17.           ? Receipt.forSuccessfulCharge(order.getAmount())
18.           : Receipt.forDeclinedCharge(result.getDeclineMessage());
19.      } catch (UnreachableException e) {
20.       transactionLog.logConnectException(e);
21.       return Receipt.forSystemFailure(e.getMessage());
22.     }
23.   }
24. }

复制代码

既然我们现在不需要任何工厂类，那么通过删除单测的 setUp 和 tearDown 方法，我们就可以简化单测：

1. public class RealBillingServiceTest extends TestCase {
3.   private final PizzaOrder order = new PizzaOrder(100);
4.   private final CreditCard creditCard = new CreditCard("1234", 11, 2010);
6.   private final InMemoryTransactionLog transactionLog = new InMemoryTransactionLog();
7.   private final FakeCreditCardProcessor processor = new FakeCreditCardProcessor();
9.   public void testSuccessfulCharge() {
10.     RealBillingService billingService
11.         = new RealBillingService(processor, transactionLog);
12.     Receipt receipt = billingService.chargeOrder(order, creditCard);
14.     assertTrue(receipt.hasSuccessfulCharge());
15.     assertEquals(100, receipt.getAmountOfCharge());
16.     assertEquals(creditCard, processor.getCardOfOnlyCharge());
17.     assertEquals(100, processor.getAmountOfOnlyCharge());
18.     assertTrue(transactionLog.wasSuccessLogged());
19.   }
20. }

复制代码

现在，每当我们添加或删除依赖关系时，编译器会提醒我们哪些测试需要修正。依赖关系暴露到了API签名里。
不幸的是，现在用到BillingService的客户端需要查找它的依赖关系。我们可以通过再次应用该模式来解决一些问题——依赖于它的类可以在它们的构造函数中接受一个BillingService。不难发现，对于顶层的那些类来说，最好能有一个框架来完成依赖注入这件事。否则，当你需要使用一个服务时，你就需要递归地构建依赖关系。

1.   public static void main(String[] args) {
2.     CreditCardProcessor processor = new PaypalCreditCardProcessor();
3.     TransactionLog transactionLog = new DatabaseTransactionLog();
4.     BillingService billingService
5.         = new RealBillingService(processor, transactionLog);
6.     ...
7.   }

复制代码

使用 Guice 进行依赖注入

使用依赖性注入这种设计模式提高了代码的模块化和可测试性，而 Guice 框架使其易于编写。
为了在我们的计费例子中使用 Guice，首先，我们需要告诉它如何将接口与实现类进行映射。通过一个实现了Module接口的 Java 类，就能完成这项配置。

1. public class BillingModule extends AbstractModule {
2.   @Override
3.   protected void configure() {
4.     bind(TransactionLog.class).to(DatabaseTransactionLog.class);
5.     bind(CreditCardProcessor.class).to(PaypalCreditCardProcessor.class);
6.     bind(BillingService.class).to(RealBillingService.class);
7.   }
8. }

复制代码

接下来，我们只要在RealBillingService的构造函数中加入@Inject就可以告诉 Guice 进行处理。Guice将检查使用了@Inject注解的构造函数，并为每个参数查找实际的值。

1. public class RealBillingService implements BillingService {
2.   private final CreditCardProcessor processor;
3.   private final TransactionLog transactionLog;
5.   @Inject
6.   public RealBillingService(CreditCardProcessor processor,
7.       TransactionLog transactionLog) {
8.     this.processor = processor;
9.     this.transactionLog = transactionLog;
10.   }
12.   public Receipt chargeOrder(PizzaOrder order, CreditCard creditCard) {
13.     try {
14.       ChargeResult result = processor.charge(creditCard, order.getAmount());
15.       transactionLog.logChargeResult(result);
17.       return result.wasSuccessful()
18.           ? Receipt.forSuccessfulCharge(order.getAmount())
19.           : Receipt.forDeclinedCharge(result.getDeclineMessage());
20.      } catch (UnreachableException e) {
21.       transactionLog.logConnectException(e);
22.       return Receipt.forSystemFailure(e.getMessage());
23.     }
24.   }
25. }

复制代码

最后，我们把这些打包到一起，使用Injector 即可获得任何一个映射的类实例。

1.   public static void main(String[] args) {
2.     Injector injector = Guice.createInjector(new BillingModule());
3.     BillingService billingService = injector.getInstance(BillingService.class);
4.     ...
5.   }

复制代码

下一节我们将会介绍这一切是如何运作的。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！