How can I get the type variable vs field mapping from a generic class?

Question

I have a generic class as below, two type variables with three fields declared.

class RowClass<T1, T2> {
    public T1 t1;
    public T2 t2;
    public T1 t3;
}

Now I want to extract a mapping as this:

t1 -> T1; t2 -> T2; t3 -> T3

So I can know exactly which type variable each field is associated to. Below code will not work as generic erasure.

for (Field declaredField : RowClass.class.getDeclaredFields()) {
    System.out.println(declaredField.getName()+" -> " +declaredField.getType());
}
// t1 -> class java.lang.Object
// t2 -> class java.lang.Object
// t3 -> class java.lang.Object
// no type variable symbol printed

Why I ask this issue? Just for study, I am try to understand how Jackson deserialize json string to Class with declared generic type, sucn as List<String>.

first, I can get the type variable list:

// the list of type variable
final TypeVariable<Class<RowClass>>[] typeParameters = RowClass.class.getTypeParameters();
Arrays.stream(typeParameters).forEach(System.out::println);

Second, I can also get the list of actual arguments:

class RowClassImpl extends RowClass<String, Integer> {
}

final ParameterizedType parameterizedType = (ParameterizedType) (RowClassImpl.class.getGenericSuperclass());
Arrays.stream(parameterizedType.getActualTypeArguments()).forEach(type -> System.out.println(type.getTypeName()));

If I can get the type variable vs field mapping, I can preserve all the generic information for each field.

Answer 1

"... Now I want to extract a mapping as this:

t1 -> T1; t2 -> T2; t3 -> T3 ..."

You wrote that incorrectly, by the way.  It should be T1 for t3.

Here is an example.

RowClass<?, ?> r = new RowClass<>();
Map<String, Type> m
    = Stream.of(r.getClass().getDeclaredFields())
            .collect(Collectors.toMap(Field::getName, Field::getGenericType));

Output

{t1=T1, t2=T2, t3=T1}

Answer 2

Preface:

You can't really get the types of generic variables.

Explanation with example:

A generic getter must return an Integer, a String or something else depending on what T is.

You can implement a method that returns T, but you have to cast the return value after that, because T can not do the things a String can.

Ways to preserve information about T:

You can preserve the class name of T in a String - something like this:

String classOfT = T.class

Workaround solution 1:

You could create a custom annotation processor which automatically creates the classes while compiling. Like Lombok does it for the builder pattern for example.

Workaround solution 2:

You can get information about the classOfT if you pass it as a parameter like this:

public class TestMain {

    public static void main(String[] args) {
        new TestMain();
    }

    public TestMain() {
        MyList<String> myList = new MyList<>(String.class);
        System.out.println("classOfTAsString=" + myList.getClassOfTAsString());
    }

    public static class MyList<T> extends ArrayList<T> {

        private Class<T> classOfT;
        private String classOfTAsString;

        public MyList(Class<T> classOfT) {
            super();
            this.classOfT = classOfT;
            this.classOfTAsString = classOfT.getName(); // or getSimpleName();
        }

        public String getClassOfTAsString() {
            return classOfTAsString;
        }

    }


}