Jak uzyskać instancję klasy generyków typu T

Szukałem sposobu, aby to zrobić sam bez dodawania dodatkowej zależności do ścieżki klasowej. Po jakimś śledztwie okazało się, że na możliwe, o ile masz ogólny supertyp. Było to dla mnie OK, ponieważ pracowałem z Dao warstwą z ogólnym supertyp warstwy. Jeśli to pasuje do twojego scenariusza, to jest to najbardziej schludne podejście IMHO.

Większość przypadków użycia generyków, z którymi się spotkałem, ma jakiś rodzaj ogólnego supertypu, np. List<T> dla ArrayList<T> lub GenericDAO<T> dla DAO<T>, itd.

Pure Java solution

Artykuł uzyskiwanie dostępu do typów generycznych podczas pracy w Javie wyjaśnia, jak można to zrobić za pomocą czystej Javy.

Rozwiązanie sprężyny

Mój projekt wykorzystywał Spring co jest jeszcze lepsze, ponieważ Spring ma przydatną metodę znajdowania typu. Jest to dla mnie najlepsze podejście, ponieważ wygląda schludnie. Myślę, że gdybyś nie używał Springa, mógłbyś napisać własną metodę użytkową.

import org.springframework.core.GenericTypeResolver;

public abstract class AbstractHibernateDao<T extends DomainObject> implements DataAccessObject<T>
{

    @Autowired
    private SessionFactory sessionFactory;

    private final Class<T> genericType;

    private final String RECORD_COUNT_HQL;
    private final String FIND_ALL_HQL;

    @SuppressWarnings("unchecked")
    public AbstractHibernateDao()
    {
        this.genericType = (Class<T>) GenericTypeResolver.resolveTypeArgument(getClass(), AbstractHibernateDao.class);
        this.RECORD_COUNT_HQL = "select count(*) from " + this.genericType.getName();
        this.FIND_ALL_HQL = "from " + this.genericType.getName() + " t ";
    }

Istnieje jednak mała luka: jeśli zdefiniujesz klasę Foo jako abstrakcyjną. Oznacza to, że musisz utworzyć klasę jako:

Foo<MyType> myFoo = new Foo<MyType>(){};

(zwróć uwagę na podwójne szelki na końcu.)

Teraz możesz pobrać typ T w czasie wykonywania:

Type mySuperclass = myFoo.getClass().getGenericSuperclass();
Type tType = ((ParameterizedType)mySuperclass).getActualTypeArguments()[0];

Zauważ jednak, że mySuperclass musi być superklasą definicji klasy faktycznie definiującej ostateczny typ dla T.

Nie jest też zbyt elegancki, ale musisz zdecydować, czy wolisz new Foo<MyType>(){} czy new Foo<MyType>(MyType.class); w Twoim kodzie.

Na przykład:

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

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.NoSuchElementException;

/**
 * Captures and silently ignores stack exceptions upon popping.
 */
public abstract class SilentStack<E> extends ArrayDeque<E> {
  public E pop() {
    try {
      return super.pop();
    }
    catch( NoSuchElementException nsee ) {
      return create();
    }
  }

  public E create() {
    try {
      Type sooper = getClass().getGenericSuperclass();
      Type t = ((ParameterizedType)sooper).getActualTypeArguments()[ 0 ];

      return (E)(Class.forName( t.toString() ).newInstance());
    }
    catch( Exception e ) {
      return null;
    }
  }
}

Potem:

public class Main {
    // Note the braces...
    private Deque<String> stack = new SilentStack<String>(){};

    public static void main( String args[] ) {
      // Returns a new instance of String.
      String s = stack.pop();
      System.out.printf( "s = '%s'\n", s );
    }
}

Standardowym podejściem / obejściem / rozwiązaniem jest dodanie class obiektu do konstruktora(ów), np.:

 public class Foo<T> {

    private Class<T> type;
    public Foo(Class<T> type) {
      this.type = type;
    }

    public Class<T> getType() {
      return type;
    }

    public T newInstance() {
      return type.newInstance();
    }
 }

Wyobraź sobie, że masz abstrakcyjną superklasę, która jest ogólna:

public abstract class Foo<? extends T> {}

I wtedy masz drugą klasę, która rozszerza Foo z ogólnym paskiem, który rozszerza T:

public class Second extends Foo<Bar> {}

Możesz uzyskać klasę Bar.class w klasie Foo, wybierając Type (od odpowiedzi Berta bruynooghe) i wnioskując ją za pomocą instancji Class:

Type mySuperclass = myFoo.getClass().getGenericSuperclass();
Type tType = ((ParameterizedType)mySuperclass).getActualTypeArguments()[0];
//Parse it as String
String className = tType.toString().split(" ")[1];
Class clazz = Class.forName(className);

Należy zauważyć, że ta operacja nie jest idealna, więc dobrym pomysłem jest buforowanie obliczonej wartości, aby uniknąć wielokrotnych obliczeń na tej podstawie. Jednym z typowych zastosowań jest w ogólnej implementacji DAO.

Ostateczna realizacja:

public abstract class Foo<T> {

    private Class<T> inferedClass;

    public Class<T> getGenericClass(){
        if(inferedClass == null){
            Type mySuperclass = getClass().getGenericSuperclass();
            Type tType = ((ParameterizedType)mySuperclass).getActualTypeArguments()[0];
            String className = tType.toString().split(" ")[1];
            inferedClass = Class.forName(className);
        }
        return inferedClass;
    }
}

Zwracana wartość to Bar.Klasa wywołana z klasy Foo w innej funkcji lub z klasy Bar.

Oto rozwiązanie robocze:

@SuppressWarnings("unchecked")
private Class<T> getGenericTypeClass() {
    try {
        String className = ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0].getTypeName();
        Class<?> clazz = Class.forName(className);
        return (Class<T>) clazz;
    } catch (Exception e) {
        throw new IllegalStateException("Class is not parametrized with generic type!!! Please use extends <> ");
    }
} 

Przypisy: może być używany tylko jako superclass

1. musi być rozszerzona o klasę typed(Child extends Generic<Integer>)

lub

1. musi być utworzona jako implementacja anonimowa (new Generic<Integer>() {};)

Miałem ten problem w abstrakcyjnej klasie generycznej. W tym konkretnym przypadku rozwiązanie jest prostsze:

abstract class Foo<T> {
    abstract Class<T> getTClass();
    //...
}

I Później Klasa pochodna:

class Bar extends Foo<Whatever> {
    @Override
    Class<T> getTClass() {
        return Whatever.class;
    }
}

Nie możesz tego zrobić z powodu typu kasowania. Zobacz także pytanie o przepełnienie stosuJava generics - type erasure-kiedy i co się dzieje.

Lepszą drogą niż klasa, którą sugerują inni, jest przejście do obiektu, który może zrobić to, co zrobiłbyś z klasą, np. utworzyć nową instancję.

interface Factory<T> {
  T apply();
}

<T> void List<T> make10(Factory<T> factory) {
  List<T> result = new ArrayList<T>();
  for (int a = 0; a < 10; a++)
    result.add(factory.apply());
  return result;
}

class FooFactory<T> implements Factory<Foo<T>> {
  public Foo<T> apply() {
    return new Foo<T>();
  }
}

List<Foo<Integer>> foos = make10(new FooFactory<Integer>());

To możliwe:

class Foo<T> {
  Class<T> clazz = (Class<T>) DAOUtil.getTypeArguments(Foo.class, this.getClass()).get(0);
}

Potrzebujesz dwóch funkcji z svn/trunk/dao/src/main/java/com/googlecode/genericdao/dao/ DAOUtil.java .

Aby uzyskać więcej wyjaśnień, zobacz refleksyjne leki generyczne.

Mam (brzydkie, ale skuteczne) rozwiązanie tego problemu, z którego ostatnio korzystałem:

import java.lang.reflect.TypeVariable;


public static <T> Class<T> getGenericClass()
{
    __<T> ins = new __<T>();
    TypeVariable<?>[] cls = ins.getClass().getTypeParameters(); 

    return (Class<T>)cls[0].getClass();
}

private final class __<T> // generic helper class which does only provide type information
{
    private __()
    {
    }
}

Znalazłem na to ogólny i prosty sposób. W mojej klasie stworzyłem metodę, która zwraca typ generyczny zgodnie z jego pozycją w definicji klasy. Przyjmijmy taką definicję klasy:

public class MyClass<A, B, C> {

}

Teraz stwórzmy kilka atrybutów do utrzymywania typów:

public class MyClass<A, B, C> {

    private Class<A> aType;

    private Class<B> bType;

    private Class<C> cType;

// Getters and setters (not necessary if you are going to use them internally)

    } 

Następnie można utworzyć metodę generyczną, która zwraca typ na podstawie indeksu definicji generycznej:

   /**
     * Returns a {@link Type} object to identify generic types
     * @return type
     */
    private Type getGenericClassType(int index) {
        // To make it use generics without supplying the class type
        Type type = getClass().getGenericSuperclass();

        while (!(type instanceof ParameterizedType)) {
            if (type instanceof ParameterizedType) {
                type = ((Class<?>) ((ParameterizedType) type).getRawType()).getGenericSuperclass();
            } else {
                type = ((Class<?>) type).getGenericSuperclass();
            }
        }

        return ((ParameterizedType) type).getActualTypeArguments()[index];
    }

Na koniec, w konstruktorze wystarczy wywołać metodę i wysłać indeks dla każdego Typ. Pełny kod powinien wyglądać następująco:

public class MyClass<A, B, C> {

    private Class<A> aType;

    private Class<B> bType;

    private Class<C> cType;


    public MyClass() {
      this.aType = (Class<A>) getGenericClassType(0);
      this.bType = (Class<B>) getGenericClassType(1);
      this.cType = (Class<C>) getGenericClassType(2);
    }

   /**
     * Returns a {@link Type} object to identify generic types
     * @return type
     */
    private Type getGenericClassType(int index) {

        Type type = getClass().getGenericSuperclass();

        while (!(type instanceof ParameterizedType)) {
            if (type instanceof ParameterizedType) {
                type = ((Class<?>) ((ParameterizedType) type).getRawType()).getGenericSuperclass();
            } else {
                type = ((Class<?>) type).getGenericSuperclass();
            }
        }

        return ((ParameterizedType) type).getActualTypeArguments()[index];
    }
}

Jak wyjaśniono w innych odpowiedziach, aby użyć tego podejścia ParameterizedType, musisz rozszerzyć klasę, ale wydaje się to dodatkową pracą, aby stworzyć zupełnie nową klasę, która ją rozszerza...

Więc, uczynienie klasy abstrakcyjną zmusza cię do jej rozszerzenia, spełniając w ten sposób wymóg podklasowania. (za pomocą lombok ' s @Getter).

@Getter
public abstract class ConfigurationDefinition<T> {

    private Class<T> type;
    ...

    public ConfigurationDefinition(...) {
        this.type = (Class<T>) ((ParameterizedType) this.getClass().getGenericSuperclass()).getActualTypeArguments()[0];
        ...
    }
}

Teraz rozszerzyć go bez definiowania nowej klasy. (Zwróć uwagę na {} na końcu... rozszerzone, ale nie nadpisuj niczego-chyba, że chcesz).

private ConfigurationDefinition<String> myConfigA = new ConfigurationDefinition<String>(...){};
private ConfigurationDefinition<File> myConfigB = new ConfigurationDefinition<File>(...){};
...
Class stringType = myConfigA.getType();
Class fileType = myConfigB.getType();

   public <T> T yourMethodSignature(Class<T> type) {

        // get some object and check the type match the given type
        Object result = ...            

        if (type.isAssignableFrom(result.getClass())) {
            return (T)result;
        } else {
            // handle the error
        }
   }

Jeśli rozszerzasz lub implementujesz dowolną klasę / interfejs, która używa generycznych, możesz uzyskać ogólny typ nadrzędnej klasy / interfejsu, bez modyfikowania żadnej istniejącej klasy/interfejsu.

Mogą być trzy możliwości,

Przypadek 1 Kiedy twoja klasa rozszerza klasę, która używa generyków

public class TestGenerics {
    public static void main(String[] args) {
        Type type = TestMySuperGenericType.class.getGenericSuperclass();
        Type[] gTypes = ((ParameterizedType)type).getActualTypeArguments();
        for(Type gType : gTypes){
            System.out.println("Generic type:"+gType.toString());
        }
    }
}

class GenericClass<T> {
    public void print(T obj){};
}

class TestMySuperGenericType extends GenericClass<Integer> {
}

Przypadek 2 Kiedy twoja klasa implementuje interfejs, który używa Generics

public class TestGenerics {
    public static void main(String[] args) {
        Type[] interfaces = TestMySuperGenericType.class.getGenericInterfaces();
        for(Type type : interfaces){
            Type[] gTypes = ((ParameterizedType)type).getActualTypeArguments();
            for(Type gType : gTypes){
                System.out.println("Generic type:"+gType.toString());
            }
        }
    }
}

interface GenericClass<T> {
    public void print(T obj);
}

class TestMySuperGenericType implements GenericClass<Integer> {
    public void print(Integer obj){}
}

Przypadek 3 Gdy twój interfejs jest rozszerzenie interfejsu używającego Generics

public class TestGenerics {
    public static void main(String[] args) {
        Type[] interfaces = TestMySuperGenericType.class.getGenericInterfaces();
        for(Type type : interfaces){
            Type[] gTypes = ((ParameterizedType)type).getActualTypeArguments();
            for(Type gType : gTypes){
                System.out.println("Generic type:"+gType.toString());
            }
        }
    }
}

interface GenericClass<T> {
    public void print(T obj);
}

interface TestMySuperGenericType extends GenericClass<Integer> {
}

Właściwie, przypuszczam, że masz pole w swojej klasie typu T. Jeśli nie ma pola typu T, jaki jest sens posiadania typu ogólnego? Możesz więc po prostu zrobić instanceof na tym polu.

W moim przypadku mam

List<T> items;

if (items.get(0) instanceof Locality) ...

Oczywiście działa to tylko wtedy, gdy całkowita liczba możliwych klas jest ograniczona.

Używam do tego obejścia:

class MyClass extends Foo<T> {
....
}

MyClass myClassInstance = MyClass.class.newInstance();