Guice 4.1教程

Guice是Google开发的一个开源轻量级的依赖注入框架，运行速度快，使用简单。

项目地址：https://github.com/google/guice/

最新的版本是4.1，本文基于此版本。

0. 什么是依赖注入？

依赖注入（Dependency Injection）是一种思想。

在一般的编程中，如果我们想要使用一个class的实例，那么必须要调用构造方法new class()手动将其实例化，如果这个class中又有对其他class属性的引用，那么在构造方法中，又要调用其他class的构造方法将其实例化。

这就是“依赖”。

Guice这种依赖注入框架的作用就是接管class之间的依赖关系，如果我们想要使用一个class的实例，Guice会自动生成实现类的实例并交给我们。

这个过程就叫做“注入”。

1. 利用Module的依赖注入

//定义Dog接口
public interface Dog {
    void bark();
}

//定义BlackDog实现类
public class BlackDog implements Dog{
    @Override
    public void bark() {
        System.out.println("i am black dog");
    }
}

//依赖注入
public class GuiceTest {
    public static void main(String[] args) {
        Injector injector = Guice.createInjector(new Module() {
            @Override
            public void configure(Binder binder) {
                binder.bind(Dog.class).to(BlackDog.class);
            }
        });
        Dog dog = injector.getInstance(Dog.class);
        dog.bark();
    }
}

输出结果如下

i am black dog

这个例子非常简单，先在自定义的Module中将Dog接口与BlackDog实现类关联起来。此时如果调用getInstance方法想要获取Dog接口的实例，就自动创建一个BlackDog的实例并返回。

2. 绑定到实例的依赖注入

public static void main(String[] args) {
        Injector injector = Guice.createInjector(new Module() {
            @Override
            public void configure(Binder binder) {
                binder.bind(Dog.class).toInstance(new BlackDog());
            }
        });

        Dog dog = injector.getInstance(Dog.class);
        dog.bark();
    }

可以看到Dog接口已经与某个BlackDog的实例绑定起来了。

3. 利用Provider的依赖注入

    public static void main(String[] args) {
        Injector injector = Guice.createInjector(new Module() {
            @Override
            public void configure(Binder binder) {
                binder.bind(Dog.class).toProvider(new Provider<Dog>() {
                    Dog dog = new BlackDog();

                    @Override
                    public Dog get() {
                        return dog;
                    }
                });
            }
        });

        Dog dog = injector.getInstance(Dog.class);
        dog.bark();
    }

换了一种方法的绑定，在自定义的Provider类中，我们可以执行一些复杂的操作。

4. 基于注解的依赖注入

可以在接口上添加@ImplementedBy完成绑定操作

@ImplementedBy(BlackDog.class)
public interface Dog {
    void bark();
}

public class BlackDog implements Dog{
    @Override
    public void bark() {
        System.out.println("i am black dog");
    }
}

public class GuiceTest {
    public static void main(String[] args) {
        Injector injector = Guice.createInjector();
        Dog dog = injector.getInstance(Dog.class);
        dog.bark();
    }
}

可以看到没有为Guice指定任何Module，也完成了依赖注入的操作

当然，也可以用@ProvidedBy注解完成绑定操作

@ProvidedBy(BlackDogProvider.class)
public interface Dog {
    void bark();
}

public class BlackDogProvider implements Provider<Dog> {
    @Override
    public Dog get() {
        return new BlackDog();
    }
}

public class GuiceTest {
    public static void main(String[] args) {
        Injector injector = Guice.createInjector();
        Dog dog = injector.getInstance(Dog.class);
        dog.bark();
    }
}

基于注解的依赖注入其实与基于Module的依赖注入差别不大，只是口味上的区别

但是Module里的配置会覆盖注解里的配置

5. 单例

在默认情况下，每次调用getInstance方法，都会创建一个新的对象并返回（Provider注入与实例注入除外）

@ImplementedBy(BlackDog.class)
public interface Dog {
    void bark();
}

public class BlackDog implements Dog{
    @Override
    public void bark() {
        System.out.println("i am black dog");
    }
}

public class GuiceTest {
    public static void main(String[] args) {
        Injector injector = Guice.createInjector();
        for (int i = 0; i < 10; i++) {
            System.out.println(injector.getInstance(Dog.class).hashCode());
        }
    }
}

调用10次getInstance方法，分别计算得到对象的hashCode，结果如下

1709366259
1335298403
1643691748
2068434592
143110009
2142003995
1535634836
1846412426
1539805781
1206883981

可以看出，每次调用getInstance方法，都会生成一个全新的对象。

如果我们希望返回的是同一个对象（单例模式），那么只需要在实现类上加一个@Singleton注解

@ImplementedBy(BlackDog.class)
public interface Dog {
    void bark();
}

@Singleton
public class BlackDog implements Dog{
    @Override
    public void bark() {
        System.out.println("i am black dog");
    }
}

public class GuiceTest {
    public static void main(String[] args) {
        Injector injector = Guice.createInjector();
        for (int i = 0; i < 10; i++) {
            System.out.println(injector.getInstance(Dog.class).hashCode());
        }
    }
}

运行结果如下：

1632492873
1632492873
1632492873
1632492873
1632492873
1632492873
1632492873
1632492873
1632492873
1632492873

可以看到@Singleton注解已经生效，调用getInstance方法返回的对象已经是单例的了

6. 属性注入

Guice可以在某个类初始化时，为它的属性自动注入实例，无需我们手动赋值

@ImplementedBy(BlackDog.class)
public interface Dog {
    void bark();
}

public class BlackDog implements Dog{
    @Override
    public void bark() {
        System.out.println("i am black dog");
    }
}

public class GuiceTest {
    @Inject
    private Dog dog;

    public static void main(String[] args) {
        Injector injector = Guice.createInjector();

        GuiceTest guiceTest = injector.getInstance(GuiceTest.class);
        guiceTest.dog.bark();
    }
}

程序的输出结果为：

i am black dog

可以看到，通过getInstance方法创建出来的GuiceTest实例中的dog属性，已经被自动注入了一个BlackDog实例。

这就是@Inject注解的效果，如果dog属性没有这个@Inject注解，程序会抛出NullPointerException

7. 构造函数注入

如果在构造函数上添加@Inject注解，那么可以实现在对象初始化的时候自动提供参数，代码如下

public class GuiceTest {
    private Dog dog;

    @Inject
    public GuiceTest(Dog dog) {
        this.dog = dog;
    }

    public static void main(String[] args) {
        Injector injector = Guice.createInjector();

        GuiceTest guiceTest = injector.getInstance(GuiceTest.class);
        guiceTest.dog.bark();
    }
}

在调用getInstance获取GuiceTest实例的时候，会自动调用唯一的GuiceTest构造方法并传入参数

需要注意的是，此时必须有且只有一个带有@Inject注解的构造方法，否则会抛出类似如下的异常：

GuiceTest has more than one constructor annotated with @Inject. Classes must have either one (and only one) constructor annotated with @Inject or a zero-argument constructor that is not private.

8. Setter注入

与之前提到的属性注入非常类似，只需要在setter方法上添加一个@Inject注解即可。

public class GuiceTest {
    private Dog dog;

    public Dog getDog() {
        return dog;
    }

    @Inject
    public void setDog(Dog dog) {
        this.dog = dog;
    }

    public static void main(String[] args) {
        Injector injector = Guice.createInjector();

        GuiceTest guiceTest = injector.getInstance(GuiceTest.class);
        guiceTest.dog.bark();
    }
}

9. 静态变量注入

上面的注入都是针对某个类的非静态属性进行注入，如果我们对某个类的静态属性进行注入，会发生什么呢？

public class GuiceTest {
    @Inject private static Dog dog;

    public static void main(String[] args) {
        Injector injector = Guice.createInjector();

        GuiceTest guiceTest = injector.getInstance(GuiceTest.class);
        guiceTest.dog.bark();
    }
}

程序的执行结果是：

Exception in thread "main" java.lang.NullPointerException

很显然，注入失败了。因为getInstance方法是针对某个类的实例进行注入，而类的静态属性是被这个类的所有对象全局共享的，所以直接注入会失败。

正确的注入姿势如下：

public class GuiceTest {
    @Inject private static Dog dog;

    public static void main(String[] args) {
        Injector injector = Guice.createInjector(new Module() {
            @Override
            public void configure(Binder binder) {
                binder.requestStaticInjection(GuiceTest.class);
            }
        });
        
        GuiceTest.dog.bark();
    }
}

程序的执行结果如下：

i am black dog

注入成功！

虽然目前还不知道具体的实现原理，但是可以猜出Guice一开始就直接往GuiceTest的静态变量里注入了对象。

10. 直接注入属性

还有一种简单暴力的方式来完成属性的依赖注入

public class GuiceTest {
    @Inject private Dog dog;

    public static void main(String[] args) {
        Injector injector = Guice.createInjector();

        GuiceTest guiceTest = new GuiceTest();
        injector.injectMembers(guiceTest);
        guiceTest.dog.bark();
    }
}

对GuiceTest的实例直接调用injectMembers方法，完成对实例的属性的依赖注入

11. 单接口多实例

如果一个接口有多个实现类，Guice提供了一种非常灵活的注入方案

public interface Dog {
    void bark();
}

public class BlackDog implements Dog{
    @Override
    public void bark() {
        System.out.println("i am black dog");
    }
}

public class WhiteDog implements Dog {
    @Override
    public void bark() {
        System.out.println("i am white dog");
    }
}

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

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

public class GuiceTest {
    @Inject @Black private Dog dog;

    public static void main(String[] args) {
        Injector injector = Guice.createInjector(new Module() {
            @Override
            public void configure(Binder binder) {
                binder.bind(Dog.class).annotatedWith(White.class).to(WhiteDog.class);
                binder.bind(Dog.class).annotatedWith(Black.class).to(BlackDog.class);
            }
        });

        GuiceTest guiceTest = new GuiceTest();
        injector.injectMembers(guiceTest);
        guiceTest.dog.bark();
    }
}

运行结果如下：

i am black dog

额外定义了@Black与@White注解，然后在Module里定义了两条规则，这样被@Black注解修饰的dog属性就被注入了BlackDog的依赖。

非常灵活，在特定场景下十分有用。

比方说可能实现类分为Debug与Release两类，调试的时候所有待注入的属性都用@Debug注解修饰，发布前将所有@Debug替换成@Release即可。

12. @Named注解

如果懒得额外定义注解，那么可以直接使用Guice提供的@Named注解完成相似的功能。

public class GuiceTest {
    @Inject @Named("Black") private Dog dog;

    public static void main(String[] args) {
        Injector injector = Guice.createInjector(new Module() {
            @Override
            public void configure(Binder binder) {
                binder.bind(Dog.class).annotatedWith(Names.named("White")).to(WhiteDog.class);
                binder.bind(Dog.class).annotatedWith(Names.named("Black")).to(BlackDog.class);
            }
        });

        GuiceTest guiceTest = new GuiceTest();
        injector.injectMembers(guiceTest);
        guiceTest.dog.bark();
    }
}

可以看到@Named注解也能完成指定实现类的关联工作

总结

本文简单介绍了Guice这个轻量级的依赖注入框架的基本使用方法。

虽然简单，但是也展现了依赖注入思想的精华之处：由容器来解决依赖对象的构建问题，程序员只需要提供属性的关联关系即可。使得程序松耦合，减少代码之间的依赖关系，便于后续的修改。

更详细的信息，请参见官方Wiki