Google Guice 入门教程04 - 依赖注入

本章节继续讨论依赖注入的其他话题，包括作用域（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
 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  
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服务了。

 

到此为止，Guice依赖注入的基本教程就学习完了，下面的章节我们进入经典的AOP教程学习。