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那个注解绑定，用于绑定属性常量也很方便。