Guice进阶

    能跑HelloWorld程序之后，就要开始一点点深入去探寻Guice的奥秘了，未知的领域总是充满了诱惑力，新的东西总是能给人带来无限的激情，这就是为什么人们都喜欢去旅游，去探险的原因之一吧；既然开启了Guice的瓶盖，就好好去尝尝Guice的味道。

 

1、隐式绑定

    之前的Helloworld程序是显式的绑定接口的实现，类似这样的形式： bind(TestService.class).to(TestServiceAnotherImpl.class)；Guice提供了一种隐式绑定的方式，给接口默认的实现。如：

TestServiceImpl.java

public class TestServiceImpl implements TestService {

    @Override

    public void info() {

        System.out.println("Say,info");

    }

}

TestService.java

@ImplementedBy(TestServiceImpl.class)

public interface TestService {

    void info();

}

TestServiceModule.java

public class TestServiceModule extends AbstractModule{

    @Override

    protected void configure() {

        bind(TestService.class);

    }

}

TestServiceMain.java

public class TestServiceMain {

    public static void main(String[] args) {

        Injector injector = Guice.createInjector(new TestServiceModule());

        TestService testService = injector.getInstance(TestService.class);

        testService.info();

    }

}

输出：Say,info

这个时候Module里面就无需显式的绑定实现类 ，自动的绑定默认实现。

但是如果接口又显式定义了另外一个实现呢，那么哪个优先级高一点？

TestServiceAnotherImpl.java

public class TestServiceAnotherImpl implements TestService {

    @Override

    public void info() {

        System.out.println("Say: another!");

    }

}

TestServiceAnotherModule.java

public class TestServiceAnotherModule extends AbstractModule{

    @Override

    protected void configure() {

        bind(TestService.class).to(TestServiceAnotherImpl.class);

    }

}

将这个Module载入Injector，跑起来之后，输出结果：Say:another! 说明Module配置总是高于注解配置。

 

2、对象作用域(Scope)

Guice的默认行为是每次请求对象或者注入的时候都会创建一个新的实例对象。作用域(Scope)能让你自定义对象的生命周期。代码说明一切：

TestSingletonModule.java

public class TestSingletonModule extends AbstractModule {

    @Override

    protected void configure() {

        bind(TestSingleton.class).to(TestSingletonImpl.class);

    }

}

TestSingletonMain.java

public class TestSingletonMain {

    public static void main(String[] args) {

        Injector injector = Guice.createInjector(new TestSingletonModule());

        TestSingleton testSingleton = injector.getInstance(TestSingleton.class);

        System.out.println(testSingleton);

        TestSingleton testSingleton2 = injector.getInstance(TestSingleton.class);

        System.out.println(testSingleton2);

    }

}

输出：

com.lemon.guice.example2.TestSingletonImpl@535b58

com.lemon.guice.example2.TestSingletonImpl@922804

说明是两个不同的对象

 

当修改一下上述代码，设置成为单例的：

TestSingletonModule.java

public class TestSingletonModule extends AbstractModule {

    @Override

    protected void configure() {

        bind(TestSingleton.class).to(TestSingletonImpl.class).in(Scopes.SINGLETON);

    }

}

上述的TestSingletonMain输出为：

com.lemon.guice.example2.TestSingletonImpl@535b58

com.lemon.guice.example2.TestSingletonImpl@535b58

确实是单例的。

 

说到单例的，大家肯定会想到懒汉式的和恶汉式的单例实现，这个取决于之前所说的Stage的设置。

默认的Stage.DEVELOPMENT是 懒汉式的，Stage.PRODUCTION是饿汉式的，但是在DEVELOPMENT可以使用asEagerSingleton()方法：

bind(TestSingleton.class).to(TestSingletonImpl.class).asEagerSingleton();

显式的使用饿汉式加载方式的。

 

对于Servlet，作用域还有request和session的区别，这个之后再讲。

 

3、对象生产者(Provider)

    在向Guice申请对象的时候，仅仅是找到构造器然后执行它。但是有些时候你并不想这样：

• 延迟加载
• 需要类的多个对象
• 想提供实例生成的自定义实现。
• 在创建对象的时候需要做其他的一些方式的校验， 在某些情况下需要抛出异常。
• 想使用第三方包，但是不能直接添加@Inject注解。
• 需要复用代码的时候。

    首先看看生产者接口：位于Guice jar包内部，继承的是JSR-330 的规范接口

 

public interface Provider<T> extends javax.inject.Provider<T> {

 

  /**

   * Provides an instance of {@code T}. Must never return {@code null}.

   *

   * @throws OutOfScopeException when an attempt is made to access a scoped object while the scope

   *     in question is not currently active

   * @throws ProvisionException if an instance cannot be provided. Such exceptions include messages

   *     and throwables to describe why provision failed.

   */

  T get();

}    

 

    要想使用Provider，首先是实现其接口：

这里沿用 Google Guice这本书的例子：

Gum.java

public class Gum { }

 

GumProvider.java

public class GumProvider implements Provider<Gum> {

    @Override

    public Gum get() {

        return new Gum();

    }

}

GumballMachine.java（对象生产工具，类似工厂）

public class GumballMachine {

    @Inject

    private Provider<Gum> gumProvider;

 

    public Gum dispense(){

        return gumProvider.get();

    }

}

配置的Module

GumModule.java

public class GumModule extends AbstractModule {

    @Override

    protected void configure() {

        bind(Gum.class).toProvider(GumProvider.class);

    }

}

然后测试：

GumballExample.java

public class GumballExample {

    public static void main(String[] args) {

        Injector injector = Guice.createInjector(new GumModule());

        GumballMachine m = injector.getInstance(GumballMachine.class);

        System.out.println(m.dispense());

        System.out.println(m.dispense());

    }

}

 

输出：

com.lemon.guice.example3.Gum@5e3974

com.lemon.guice.example3.Gum@df503

 

这样的话在GumProvider和GumballMachine里面就能玩各种花样，在多线程环境下，这样可能存在线程安全问题，这点要注意。

像ImplementedBy注解一样，可以提供@ProvidedBy注解来省去Module的toProvider的配置

@ProvidedBy(GumProvider.class)

public class Gum {

}

 

4、@Named注解

 

这里先抛出一个问题，如果一个接口有多个实现，在不同的条件下使用不同的实现，

如果在Spring中，配置会比较简单，直接在配置文件里面指定实现就Ok，在Guice该肿么解决？

有了@Named注解，就会变得比较方便了。

例子：

Actor.java

public interface Actor {

    void iCanDo();

}

LiXiaolong.java

public class LiXiaolong implements Actor {

 

    @Override

    public void iCanDo() {

        System.out.println("I can do everything!");

    }

}

ZhouXingXing.java

public class ZhouXingXing implements Actor {

    @Override

    public void iCanDo() {

        System.out.println("I'm just an actor!");

    }

}

ActionMovie.java

public class ActionMovie {

    @Inject @Named("lixiaolong")

    private Actor lixiaolong;

    @Inject @Named("zhouxingchi")

    private Actor zhouxingchi;

 

    public void show(){

        lixiaolong.iCanDo();

        zhouxingchi.iCanDo();

    }

}

ActionModule.java

public class ActionModule extends AbstractModule {

    @Override

    protected void configure() {

        bind(Actor.class).annotatedWith(Names.named("lixiaolong")).to(LiXiaolong.class);

        bind(Actor.class).annotatedWith(Names.named("zhouxingchi")).to(ZhouXingXing.class);

    }

}

ActionExample.java

public class ActionExample {

    public static void main(String[] args) {

        Injector injector = Guice.createInjector(new ActionModule());

        ActionMovie actionMovie = injector.getInstance(ActionMovie.class);

        actionMovie.show();

    }

}

输出的当然是你想要的东西