fromjson - Java Type Generic como argumento para GSON

java gson to list

Question

En GSON para obtener una lista de objetos que haces

Gson gson = new Gson();
Type token = new TypeToken<List<MyType>>(){}.getType();
return gson.fromJson(json, token);

Funciona muy bien, pero quiero ir más allá y tener MyType parametrizado para que pueda tener una función común para analizar la lista de objetos con este código

// the common function 
public <T> List<T> fromJSonList(String json, Class<T> type) {
  Gson gson = new Gson();
  Type collectionType = new TypeToken<List<T>>(){}.getType();
  return gson.fromJson(json, collectionType);
}

// the call
List<MyType> myTypes = parser.fromJSonList(jsonString, MyType.class);

Tristemente devuelve una matriz de StringMaps, no el tipo. T se interpreta como otro tipo genérico, no mi tipo. Cualquier solución?

Answer 1

En kotlin uso simple por ejemplo:

Obtener la función de lugares

fun getPlaces<T> (jsonString : String, clazz: Class<T>) : T { val places : T = Gson().fromJson(jsonString,clazz) return places }

Entonces puedes usar como:

val places = getPlaces(Array<Place>::class.java)

Answer 2

Esto ha sido respondido en preguntas anteriores. Básicamente, hay 2 opciones:

1. Pase el Type desde el sitio que llama. El código de llamada usará TypeToken o lo que sea para construirlo.
2. Construya un Type correspondiente al tipo parametrizado usted mismo. Esto requerirá que escribas una clase que implemente ParameterizedType

Answer 3

He llevado Raffaele''s enfoque Raffaele''s un paso más allá y he generalizado la clase, de modo que funciona con todas las clases A, donde B es una clase no parametrizada. Puede ser útil para Conjuntos y otras Colecciones.

    public class GenericOf<X, Y> implements ParameterizedType {

    private final Class<X> container;
    private final Class<Y> wrapped;

    public GenericOf(Class<X> container, Class<Y> wrapped) {
        this.container = container;
        this.wrapped = wrapped;
    }

    public Type[] getActualTypeArguments() {
        return new Type[]{wrapped};
    }

    public Type getRawType() {
        return container;
    }

    public Type getOwnerType() {
        return null;
    }

}

Answer 4

La solución Kotlin "ListOfSomething" que funcionó para mí:

fun <T: Any> getGsonList(json: String, kclass: KClass<T>) : List<T> {

    return getGsonInstance().fromJson<List<T>>(json, ListOfSomething<T>(kclass.java))
}


internal class ListOfSomething<X>(wrapped: Class<X>) : ParameterizedType {

    private val wrapped: Class<*>

    init {
        this.wrapped = wrapped
    }

    override fun getActualTypeArguments(): Array<Type> {
        return arrayOf<Type>(wrapped)
    }

    override fun getRawType(): Type {
        return ArrayList::class.java
    }

    override fun getOwnerType(): Type? {
        return null
    }
}

Answer 5

Los genéricos funcionan en tiempo de compilación. La razón por la cual los tokens de tipo súper funcionan, se debe a que las clases internas (anónimas) pueden acceder a los argumentos tipo para sus superclases genéricas (superinterfaces), que a su vez se almacenan directamente en los metadatos de bytecode.

Una vez que se compila el archivo fuente .java, obviamente se descarta el parámetro de tipo <T> . Como no se conoce en tiempo de compilación, no se puede almacenar en bytecode, por lo que se borra y Gson no puede leerlo.

ACTUALIZAR

Después de la respuesta de newacct, traté de implementar lo que él sugirió en su opción 2, es decir, implementar un ParameterizedType . El código se ve así (aquí hay una test básica):

class ListOfSomething<X> implements ParameterizedType {

    private Class<?> wrapped;

    public ListOfSomething(Class<X> wrapped) {
        this.wrapped = wrapped;
    }

    public Type[] getActualTypeArguments() {
        return new Type[] {wrapped};
    }

    public Type getRawType() {
        return List.class;
    }

    public Type getOwnerType() {
        return null;
    }

}

el propósito de este código, se debe usar dentro de getFromJsonList() :

public List<T> fromJsonList(String json, Class<T> klass) {
    Gson gson = new Gson();
    return gson.fromJson(json, new ListOfSomething<T>(klass));
}

Incluso si la técnica funciona y es realmente muy inteligente (no lo sabía y nunca lo hubiera pensado), este es el logro final:

List<Integer> list = new Factory<Integer>()
         .getFromJsonList(text, Integer.class)

en lugar de

List<Integer> list = new Gson().fromJson(text,
         new TypeToken<List<Integer>>(){}.getType());

Para mí, todo esto es inútil, incluso si estoy de acuerdo con que TypeToken haga que el código se vea desagradable: P

Answer 6

Si programamos en kotlin, podemos usar el reified type parameter en la función en línea

class GenericGson {

    companion object {
        inline fun <reified T : Any> Gson.fromJsonTokenType(jsonString: String): T {
            val type = object : TypeToken<T>() {}.type
            return this.fromJson(jsonString, type)
        }

        inline fun <reified T : Any> Gson.fromJsonType(jsonString: String): T = this.fromJson(jsonString, T::class.java)

        inline fun <reified T : Any> fromJsonTokenType(jsonString: String): T = Gson().fromJsonTokenType(jsonString)

        inline fun <reified T : Any> fromJsonType(jsonString: String): T = Gson().fromJsonType(jsonString)
    }
}

Y utilícelos a continuación en su código

val arrayList = GenericGson.fromJsonTokenType<ArrayList<Person>>(json)

Answer 7

Sinnce gson 2.8.0 , puede usar TypeToken#getParametized((Type rawType, Type... typeArguments)) para crear el typeToken , luego getType() debería hacer el truco.

Por ejemplo:

TypeToken.getParameterized(List.class, myType).getType();

Answer 8

public static final <T> List<T> getList(final Class<T[]> clazz, final String json)
{
    final T[] jsonToObject = new Gson().fromJson(json, clazz);

    return Arrays.asList(jsonToObject);
}

Ejemplo:

getList(MyClass[].class, "[{...}]");