Guice框架-DI(依赖注入之作用域)

本章节继续讨论依赖注入的其他话题，包括作用域（scope，这里有一个与线程绑定的作用域例子）、立即初始化（Eagerly Loading Bindings）、运行阶段（Stage）、选项注入（Optional Injection）等等。

 

 

1.3.5 Scope(作用域)

 

在1.1章节中我们初步了解了对象的单例模式，在Guice中提供了一些常见的作用域，比如对于单例模式有下面两个作用域。

 

 

    com.google.inject.Scopes.SINGLETON

 

    com.google.inject.Scopes.NO_SCOPE

 

在使用上，可以使用Module的bind来实现，看下面的例子。

 

 

 1     public class ScopeDemo {

 2         public static void main(String[] args) {

 3 

 4             Service service = Guice.createInjector(new Module() {

 5                 @Override

 6                 public void configure(Binder binder) {

 7                     binder.bind(Service.class).to(WwwService.class).in(Scopes.SINGLETON);

 8                 }

 9             }).getInstance(Service.class);

10             service.execute();

11         }

12     }

13 

14 

当然单例模式还可以似乎用@Singleton注解。

 

 

在com.google.inject.binder.ScopedBindingBuilder.in(Scope)方法中，一个Scope除了可以使上面的SINGLETION和NO_SCOPE外，还可以是自己定义的Scope。下面的例子演示了一个与线程绑定的Scope例子。

 

 1 /**

 2  * $Id: ThreadScopeDemo.java 90 2009-12-25 08:12:21Z xylz $

 3  * xylz study project (www.imxylz.cn)

 4  */

 5 package cn.imxylz.study.guice.inject.more;

 6 

 7 import com.google.inject.Binder;

 8 import com.google.inject.Guice;

 9 import com.google.inject.Injector;

10 import com.google.inject.Key;

11 import com.google.inject.Module;

12 import com.google.inject.Provider;

13 import com.google.inject.Scope;

14 

15 /** a demo with thread-scope

16  * @author xylz (www.imxylz.cn)

17  * @version $Rev: 90 $

18  */

19 public class ThreadScopeDemo {

20 

21     static class ThreadServiceScope implements Scope {

22 

23         static ThreadLocal<Object> threadLocal = new ThreadLocal<Object>();

24 

25         @Override

26         public <T> Provider<T> scope(final Key<T> key, final Provider<T> unscoped) {

27             return new Provider<T>() {

28                 @Override

29                 public T get() {

30                     T instance = (T) threadLocal.get();

31                     if (instance == null) {

32                         instance = unscoped.get();

33                         threadLocal.set(instance);

34                     }

35                     return instance;

36                 }

37             };

38         }

39 

40         @Override

41         public String toString() {

42             return "Scopes.ThreadServiceScope";

43         }

44     }

45     

46     public static void main(String[] args) {

47         final Injector inj=Guice.createInjector(new Module() {

48             @Override

49             public void configure(Binder binder) {

50                 binder.bind(Service.class).to(WwwService.class).in(new ThreadServiceScope());

51             }

52         });

53         for(int i=0;i<3;i++) {

54             new Thread("Thread-"+i) {

55                 public void run() {

56                     for(int m=0;m<3;m++) {

57                         System.out.println(String.format("%s-%d:%d",//

58                                 getName()//

59                                 ,m//

60                                 ,inj.getInstance(Service.class).hashCode()));

61                         try {

62                             Thread.sleep(50L);

63                         } catch (Exception e) {

64                         }

65                     }

66                 }

67             }.start();

68         }

69     }

70 }

71

 

注意，这里用到了《Google Guice 入门教程03 - 依赖注入》的中的两个类Service和WwwService。在本例中ThreadServiceScope类是一个与线程绑定的作用域（利用ThreadLocal特性），当当前线程中没有构造一个对象的时候先构造一个出来，然后放入线程上下文中，以后每次都从线程中获取对象。第50行是将WwwService服务以ThreadServiceScope的作用域绑定到Service服务上。第57-60行输出当前对象的hashCode,如果此类是同一对象的话就应该输出相同的hashCode。为了看到效果，我们使用3个线程，每个线程输出三次来看结果。

 

Thread-0-0:18303751

Thread-1-0:23473608

Thread-2-0:21480956

Thread-1-1:23473608

Thread-0-1:18303751

Thread-2-1:21480956

Thread-1-2:23473608

Thread-2-2:21480956

Thread-0-2:18303751

 

我们看到对于同一个线程（比如说Thread-0）的三次都输出了相同的对象（hashCode为18303751），而与线程2和线程3的hashCode不同。

 

（特别说明：如果两个线程输出了同一个hashCode不必惊慌，那是因为可能前一个线程生成的对象的地址空间被GC释放了，结果下一个线程使用了上一个线程的相同空间，所以这里使用Thread.sleep来降低这种可能性）

 

 

事实上在guice-servlet-2.0.jar中有与request和session绑定的scope。

 

com.google.inject.servlet.ServletScopes.REQUEST

com.google.inject.servlet.ServletScopes.SESSION

 

1.3.6 Eagerly Loading Bindings （立即初始化）

 

 

除了可以绑定scope外，对象默认在第一次调用时被创建，也即所谓的延时加载，Guice也允许对象在注入到Guice容器中时就被创建出来(显然这是针对单例模式才有效)。

 

 1 public class EagerSingletonDemo {

 2 

 3     public EagerSingletonDemo() {

 4         System.out.println(" constuctor:"+System.nanoTime());

 5     }

 6     void doit() {

 7         System.out.println("       doit:"+System.nanoTime());

 8     }

 9     public static void main(String[] args) throws Exception{

10         Injector inj = Guice.createInjector(new Module() {

11             @Override

12             public void configure(Binder binder) {

13                 binder.bind(EagerSingletonDemo.class).asEagerSingleton();

14             }

15         });

16         System.out.println("before call:"+System.nanoTime());

17         Thread.sleep(100L);

18         inj.getInstance(EagerSingletonDemo.class).doit();

19     }

20 }

 

结果输出如下：

 

 constuctor:26996967388652

before call:26996967713635

       doit:26997069993702

 

可以看到我们的对象在调用getInstance之前就已经被构造出来了。

 

 

1.3.7 Stages (运行阶段)

 

Guice还有一个特效，可以指定Guice运行模式来控制Guice的加载速度。在com.google.inject.Stage枚举中提供了TOOL，DEVELOPMENT，PRODUCTION三种模式。

 

TOOL描述的是带有IDE等插件的运行模式；DEVELOPMENT是指在开发阶段只加载自己需要的功能（对于非立即初始化单例对象采用延后加载），这样来降低加载不需要功能的时间；而PRODUCTION模式是指完全加载所有功能（对于单例对象采用立即加载方式），这样可以更早的发现问题，免得等需要某些功能的时候才发现问题（要知道我们某些功能可能需要特定的条件才能触发）。

 

其实只有比较多的单例对象，并且单例对象构造比较耗时的情况下才能有用。大部分情况下这点性能可能都忽略不计了。

 

 

默认情况下Guice采用DEVELOPMENT模式。

 

 

 

 

 

1.3.8 Optional Injection (选项注入 )

 

选项注入描述的是如果不能从Guice容器中注入一个对象，那么可以使用一个默认的对象。看下面的例子。

 

 

 1 public class OptionalInjectionDemo {

 2     @Inject(optional=true)

 3     Service service = new WwwService();

 4     public static void main(String[] args) {

 5         Guice.createInjector(new Module() {

 6             public void configure(Binder binder) {

 7                 //binder.bind(Service.class).to(HomeService.class);

 8             }

 9         }).getInstance(OptionalInjectionDemo.class).service.execute();

10     }

11 }

 

上述例子中第2行描述的是选项注入，如果不能从Guice容器中获取一个Service服务那么就使用默认的WwwService，否则就是用获取的服务。如果将第7行注释去掉我们就可以看到实际上调用的是HomeService服务了。