关于java:Google-开源的依赖注入库比-Spring-更小更快

Guice是Google开源的一个依赖注入类库,相比于Spring IoC来说更小更快。Elasticsearch大量应用了Guice,本文简略的介绍下Guice的基本概念和应用形式。

学习指标

概述:理解Guice是什么,有什么特点;
疾速开始:通过实例理解Guice;
外围概念:理解Guice波及的外围概念,如绑定(Binding)、范畴(Scope)和注入(Injection);
最佳实际:官网举荐的最佳实际;

Guice概述

Guice是Google开源的依赖注入类库,通过Guice缩小了对工厂办法和new的应用,使得代码更易交付、测试和重用;
Guice能够帮忙咱们更好地设计API,它是个轻量级非侵入式的类库;
Guice对开发敌对,当有异样产生时能提供更多有用的信息用于剖析;

疾速开始
假如一个在线预订Pizza的网站,其有一个计费服务接口:

public interface BillingService {
 /**
  * 通过信用卡领取。无论领取胜利与否都须要记录交易信息。
  *
  * @return 交易回执。领取胜利时返回胜利信息,否则记录失败起因。
  */
  Receipt chargeOrder(PizzaOrder order, CreditCard creditCard);
}

应用new的形式获取信用卡领取处理器和数据库交易日志记录器:

public class RealBillingService implements BillingService {
  public Receipt chargeOrder(PizzaOrder order, CreditCard creditCard) {
    CreditCardProcessor processor = new PaypalCreditCardProcessor();
    TransactionLog transactionLog = new DatabaseTransactionLog();

    try {
      ChargeResult result = processor.charge(creditCard, order.getAmount());
      transactionLog.logChargeResult(result);

      return result.wasSuccessful()
          ? Receipt.forSuccessfulCharge(order.getAmount())
          : Receipt.forDeclinedCharge(result.getDeclineMessage());
     } catch (UnreachableException e) {
      transactionLog.logConnectException(e);
      return Receipt.forSystemFailure(e.getMessage());
    }
  }
}

应用new的问题是使得代码耦合,不易保护和测试。比方在UT里不可能间接用实在的信用卡领取,须要Mock一个CreditCardProcessor。相比于new,更容易想到的改良是应用工厂办法,然而工厂办法在测试中仍存在问题(因为通常应用全局变量来保留实例,如果在用例中未重置可能会影响其余用例)。更好的形式是通过构造方法注入依赖:

public class RealBillingService implements BillingService {
  private final CreditCardProcessor processor;
  private final TransactionLog transactionLog;

  public RealBillingService(CreditCardProcessor processor,
      TransactionLog transactionLog) {
    this.processor = processor;
    this.transactionLog = transactionLog;
  }

  public Receipt chargeOrder(PizzaOrder order, CreditCard creditCard) {
    try {
      ChargeResult result = processor.charge(creditCard, order.getAmount());
      transactionLog.logChargeResult(result);

      return result.wasSuccessful()
          ? Receipt.forSuccessfulCharge(order.getAmount())
          : Receipt.forDeclinedCharge(result.getDeclineMessage());
     } catch (UnreachableException e) {
      transactionLog.logConnectException(e);
      return Receipt.forSystemFailure(e.getMessage());
    }
  }
}

对于实在的网站利用能够注入真正的业务解决服务类:

public static void main(String[] args) {
    CreditCardProcessor processor = new PaypalCreditCardProcessor();
    TransactionLog transactionLog = new DatabaseTransactionLog();
    BillingService billingService
        = new RealBillingService(processor, transactionLog);
    …
  }

而在测试用例中能够注入Mock类:

public class RealBillingServiceTest extends TestCase {

  private final PizzaOrder order = new PizzaOrder(100);
  private final CreditCard creditCard = new CreditCard(“1234”, 11, 2010);

  private final InMemoryTransactionLog transactionLog = new InMemoryTransactionLog();
  private final FakeCreditCardProcessor processor = new FakeCreditCardProcessor();

  public void testSuccessfulCharge() {
    RealBillingService billingService
        = new RealBillingService(processor, transactionLog);
    Receipt receipt = billingService.chargeOrder(order, creditCard);

    assertTrue(receipt.hasSuccessfulCharge());
    assertEquals(100, receipt.getAmountOfCharge());
    assertEquals(creditCard, processor.getCardOfOnlyCharge());
    assertEquals(100, processor.getAmountOfOnlyCharge());
    assertTrue(transactionLog.wasSuccessLogged());
  }
}

那通过Guice怎么实现依赖注入呢?首先咱们须要通知Guice如果找到接口对应的实现类,这个能够通过模块 来实现:

public class BillingModule extends AbstractModule {
  @Override
  protected void configure() {
    bind(TransactionLog.class).to(DatabaseTransactionLog.class);
    bind(CreditCardProcessor.class).to(PaypalCreditCardProcessor.class);
    bind(BillingService.class).to(RealBillingService.class);
  }
}

这里的模块只须要实现Module接口或继承自AbstractModule,而后在configure办法中设置绑定 (前面会持续介绍)即可。而后只需在原有的构造方法中减少@Inject注解即可注入 :

public class RealBillingService implements BillingService {
  private final CreditCardProcessor processor;
  private final TransactionLog transactionLog;

  @Inject
  public RealBillingService(CreditCardProcessor processor,
      TransactionLog transactionLog) {
    this.processor = processor;
    this.transactionLog = transactionLog;
  }

  public Receipt chargeOrder(PizzaOrder order, CreditCard creditCard) {
    try {
      ChargeResult result = processor.charge(creditCard, order.getAmount());
      transactionLog.logChargeResult(result);

      return result.wasSuccessful()
          ? Receipt.forSuccessfulCharge(order.getAmount())
          : Receipt.forDeclinedCharge(result.getDeclineMessage());
     } catch (UnreachableException e) {
      transactionLog.logConnectException(e);
      return Receipt.forSystemFailure(e.getMessage());
    }
  }
}

最初,再看看main办法中是如何调用的:

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

绑定
连贯绑定
连贯绑定是最罕用的绑定形式,它将一个类型和它的实现进行映射。上面的例子中将TransactionLog接口映射到它的实现类DatabaseTransactionLog。

public class BillingModule extends AbstractModule {
  @Override
  protected void configure() {
    bind(TransactionLog.class).to(DatabaseTransactionLog.class);
  }
}

连贯绑定还反对链式,比方上面的例子最终将TransactionLog接口映射到实现类MySqlDatabaseTransactionLog。

public class BillingModule extends AbstractModule {
  @Override
  protected void configure() {
    bind(TransactionLog.class).to(DatabaseTransactionLog.class);
    bind(DatabaseTransactionLog.class).to(MySqlDatabaseTransactionLog.class);
  }
}

注解绑定
通过一个类型可能存在多个实现,比方在信用卡领取处理器中存在PayPal的领取和Google领取,这样通过连贯绑定就搞不定。这时咱们能够通过注解绑定来实现:

@BindingAnnotation
@Target({ FIELD, PARAMETER, METHOD })
@Retention(RUNTIME)
public @interface PayPal {}

public class RealBillingService implements BillingService {

  @Inject
  public RealBillingService(@PayPal CreditCardProcessor processor,
      TransactionLog transactionLog) {
    …
  }
}

// 当注入的办法参数存在@PayPal注解时注入PayPalCreditCardProcessor实现
bind(CreditCardProcessor.class).annotatedWith(PayPal.class).to(PayPalCreditCardProcessor.class);

能够看到在模块的绑定时用annotatedWith办法指定具体的注解来进行绑定,这种形式有一个问题就是咱们必须减少自定义的注解来绑定,基于此Guice内置了一个@Named注解满足该场景:

public class RealBillingService implements BillingService {

  @Inject
  public RealBillingService(@Named(“Checkout”) CreditCardProcessor processor,
      TransactionLog transactionLog) {
    …
  }
}

// 当注入的办法参数存在@Named注解且值为Checkout时注入CheckoutCreditCardProcessor实现
bind(CreditCardProcessor.class).annotatedWith(Names.named(“Checkout”)).to(CheckoutCreditCardProcessor.class);

实例绑定
将一个类型绑定到一个具体的实例而非实现类,这个通过是在无依赖的对象(比方值对象)中应用。如果toInstance蕴含简单的逻辑会导致启动速度,此时应该通过@Provides办法绑定。

bind(String.class).annotatedWith(Names.named(“JDBC URL”)).toInstance(“jdbc:mysql://localhost/pizza”);
bind(Integer.class).annotatedWith(Names.named(“login timeout seconds”)).toInstance(10);

@Provides办法绑定
模块中定义的、带有@Provides注解的、办法返回值即为绑定映射的类型。

public class BillingModule extends AbstractModule {
  @Override
  protected void configure() {
    …
  }

  @Provides
  TransactionLog provideTransactionLog() {
    DatabaseTransactionLog transactionLog = new DatabaseTransactionLog();
    transactionLog.setJdbcUrl(“jdbc:mysql://localhost/pizza”);
    transactionLog.setThreadPoolSize(30);
    return transactionLog;
  }

  @Provides @PayPal
  CreditCardProcessor providePayPalCreditCardProcessor(@Named(“PayPal API key”) String apiKey) {
    PayPalCreditCardProcessor processor = new PayPalCreditCardProcessor();
    processor.setApiKey(apiKey);
    return processor;
  }
}

Provider绑定
如果应用@Provides办法绑定逻辑越来越简单时就能够通过Provider绑定(一个实现了Provider接口的实现类)来实现。

public interface Provider<T> {
  T get();
}

public class DatabaseTransactionLogProvider implements Provider<TransactionLog> {
  private final Connection connection;

  @Inject
  public DatabaseTransactionLogProvider(Connection connection) {
    this.connection = connection;
  }

  public TransactionLog get() {
    DatabaseTransactionLog transactionLog = new DatabaseTransactionLog();
    transactionLog.setConnection(connection);
    return transactionLog;
  }
}

public class BillingModule extends AbstractModule {
  @Override
  protected void configure() {
    bind(TransactionLog.class).toProvider(DatabaseTransactionLogProvider.class);
  }
}

无指标绑定
当咱们想提供对一个具体的类给注入器时就能够采纳无指标绑定。

bind(MyConcreteClass.class);
bind(AnotherConcreteClass.class).in(Singleton.class);

结构器绑定
3.0新增的绑定,实用于第三方提供的类或者是有多个结构器参加依赖注入。通过@Provides办法能够显式调用结构器,然而这种形式有一个限度:无奈给这些实例利用AOP。

public class BillingModule extends AbstractModule {
  @Override
  protected void configure() {
    try {
      bind(TransactionLog.class).toConstructor(DatabaseTransactionLog.class.getConstructor(DatabaseConnection.class));
    } catch (NoSuchMethodException e) {
      addError(e);
    }
  }
}

范畴
默认状况下,Guice每次都会返回一个新的实例,这个能够通过范畴(Scope)来配置。常见的范畴有单例(@Singleton)、会话(@SessionScoped)和申请(@RequestScoped),另外还能够通过自定义的范畴来扩大。

范畴的注解能够应该在实现类、@Provides办法中,或在绑定的时候指定(优先级最高):

@Singleton
public class InMemoryTransactionLog implements TransactionLog {
  / everything here should be threadsafe! /
}

// scopes apply to the binding source, not the binding target
bind(TransactionLog.class).to(InMemoryTransactionLog.class).in(Singleton.class);

@Provides @Singleton
TransactionLog provideTransactionLog() {
    …
}

另外,Guice还有一种非凡的单例模式叫饥饿单例(绝对于懒加载单例来说):

// Eager singletons reveal initialization problems sooner,
// and ensure end-users get a consistent, snappy experience.
bind(TransactionLog.class).to(InMemoryTransactionLog.class).asEagerSingleton();

注入
依赖注入的要求就是将行为和依赖拆散,它倡议将依赖注入而非通过工厂类的办法去查找。注入的形式通常有结构器注入、办法注入、属性注入等。

// 结构器注入
public class RealBillingService implements BillingService {
  private final CreditCardProcessor processorProvider;
  private final TransactionLog transactionLogProvider;

  @Inject
  public RealBillingService(CreditCardProcessor processorProvider,
      TransactionLog transactionLogProvider) {
    this.processorProvider = processorProvider;
    this.transactionLogProvider = transactionLogProvider;
  }
}

// 办法注入
public class PayPalCreditCardProcessor implements CreditCardProcessor {
  private static final String DEFAULT_API_KEY = “development-use-only”;
  private String apiKey = DEFAULT_API_KEY;

  @Inject
  public void setApiKey(@Named(“PayPal API key”) String apiKey) {
    this.apiKey = apiKey;
  }
}

// 属性注入
public class DatabaseTransactionLogProvider implements Provider<TransactionLog> {
  @Inject Connection connection;

  public TransactionLog get() {
    return new DatabaseTransactionLog(connection);
  }
}

// 可选注入:当找不到映射时不报错
public class PayPalCreditCardProcessor implements CreditCardProcessor {
  private static final String SANDBOX_API_KEY = “development-use-only”;
  private String apiKey = SANDBOX_API_KEY;

  @Inject(optional=true)
  public void setApiKey(@Named(“PayPal API key”) String apiKey) {
    this.apiKey = apiKey;
  }
}

辅助注入
辅助注入(Assisted Inject)属于Guice扩大的一部分,它通过@Assisted注解主动生成工厂来增强非注入参数的应用。

// RealPayment中有两个参数startDate和amount无奈间接注入
public class RealPayment implements Payment {
  public RealPayment(
        CreditService creditService,  // from the Injector
        AuthService authService,  // from the Injector
        Date startDate, // from the instance’s creator
        Money amount); // from the instance’s creator
  }
  …
}

// 一种形式是减少一个工厂来结构
public interface PaymentFactory {
  public Payment create(Date startDate, Money amount);
}

public class RealPaymentFactory implements PaymentFactory {
  private final Provider<CreditService> creditServiceProvider;
  private final Provider<AuthService> authServiceProvider;

  @Inject
  public RealPaymentFactory(Provider<CreditService> creditServiceProvider,
      Provider<AuthService> authServiceProvider) {
    this.creditServiceProvider = creditServiceProvider;
    this.authServiceProvider = authServiceProvider;
  }

  public Payment create(Date startDate, Money amount) {
    return new RealPayment(creditServiceProvider.get(),
      authServiceProvider.get(), startDate, amount);
  }
}

bind(PaymentFactory.class).to(RealPaymentFactory.class);

// 通过@Assisted注解能够缩小RealPaymentFactory
public class RealPayment implements Payment {
  @Inject
  public RealPayment(
        CreditService creditService,
        AuthService authService,
        @Assisted Date startDate,
        @Assisted Money amount);
  }
  …
}

// Guice 2.0
//bind(PaymentFactory.class).toProvider(FactoryProvider.newFactory(PaymentFactory.class, RealPayment.class));
// Guice 3.0
install(new FactoryModuleBuilder().implement(Payment.class, RealPayment.class).build(PaymentFactory.class));

最佳实际

最小化可变性:尽可能注入的是不可变对象;
只注入间接依赖:不必注入一个实例来获取真正须要的实例,减少复杂性且不易测试;
防止循环依赖
防止动态状态:动态状态和可测试性就是天敌;
采纳@Nullable:Guice默认状况下禁止注入null对象;
模块的解决必须要快并且无副作用
在Providers绑定中当心IO问题:因为Provider不查看异样、不反对超时、不反对重试;
不必在模块中解决分支逻辑
尽可能不要裸露结构器

起源:zhuanlan.zhihu.com/p/24924391

【腾讯云】云产品限时秒杀,爆款1核2G云服务器,首年50元

阿里云限时活动-2核2G-5M带宽-60G SSD-1000G月流量 ,特惠价99元/年(原价1234.2元/年,可以直接买3年),速抢

本文由乐趣区整理发布,转载请注明出处,谢谢。

您可能还喜欢...

发表评论

您的电子邮箱地址不会被公开。

此站点使用Akismet来减少垃圾评论。了解我们如何处理您的评论数据