guice 常用的绑定方式 <4>

Posted on | In |   本文总阅读量 次

guice 常用的绑定方式 <4>

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

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

下面直接看代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import com.google.inject.AbstractModule;
import com.google.inject.name.Names;

/**
 * 继承 AbstractModule这个抽象类
 * @author bruce
 *
 */
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);//类似于绑定了一个常量
        
    }
}

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Dog {
    
    void eat(){
        System.out.println("父类的在go，go,go。。。");
    }
}

 
 
 public class DarkDog extends Dog{
 
     @Override
     void eat() {
         System.out.println("heeeelo");
         //super.eat();
     }
 
     
 }

类似于注解绑定:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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 bruce
 *
 */
@BindingAnnotation
@Target({ElementType.FIELD,ElementType.PARAMETER,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface CSV {
    String value() default "";
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

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 bruce
 *
 */
@BindingAnnotation
@Target({ElementType.FIELD,ElementType.PARAMETER,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface CSV1 {

}

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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，实现依赖!");
         
     }
 
 }
1
2
3
4
5
6
7
8
9
10
11
 public class DaoImpl2 implements Dao{

    @Override
    public void testGuice() {
        
        System.out.println("第二个实现耶....");
        
    }

    
}

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
import com.google.inject.Inject;
import com.google.inject.Singleton;
import com.google.inject.name.Named;

/**
 * 测试几种注入方式
 * @author bruce
 *
 */
@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();
    }
}

测试代码:

1
2
3
4
5
6
7
8
9
10
11
12
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 类。

1
2
3
4
5
6
7
8
9
import com.google.inject.ProvidedBy;

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

public class ConnectionProvider implements Provider<ConnectionI> {

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

    
}
1
2
3
4
5
6
7
8
9
10
public class MockConnection implements ConnectionI{

    public void open(){
        System.out.println("open...");
    }
    
    public void close(){
        System.out.println("close...");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import com.google.inject.AbstractModule;
import com.ming.user.test.provide.ConnectionI;
import com.ming.user.test.provide.ConnectionProvider;

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

    @Override
    protected void configure() {
        
        //实现Provider接口的绑定
        bind(ConnectionI.class).toProvider(ConnectionProvider.class);
    }
    
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
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那个注解绑定，用于绑定属性常量也很方便。

生活不止苟且,还有我喜爱的海岸.