¿Cómo obtener el tipo genérico en tiempo de ejecución?

Question

Este es mi código: El ExecutorImp extiende AbstractExecutor que extrae las mismas lógicas de ejecución de sus ejecutores (ExecutorImp es un caso), al llamar al método execute() de ExecutorImp, llamará al método en su supertipo, pero el supertipo (el AbstractExcutor) debe conocer otra clase de unión al implementador (en el ejemplo, es la clase de usuario):

import java.lang.reflect.InvocationTargetException; 
import java.util.ArrayList; 

abstract class AbstractExecutor<E> { 
    public void execute() throws Exception { 
     ArrayList<E> list = new ArrayList<E>(); 
     // here I want to get the real type of 'E' 
     Class cl = this.getClass().getTypeParameters()[0].getGenericDeclaration().getClass(); 
     Object o = cl.getConstructor(String.class).newInstance("Gate"); 
     list.add((E) o); 
     System.out.println(format(list)); 
    } 
    public abstract String format(ArrayList<E> list); 
    public abstract String getType(); 
} 

public class ExectorImp<E> extends AbstractExecutor<User> { 
    @Override 
    public String getType() { 
     return "user"; 
    } 
    @Override 
    public String format(ArrayList<User> list) { 
     StringBuffer sb = new StringBuffer(); 
     for (User u : list) { 
      sb.append(u.toString() + " "); 
     } 
     return sb.toString(); 
    } 
    public static void main(String[] args) throws Exception { 
     new ExectorImp().execute(); 
    } 
} 
class User { 
    String name; 
    public User(String name) { 
     this.name = name; 
    } 
} 

así, cuál es el problema con mis códigos?

Answer 1

Aquí hay algo de confusión. Debido al tipo de borrado no se puede obtener el tipo de información de la ejecución de tipo parametrizado como:

Class<E> cls = E.getClass(); // Error. 
E e = new E(); // Error. 

Sin embargo, se puede obtener información de tiempo de compilación tipo parametrizado de la clase, el campo y declaración de método por ParameterizedType#getActualTypeArguments().

abstract class AbstractExecutor<E> { 

    public void execute() throws Exception { 
     List<E> list = new ArrayList<E>(); 
     Class<E> cls = (Class<E>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0]; 
     E e = cls.getConstructor(String.class).newInstance("Gate"); 
     list.add(e); 
     System.out.println(format(list)); 
    } 

    // ... 
} 

---

actualización: en cuanto a si esto es recomendable o no, aunque esto va a funcionar, esto es sensible a los problemas de tiempo de ejecución siempre que se produzcan cambios menores en la declaración de clase. Usted como desarrollador debe documentarlo adecuadamente. Como una alternativa completamente diferente, puedes utilizar el polimorfismo.

abstract class AbstractExecutor<E> { 

    public void execute() throws Exception { 
     List<E> list = new ArrayList<E>(); 
     E e = create("Gate"); 
     list.add(e); 
     System.out.println(format(list)); 
    } 

    public abstract E create(String name); 

    // ... 
} 

e implementar UserExecutor en consecuencia.

class UserExecutor extends AbstractExecutor<User> { 

    @Override 
    public User create(String name) { 
     return new User(name); 
    } 

    // ... 
} 

Answer 2

Creo que debería usar getActualTypeParameters; como getTypeParameters no se refiere a lo que se ha puesto en su creación de instancias actual en lugar de E, sino a E (para describir cómo está limitado, etc.).

Para obtener el ParameterizedType primero debe usar getGenericSuperclass.

actualización: pero lo anterior sólo funciona si el objeto actual se deriva de una clase genérica con el argumento genérico instancia, como:

class StringList extends ArrayList<String> { 
    public Type whatsMyGenericType() { 
     return ((ParameterizedType)getGenericSuperClass()).getActualTypeParameters()[0]; 
    } 
} 

deberían volver String.class.

Answer 3

No creo que pueda obtener el tipo genérico en tiempo de ejecución. El tipo genérico es una restricción que se aplica en tiempo de compilación. Como recuerdo en tiempo de ejecución, no hay diferencia entre una colección genérica y una colección sin un tipo genérico.

Answer 4

El enfoque habitual para solucionar el problema es cambiar ligeramente el código. Defina el constructor en la clase base aceptando el parámetro Class<E>. Asigna este parámetro al campo interno.

En la subclase defina el constructor sin parámetros y llame a super(User.class) desde allí.

De esta manera sabrá la clase de argumento sin demasiada sobrecarga para los clientes de las subclases.