Google Guice 3.0 入門介紹

檸檬冰啡咖 2018-01-26

展開全文

一. 概述

Guice是一個輕量級的DI框架。本文對Guice的基本用法作以介紹。

本文的所有例子基于Guice 3.0

本文的很多代碼來源于Guice主頁：http://code.google.com/p/google-guice/wiki/GettingStarted

考慮到是入門介紹，本文中并未涉及到AOP相關(guān)內(nèi)容，如有需要還請參考上面鏈接。

二. 舉例說明Guice的用法

Guice本身只是一個輕量級的DI框架，首先我們通過一個例子來看看怎么使用Guice。

首先有一個需要被實現(xiàn)的接口：

[java] view plain copy print?
public interface BillingService {  
  
  /** 
   * Attempts to charge the order to the credit card. Both successful and 
   * failed transactions will be recorded. 
   * 
   * @return a receipt of the transaction. If the charge was successful, the 
   *      receipt will be successful. Otherwise, the receipt will contain a 
   *      decline note describing why the charge failed. 
   */  
  Receipt chargeOrder(PizzaOrder order, CreditCard creditCard);  
}

然后，有一個實現(xiàn)該接口的實現(xiàn)類：

[java] view plain copy print?
class RealBillingService implements BillingService {  
  private final CreditCardProcessor processor;  
  private final TransactionLog transactionLog;  
  
  @Inject  
  RealBillingService(CreditCardProcessor processor,   
      TransactionLog transactionLog) {  
    this.processor = processor;  
    this.transactionLog = transactionLog;  
  }  
  
  @Override  
  public Receipt chargeOrder(PizzaOrder order, CreditCard creditCard) {  
    ...  
  }  
}

現(xiàn)在接口有了，實現(xiàn)類也有了，接下來就是如何將接口和實現(xiàn)類關(guān)聯(lián)的問題了，在Guice中需要定義Module來進行關(guān)聯(lián)

[java] view plain copy print?
public class BillingModule extends AbstractModule {  
  @Override   
  protected void configure() {  
  
     /* 
      * This tells Guice that whenever it sees a dependency on a TransactionLog, 
      * it should satisfy the dependency using a DatabaseTransactionLog. 
      */  
    bind(TransactionLog.class).to(DatabaseTransactionLog.class);  
  
     /* 
      * Similarly, this binding tells Guice that when CreditCardProcessor is used in 
      * a dependency, that should be satisfied with a PaypalCreditCardProcessor. 
      */  
    bind(CreditCardProcessor.class).to(PaypalCreditCardProcessor.class);  
  }  
}

好了，現(xiàn)在萬事俱備，就讓我們一起看看怎么使用Guice進行依賴注入吧：

[java] view plain copy print?
public static void main(String[] args) {  
   /* 
    * Guice.createInjector() takes your Modules, and returns a new Injector 
    * instance. Most applications will call this method exactly once, in their 
    * main() method. 
    */  
   Injector injector = Guice.createInjector(new BillingModule());  
  
   /* 
    * Now that we've got the injector, we can build objects. 
    */  
   RealBillingService billingService = injector.getInstance(RealBillingService.class);  
   ...  
 }

以上就是使用Guice的一個完整的例子，很簡單吧，不需要繁瑣的配置，只需要定義一個Module來表述接口和實現(xiàn)類，以及父類和子類之間的關(guān)聯(lián)關(guān)系的綁定。本文不對比guice和spring，只是單純介紹Guice的用法。

三. 綁定方式的介紹

從上面我們可以看出，其實對于Guice而言，程序員所要做的，只是創(chuàng)建一個代表關(guān)聯(lián)關(guān)系的Module，然后使用這個Module即可得到對應(yīng)關(guān)聯(lián)的對象。因此，主要的問題其實就是在如何關(guān)聯(lián)實現(xiàn)類和接口（子類和父類）。

1. 在自定義的Module類中進行綁定

1.1 在configure方法中綁定

1.1.1 鏈式綁定

鏈式綁定是最簡單，最直接，也是使用最多的綁定方式。

[java] view plain copy print?
protected void configure() {  
  bind(TransactionLog.class).to(DatabaseTransactionLog.class);  
}

就是直接把一種類型的class對象綁定到另外一種類型的class對象，這樣，當外界獲取TransactionLog時，其實返回的就是一個DatabaseTransactionLog對象。當然，鏈式綁定也可以串起來，如：

[java] view plain copy print?
protected void configure() {  
  bind(TransactionLog.class).to(DatabaseTransactionLog.class);  
  bind(DatabaseTransactionLog.class).to(MySqlDatabaseTransactionLog.class);  
}

這樣，當外界請求TransactionLog時，其實返回的就會是一個MySqlDatabaseTransactionLog對象。

1.1.2 注解（Annotations）綁定

鏈式綁定針對于同樣的類型都綁定到同一種目標類型時，非常好用，但是對于一個接口有多種實現(xiàn)的時候，鏈式綁定就不好區(qū)分該用哪種實現(xiàn)了?？梢园袮nnotations綁定方式看作是鏈式綁定的一種擴展，專門用來解決這種同一個接口有多種實現(xiàn)的問題。Annotations綁定又可以分為兩種，一種是需要自己寫Annotations，另外一種則簡化了一些。

1.1.2.1 自己寫Annotations的方式

首先，寫一個注解

[java] view plain copy print?
import com.google.inject.BindingAnnotation;  
import java.lang.annotation.Target;  
import java.lang.annotation.Retention;  
import static java.lang.annotation.RetentionPolicy.RUNTIME;  
import static java.lang.annotation.ElementType.PARAMETER;  
import static java.lang.annotation.ElementType.FIELD;  
import static java.lang.annotation.ElementType.METHOD;  
  
@BindingAnnotation @Target({ FIELD, PARAMETER, METHOD }) @Retention(RUNTIME)  
public @interface PayPal {}

然后，使用這個注解去修飾目標字段或參數(shù)，如：

[java] view plain copy print?
public class RealBillingService implements BillingService {  
  
  @Inject  
  public RealBillingService(@PayPal CreditCardProcessor processor,  
      TransactionLog transactionLog) {  
    ...  
  }  
｝

或

[java] view plain copy print?
public class RealBillingService implements BillingService {  
  @Inject  
  @Www  
  private CreditCardProcessor processor;  
  ...  
}

最后，在我們進行鏈式綁定時，就可以區(qū)分一個接口的不同實現(xiàn)了，如：

[java] view plain copy

print?

bind(CreditCardProcessor.class)
.annotatedWith(PayPal.class)
.to(PayPalCreditCardProcessor.class);

這樣，被Annotations PayPal?修飾的CreditCardProcessor就會被綁定到目標實現(xiàn)類PayPalCreditCardProcessor。如果有其他的實現(xiàn)類，則可把用不同Annotations修飾的CreditCardProcessor綁定到不同的實現(xiàn)類

1.1.2.2 使用@Named的方式

使用@Named的方式和上面自己寫Annotation的方式很類似，只不過做了相應(yīng)的簡化，不再需要自己去寫Annotation了。

[java] view plain copy print?
public class RealBillingService implements BillingService {  
  
  @Inject  
  public RealBillingService(@Named("Checkout") CreditCardProcessor processor,  
      TransactionLog transactionLog) {  
    ...  
  }

直接使用@Named修飾要注入的目標，并起個名字，下面就可以把用這個名字的注解修飾的接口綁定到目標實現(xiàn)類了

[java] view plain copy print?
bind(CreditCardProcessor.class)  
    .annotatedWith(Names.named("Checkout"))  
    .to(CheckoutCreditCardProcessor.class);

1.1.3 實例綁定

上面介紹的鏈式綁定是把接口的class對象綁定到實現(xiàn)類的class對象，而實例綁定則可以看作是鏈式綁定的一種特例，它直接把一個實例對象綁定到它的class對象上。

[java] view plain copy

print?

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

需要注意的是，實例綁定要求對象不能包含對自己的引用。并且，盡量不要對那種創(chuàng)建實例比較復(fù)雜的類使用實例綁定，否則會讓應(yīng)用啟動變慢

1.1.4 Provider綁定

在下面會介紹基于@Provides方法的綁定。其實Provider綁定是基于@Provides方法綁定的后續(xù)發(fā)展，所以應(yīng)該在介紹完基于@Provides方法綁定之后再來介紹，不過因為Provider綁定也是在configure方法中完成的，而本文又是按照綁定的位置來組織的，因為就把Provider綁定放在這了，希望大家先跳到后面看過基于@Provides方法的綁定再回來看這段。

在使用基于@Provides方法綁定的過程中，如果方法中創(chuàng)建對象的過程很復(fù)雜，我們就會考慮，是不是可以把它獨立出來，形成一個專門作用的類。Guice提供了一個接口：

[java] view plain copy print?
public interface Provider {  
  T get();  
}

實現(xiàn)這個接口，我們就會得到專門為了創(chuàng)建相應(yīng)類型對象所需的類：

[java] view plain copy print?
public class DatabaseTransactionLogProvider implements Provider {  
  private final Connection connection;  
  
  @Inject  
  public DatabaseTransactionLogProvider(Connection connection) {  
    this.connection = connection;  
  }  
  
  public TransactionLog get() {  
    DatabaseTransactionLog transactionLog = new DatabaseTransactionLog();  
    transactionLog.setConnection(connection);  
    return transactionLog;  
  }  
}

這樣以來，我們就可以在configure方法中，使用toProvider方法來把一種類型綁定到具體的Provider類。當需要相應(yīng)類型的對象時，Provider類就會調(diào)用其get方法獲取所需的對象。

其實，個人感覺在configure方法中使用Provider綁定和直接寫@Provides方法所實現(xiàn)的功能是沒有差別的，不過使用Provider綁定會使代碼更清晰。而且當提供對象的方法中也需要有其他類型的依賴注入時，使用Provider綁定會是更好的選擇。

1.1.5 無目標綁定

無目標綁定是鏈接綁定的一種特例，在綁定的過程中不指明目標，如：

[java] view plain copy print?
bind(MyConcreteClass.class);  
bind(AnotherConcreteClass.class).in(Singleton.class);

如果使用注解綁定的話，就不能用無目標綁定，必須指定目標，即使目標是它自己。如：

[java] view plain copy

print?

bind(MyConcreteClass.class).annotatedWith(Names.named("foo")).to(MyConcreteClass.class);
bind(AnotherConcreteClass.class).annotatedWith(Names.named("foo")).to(AnotherConcreteClass.class).in(Singleton.class);

無目標綁定，主要是用于與被@ImplementedBy 或者 @ProvidedBy修飾的類型一起用。如果無目標綁定的類型不是被@ImplementedBy 或者 @ProvidedBy修飾的話，該類型一定不能只提供有參數(shù)的構(gòu)造函數(shù)，要么不提供構(gòu)造函數(shù)，要么提供的構(gòu)造函數(shù)中必須有無參構(gòu)造函數(shù)。因為guice會默認去調(diào)用該類型的無參構(gòu)造函數(shù)。

1.1.6 指定構(gòu)造函數(shù)綁定

在configure方法中，將一種類型綁定到另外一種類型的過程中，指定目標類型用那種構(gòu)造函數(shù)生成對象。

[java] view plain copy print?
public class BillingModule extends AbstractModule {  
  @Override   
  protected void configure() {  
    try {  
      bind(TransactionLog.class).toConstructor(  
          DatabaseTransactionLog.class.getConstructor(DatabaseConnection.class));  
    } catch (NoSuchMethodException e) {  
      addError(e);  
    }  
  }  
}

這種綁定方式主要用于不方便用注解@Inject修飾目標類型的構(gòu)造函數(shù)的時候。比如說目標類型是第三方提供的類型，或者說目標類型中有多個構(gòu)造函數(shù)，并且可能會在不同情況采用不同的構(gòu)造函數(shù)。

1.1.7 Built-in綁定

Built-in綁定指的是不用程序員去指定，Guice會自動去做的綁定。目前，Guice所支持的Built-in綁定只有對java.util.logging.Logger的綁定。個人感覺，所謂的Built-in綁定，只是在比較普遍的東西上為大家?guī)矸奖愕囊环N做法。

[java] view plain copy print?
@Singleton  
public class ConsoleTransactionLog implements TransactionLog {  
  
  private final Logger logger;  
  
  @Inject  
  public ConsoleTransactionLog(Logger logger) {  
    this.logger = logger;  
  }  
  
  public void logConnectException(UnreachableException e) {  
    /* the message is logged to the "ConsoleTransacitonLog" logger */  
    logger.warning("Connect exception failed, " + e.getMessage());  
  }

1.2 在@Provides方法中進行綁定

當你只是需要在需要的時候，產(chǎn)生相應(yīng)類型的對象的話，@Provides Methods是個不錯的選擇。方法返回的類型就是要綁定的類型。這樣當需要創(chuàng)建一個該類型的對象時，該provide方法會被調(diào)用，從而得到一個該類型的對象。

[java] view plain copy print?
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;  
  }  
}

需要注意的是Provide方法必須被@Provides所修飾。同時，@Provides方法綁定方式是可以和上面提到的注解綁定混合使用的，如：

[java] view plain copy print?
@Provides @PayPal  
CreditCardProcessor providePayPalCreditCardProcessor(  
    @Named("PayPal API key") String apiKey) {  
  PayPalCreditCardProcessor processor = new PayPalCreditCardProcessor();  
  processor.setApiKey(apiKey);  
  return processor;  
}

這樣一來，只有被@PayPal修飾的CreditCardProcessor對象才會使用provide方法來創(chuàng)建對象，同時

2. 在父類型中進行綁定

2.1 @ImplementedBy

在定義父類型的時候，直接指定子類型的方式。
這種方式其實和鏈式綁定的效果是完全一樣的，只是聲明綁定的位置不同。
和鏈式綁定不同的是它們的優(yōu)先級，@ImplementedBy實現(xiàn)的是一種default綁定，當同時存在@ImplementedBy和鏈式綁定時，鏈式綁定起作用。

[java] view plain copy print?
@ImplementedBy(PayPalCreditCardProcessor.class)  
public interface CreditCardProcessor {  
  ChargeResult charge(String amount, CreditCard creditCard)  
      throws UnreachableException;  
}

等價于：

[java] view plain copy print?
bind(CreditCardProcessor.class).to(PayPalCreditCardProcessor.class);

2.2 @ProvidedBy

在定義類型的時候直接指定子類型的Provider類。

[java] view plain copy print?
@ProvidedBy(DatabaseTransactionLogProvider.class)  
public interface TransactionLog {  
  void logConnectException(UnreachableException e);  
  void logChargeResult(ChargeResult result);  
}

等價于:

[java] view plain copy print?
bind(TransactionLog.class)  
    .toProvider(DatabaseTransactionLogProvider.class);

并且，和@ImplementedBy類似，@ProvidedBy的優(yōu)先級也比較低，是一種默認實現(xiàn)，當@ProvidedBy和toProvider函數(shù)兩種綁定方式并存時，后者有效。

3. 在子類型中進行注入

3.1 構(gòu)造函數(shù)注入

在構(gòu)造函數(shù)綁定中，Guice要求目標類型要么有無參構(gòu)造函數(shù)，要么有被@Inject注解修飾的構(gòu)造函數(shù)。這樣，當需要創(chuàng)建該類型的對象時，Guice可以幫助進行相應(yīng)的綁定，從而生成對象。在Guice創(chuàng)建對象的過程中，其實就是調(diào)用該類型被@Inject注解修飾的構(gòu)造函數(shù)，如果沒要@Inject注解修飾的構(gòu)造函數(shù)，則調(diào)用無參構(gòu)造函數(shù)。在使用構(gòu)造函數(shù)綁定時，無需再在Module中定義任何綁定關(guān)系。

這里需要注意的是，Guice在創(chuàng)建對象的過程中，無法初始化該類型的內(nèi)部類（除非內(nèi)部類有static修飾符），因為內(nèi)部類會有隱含的對外部類的引用，Guice無法處理。

[java] view plain copy print?
public class PayPalCreditCardProcessor implements CreditCardProcessor {  
  private final String apiKey;  
  
  @Inject  
  public PayPalCreditCardProcessor(@Named("PayPal API key") String apiKey) {  
    this.apiKey = apiKey;  
  }

3.2 屬性注入

屬性綁定的目的是告訴Guice，當創(chuàng)建該類型的對象時，哪些屬性也需要進行依賴注入。用一個例子來看：
首先，有一個接口：

[java] view plain copy print?
package guice.test;  
  
import com.google.inject.ImplementedBy;;  
  
@ImplementedBy (SayHello.class)  
public interface Talk {  
    public void sayHello();  
}

該接口指明了它的實現(xiàn)類SayHello

[java] view plain copy print?
package guice.test;  
  
public class SayHello implements Talk{  
    @Override  
    public void sayHello() {  
        System.out.println("Say Hello!");  
          
    }  
}

接下來就是屬性注入的例子：

[java] view plain copy print?
package guice.test;  
  
import com.google.inject.Inject;  
  
public class FieldDI {  
    @Inject  
    private Talk bs;  
  
    public Talk getBs() {  
        return bs;  
    }  
}

這里面，指明熟悉Talk類型的bs將會被注入。使用的例子是：

[java] view plain copy print?
package guice.test;  
  
import com.google.inject.Guice;  
import com.google.inject.Injector;  
  
public class Test {  
     public static void main(String[] args) {  
  
            Injector injector = Guice.createInjector(new BillingModule());  
  
              
            FieldDI fdi = injector.getInstance(FieldDI.class);  
            fdi.getBs().sayHello();  
          }  
}

如果我們沒有用@Inject修飾Talk bs的話，就會得到如下錯誤：

Exception in thread "main" java.lang.NullPointerException

如果我們用@Inject修飾Talk bs了，但是Talk本身沒有被@ImplementedBy修飾的話，會得到如下錯誤：

[java] view plain copy print?
Exception in thread "main" com.google.inject.ConfigurationException: Guice configuration errors:  
  
1) No implementation for guice.test.Talk was bound.  
  while locating guice.test.Talk  
    for field at guice.test.FieldDI.bs(FieldDI.java:5)  
  while locating guice.test.FieldDI  
  
1 error  
    at com.google.inject.internal.InjectorImpl.getProvider(InjectorImpl.java:1004)  
    at com.google.inject.internal.InjectorImpl.getProvider(InjectorImpl.java:961)  
    at com.google.inject.internal.InjectorImpl.getInstance(InjectorImpl.java:1013)  
    at guice.test.Test.main(Test.java:24)

另外，屬性注入的一種特例是注入provider。如：

[java] view plain copy print?
public class RealBillingService implements BillingService {  
  private final Provider processorProvider;  
  private final Provider transactionLogProvider;  
  
  @Inject  
  public RealBillingService(Provider processorProvider,  
      Provider transactionLogProvider) {  
    this.processorProvider = processorProvider;  
    this.transactionLogProvider = transactionLogProvider;  
  }  
  
  public Receipt chargeOrder(PizzaOrder order, CreditCard creditCard) {  
    CreditCardProcessor processor = processorProvider.get();  
    TransactionLog transactionLog = transactionLogProvider.get();  
  
    /* use the processor and transaction log here */  
  }  
}

其中，Provider的定義如下：

[java] view plain copy print?
public interface Provider {  
  T get();  
}

3.3 Setter方法注入

有了上面的基礎(chǔ)我們再來看Setter注入就非常簡單了，只不過在setter方法上增加一個@Inject注解而已。還是上面的例子，只是有一點修改：

[java] view plain copy print?
package guice.test;  
  
import com.google.inject.Inject;  
  
public class FieldDI {  
  
    @Inject  
    public void setBs(Talk bs) {  
        this.bs = bs;  
    }  
  
    private Talk bs;  
  
    public Talk getBs() {  
        return bs;  
    }  
}

四. 對象產(chǎn)生的Scopes

在默認情況下，每次通過Guice去請求對象時，都會得到一個新的對象，這種行為是通過Scopes去配置的。
Scope的配置使得我們重用對象的需求變得可能。目前，Guice支持的Scope有@Singleton, @SessionScoped, @RequestScoped。
同樣，程序員也可以自定義自己的Scope，本文不涉及自定義scope，如果有興趣，請參考：http://code.google.com/p/google-guice/wiki/CustomScopes

下面我們就以@Singleton舉例說明怎么來告訴Guice我們要以@Singleton的方式產(chǎn)生對象：1. 在定義子類型時聲明

[java] view plain copy print?
@Singleton  
public class InMemoryTransactionLog implements TransactionLog {  
  /* everything here should be threadsafe! */  
}

2.在module的configure方法中做綁定時聲明

 bind(TransactionLog.class).to(InMemoryTransactionLog.class).in(Singleton.class);

3.在module的Provides方法里聲明

[java] view plain copy print?
@Provides @Singleton  
TransactionLog provideTransactionLog() {  
  ...  
}

這里有一點需要注意的是，如果發(fā)生下面的情況：

[java] view plain copy print?
bind(Bar.class).to(Applebees.class).in(Singleton.class);  
bind(Grill.class).to(Applebees.class).in(Singleton.class);

這樣一共會生成2個Applebees對象，一個給Bar用，一個給Grill用。如果在上面的配置的情況下，還有下面的配置，

[java] view plain copy

print?

bind(Applebees.class).in(Singleton.class);

這樣一來，Bar和Grill就會共享同樣的對象了。

本站是提供個人知識管理的網(wǎng)絡(luò)存儲空間，所有內(nèi)容均由用戶發(fā)布，不代表本站觀點。請注意甄別內(nèi)容中的聯(lián)系方式、誘導(dǎo)購買等信息，謹防詐騙。如發(fā)現(xiàn)有害或侵權(quán)內(nèi)容，請點擊一鍵舉報。

轉(zhuǎn)藏 分享

QQ空間 QQ好友新浪微博微信

獻花（0） +1

來自：檸檬冰啡咖 > 《Guice》

舉報/認領(lǐng)

0條評論

發(fā)表

請遵守用戶評論公約

類似文章 更多

檸檬冰啡咖

關(guān)注對話

TA的最新館藏

Android屏幕密度（Density）和分辨率的解釋
tty驅(qū)動程序框架
[轉(zhuǎn)] TTY的那些事兒
讀懂籌碼分布運用
[轉(zhuǎn)] 陳浩----籌碼分布講義完全版
[轉(zhuǎn)] CYQ籌碼分布指標 - 指標公式分享交流區(qū) - 股參網(wǎng) www.stockre.com|專...

喜歡該文的人也喜歡更多

熱門閱讀換一換

乡下人产国偷v产偷v自拍,国产午夜片在线观看,婷婷成人亚洲综合国产麻豆,久久综合给合久久狠狠狠9

Google Guice 3.0 入門介紹

一. 概述

二. 舉例說明Guice的用法

三. 綁定方式的介紹

1. 在自定義的Module類中進行綁定

1.1 在configure方法中綁定

1.1.1 鏈式綁定

1.1.2 注解（Annotations）綁定

1.1.2.1 自己寫Annotations的方式

1.1.2.2 使用@Named的方式

1.1.3 實例綁定

1.1.4 Provider綁定

1.1.5 無目標綁定

1.1.6 指定構(gòu)造函數(shù)綁定

1.1.7 Built-in綁定

1.2 在@Provides方法中進行綁定

2. 在父類型中進行綁定

2.1 @ImplementedBy

2.2 @ProvidedBy

3. 在子類型中進行注入

3.1 構(gòu)造函數(shù)注入

3.2 屬性注入

3.3 Setter方法注入

四. 對象產(chǎn)生的Scopes