Google Gson - désérialiser l'objet <classe> de la liste? (type générique)

Je souhaite transférer un objet liste via Google Gson, mais je ne sais pas comment désérialiser des types génériques.

Ce que j'ai essayé après avoir regardé cela (réponse de BalusC):

MyClass mc = new Gson().fromJson(result, new List<MyClass>(){}.getClass());

mais alors j'obtiens une erreur dans l'éclipse disant "Le type nouveau List () {} doit implémenter la méthode abstraite héritée ..." et si j'utilise une solution rapide, j'obtiens un monstre de plus de 20 stubs de méthode.

Je suis presque sûr qu'il existe une solution plus simple, mais il me semble impossible de la trouver!

Éditer:

Maintenant j'ai

Type listType = new TypeToken<List<MyClass>>()
                {
                }.getType();

MyClass mc = new Gson().fromJson(result, listType);

Cependant, j'obtiens l'exception suivante sur la ligne "fromJson":

java.lang.NullPointerException
at org.apache.harmony.luni.lang.reflect.ListOfTypes.length(ListOfTypes.java:47)
at org.apache.harmony.luni.lang.reflect.ImplForType.toString(ImplForType.java:83)
at java.lang.StringBuilder.append(StringBuilder.java:203)
at com.google.gson.JsonDeserializerExceptionWrapper.deserialize(JsonDeserializerExceptionWrapper.java:56)
at com.google.gson.JsonDeserializationVisitor.invokeCustomDeserializer(JsonDeserializationVisitor.java:88)
at com.google.gson.JsonDeserializationVisitor.visitUsingCustomHandler(JsonDeserializationVisitor.java:76)
at com.google.gson.ObjectNavigator.accept(ObjectNavigator.java:106)
at com.google.gson.JsonDeserializationContextDefault.fromJsonArray(JsonDeserializationContextDefault.java:64)
at com.google.gson.JsonDeserializationContextDefault.deserialize(JsonDeserializationContextDefault.java:49)
at com.google.gson.Gson.fromJson(Gson.java:568)
at com.google.gson.Gson.fromJson(Gson.java:515)
at com.google.gson.Gson.fromJson(Gson.java:484)
at com.google.gson.Gson.fromJson(Gson.java:434)

Je fais JsonParseExceptions de capture et « résultat » est non nul.

J'ai vérifié listType avec le débogueur et j'ai obtenu ce qui suit:

• type de liste
  • args = ListOfTypes
    • list = null
    • olvedTypes = Type [1]
  • loader = PathClassLoader
  • ownerType0 = null
  • ownerTypeRes = null
  • rawType = Classe (java.util.ArrayList)
  • rawTypeName = "java.util.ArrayList"

il semble donc que l'invocation "getClass" ne fonctionne pas correctement. Aucune suggestion...?

Edit2: I'v vérifié sur le Guide de l'utilisateur Gson . Il mentionne une exception d'exécution qui devrait se produire lors de l'analyse d'un type générique vers Json. Je l'ai fait "mal" (non illustré ci-dessus), comme dans l'exemple, mais je n'ai pas du tout obtenu cette exception. J'ai donc changé la sérialisation comme dans le guide d'utilisation suggéré. Mais ça n'a pas aidé.

Edit3: Résolu, voir ma réponse ci-dessous.

Méthode pour désérialiser la collection générique:

import java.lang.reflect.Type;
import com.google.gson.reflect.TypeToken;

...

Type listType = new TypeToken<ArrayList<YourClass>>(){}.getType();
List<YourClass> yourClassList = new Gson().fromJson(jsonArray, listType);

Étant donné que plusieurs personnes dans les commentaires l'ont mentionné, voici une explication de la façon dont la TypeTokenclasse est utilisée. La construction new TypeToken<...>() {}.getType()capture un type au moment de la compilation (entre le <et >) dans un java.lang.reflect.Typeobjet d' exécution . Contrairement à un Classobjet, qui ne peut représenter qu'un type brut (effacé), l' Typeobjet peut représenter n'importe quel type en langage Java, y compris une instanciation paramétrée d'un type générique.

La TypeTokenclasse elle-même n'a pas de constructeur public, car vous n'êtes pas censé le construire directement. Au lieu de cela, vous construisez toujours une sous-classe anonyme (d'où le {}, qui est une partie nécessaire de cette expression).

En raison de l'effacement des types, la TypeTokenclasse ne peut capturer que les types entièrement connus au moment de la compilation. (Autrement dit, vous ne pouvez pas faire new TypeToken<List<T>>() {}.getType()pour un paramètre de type T.)

Pour plus d'informations, consultez la documentation de la TypeTokenclasse .

Une autre façon consiste à utiliser un tableau comme type, par exemple:

MyClass[] mcArray = gson.fromJson(jsonString, MyClass[].class);

De cette façon, vous évitez tous les tracas avec l'objet Type, et si vous avez vraiment besoin d'une liste, vous pouvez toujours convertir le tableau en liste en:

List<MyClass> mcList = Arrays.asList(mcArray);

À mon humble avis, c'est beaucoup plus lisible.

Et pour en faire une liste réelle (qui peut être modifiée, voir les limitations de Arrays.asList()), procédez comme suit:

List<MyClass> mcList = new ArrayList<>(Arrays.asList(mcArray));

Référez-vous à ce post. Type Java générique comme argument pour GSON

J'ai une meilleure solution pour cela. Voici la classe wrapper pour list afin que le wrapper puisse stocker exactement le type de liste.

public class ListOfJson<T> implements ParameterizedType
{
  private Class<?> wrapped;

  public ListOfJson(Class<T> wrapper)
  {
    this.wrapped = wrapper;
  }

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

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

  @Override
  public Type getOwnerType()
  {
    return null;
  }
}

Et puis, le code peut être simple:

public static <T> List<T> toList(String json, Class<T> typeClass)
{
    return sGson.fromJson(json, new ListOfJson<T>(typeClass));
}

Depuis Gson 2.8, nous pouvons créer une fonction util comme

public <T> List<T> getList(String jsonArray, Class<T> clazz) {
    Type typeOfT = TypeToken.getParameterized(List.class, clazz).getType();
    return new Gson().fromJson(jsonArray, typeOfT);
}

Exemple utilisant

String jsonArray = ...
List<User> user = getList(jsonArray, User.class);

Wep, une autre façon d'obtenir le même résultat. Nous l'utilisons pour sa lisibilité.

Au lieu de faire cette phrase difficile à lire:

Type listType = new TypeToken<ArrayList<YourClass>>(){}.getType();
List<YourClass> list = new Gson().fromJson(jsonArray, listType);

Créez une classe vide qui étend une liste de votre objet:

public class YourClassList extends ArrayList<YourClass> {}

Et utilisez-le pour analyser le JSON:

List<YourClass> list = new Gson().fromJson(jsonArray, YourClassList.class);

Pour Kotlin, simplement:

import java.lang.reflect.Type
import com.google.gson.reflect.TypeToken
...
val type = object : TypeToken<List<T>>() {}.type

ou, voici une fonction utile:

fun <T> typeOfList(): Type {
    return object : TypeToken<List<T>>() {}.type
}

Ensuite, pour utiliser:

val type = typeOfList<YourMagicObject>()

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

Exemple:

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

Comme il répond à ma question d'origine, j'ai accepté la réponse du doc_180, mais si quelqu'un rencontre à nouveau ce problème, je répondrai également à la 2e moitié de ma question:

Le NullPointerError que j'ai décrit n'avait rien à voir avec la liste elle-même, mais avec son contenu!

La classe "MyClass" n'avait pas de constructeur "no args", et ni l'un ni l'autre n'avait sa superclasse. Une fois que j'ai ajouté un simple constructeur "MyClass ()" à MyClass et à sa superclasse, tout a bien fonctionné, y compris la sérialisation et la désérialisation de liste comme suggéré par doc_180.

Voici une solution qui fonctionne avec un type défini dynamiquement. L'astuce consiste à créer le type de tableau approprié à l'aide de Array.newInstance ().

    public static <T> List<T> fromJsonList(String json, Class<T> clazz) {
    Object [] array = (Object[])java.lang.reflect.Array.newInstance(clazz, 0);
    array = gson.fromJson(json, array.getClass());
    List<T> list = new ArrayList<T>();
    for (int i=0 ; i<array.length ; i++)
        list.add(clazz.cast(array[i]));
    return list; 
}

Je veux ajouter pour une possibilité de plus. Si vous ne souhaitez pas utiliser TypeToken et que vous souhaitez convertir un tableau d'objets json en ArrayList, vous pouvez procéder comme suit:

Si votre structure json est comme:

{

"results": [
    {
        "a": 100,
        "b": "value1",
        "c": true
    },
    {
        "a": 200,
        "b": "value2",
        "c": false
    },
    {
        "a": 300,
        "b": "value3",
        "c": true
    }
]

}

et votre structure de classe est comme:

public class ClassName implements Parcelable {

    public ArrayList<InnerClassName> results = new ArrayList<InnerClassName>();
    public static class InnerClassName {
        int a;
        String b;
        boolean c;      
    }
}

alors vous pouvez l'analyser comme:

Gson gson = new Gson();
final ClassName className = gson.fromJson(data, ClassName.class);
int currentTotal = className.results.size();

Vous pouvez maintenant accéder à chaque élément de l'objet className.

Reportez-vous à l'exemple 2 pour la compréhension de la classe «Type» de Gson.

Exemple 1: dans ce deserilizeResturant, nous avons utilisé le tableau Employee [] et obtenu les détails

public static void deserializeResturant(){

       String empList ="[{\"name\":\"Ram\",\"empId\":1},{\"name\":\"Surya\",\"empId\":2},{\"name\":\"Prasants\",\"empId\":3}]";
       Gson gson = new Gson();
       Employee[] emp = gson.fromJson(empList, Employee[].class);
       int numberOfElementInJson = emp.length();
       System.out.println("Total JSON Elements" + numberOfElementInJson);
       for(Employee e: emp){
           System.out.println(e.getName());
           System.out.println(e.getEmpId());
       }
   }

Exemple 2:

//Above deserilizeResturant used Employee[] array but what if we need to use List<Employee>
public static void deserializeResturantUsingList(){

    String empList ="[{\"name\":\"Ram\",\"empId\":1},{\"name\":\"Surya\",\"empId\":2},{\"name\":\"Prasants\",\"empId\":3}]";
    Gson gson = new Gson();

    // Additionally we need to se the Type then only it accepts List<Employee> which we sent here empTypeList
    Type empTypeList = new TypeToken<ArrayList<Employee>>(){}.getType();


    List<Employee> emp = gson.fromJson(empList, empTypeList);
    int numberOfElementInJson = emp.size();
    System.out.println("Total JSON Elements" + numberOfElementInJson);
    for(Employee e: emp){
        System.out.println(e.getName());
        System.out.println(e.getEmpId());
    }
}

J'ai aimé la réponse de kays1 mais je n'ai pas pu l'implémenter. J'ai donc construit ma propre version en utilisant son concept.

public class JsonListHelper{
    public static final <T> List<T> getList(String json) throws Exception {
        Gson gson = new GsonBuilder().setDateFormat("yyyy-MM-dd HH:mm:ss").create();
        Type typeOfList = new TypeToken<List<T>>(){}.getType();
        return gson.fromJson(json, typeOfList);
    }
}

Usage:

List<MyClass> MyList= JsonListHelper.getList(jsonArrayString);

Dans mon cas, la réponse de @ uncaught_exceptions n'a pas fonctionné, j'ai dû utiliser à la List.classplace de java.lang.reflect.Type:

String jsonDuplicatedItems = request.getSession().getAttribute("jsonDuplicatedItems").toString();
List<Map.Entry<Product, Integer>> entries = gson.fromJson(jsonDuplicatedItems, List.class);