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那個注解綁定，用於綁定屬性常量也很方便。