유형 매개 변수가 적용된 구현 인터페이스의 유형 인스턴스 가져 오기

Question

Type 인스턴스 (Class 또는 ParameterizedType 일 수 있음)가 주어지면 클래스에서 구현 된 특정 유형의 인터페이스를 가져와야합니다. generics가 없다면 이것은 쉽습니다. Class 인스턴스에서 getInterfaces()를 호출하면 완료됩니다. 그러나 구현 된 인터페이스에 원래 클래스의 유형 매개 변수 자체에 종속되거나 종속되지 않는 자체 유형 매개 변수가있는 경우에도이 기능이 필요합니다. 클래스

class Foo implements Iterable<Integer> {} 

에게 주어진뿐만 아니라 클래스에게 주어진 Iterable을 < 문자열 >을 반환해야 할 때

예로, 함수의 Iterable < 정수 >를 반환해야

class Bar<T> implements Iterable<T> {} 

과 바 <을 나타내는 ParmeterizedType 문자열 >

내장 된 리플렉션, 타사 도구 등으로 쉽게이 작업을 수행 할 수 있습니까?

명확히하려면 리터럴 (Foo.class 등)을 통해 검색된 유형 인스턴스뿐만 아니라 적용된 유형 매개 변수를 포함 할 수있는 리플렉션을 통해 반환 된 유형 (예 : 메소드에서 리플렉션을 통해 반환 된 리턴 유형)도 작동해야합니다.

static Bar<String> magic() { ... } 

이것은 원시 Bar 클래스 및 String 유형 인수를 참조하는 ParameterizedType입니다.

Answer 1

를 사용하는 예입니다 Google Guava TypeToken 클래스 : http://code.google.com/p/guava-libraries/wiki/ReflectionExplained

다양한 유형의 유형을 해결하기위한 정교한 메커니즘을 제공합니다.그리고 내가 제대로 질문을 이해 경우 는 다음 TypeToken#resolveType(Type) 방법 같은 것을 당신이 찾고있는 무엇에 가까운 수 있습니다 :

는

import java.lang.reflect.Method; 
import java.lang.reflect.Type; 
import java.util.Iterator; 

import com.google.common.reflect.TypeToken; 

class Foo implements Iterable<Integer> { 

    @Override 
    public Iterator<Integer> iterator() 
    { 
     return null; 
    } 
} 

class Bar<T> implements Iterable<T> { 

    @Override 
    public Iterator<T> iterator() 
    { 
     return null; 
    } 
} 

public class TypeParameterTest 
{ 
    public static void main(String[] args) throws Exception 
    { 
     Type i0 = getInterface(Foo.class, 0); 
     System.out.println("First interface implemented by Foo: "+i0); 

     Method method = TypeParameterTest.class.getDeclaredMethod("magic"); 
     Type returnType = method.getGenericReturnType(); 

     System.out.println("Magic method return type: "+returnType); 

     Type i1 = getInterface(returnType, 0); 
     System.out.println("First interface implemented by Bar<String>: "+i1); 
    } 

    private static Type getInterface(Type type, int interfaceIndex) 
    { 
     TypeToken<?> typeToken = TypeToken.of(type); 
     Class<?> c = typeToken.getRawType(); 
     Type[] interfaces = c.getGenericInterfaces(); 
     if (interfaces.length == 0) 
     { 
      return null; 
     } 
     Type i = interfaces[interfaceIndex]; 
     return typeToken.resolveType(i).getType(); 
    } 

    public static Bar<String> magic() { return null; } 
} 

출력은 여기 이것은 단순히 사실이 아니다

First interface implemented by Foo: java.lang.Iterable<java.lang.Integer> 
Magic method return type: Bar<java.lang.String> 
First interface implemented by Bar<String>: java.lang.Iterable<java.lang.String> 

Answer 2

유형이 하드 코딩 된 경우 반사를 사용할 수 있습니다. 특정 유형을 하위 클래스로 지정하기 때문입니다. 여기서 유형은 클래스 정보에 저장됩니다.

당신이 반사를 사용하는 경우 Foo이 Iterable<String>를 확장하지만 당신은 Bar<String>있는 경우이 때문에 형의 삭제에 불과 런타임에 Bar이며, 당신이 보는 모두가 당신이있는 경우 Bar이 Iterable<T>

을 확장하는 것을 볼 수 있습니다 매개 변수화 된 제네릭 형식은 런타임에 아무런 작업도 수행하지 않으므로 아무데도 기록되지 않습니다. 이 유형이 필요한 경우 추가 필드로 저장해야합니다.

이 런타임에 유형을 확인하는 수준의 Collections.CheckedMap이고 그 다음이

private static class CheckedMap<K,V> 
    implements Map<K,V>, Serializable 
{ 
    private static final long serialVersionUID = 5742860141034234728L; 

    private final Map<K, V> m; 
    final Class<K> keyType; 
    final Class<V> valueType; 

Answer 3

처럼 시작하면 아마 한 번 봐 가지고 있어야하는 ParameterizedType

import java.lang.reflect.*; 

public class Foo { 

    static class Bar<T> { 

    } 
    static class SubBar extends Bar<Integer> { 

    } 

    public static void main(String argv[]) { 

    ParameterizedType pt = (ParameterizedType)SubBar.class.getGenericSuperclass(); 
    Type[] t = pt.getActualTypeArguments(); 

    for (int i=0;i<t.length;i++) { 

     System.out.println(t[i]); 
    } 
    } 
} 

Answer 4

import java.lang.reflect.ParameterizedType; 
import java.lang.reflect.Type; 
import java.util.Iterator; 

public class Dummy implements Iterable<Integer> { 

    public static void main(String args[]) throws Exception { 

     Dummy d = new Dummy(); 

     Type[] genericInterfaces = Dummy.class.getGenericInterfaces(); 

     for (Type genericInterface : genericInterfaces) { 
      if (genericInterface instanceof ParameterizedType) { 
       Type[] genericTypes = ((ParameterizedType) genericInterface).getActualTypeArguments(); 

       for (Type genericType : genericTypes) { 

        System.out.println("Generic type: " + genericType); 
       } 
      } 
    } 
    } 

    @Override 
    public Iterator<Integer> iterator() { 
     // TODO Auto-generated method stub 
     return null; 
    } 

}