¿Cómo se determina la clase de un tipo genérico?

Question

Estoy creando una clase genérica y en uno de los métodos necesito conocer la Clase del tipo genérico actualmente en uso. La razón es que uno de los métodos que llamo espera esto como un argumento.

Ejemplo:

public class MyGenericClass<T> { 
    public void doSomething() { 
    // Snip... 
    // Call to a 3rd party lib 
    T bean = (T)someObject.create(T.class); 
    // Snip... 
    } 
} 

Es evidente que el ejemplo anterior no funciona y da como resultado el siguiente error: clase Ilegal literal para el parámetro de tipo T.

Mi pregunta es: ¿Alguien sabe un buen alternativa o solución para esto?

Answer 1

Sigue siendo el mismo problema: la información genérica se borra durante el tiempo de ejecución, no se puede recuperar. Una solución consiste en pasar la clase T en el parámetro de un método estático:

public class MyGenericClass<T> { 

    private final Class<T> clazz; 

    public static <U> MyGenericClass<U> createMyGeneric(Class<U> clazz) { 
     return new MyGenericClass<U>(clazz); 
    } 

    protected MyGenericClass(Class<T> clazz) { 
     this.clazz = clazz; 
    } 

    public void doSomething() { 
     T instance = clazz.newInstance(); 
    } 
} 

Es feo, pero funciona.

Answer 2

me acaba de señalar a esta solución:

import java.lang.reflect.ParameterizedType; 

public abstract class A<B> { 
    public Class<B> g() throws Exception { 
     ParameterizedType superclass = 
      (ParameterizedType) getClass().getGenericSuperclass(); 

     return (Class<B>) superclass.getActualTypeArguments()[0]; 
    } 
} 

Esto funciona si A se da un tipo concreto por una subclase:

new A<String>() {}.g() // this will work 

class B extends A<String> {} 
new B().g() // this will work 

class C<T> extends A<T> {} 
new C<String>().g() // this will NOT work 

Answer 3

Desafortunadamente solución de Christoph tal como está escrita sólo funciona en circunstancias muy limitadas . [EDITAR: como se comenta a continuación, ya no recuerdo mi razonamiento para esta frase y es probable que esté equivocado: "Tenga en cuenta que esto solo funcionará en clases abstractas, en primer lugar."] La siguiente dificultad es que g() solo funciona desde subclases DIRECTAS de A. Sin embargo, podemos solucionarlo:

private Class<?> extractClassFromType(Type t) throws ClassCastException { 
    if (t instanceof Class<?>) { 
     return (Class<?>)t; 
    } 
    return (Class<?>)((ParameterizedType)t).getRawType(); 
} 

public Class<B> g() throws ClassCastException { 
    Class<?> superClass = getClass(); // initial value 
    Type superType; 
    do { 
     superType = superClass.getGenericSuperclass(); 
     superClass = extractClassFromType(superType); 
    } while (! (superClass.equals(A.class))); 

    Type actualArg = ((ParameterizedType)superType).getActualTypeArguments()[0]; 
    return (Class<B>)extractClassFromType(actualArg); 
} 

Esto funcionará en muchas situaciones en la práctica, pero no TODO el tiempo. Considere lo siguiente:

public class Foo<U,T extends Collection<?>> extends A<T> {} 

(new Foo<String,List<Object>>() {}).g(); 

Esto lanzará un ClassCastException, porque el argumento de tipo aquí no es un Class o una ParameterizedType en absoluto; es el TypeVariableT. Así que ahora estarías atascado tratando de averiguar qué tipo se suponía que representaba el T, y así sucesivamente en el agujero del conejo.

Creo que la única respuesta razonable y general es algo parecido a la respuesta inicial de Nicolas: en general, si su clase necesita instanciar objetos de otra clase desconocida en tiempo de compilación, los usuarios de su clase deben pasar esa clase literal (o, tal vez, una fábrica) para su clase de forma explícita y no depender únicamente de los genéricos.

Answer 4

encuentro otro modo de obtener la clase del objeto genérico

public Class<?> getGenericClass(){ 
     Class<?> result =null; 
     Type type =this.getClass().getGenericSuperclass(); 

     if(type instanceofParameterizedType){ 
       ParameterizedType pt =(ParameterizedType) type; 
       Type[] fieldArgTypes = pt.getActualTypeArguments(); 
       result =(Class<?>) fieldArgTypes[0]; 
     } 
     return result; 
    } 

Answer 5

T puede resolverse con bastante facilidad utilizando TypeTools:

Class<T> t = (Class<T>) TypeResolver.resolveRawArguments(
           MyGenericClass.class, getClass()); 

Answer 6

voy a elaborar una solución de Christoph.

Aquí es la clase abstracta ClassGetter:

private abstract class ClassGetter<T> { 
    public final Class<T> get() { 
     final ParameterizedType superclass = (ParameterizedType) 
      getClass().getGenericSuperclass(); 
     return (Class<T>)superclass.getActualTypeArguments()[0]; 
    } 
} 

Aquí es un método estático que utiliza la clase de arriba para encontrar una clase genérica de tipo:

public static <T> Class<T> getGenericClass() { 
    return new ClassGetter<T>() {}.get(); 
} 

Como ejemplo de su uso, usted podría hacer este método:

public static final <T> T instantiate() { 
    final Class<T> clazz = getGenericClass(); 
    try { 
     return clazz.getConstructor((Class[])null).newInstance(null); 
    } catch (Exception e) { 
     return null; 
    } 
} 

y luego usarlo como esto:

T var = instantiate();