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

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

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

下面直接看代码:

 package com.ming.user.test;

 import com.google.inject.AbstractModule;
 import com.google.inject.name.Names;

 /**
  * 继承 AbstractModule这个抽象类
  * @author mingge
  *
  */
 public class TestModule extends AbstractModule{

     @Override
     protected void configure() {

         //普通绑定
         bind(Dog.class).to(DarkDog.class);

         //自定义注解绑定--一个接口可以多个实现
         bind(Dao.class).annotatedWith(CSV.class).to(DaoImpl.class);
         bind(Dao.class).annotatedWith(CSV1.class) .to(DaoImpl2.class);

         //names注解常量绑定--也可用于一个接口多个实现的绑定
         bindConstant().annotatedWith(Names.named("maxResults")).to(10);//类似于绑定了一个常量

     }
 }

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

 package com.ming.user.test;

 public class Dog {

     void eat(){
         System.out.println("父类的在go，go,go。。。");
     }
 }

 package com.ming.user.test;

 public class DarkDog extends Dog{

     @Override
     void eat() {
         System.out.println("heeeelo");
         //super.eat();
     }

 }

类似与注解绑定:

 package com.ming.user.test;

 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;

 /**
  * 自定义一个绑定注解
  * @author mingge
  *
  */
 @BindingAnnotation
 @Target({ElementType.FIELD,ElementType.PARAMETER,ElementType.METHOD})
 @Retention(RetentionPolicy.RUNTIME)
 public @interface CSV {
     String value() default "";
 }

 package com.ming.user.test;

 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;

 /**
  * 自定义一个绑定注解
  * @author mingge
  *
  */
 @BindingAnnotation
 @Target({ElementType.FIELD,ElementType.PARAMETER,ElementType.METHOD})
 @Retention(RetentionPolicy.RUNTIME)
 public @interface CSV1 {

 }

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

 package com.ming.user.test;

 public interface Dao {

     void testGuice();
 }

 package com.ming.user.test;

 import com.google.inject.Singleton;

 @Singleton
 public class DaoImpl implements Dao{

     @Override
     public void testGuice() {

         System.out.println("测试guice，实现依赖!");

     }

 }

 package com.ming.user.test;

 public class DaoImpl2 implements Dao{

     @Override
     public void testGuice() {

         System.out.println("第二个实现耶....");

     }

 }

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

 package com.ming.user.test;

 import com.google.inject.Inject;
 import com.google.inject.Singleton;
 import com.google.inject.name.Named;

 /**
  * 测试几种注入方式
  * @author mingge
  *
  */
 @Singleton
 public class TestDaoInjection {

     private Dao dao;

     @Inject
     @CSV1
     private Dao dao1;

     @Inject
     public void setDao(@CSV Dao dao) {//自定义注解绑定实现
         this.dao = dao;
     }

     private int maxResults;

     @Inject
     public void setMaxResults(@Named("maxResults") int maxResults) {//按名称绑定
         this.maxResults = maxResults;
     }

     @Inject
     private Dog dog;//普通注入

     void test(){
         System.out.println("这个是注入...");
         dao.testGuice();
         System.out.println(maxResults);
         dog.eat();

         dao1.testGuice();
     }
 }

测试代码:

 package com.ming.user.test;

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

 public class Test {

     public static void main(String[] args) {
          Injector injector = Guice.createInjector(new TestModule());
          TestDaoInjection test=injector.getInstance(TestDaoInjection.class);
          test.test();
     }
 }

使用provider

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

 package com.ming.user.test.provide;

 import com.google.inject.ProvidedBy;

 @ProvidedBy(ConnectionProvider.class)
 public interface ConnectionI {

     void open();

     void close();
 }

 package com.ming.user.test.provide;

 import com.google.inject.Provider;

 public class ConnectionProvider implements Provider<ConnectionI> {

     @Override
     public ConnectionI get() {
         ConnectionI c=new MockConnection();
         return c;
     }

 }

 package com.ming.user.test.provide;

 public class MockConnection implements ConnectionI{

     public void open(){
         System.out.println("open...");
     }

     public void close(){
         System.out.println("close...");
     }
 }

 package com.ming.user.test;

 import com.google.inject.AbstractModule;
 import com.ming.user.test.provide.ConnectionI;
 import com.ming.user.test.provide.ConnectionProvider;

 /**
  * 继承 AbstractModule这个抽象类
  * @author mingge
  *
  */
 public class TestModule extends AbstractModule{

     @Override
     protected void configure() {

         //实现Provider接口的绑定
         bind(ConnectionI.class).toProvider(ConnectionProvider.class);
     }

 }

 package com.ming.user.test;

 import com.google.inject.Guice;
 import com.google.inject.Injector;
 import com.ming.user.test.provide.MockConnection;

 public class Test {

     public static void main(String[] args) {
          Injector injector = Guice.createInjector(new TestModule());
          MockConnection test=injector.getInstance(MockConnection.class);
          test.open();
          test.close();
     }
 }

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