xylz,imxylz

关注后端架构、中间件、分布式和并发编程

   :: 首页 :: 新随笔 :: 联系 :: 聚合  :: 管理 ::
  111 随笔 :: 10 文章 :: 2680 评论 :: 0 Trackbacks

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


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

上一篇:Google Guice 入门教程03 - 依赖注入(3)

下一篇:Google Guice 入门教程05 - AOP(面向切面编程)



©2009-2014 IMXYLZ |求贤若渴
posted on 2009-12-25 18:02 imxylz 阅读(16581) 评论(1)  编辑  收藏 所属分类: J2EEGoogle Guice

评论

# re: Google Guice 入门教程04 - 依赖注入(4)[未登录] 2011-03-30 12:28 kevin
写得 很好 学习了  回复  更多评论
  


只有注册用户登录后才能发表评论。


网站导航:
 

©2009-2014 IMXYLZ