Google Guice 之绑定1

绑定和依赖注入区别

绑定，使用时 需要通过 injector 显示获取

依赖注入，只需要显示获取主类，他的依赖是通过@Injector 和 绑定关系 隐式注入的

http://blog.csdn.net/jing_le/article/category/1403309

http://blog.csdn.net/java_le/article/details/24850355

1. Injector in = Guice.createInjector(new MyModule()) ;
2. Hello hello = in.getInstance(Hello.class)

Google Guice 绑定2

http://blog.csdn.net/java_le/article/details/24850777

上一章简单介绍了，如何使用Guice框架来完成接口（父类）和具体的实现类（子类）之间的关联。通过MyModule中：

binder.bind(Hello.class).to(HelloImpl.class).in(Singleton.class) ;

来实现关联关系，这节介绍通过注解来实现关联关系

（1）首先还是Hello.java接口(注意类头上的注解，描述了这个接口要绑定的实现类)

1. @ImplementedBy(HelloImpl.class)
2. public interface Hello {
3. void sayHello() ;
4. }

Hello.java这个接口的具体实现类：HelloImpl.java(类头上的注解，这类是单列还是动态创建)

1. @Singleton
2. public class HelloImpl implements Hello{
3. @Override
4. public void sayHello() {
5. System.out.println("HelloImpl say hello");
6. }
7. }

我们的MyModule实现类(具体的绑定关系被注释了)

1. package guice.binder;
2. import com.google.inject.Binder;
3. import com.google.inject.Module;
4. public class MyModule implements Module{
5. @Override
6. public void configure(Binder binder) {
7. //将借口hello.java 绑定到实现类HelloImpl.java上
8. //Singleton：表示是scope是单列的,Guice中类的scope只有两类，单例，或者每次都是new的一个新的对象
9. //<span style="white-space:pre">        </span>binder.bind(Hello.class).to(HelloImpl.class).in(Singleton.class) ;
10. }
11. }

1. Injector in = Guice.createInjector(new MyModule()) ;
2. Hello hello = in.getInstance(Hello.class) ;//hello -->HelloImpl实例

输出的结果依然还是HelloImpl say hello,

Google Guice 注入（@Inject注解）

上一节介绍通过注解来实现绑定关系，这一节介绍如何通过@Inject来完成依赖注入的功能：

（1）属性注入

（2）构造方法注入

（3）setter方法注入

一.属性注入

（1）创建一个接口Hello.java和一个实现类HelloImpl

创建一个HelloCaller（包含一个Hello属性）

1. package guice.di;
2. import com.google.inject.Inject;
3. //HelloCaller将会去调用Hello这个接口提供的服务
4. public class HelloCaller {
5. //通过@Inject，来完成属性的注入
6. @Inject
7. private Hello hello ;
8. //调用Hello的sayHello方法（实际上就是去调用HelloImpl的sayHello，因为我们将Hello的实现指定是HelloImpl）
9. public void sayHello(){
10. hello.sayHello() ;
11. }
12. }

通过@Inject注解将Hello属性的实例注入进来

1. Injector in = Guice.createInjector(new Module(){
2. @Override
3. public void configure(Binder arg0) {
4. //什么也不写
5. }
6. }) ;
7. //得到HelloCaller的实例
8. HelloCaller helloCaller = in.getInstance(HelloCaller.class) ;
9. //调用sayHello方法
10. helloCaller.sayHello() ;

构造方法注入

（1）Hello和HelloImpl类还是上面那样不用变，唯一变化的是HelloCaller类

1. package guice.di;
2. import com.google.inject.Inject;
3. public class HelloCaller1 {
4. //包含一个Hello属性
5. private Hello hello ;
6. //@Inject注解写在构造方法上，通过构造方法的方式注入属性hello
7. @Inject
8. public HelloCaller1(Hello hello){
9. this.hello = hello ;
10. }
11. public void sayHello(){
12. hello.sayHello() ;
13. }
14. }

setter方式注入

（1）Hello和HelloImpl类还是上面那样不用变，唯一变化的是HelloCaller类

1. //通过setter方法来注入hello属性
2. @Inject
3. public void setHello(Hello hello) {
4. this.hello = hello;