it-swarm.com.de

So analysieren Sie das JSON-Array mit Gson

Ich möchte JSON-Arrays und mit Gson analysieren. Erstens kann ich die JSON-Ausgabe protokollieren, der Server reagiert deutlich auf den Client. 

Hier ist meine JSON-Ausgabe:

 [
      {
           id : '1',
           title: 'sample title',
           ....
      },
      {
           id : '2',
           title: 'sample title',
           ....
     },
      ...
 ]

Ich habe diese Struktur zum Parsen ausprobiert. Eine Klasse, die für alle JSONArray von einzelnen array und ArrayList abhängig ist.

 public class PostEntity {

      private ArrayList<Post> postList = new ArrayList<Post>();

      public List<Post> getPostList() { 
           return postList; 
      }

      public void setPostList(List<Post> postList) { 
           this.postList = (ArrayList<Post>)postList; 
      } 
 }

Nach dem Unterricht:

 public class Post {

      private String id;
      private String title;

      /* getters & setters */
 }

Wenn ich versuche, gson ohne Fehler, keine Warnung und kein Protokoll zu verwenden:

 GsonBuilder gsonb = new GsonBuilder();
 Gson gson = gsonb.create();

 PostEntity postEnt;
 JSONObject jsonObj = new JSONObject(jsonOutput);
 postEnt = gson.fromJson(jsonObj.toString(), PostEntity.class);

 Log.d("postLog", postEnt.getPostList().get(0).getId());

Was ist los, wie kann ich das lösen?

61
Ogulcan Orhan

Sie können die JSONArray direkt parsen, Sie müssen Ihre Post-Klasse nicht noch einmal mit PostEntity umschließen und benötigen keine neue JSONObject().toString()

Gson gson = new Gson();
String jsonOutput = "Your JSON String";
Type listType = new TypeToken<List<Post>>(){}.getType();
List<Post> posts = gson.fromJson(jsonOutput, listType);

Hoffentlich hilft das.

195
yorkw

Ich suchte nach einer Möglichkeit, Objektarrays generischer zu analysieren. hier ist mein beitrag:

CollectionDeserializer.Java:

import Java.lang.reflect.ParameterizedType;
import Java.lang.reflect.Type;
import Java.util.ArrayList;
import Java.util.Collection;
import Java.util.Iterator;

import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonDeserializationContext;
import com.google.gson.JsonDeserializer;
import com.google.gson.JsonElement;
import com.google.gson.JsonParseException;

public class CollectionDeserializer implements JsonDeserializer<Collection<?>> {

    @Override
    public Collection<?> deserialize(JsonElement json, Type typeOfT,
            JsonDeserializationContext context) throws JsonParseException {
        Type realType = ((ParameterizedType)typeOfT).getActualTypeArguments()[0];

        return parseAsArrayList(json, realType);
    }

    /**
     * @param serializedData
     * @param type
     * @return
     */
    @SuppressWarnings("unchecked")
    public <T> ArrayList<T> parseAsArrayList(JsonElement json, T type) {
        ArrayList<T> newArray = new ArrayList<T>();
        Gson gson = new Gson();

        JsonArray array= json.getAsJsonArray();
        Iterator<JsonElement> iterator = array.iterator();

        while(iterator.hasNext()){
            JsonElement json2 = (JsonElement)iterator.next();
            T object = (T) gson.fromJson(json2, (Class<?>)type);
            newArray.add(object);
        }

        return newArray;
    }

}

JSONParsingTest.Java:

public class JSONParsingTest {

    List<World> worlds;

    @Test
    public void grantThatDeserializerWorksAndParseObjectArrays(){

        String worldAsString = "{\"worlds\": [" +
            "{\"name\":\"name1\",\"id\":1}," +
            "{\"name\":\"name2\",\"id\":2}," +
            "{\"name\":\"name3\",\"id\":3}" +
        "]}";

        GsonBuilder builder = new GsonBuilder();
        builder.registerTypeAdapter(Collection.class, new CollectionDeserializer());
        Gson gson = builder.create();
        Object decoded = gson.fromJson((String)worldAsString, JSONParsingTest.class);

        assertNotNull(decoded);
        assertTrue(JSONParsingTest.class.isInstance(decoded));

        JSONParsingTest decodedObject = (JSONParsingTest)decoded;
        assertEquals(3, decodedObject.worlds.size());
        assertEquals((Long)2L, decodedObject.worlds.get(1).getId());
    }
}

World.Java:

public class World {
    private String name;
    private Long id;

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

}
6
Miere
Type listType = new TypeToken<List<Post>>() {}.getType();
List<Post> posts = new Gson().fromJson(jsonOutput.toString(), listType);
2
Salman khan

Einige der Antworten dieses Beitrags sind gültig, aber mit TypeToken generiert die Gson-Bibliothek Baumobjekte mit unrealen Typen für Ihre Anwendung.

Um es zu bekommen, musste ich das Array lesen und die Objekte innerhalb des Arrays einzeln konvertieren. Natürlich ist diese Methode nicht die schnellste und ich empfehle nicht, sie zu verwenden, wenn das Array zu groß ist, aber es hat für mich funktioniert.

Es ist notwendig, die Json-Bibliothek in das Projekt aufzunehmen. Wenn Sie unter Android entwickeln, ist Folgendes enthalten:

/**
 * Convert JSON string to a list of objects
 * @param sJson String sJson to be converted
 * @param tClass Class
 * @return List<T> list of objects generated or null if there was an error
 */
public static <T> List<T> convertFromJsonArray(String sJson, Class<T> tClass){

    try{
        Gson gson = new Gson();
        List<T> listObjects = new ArrayList<>();

        //read each object of array with Json library
        JSONArray jsonArray = new JSONArray(sJson);
        for(int i=0; i<jsonArray.length(); i++){

            //get the object
            JSONObject jsonObject = jsonArray.getJSONObject(i);

            //get string of object from Json library to convert it to real object with Gson library
            listObjects.add(gson.fromJson(jsonObject.toString(), tClass));
        }

        //return list with all generated objects
        return listObjects;

    }catch(Exception e){
        e.printStackTrace();
    }

    //error: return null
    return null;
}
2
[
      {
           id : '1',
           title: 'sample title',
           ....
      },
      {
           id : '2',
           title: 'sample title',
           ....
     },
      ...
 ]

Überprüfen Sie den Easy-Code für diese Ausgabe

 Gson gson=new GsonBuilder().create();
                List<Post> list= Arrays.asList(gson.fromJson(yourResponse.toString,Post[].class));
1
Prabh deep

sie können den Listenwert ohne Verwendung von Type object erhalten.

EvalClassName[] evalClassName;
ArrayList<EvalClassName> list;
evalClassName= new Gson().fromJson(JSONArrayValue.toString(),EvalClassName[].class);
list = new ArrayList<>(Arrays.asList(evalClassName));

Ich habe es getestet und es funktioniert.

0
Sumit Kumar

In Objektarray konvergieren

Gson gson=new Gson();
ElementType [] refVar=gson.fromJson(jsonString,ElementType[].class);

Als Beitragstyp konvertieren

Gson gson=new Gson();
Post [] refVar=gson.fromJson(jsonString,Post[].class);

Zum Lesen als Objektliste kann TypeToken verwendet werden

List<Post> posts=(List<Post>)gson.fromJson(jsonString, 
                     new TypeToken<List<Post>>(){}.getType());
0
xrcwrn

Sie können dies in Kotlin einfach mit folgendem Code tun:

val fileData = "your_json_string"
val gson = GsonBuilder().create()
val packagesArray = gson.fromJson(fileData , Array<YourClass>::class.Java).toList()

Grundsätzlich müssen Sie nur eine Array von YourClass-Objekten angeben.