Guiceを使用してジェネリックインプリメンテーションを実行する

Question

Guiceを使用してジェネリックインタフェースのジェネリックインプリメンテーションをインジェクトでき​​るようにしたいと考えています。 Castle.Windsorを使ってC＃で

public interface Repository<T> { 
    void save(T item); 
    T get(int id); 
} 

public MyRepository<T> implements Repository<T> { 
    @Override 
    public void save(T item) { 
    // do saving 
    return item; 
    } 
    @Override 
    public T get(int id) { 
    // get item and return 
    } 
} 

、私はto doことができるだろう：

Component.For(typeof(Repository<>)).ImplementedBy(typeof(MyRepository<>)) 

が、私は相当Guiceの中に存在しているとは思いません。私はGuiceのTypeLiteralを個々の実装を登録するのに使うことができると知っていますが、Windsorのようにそれらを一度に登録する方法はありますか？

編集：

ここでの使用例です：

Injector injector = Guice.createInjector(new MyModule()); 
Repository<Class1> repo1 = injector.getInstance(new Key<Repository<Class1>>() {}); 
Repository<Class2> repo2 = injector.getInstance(new Key<Repository<Class2>>() {}); 

可能性が高く使用量が別のクラスへの注入になりますが：でジェネリックを使用するためには

public class ClassThatUsesRepository { 
    private Repository<Class1> repository; 

    @Inject 
    public ClassThatUsesRepository(Repository<Class1> repository) { 
    this.repository = repository; 
    } 
} 

Answer 1

Guiceでは、TypeLiteralクラスを使用して汎用バリアントをバインドする必要があります。

package your-application.com; 

import com.google.inject.AbstractModule; 
import com.google.inject.TypeLiteral; 

public class MyModule extends AbstractModule { 
    @Override 
    protected void configure() { 
    bind(new TypeLiteral<Repository<Class1>>(){}) 
     .to(new TypeLiteral<MyRepository<Class1>>(){}); 
    } 
} 

（リポジトリは一般的なインタフェースで、MyRepositoryは一般的な実装で、Class1のは、ジェネリック医薬品に使用される特定のクラスである）：これはGuiceのインジェクタの設定は次のようになります方法の例です。

Answer 2

ジェネリックは実行時に保持されないので、最初はコンセプトを把握するのが難しくなりました。 とにかく、new ArrayList<String>().getClass()はClass<?>ではなくClass<String>ではありませんが、それをClass<? extends String>にキャストすることは安全ですが、コンパイル時の型チェック（暗黙的な検証のようなものです）があることを忘れないでください。

したがって、Repository（任意のタイプ）の新しいインスタンスが必要な場合はいつでも、Guiceを使用してMyRepository（任意のタイプ）実装を注入したい場合は、ジェネリックについて考える必要はありません型の安全性を確保するためにあなた自身で行うことができます（そのため、これらの厄介な "未チェック"警告が発生します）。

ここ

がうまく動作するコードの例を次に示します。

I'm a String 
33 

をしかし、そのリストはLinkedListによって実装です：

public class GuiceTest extends AbstractModule { 

    @Inject 
    List collection; 

    public static void main(String[] args) { 
     GuiceTest app = new GuiceTest(); 
     app.test(); 
    } 

    public void test(){ 
     Injector injector = Guice.createInjector(new GuiceTest()); 
     injector.injectMembers(this); 

     List<String> strCollection = collection; 
     strCollection.add("I'm a String"); 
     System.out.println(collection.get(0)); 

     List<Integer> intCollection = collection; 
     intCollection.add(new Integer(33)); 
     System.out.println(collection.get(1)); 
    } 

    @Override 
    protected void configure() { 
     bind(List.class).to(LinkedList.class); 
    } 
} 

これが印刷されます。この例では何かをの文字列に設定しようとすると例外が発生します。

int i = collection.get(0) 

しかし、あなたは、注射のオブジェクトを取得したい場合は、既にキャスト型、あなただけではなく、リストのList<String>を求めることができダンディが、その後、Guiceのがと同様の結合キー（の一部として、その型変数を扱います@Namedなどの修飾子）。つまり、具体的にはList<String>をArrayList<String>の実装に、List<Integer>をLinkedList<Integer>に注入したい場合、Guiceはこれを行うことができます（テストされていない、推測されていない推測）。

しかし、落とし穴があります：

@Override 
    protected void configure() { 
     bind(List<String>.class).to(LinkedList<String>.class); <-- *Not Happening* 
    } 

あなたはクラスリテラルは汎用的ではないに気づくかもしれませんが。それはGuiceのTypeLiteralsを使用する場所です。

@Override 
    protected void configure() { 
     bind(new TypeLiteral<List<String>>(){}).to(new TypeLiteral<LinkedList<String>>(){}); 
    } 

TypeLiterals所望の実装にマッピングするメタ情報の一部として、ジェネリック型変数を保持します。お役に立てれば。

Answer 3

あなたは（虐待？）を使用することができます@ImplementedBy注釈を作るためにGuiceのあなたのための汎用的なバインディングを生成：

@ImplementedBy(MyRepository.class) 
interface Repository<T> { ... } 

class MyRepository<T> implements Repository<T> { ... } 

をジャストインタイムバインディングが有効になっている限り、あなたは明示的な結合することなくRepository<Whatever>を注入することができます：

Injector injector = Guice.createInjector(); 
    System.out.println(injector.getBinding(new Key<Repository<String>>(){})); 
    System.out.println(injector.getBinding(new Key<Repository<Integer>>(){})); 

キャッチが結合のターゲットはMyRepositoryはなく、MyRepository<T>であるということである。

LinkedKeyBinding{key=Key[type=Repository<java.lang.String>, annotation=[none]], source=interface Repository, scope=Scopes.NO_SCOPE, target=Key[type=MyRepository, annotation=[none]]} 
LinkedKeyBinding{key=Key[type=Repository<java.lang.Integer>, annotation=[none]], source=interface Repository, scope=Scopes.NO_SCOPE, target=Key[type=MyRepository, annotation=[none]]} 

これは通常問題ではありませんが、MyRepositoryはTypeLiteral<T>を注入して実行時に独自の型を特定することはできません。これはこの状況で特に便利です。それを除いて、私の知る限り、これはうまく動作します。

（誰かがこれを固定のように感じる場合は、私はそれだけでソースキーからターゲット型パラメータを埋めるためにいくつかの余分な計算around hereが必要になりますかなり確信しています。）