超轻量级DI容器框架Google Guice与Spring框架的区别教程详解及其demo代码片段分享

原创不易，转载请注明出处：超轻量级DI容器框架Google
Guice与Spring框架的区别教程详解及其demo代码片段分享

代码下载地址：http://www.zuidaima.com/share/1759689106541568.htm

依赖注入，DI（Dependency Injection），它的作用自然不必多说，提及DI容器，例如spring，picoContainer，EJB容器等等，近日，google诞生了更轻巧的DI容器……Guice!

废话不多讲了，先看看Guice是如何实现注入的吧。

定义一个简单的service接口和它的实现吧：

package com.zuidaima.demo.guice;
public interface MyService ... {
 void myMethod();
}

package com.zuidaima.demo.guice;

 public class MyServiceImpl implements MyService ... {
 public void myMethod() ...{
 System.out.println("Hello,World!");
 }
}

以上是最普通的接口和其实现，没什么可说的。

定义一个测试类,这个类里边包括service对象的一个引用，这个对象是需要Guice进行注入的

package com.zuidaima.demo.guice;

import com.google.inject.Inject;
 public class Client ... {
 MyService service;
 @Inject //告诉容器，这里的service对象的引用,需要进行注入
 void setService(MyService service) ...{ //这里的方法名字可以任意定义
 this.service=service;
 }
 public void myMethod() ...{
 service.myMethod();
 }
}
 

这里除了加了一个@Inject,和Spring的配置没有任何的区别，@Inject，是表示对容器说，这里的service需要注射，等到运行的时候，容器会拿来一个实例给service，完成注射的过程。

定义Guice的Module文件 告诉容器如何进行注入

package com.zuidaima.demo.guice;

import com.google.inject.Binder;
 import com.google.inject.Module;
 import com.google.inject.Scopes;

 public class MyModule implements Module ... {
 public void configure(Binder binder) ...{ binder.bind(MyService.class).to(MyServiceImpl.class).in(Scopes.SINGLETON);
 // 这句代码的意思是说：运行时动态的将MyServiceImpl对象赋给MyService定义的对象，而且这个对象是单例的。
 }
}
 

创建测试类

package com.zuidaima.demo.guice;

import com.google.inject.Guice;
import com.google.inject.Injector;

 public class Test ... {

 public static void main(String[] args) ...{
MyModule module=new MyModule();// 定义注射规则
Injector injector=Guice.createInjector(module);// 根据注射规则，生成注射者
 Client client=new Client();
injector.injectMembers(client);// 注射者将需要注射的bean,按照规则,把client这个客户端进行注射
 client.myMethod();
}
}
 

运行测试类，控制台输出：Hello,World!

完成注入过程

下面看看Guice还有哪些其它的使用特性。

1，如果在实现你确定MyService定义的对象，就要被注射为MyServiceImpl而不是其它的实现类的话，可以在MyService接口加上@ImplementedBy(MyServiceImpl.class)

package com.zuidaima.demo.guice;

import com.google.inject.ImplementedBy;

@ImplementedBy(MyServiceImpl. class )
 // 我总觉得这样有点背离了依赖注入的初衷了
 public interface MyService ... {
 void myMethod();
}
 

这样的话，在MyModule里的configure方法中就可以不加任何东西，容器就会自动注射给MyServiceImpl对象。

2，可以对Field进行注解式注入

在Client.java中也可以把这个@Inject标注在MyService  service;的前边，如：@Inject MyService service;

3，可使用自定义Annotation标注。

package com.zuidaima.demo.guice;

 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;

 import com.google.inject.BindingAnnotation;

@Retention(RetentionPolicy.RUNTIME)
@Target( ... { ElementType.FIELD, ElementType.PARAMETER })
@BindingAnnotation
 public @ interface MyInterface ... {

}

那么Client.java需要改为

package com.zuidaima.demo.guice;

 import com.google.inject.Inject;

 public class Client ... {

 @Inject @MyInterface MyService service;

 void setService(MyService service) ...{ // 这里的方法名字可以任意定义
 this.service=service;
 }

 public void myMethod() ...{
 service.myMethod();
 }
}
 

MyModule.java中的configure方法内容需改为:

binder.bind(MyService.class).annotatedWith(MyInterface.class).to(

MyServiceImpl.class).in(Scopes.SINGLETON);

意思是说对于标注为MyInterface的MyService定义的对象进行注入

进行Annotation标注的成员（Field,method,argument等）进行自定义Annotation标注，该成员既拥有该属性，可以在运行，根据这些成员的不同属性，做一些不同的事情 例如：spring的AspectJ，xdoclet等都是如此。

下边是我做了一下对比

再借斧子的例子说一说spring与guice的区别

看下边对于不同社会形态下一个人（java对象，调用者）需要一把斧子（java对象，被调用者）的例子：

（1），原始社会时，劳动社会基本没有分工，需要斧子的人（调用者）只好自己去磨一把斧子，每个人拥有自己的斧子，如果把大家的石斧改为铁斧，需要每个人都要学会磨铁斧的本领，工作效率极低。

对应Java里的情形是：java程序里的调用者new一个被调用者的实例。类耦合度极高，修改维护烦琐，效率极低。

（2），工业社会时，工厂出现，斧子不再由普通人完成，而由工厂生产，当人们需要斧子的时候，可以到工厂购买斧子，无需关心斧子是怎么制造出来的，如果废弃铁斧为钢斧，只需改变工厂的制造工艺即可，制作工艺是工厂决定的，工厂生产什么斧子，工人们就得用什么斧子。

对应的Java里的情形是：Java程序的调用者可以以来简单工厂创建被调用者，变化点被隔离到了简单工厂里，虽然耦合度降低，但是调用者会和工厂耦合，而且需要定位自己的工厂。

（3）近代工业社会，工厂蓬勃发展，人们需要什么斧子，只需要提供一个斧子图形，商家会按照你提供的图形将你的斧子订做好，送上门。

对应Java里的情形：spring的依赖注入

（4）进入按需要分配社会，信息进入现代化，人们不再去工厂购买斧子，不再拘泥于需要什么斧子事先画好什么样的图形，只需要打个电话，描述一下需要什么类型的斧子，或许想打造一个物美价廉的斧子，商家会根据市场零件的价格，计算出最优制作工艺,打造最适合的斧子送过来，更加信息化，更加人性化。

对应Java里的情形：基于描述的注入，动态的，灵活简单的注入，如：Guice。

对于该不该使用Guice,我想也是仁者见仁,智者见智,就象好多论坛里动不动有人会在那里讨论到底学Java还是学.net或者是使用eclipse还是Jbuilder的这类无聊话题,适合和满足项目需求的,又能省工省力简单的完成工作的,就是最好的。

在此抛砖引玉,大家有异议的地方欢迎和我讨论。