Google-Guice入門介紹

jopen 10年前發布 | 63K 次閱讀面向方面AOP/IoC Google-Guice
一. 概述

Guice是一個輕量級的DI框架。本文對Guice的基本用法作以介紹。
本文的所有例子基于Guice 3.0
本文的很多代碼來源于Guice主頁：http://code.google.com/p/google-guice/wiki/GettingStarted
考慮到是入門介紹，本文中并未涉及到AOP相關內容，如有需要還請參考上面鏈接。
二. 舉例說明Guice的用法

Guice本身只是一個輕量級的DI框架，首先我們通過一個例子來看看怎么使用Guice。
首先有一個需要被實現的接口：
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);
}</pre>

然后，有一個實現該接口的實現類：
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) {
...
}
}</pre>



現在接口有了，實現類也有了，接下來就是如何將接口和實現類關聯的問題了，在Guice中需要定義Module來進行關聯
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);
}
}</pre>



好了，現在萬事俱備，就讓我們一起看看怎么使用Guice進行依賴注入吧：
 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);
...
}</pre>



以上就是使用Guice的一個完整的例子，很簡單吧，不需要繁瑣的配置，只需要定義一個Module來表述接口和實現類，以及父類和子類之間的關聯關系的綁定。本文不對比guice和spring，只是單純介紹Guice的用法。
三. 綁定方式的介紹 
從上面我們可以看出，其實對于Guice而言，程序員所要做的，只是創建一個代表關聯關系的Module，然后使用這個Module即可得到對應關聯的對象。因此，主要的問題其實就是在如何關聯實現類和接口（子類和父類）。
1. 在自定義的Module類中進行綁定 
1.1 在configure方法中綁定 
1.1.1 鏈式綁定 
鏈式綁定是最簡單，最直接，也是使用最多的綁定方式。
  protected void configure() {
bind(TransactionLog.class).to(DatabaseTransactionLog.class);
}
 就是直接把一種類型的class對象綁定到另外一種類型的class對象，這樣，當外界獲取TransactionLog時，其實返回的就是一個DatabaseTransactionLog對象。當然，鏈式綁定也可以串起來，如：
  protected void configure() {
bind(TransactionLog.class).to(DatabaseTransactionLog.class);
bind(DatabaseTransactionLog.class).to(MySqlDatabaseTransactionLog.class);
}
這樣，當外界請求TransactionLog時，其實返回的就會是一個MySqlDatabaseTransactionLog對象。
1.1.2 注解（Annotations）綁定 
鏈式綁定針對于同樣的類型都綁定到同一種目標類型時，非常好用，但是對于一個接口有多種實現的時候，鏈式綁定就不好區分該用哪種實現了。可以把Annotations綁定方式看作是鏈式綁定的一種擴展，專門用來解決這種同一個接口有多種實現的問題。Annotations綁定又可以分為兩種，一種是需要自己寫Annotations，另外一種則簡化了一些。1.1.2.1 自己寫Annotations的方式 
首先，寫一個注解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 {}</pre>然后，使用這個注解去修飾目標字段或參數，如：
public class RealBillingService implements BillingService {
@Inject
  public RealBillingService(@PayPal CreditCardProcessor processor,
      TransactionLog transactionLog) {
    ...
  }
｝</pre>或
public class RealBillingService implements BillingService {
  @Inject
  @Www
  private CreditCardProcessor processor;
  ...
}
 最后，在我們進行鏈式綁定時，就可以區分一個接口的不同實現了，如：


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

1.1.2.2 使用@Named的方式 
使用@Named的方式和上面自己寫Annotation的方式很類似，只不過做了相應的簡化，不再需要自己去寫Annotation了。public class RealBillingService implements BillingService {
@Inject
  public RealBillingService(@Named("Checkout") CreditCardProcessor processor,
      TransactionLog transactionLog) {
    ...
  }</pre>

直接使用@Named修飾要注入的目標，并起個名字，下面就可以把用這個名字的注解修飾的接口綁定到目標實現類了
    bind(CreditCardProcessor.class)
        .annotatedWith(Names.named("Checkout"))
        .to(CheckoutCreditCardProcessor.class);



1.1.3 實例綁定 

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


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



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

1.1.4 Provider綁定 
在下面會介紹基于@Provides方法的綁定。其實Provider綁定是基于@Provides方法綁定的后續發展，所以應該在介紹完基于@Provides方法綁定之后再來介紹，不過因為Provider綁定也是在configure方法中完成的，而本文又是按照綁定的位置來組織的，因為就把Provider綁定放在這了，希望大家先跳到后面看過基于@Provides方法的綁定再回來看這段。在使用基于@Provides方法綁定的過程中，如果方法中創建對象的過程很復雜，我們就會考慮，是不是可以把它獨立出來，形成一個專門作用的類。Guice提供了一個接口：

public interface Provider {
  T get();
}


實現這個接口，我們就會得到專門為了創建相應類型對象所需的類：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;
  }
}</pre>

這樣以來，我們就可以在configure方法中，使用toProvider方法來把一種類型綁定到具體的Provider類。當需要相應類型的對象時，Provider類就會調用其get方法獲取所需的對象。
其實，個人感覺在configure方法中使用Provider綁定和直接寫@Provides方法所實現的功能是沒有差別的，不過使用Provider綁定會使代碼更清晰。而且當提供對象的方法中也需要有其他類型的依賴注入時，使用Provider綁定會是更好的選擇。

1.1.5 無目標綁定 
無目標綁定是鏈接綁定的一種特例，在綁定的過程中不指明目標，如：    bind(MyConcreteClass.class);
    bind(AnotherConcreteClass.class).in(Singleton.class);


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


    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修飾的話，該類型一定不能只提供有參數的構造函數，要么不提供構造函數，要么提供的構造函數中必須有無參構造函數。因為guice會默認去調用該類型的無參構造函數。

1.1.6 指定構造函數綁定 
在configure方法中，將一種類型綁定到另外一種類型的過程中，指定目標類型用那種構造函數生成對象。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修飾目標類型的構造函數的時候。比如說目標類型是第三方提供的類型，或者說目標類型中有多個構造函數，并且可能會在不同情況采用不同的構造函數。


1.1.7 Built-in綁定 
Built-in綁定指的是不用程序員去指定，Guice會自動去做的綁定。目前，Guice所支持的Built-in綁定只有對java.util.logging.Logger的綁定。個人感覺，所謂的Built-in綁定，只是在比較普遍的東西上為大家帶來方便的一種做法。@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());
  }</pre>

1.2 在@Provides方法中進行綁定 
當你只是需要在需要的時候，產生相應類型的對象的話，@Provides Methods是個不錯的選擇。方法返回的類型就是要綁定的類型。這樣當需要創建一個該類型的對象時，該provide方法會被調用，從而得到一個該類型的對象。

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;
  }
}</pre>

需要注意的是Provide方法必須被@Provides所修飾。同時，@Provides方法綁定方式是可以和上面提到的注解綁定混合使用的，如：
  @Provides @PayPal
  CreditCardProcessor providePayPalCreditCardProcessor(
      @Named("PayPal API key") String apiKey) {
    PayPalCreditCardProcessor processor = new PayPalCreditCardProcessor();
    processor.setApiKey(apiKey);
    return processor;
  }


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


2. 在父類型中進行綁定 

2.1 @ImplementedBy 
在定義父類型的時候，直接指定子類型的方式。

這種方式其實和鏈式綁定的效果是完全一樣的，只是聲明綁定的位置不同。

和鏈式綁定不同的是它們的優先級，@ImplementedBy實現的是一種default綁定，當同時存在@ImplementedBy和鏈式綁定時，鏈式綁定起作用。

@ImplementedBy(PayPalCreditCardProcessor.class)
public interface CreditCardProcessor {
  ChargeResult charge(String amount, CreditCard creditCard)
      throws UnreachableException;
}


等價于：

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


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

@ProvidedBy(DatabaseTransactionLogProvider.class)
public interface TransactionLog {
  void logConnectException(UnreachableException e);
  void logChargeResult(ChargeResult result);
}


等價于:    bind(TransactionLog.class)
        .toProvider(DatabaseTransactionLogProvider.class);


并且，和@ImplementedBy類似，@ProvidedBy的優先級也比較低，是一種默認實現，當@ProvidedBy和toProvider函數兩種綁定方式并存時，后者有效。3. 在子類型中進行注入 

3.1 構造函數注入 
在構造函數綁定中，Guice要求目標類型要么有無參構造函數，要么有被@Inject注解修飾的構造函數。這樣，當需要創建該類型的對象時，Guice可以幫助進行相應的綁定，從而生成對象。在Guice創建對象的過程中，其實就是調用該類型被@Inject注解修飾的構造函數，如果沒要@Inject注解修飾的構造函數，則調用無參構造函數。在使用構造函數綁定時，無需再在Module中定義任何綁定關系。這里需要注意的是，Guice在創建對象的過程中，無法初始化該類型的內部類（除非內部類有static修飾符），因為內部類會有隱含的對外部類的引用，Guice無法處理。


public class PayPalCreditCardProcessor implements CreditCardProcessor {
  private final String apiKey;
@Inject
  public PayPalCreditCardProcessor(@Named("PayPal API key") String apiKey) {
    this.apiKey = apiKey;
  }</pre>


3.2 屬性注入 
屬性綁定的目的是告訴Guice，當創建該類型的對象時，哪些屬性也需要進行依賴注入。用一個例子來看：

首先，有一個接口：package guice.test;
import com.google.inject.ImplementedBy;;
@ImplementedBy (SayHello.class)
public interface Talk {
    public void sayHello();
}</pre>

該接口指明了它的實現類SayHello
package guice.test;
public class SayHello implements Talk{
    @Override
    public void sayHello() {
        System.out.println("Say Hello!");

}

}</pre>

接下來就是屬性注入的例子：
package guice.test;
import com.google.inject.Inject;
public class FieldDI {
    @Inject
    private Talk bs;

public Talk getBs() {
    return bs;
}

}</pre>



這里面，指明熟悉Talk類型的bs將會被注入。使用的例子是：
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();
      }

}</pre>

如果我們沒有用@Inject修飾Talk bs的話，就會得到如下錯誤： Exception in thread "main" java.lang.NullPointerException
如果我們用@Inject修飾Talk bs了，但是Talk本身沒有被@ImplementedBy修飾的話，會得到如下錯誤：

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)</pre>



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

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 */

}
}</pre>

其中，Provider的定義如下：
public interface Provider {
  T get();
}





3.3 Setter方法注入 
有了上面的基礎我們再來看Setter注入就非常簡單了，只不過在setter方法上增加一個@Inject注解而已。 還是上面的例子，只是有一點修改：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;
}

}</pre>


四. 對象產生的Scopes 
在默認情況下，每次通過Guice去請求對象時，都會得到一個新的對象，這種行為是通過Scopes去配置的。

Scope的配置使得我們重用對象的需求變得可能。目前，Guice支持的Scope有@Singleton, @SessionScoped, @RequestScoped。

同樣，程序員也可以自定義自己的Scope，本文不涉及自定義scope，如果有興趣，請參考：http://code.google.com/p/google-guice/wiki/CustomScopes

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

@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方法里聲明  @Provides @Singleton
  TransactionLog provideTransactionLog() {
    ...
  }


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

  bind(Bar.class).to(Applebees.class).in(Singleton.class);
  bind(Grill.class).to(Applebees.class).in(Singleton.class);


這樣一共會生成2個Applebees對象，一個給Bar用，一個給Grill用。如果在上面的配置的情況下，還有下面的配置，bind(Applebees.class).in(Singleton.class);


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



來自：http://blog.csdn.net/derekjiang/article/details/7231490
本文由用戶 jopen 自行上傳分享，僅供網友學習交流。所有權歸原作者，若您的權利被侵害，請聯系管理員。
轉載本站原創文章，請注明出處，并保留原始鏈接、圖片水印。
本站是一個以用戶分享為主的開源技術平臺，歡迎各類分享！
本文地址：http://www.baiduhome.net/lib/view/open1406115847679.html
面向方面AOP/IoC Google-Guice
Google-Guice入門介紹

一. 概述

二. 舉例說明Guice的用法

相關經驗

相關資訊

相關文檔

目錄
