Java-Typ Generische als Argument für GSON

In GSON, um eine Liste von Objekten, die Sie tun

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

Funktioniert es Super, aber ich möchte noch weiter gehen und haben gleichen Typ eingestellt, so kann ich haben eine gemeinsame Funktion zu analysieren, Liste der Objekte, die mit diesem code

//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);

Leider gibt ein array von StringMaps, nicht der Typ. T wird interpretiert als ein anderer generischer Typ, nicht mein Typ. Abhilfe ?

Vielleicht sind diese links hilfreich: stackoverflow.com/questions/75175/... stackoverflow.com/questions/356583/... velocityreviews.com/forums/... tutorials.jenkov.com/java-reflection/generics.html In der zweiten Verbindung, die Sie vorschlagen, eine factory-Methode. Hmm... ich bin mir nicht sicher, ob die Verwendung ? statt T könnte das problem lösen.

InformationsquelleAutor Rodrigo Asensio | 2013-01-03

42

Generika Arbeit zur compile-Zeit. Der Grund super-Typ-Token arbeiten, ist da eine (anonyme) innere Klassen können auf die Art Argumente, um Ihre generischen Oberklassen (superinterfaces), die wiederum gespeichert sind, direkt in den bytecode Metadaten.

Sobald Ihr .java-Quelldatei kompiliert wird, der parameter type <T> ist offensichtlich weggeworfen. Da ist es zur Kompilierzeit nicht bekannt, es kann nicht gespeichert werden in bytecode, also ist es gelöscht und Gson kann es nicht Lesen.

UPDATE

Nach newacct Antwort, ich habe versucht, das umzusetzen, was er vorgeschlagen hat in seiner option 2, dh die Umsetzung einer ParameterizedType. Der code sieht so aus (hier ist eine grundlegende test):
```
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;
    }

}
```
der Zweck dieses code ist auf getFromJsonList():
```
public List<T> fromJsonList(String json, Class<T> klass) {
    Gson gson = new Gson();
    return gson.fromJson(json, new ListOfSomething<T>(klass));
}
```
Selbst wenn die Technik funktioniert und ist in der Tat sehr klug (ich wusste es nicht, und ich hätte nie thinked es), dies ist die Letzte Errungenschaft:
```
List<Integer> list = new Factory<Integer>()
         .getFromJsonList(text, Integer.class)
```
statt
```
List<Integer> list = new Gson().fromJson(text,
         new TypeToken<List<Integer>>(){}.getType());
```
Zu mir, alle, diese Verpackung in nutzlos, auch wenn ich damit einverstanden, dass TypeTokens den code schauen böse 😛

ziemlich klar, leider sieht begrenzt
Es ist. Der entscheidende Punkt ist, dass, um für die super-Typ-token-machinary zu arbeiten, wir müssen erstellen Sie eine fiktive anonyme Klasse, dh ein Teil der bytecode, der hat sogar seinen eigenen Outer.$N.class - Datei. Dies ist der trick, macht TypeToken arbeiten, kann aber nicht wirklich in Ihrem Fall nicht, denn wenn die bereitgestellte Methode Quelle kompiliert wird, wird die Class<T> argument fo fromJSonList gelöscht
Es ist nicht "gelöscht" in der Type. Eher, das generische argument wird gespeichert als TypeVariable eher als eine Class
vielleicht haben Sie falsch verstanden, der Satz. Ich meine, im inneren fonrJsonList(), die type argument ist ein raw -Class.
Souldn nicht getRawType zurück ListOfSomething.class statt? Ansonsten danke, das du mir den Arsch gerettet heute 🙂

InformationsquelleAutor Raffaele
29

Seit gson 2.8.0, die Sie verwenden können, TypeToken#getParametized((Typ rawType, Typ... typeArguments)) zu erstellen, die typeToken, dann getType() sollte den trick tun.

Beispiel:
```
TypeToken.getParameterized(List.class, myType).getType();
```
InformationsquelleAutor oldergod
27
```
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);
}
```
Beispiel:
```
getList(MyClass[].class, "[{...}]");
```
Netten workaround! Danke.
Super Antwort! Dank
Wie man für immer Singel-Objekt von <T>
Gute Antwort, aber bewusst sein, dass die List zurückgegeben Arrays.asList ist ein nur-lese-wrapper für das array. Es ist nicht eine ArrayList. Sie können nicht hinzufügen oder ändern von Elementen.

InformationsquelleAutor kayz1

Habe ich Raffaele ist Ansatz einen Schritt weiter und generified der Klasse, so dass es funktioniert mit jeder Klasse A, wobei B eine nicht-parametrisierte Klasse. Könnte nützlich sein, für Sets und andere Sammlungen.

    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;
    }

}

InformationsquelleAutor Christian Brüggemann

Hier ist der vollständige code-Basis auf Super Antwort von @oldergod

public <T> List<T> fromJSonList(String json, Class<T> myType) {
    Gson gson = new Gson();
    Type collectionType = TypeToken.getParameterized(List.class, myType).getType();
    return gson.fromJson(json, collectionType);
}

Mit

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

Hoffe, es hilft

InformationsquelleAutor Phan Van Linh

3

Diese beantwortet wurde in vorherigen Fragen. Grundsätzlich gibt es 2 Möglichkeiten:
1. Pass die Type in der aufrufenden Seite. Der aufrufende code verwenden TypeToken oder was auch immer, um es zu konstruieren.
2. Konstruieren Type entsprechend der parametrisierte Typ selbst. Dies erfordert, dass Sie eine Klasse schreiben, die ParameterizedType
Ich denke option 1 vollständig Niederlagen der Zweck der fromJsonList() - option 2 ist sehr clever statt. Ist dieser was meinst du?
vielleicht. Oder Sie können kopieren Sie die Quelle der ParameterizedTypeImpl (wird intern von vielen Java-Bibliotheken) aus dem Internet

InformationsquelleAutor newacct

Wenn die Programmierung in kotlin, wir können reified type parameter im inline-Funktion

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)
    }
}

Und verwenden Sie wie unten im code

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

InformationsquelleAutor alijandro

Kotlin "ListOfSomething" - Lösung, die für mich gearbeitet:

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
    }
}

InformationsquelleAutor Michael Peterson

0

In kotlin einfach verwenden, zum Beispiel:

Orte-Funktion

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

Dann können Sie verwenden als:
```
val places = getPlaces(Array<Place>::class.java)
```
InformationsquelleAutor Cristian Cardoso

  public static <T> T getObject(String gsonStr) {
        Gson gson = new GsonBuilder()
                .setLenient()
                .create();
        Type collectionType = new TypeToken< T>(){}.getType();
        return gson.fromJson(gsonStr,
                collectionType);
    }

Wenn verwenden:

Class1 class1=  getObject(jsonStr);

InformationsquelleAutor Ahmad Aghazadeh

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.