能跑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();
}
}
输出的当然是你想要的东西