guice基本使用,常用的绑定方式（四）

guice在moudle中提供了良好的绑定方法。

它提供了普通的绑定，自定义注解绑定，按名称绑定等。

下面直接看代码:

 1 package com.ming.user.test;
 2 
 3 import com.google.inject.AbstractModule;
 4 import com.google.inject.name.Names;
 5 
 6 /**
 7  * 继承 AbstractModule这个抽象类
 8  * @author mingge
 9  *
10  */
11 public class TestModule extends AbstractModule{
12 
13     @Override
14     protected void configure() {
15         
16         //普通绑定
17         bind(Dog.class).to(DarkDog.class);
18         
19         //自定义注解绑定--一个接口可以多个实现
20         bind(Dao.class).annotatedWith(CSV.class).to(DaoImpl.class);
21         bind(Dao.class).annotatedWith(CSV1.class) .to(DaoImpl2.class);
22         
23         //names注解常量绑定--也可用于一个接口多个实现的绑定
24         bindConstant().annotatedWith(Names.named("maxResults")).to(10);//类似于绑定了一个常量
25         
26     }
27 }

类似与普通绑定，很简单:

1 package com.ming.user.test;
2 
3 public class Dog {
4     
5     void eat(){
6         System.out.println("父类的在go，go,go。。。");
7     }
8 }

 1 package com.ming.user.test;
 2 
 3 public class DarkDog extends Dog{
 4 
 5     @Override
 6     void eat() {
 7         System.out.println("heeeelo");
 8         //super.eat();
 9     }
10 
11     
12 }

类似与注解绑定:

 1 package com.ming.user.test;
 2 
 3 import java.lang.annotation.ElementType;
 4 import java.lang.annotation.Retention;
 5 import java.lang.annotation.RetentionPolicy;
 6 import java.lang.annotation.Target;
 7 
 8 import com.google.inject.BindingAnnotation;
 9 
10 
11 /**
12  * 自定义一个绑定注解
13  * @author mingge
14  *
15  */
16 @BindingAnnotation
17 @Target({ElementType.FIELD,ElementType.PARAMETER,ElementType.METHOD})
18 @Retention(RetentionPolicy.RUNTIME)
19 public @interface CSV {
20     String value() default "";
21 }

 1 package com.ming.user.test;
 2 
 3 import java.lang.annotation.ElementType;
 4 import java.lang.annotation.Retention;
 5 import java.lang.annotation.RetentionPolicy;
 6 import java.lang.annotation.Target;
 7 
 8 import com.google.inject.BindingAnnotation;
 9 
10 /**
11  * 自定义一个绑定注解
12  * @author mingge
13  *
14  */
15 @BindingAnnotation
16 @Target({ElementType.FIELD,ElementType.PARAMETER,ElementType.METHOD})
17 @Retention(RetentionPolicy.RUNTIME)
18 public @interface CSV1 {
19 
20 }

然后是一个接口，两个实现:

1 package com.ming.user.test;
2 
3 public interface Dao {
4     
5     void testGuice();
6 }

 1 package com.ming.user.test;
 2 
 3 import com.google.inject.Singleton;
 4 
 5 @Singleton
 6 public class DaoImpl implements Dao{
 7 
 8     @Override
 9     public void testGuice() {
10         
11         System.out.println("测试guice，实现依赖!");
12         
13     }
14 
15 }

 1 package com.ming.user.test;
 2 
 3 public class DaoImpl2 implements Dao{
 4 
 5     @Override
 6     public void testGuice() {
 7         
 8         System.out.println("第二个实现耶....");
 9         
10     }
11 
12     
13 }

最后就是通过guice自定义的Name方式绑定:

 1 package com.ming.user.test;
 2 
 3 import com.google.inject.Inject;
 4 import com.google.inject.Singleton;
 5 import com.google.inject.name.Named;
 6 
 7 /**
 8  * 测试几种注入方式
 9  * @author mingge
10  *
11  */
12 @Singleton
13 public class TestDaoInjection {
14 
15     
16     private Dao dao;
17     
18     @Inject
19     @CSV1
20     private Dao dao1;
21     
22     @Inject
23     public void setDao(@CSV Dao dao) {//自定义注解绑定实现
24         this.dao = dao;
25     }
26 
27     private int maxResults;
28     
29     @Inject
30     public void setMaxResults(@Named("maxResults") int maxResults) {//按名称绑定
31         this.maxResults = maxResults;
32     }
33 
34     @Inject
35     private Dog dog;//普通注入
36     
37     void test(){
38         System.out.println("这个是注入...");
39         dao.testGuice();
40         System.out.println(maxResults);
41         dog.eat();
42         
43         dao1.testGuice();
44     }
45 }

测试代码:

 1 package com.ming.user.test;
 2 
 3 import com.google.inject.Guice;
 4 import com.google.inject.Injector;
 5 
 6 
 7 public class Test {
 8     
 9     public static void main(String[] args) {
10          Injector injector = Guice.createInjector(new TestModule());  
11          TestDaoInjection test=injector.getInstance(TestDaoInjection.class);
12          test.test();
13     }
14 }

使用provider

在 Guice 中 Providers 就像 Factories 一样创建和返回对象。在大部分情况下，客户端可以直接依赖 Guice 框架来为服务（Services）创建依赖的对象。但是少数情况下，应用程序代码需要为一个特定的类型定制对象创建流程（Object creation process），这样可以控制对象创建的数量，提供缓存（Cache）机制等，这样的话我们就要依赖 Guice 的 Provider 类。

 1 package com.ming.user.test.provide;
 2 
 3 import com.google.inject.ProvidedBy;
 4 
 5 @ProvidedBy(ConnectionProvider.class)
 6 public interface ConnectionI {
 7     
 8     void open();
 9     
10     void close();
11 }

 1 package com.ming.user.test.provide;
 2 
 3 import com.google.inject.Provider;
 4 
 5 public class ConnectionProvider implements Provider<ConnectionI> {
 6 
 7     @Override
 8     public ConnectionI get() {
 9         ConnectionI c=new MockConnection();
10         return c;
11     }
12 
13     
14 }

 1 package com.ming.user.test.provide;
 2 
 3 public class MockConnection implements ConnectionI{
 4 
 5     public void open(){
 6         System.out.println("open...");
 7     }
 8     
 9     public void close(){
10         System.out.println("close...");
11     }
12 }

 1 package com.ming.user.test;
 2 
 3 import com.google.inject.AbstractModule;
 4 import com.ming.user.test.provide.ConnectionI;
 5 import com.ming.user.test.provide.ConnectionProvider;
 6 
 7 /**
 8  * 继承 AbstractModule这个抽象类
 9  * @author mingge
10  *
11  */
12 public class TestModule extends AbstractModule{
13 
14     @Override
15     protected void configure() {
16         
17         //实现Provider接口的绑定
18         bind(ConnectionI.class).toProvider(ConnectionProvider.class);
19     }
20     
21 }

 1 package com.ming.user.test;
 2 
 3 import com.google.inject.Guice;
 4 import com.google.inject.Injector;
 5 import com.ming.user.test.provide.MockConnection;
 6 
 7 
 8 public class Test {
 9     
10     public static void main(String[] args) {
11          Injector injector = Guice.createInjector(new TestModule());  
12          MockConnection test=injector.getInstance(MockConnection.class);
13          test.open();
14          test.close();
15     }
16 }

Summary一下:普通绑定用得最多，name那个方法绑定用于多个接口实现，自定注解那种按特殊情况使用。说明一下，name那个注解绑定，用于绑定属性常量也很方便。