感谢本文的原作者让我对Guice可以初步的了解一点，出于项目的考虑，有时候Spring并不能作为一个通用的框架，尤其需要一个轻量级的纯DI框架时，个人认为Guice是个不错的选择。在文章最后还附了一段关于Spring和Guice的比较，有兴趣的童鞋可以看看
本文出处：http://blog.csdn.net/derekjiang/article/details/7231490
一. 概述
Guice是一个轻量级的DI框架。本文对Guice的基本用法作以介绍。
本文的所有例子基于Guice 3.0
考虑到是入门介绍，本文中并未涉及到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);
}
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) {
}
}现在接口有了，实现类也有了，接下来就是如何将接口和实现类关联的问题了，在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);
}
}好了，现在万事俱备，就让我们一起看看怎么使用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);
}三. 绑定方式的介绍
从上面我们可以看出，其实对于Guice而言，程序员所要做的，只是创建一个代表关联关系的Module，然后使用这个Module即可得到对应关联的对象。因此，主要的问题其实就是在如何关联实现类和接口（子类和父类）。1. 在自定义的Module类中进行绑定
1.1 在configure方法中绑定
1.1.1 链式绑定
链式绑定是最简单，最直接，也是使用最多的绑定方式。
protected void configure() {
bind(TransactionLog.class).to(DatabaseTransactionLog.class);
}protected void configure() {
bind(TransactionLog.class).to(DatabaseTransactionLog.class);
bind(DatabaseTransactionLog.class).to(MySqlDatabaseTransactionLog.class);
}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 {
}public class RealBillingService implements BillingService {
@Inject
public RealBillingService(@PayPal CreditCardProcessor processor,
TransactionLog transactionLog) {
}
}public class RealBillingService implements BillingService {
@Inject
@Www
private CreditCardProcessor processor;
}bind(CreditCardProcessor.class)
.annotatedWith(PayPal.class)
.to(PayPalCreditCardProcessor.class);1.1.2.2 使用@Named的方式
使用@Named的方式和上面自己写Annotation的方式很类似，只不过做了相应的简化，不再需要自己去写Annotation了。
public class RealBillingService implements BillingService {
@Inject
public RealBillingService(@Named("Checkout") CreditCardProcessor processor,
TransactionLog transactionLog) {
}
}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;
}
}其实，个人感觉在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); 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);
}
}
}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());
}
}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;
}
}@Provides
@PayPal
CreditCardProcessor providePayPalCreditCardProcessor(
@Named("PayPal API key") String apiKey) {
PayPalCreditCardProcessor processor = new PayPalCreditCardProcessor();
processor.setApiKey(apiKey);
return processor;
}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); 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;
}
}3.2 属性注入 属性绑定的目的是告诉Guice，当创建该类型的对象时，哪些属性也需要进行依赖注入。用一个例子来看：
首先，有一个接口：
package guice.test;
import com.google.inject.ImplementedBy;
@ImplementedBy(SayHello.class)
public interface Talk {
public void sayHello();
}该接口指明了它的实现类SayHello
package guice.test;
public class SayHello implements Talk {
@Override
public void sayHello() {
System.out.println("Say Hello!");
}
}接下来就是属性注入的例子：
package guice.test;
import com.google.inject.Inject;
public class FieldDI {
@Inject
private Talk bs;
public Talk getBs() {
return bs;
}
}这里面，指明熟悉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();
}
}如果我们没有用@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)
另外，属性注入的一种特例是注入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 */
}
}其中，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;
}
}四. 对象产生的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! */
}bind(TransactionLog.class).to(InMemoryTransactionLog.class).in(Singleton.class);@Provides @Singleton
TransactionLog provideTransactionLog() {
}bind(Bar.class).to(Applebees.class).in(Singleton.class);
bind(Grill.class).to(Applebees.class).in(Singleton.class);bind(Applebees.class).in(Singleton.class);
附：关于选择Spring还是Google-Guice的一些想法
Spring已经出来好多年了，当年是作为轻量级J2EE容器和EJB抗衡的，不过随着技术和时间的发展，Spring越来越全面，越来越强大，也就越来越Heavy了。而且，在使用Spring的过程中，因为所有Bean直接的关联都是在XML配置文件中完成的，于是当系统变大之后，XML配置中的内容会非常的多，感觉会很乱。
Google－Guice是最近几年刚刚出来的一种DI框架，它的好处就是简单，轻量级，快。Guice中的Bean之间的关联都是在Module中定义的，如果需要定义不同的关联，则需要定义不同的Module，这点相对来说会麻烦一些，但是这种使用Annotation和Module的方式，对于程序员来说，可能会感觉更为直接。另外，Guice启动的时候比Spring要快很多，据说要快100倍，这主要是因为Spring要去读配置文件，要Parse
XML文件。但是个人感觉这种快，其实作用有限，因为这种速度的差异，只是在load Bean的时候，当Bean都已经被load到内存之后，其实就没什么差别了，所以Guice快只是快在启动阶段。
关于在做项目时，到底选择Spring还是选择Guice呢？ 个人感觉，如果你原来一直在使用Spring或者Guice，那么其实完全没有必要换，因为这样会带来额外的复杂度。原来熟悉那个用那个就OK了。 如果Spring和Guice都没用过，或者说都用过，那么我觉得就看项目需要了，如果项目需要的仅仅是个DI容器，那么我觉得Guice就足够了，好处就是简单，上手快，启动快；如果项目需要更多功能，要和其他的框架进行兼容，那么个人感觉选择Spring仍然是不错的选择，比较Spring出道时间长，和很多成熟框架之间都有很好的兼容，虽然Guice新的版本已经可以支持AOP功能，并且也可以支持和一些其他框架进行兼容，但是Guice想要在短时间内取代Spring，个人感觉还是非常难的。
| Spring | Guice | |
| 使用XML | 使用将类与类之间的关系隔离到xml中，由容器负责注入被调用的对象，因此叫做依赖注入 | 不使用xml,将类与类之间的关系隔离到Module中，声名何处需要注入，由容器根据Module里的描述，注入被调用的对象。 |
| 使用Annotation | 使用 支持自定义Annotation标注，对于相同的接口定义的对象引用，为它们标注上不同的自定义Annotation注释，就可以达到同一个类里边的同一个接口的引用，注射给不同的实现，在Module里用标注做区分，灵活性大大增加。 使用Annotation也未必是好事，范型等新特性也未必是好事，目前大多的服务器均不支持jdk1.5,wls要9以前才支持，而目前的客户由于价格原因也很少选用wls9的，至少我们做过的项目中都没有。功能再强，客户不需要，何用？ |
|
| 运行效率 | 装载spring配置文件时，需解析xml，效率低，getBean效率也不高，不过使用环境不会涉及到getBean，只有生产环境的时候会用到getBean,在装载spring应用程序的时候，已经完成全部的注射，所以这个低效率的问题不是问题。 | 使用Annotation，cglib, 效率高与spring最明显的一个区别，spring是在装载spring配置文件的时候把该注入的地方都注入完，而Guice呢，则是在使用的时候去注射，运行效率和灵活性高。 |
| 类耦合度 | 耦合度低，强调类非侵入，以外部化的方式处理依赖关系，类里边是很干净的，在配置文件里做文章，对类的依赖性极低。 | 高，代码级的标注，DI标记@inject侵入代码中，耦合到了类层面上来，何止侵入，简直侵略，代码耦合了过多guice的东西，大大背离了依赖注入的初衷，对于代码的可维护性，可读性均不利 |
| 类编写时 | 需要编写xml，配置Bean，配置注入 | 只需声明为@inject,等着被注入， 最后在统一的Module里声明注入方式 |
| 仅支持IOC | 否，spring目前已经涉猎很多部分 | 是，目前仅仅是个DI容器 |
| 是否易于代码重构 | 统一的xml配置入口，更改容易 | 配置工作是在Module里进行，和spring异曲同功 |
| 支持多种注入方式 | 构造器，setter方法 | Field,构造器，setter方法 |
| 灵活性 |
1,如果同一个接口定义的引用需要注入不同的实现，就要编写不同的Module，烦琐 2,动态注入 如果你想注射的一个实现，你还未知呢，怎么办呢，spring是没办法，事先在配置文件里写死的，而Guice就可以做到，就是说我想注射的这个对象我还不知道注射给谁呢，是在运行时才能得到的的这个接口的实现，所以这就大大提高了依赖注射的灵活性，动态注射。 |
|
| 与现有框架集成度 | 1， 高，众多现有优秀的框架（如struts1.x等）均提供了spring的集成入口，而且spring已经不仅仅是依赖注入，包括众多方面。 2， Spring也提供了对Hibernate等的集成，可大大简化开发难度。 3， 提供对于orm,rmi,webservice等等接口众多，体系庞大。 |
1，可以与现有框架集成，不过仅仅依靠一个效率稍高的DI，就想取代spring的地位，有点难度。 |
| 配置复杂度 | 在xml中定位类与类之间的关系,难度低 | 代码级定位类与类之间的关系,难度稍高 |
