Comment parser du JSON en Java

La org.json bibliothèque est facile à utiliser. Exemple de code ci-dessous:

import org.json.*;


JSONObject obj = new JSONObject(" .... ");
String pageName = obj.getJSONObject("pageInfo").getString("pageName");

JSONArray arr = obj.getJSONArray("posts");
for (int i = 0; i < arr.length(); i++)
{
    String post_id = arr.getJSONObject(i).getString("post_id");
    ......
}

Vous pouvez trouver plus d'exemples de: Parser JSON en Java

Téléchargeable jar: http://mvnrepository.com/artifact/org.json/json

OriginalL'auteur user1931858

1. Si l'on veut créer un objet Java à partir de JSON et vice versa, utiliser GSON ou JACKSON tiers des pots etc.

   //from object to JSON 
   Gson gson = new Gson();
   gson.toJson(yourObject);
   
   //from JSON to object 
   yourObject o = gson.fromJson(JSONString,yourObject.class);

2. Mais si l'on veux juste d'analyser une chaîne JSON et d'obtenir certaines valeurs, (OU de créer une chaîne JSON à partir de zéro à envoyer sur le fil) utilisation JaveEE jar qui contient JsonReader, JsonArray, JsonObject etc. Vous pouvez télécharger la mise en œuvre de cette spécification comme javax.json. Avec ces deux pots, je suis capable de parser le json et utiliser les valeurs.

   Ces Api en fait de suivre les DOM/SAX de l'analyse du modèle de données XML.

   Response response = request.get(); //REST call 
       JsonReader jsonReader = Json.createReader(new StringReader(response.readEntity(String.class)));
       JsonArray jsonArray = jsonReader.readArray();
       ListIterator l = jsonArray.listIterator();
       while ( l.hasNext() ) {
             JsonObject j = (JsonObject)l.next();
             JsonObject ciAttr = j.getJsonObject("ciAttributes");

OriginalL'auteur nondescript

Une Explication

Vous pouvez utiliser Jackson bibliothèques, pour la liaison de Chaîne JSON dans POJO (Plain Old Java Object) des cas. POJO est simplement une classe avec seulement champs privés et publics getter/setter. Jackson va traverser les méthodes (à l'aide de réflexion), et des cartes de l'objet JSON dans le POJO exemple que les noms de champ de la classe correspond aux noms des champs de l'objet JSON.

Dans votre objet JSON, qui est en fait un composite objet, l'objet principal consiste en deux sous-objets. Donc, nos classes POJO doivent avoir la même hiérarchie. Je vais appeler l'ensemble de l'Objet JSON comme Page objet. Page objet se composent d'un PageInfo objet, et un Post tableau d'objets.

Nous devons donc créer trois classes POJO;

• Page Classe, un composite de PageInfo Classe et un ensemble de Post Instances
• PageInfo Classe
• Postes Classe

Le seul paquet que j'ai utilisé est Jackson ObjectMapper, ce que nous faisons est de la liaison de données;

com.fasterxml.jackson.databind.ObjectMapper

Les dépendances nécessaires, les fichiers jar sont énumérés ci-dessous;

• jackson-core-2.5.1.jar
• jackson-databind-2.5.1.jar
• jackson-annotations-2.5.0.jar

Voici le code requis;

B - Principal de Classe POJO : Page

package com.levo.jsonex.model;

public class Page {

    private PageInfo pageInfo;
    private Post[] posts;

    public PageInfo getPageInfo() {
        return pageInfo;
    }

    public void setPageInfo(PageInfo pageInfo) {
        this.pageInfo = pageInfo;
    }

    public Post[] getPosts() {
        return posts;
    }

    public void setPosts(Post[] posts) {
        this.posts = posts;
    }

}

C - Enfant de Classe POJO : PageInfo

package com.levo.jsonex.model;

public class PageInfo {

    private String pageName;
    private String pagePic;

    public String getPageName() {
        return pageName;
    }

    public void setPageName(String pageName) {
        this.pageName = pageName;
    }

    public String getPagePic() {
        return pagePic;
    }

    public void setPagePic(String pagePic) {
        this.pagePic = pagePic;
    }

}

D - Enfant de Classe POJO : Post

package com.levo.jsonex.model;
public class Post {
private String post_id;
private String actor_id;
private String picOfPersonWhoPosted;
private String nameOfPersonWhoPosted;
private String message;
private int likesCount;
private String[] comments;
private int timeOfPost;
public String getPost_id() {
return post_id;
}
public void setPost_id(String post_id) {
this.post_id = post_id;
}
public String getActor_id() {
return actor_id;
}
public void setActor_id(String actor_id) {
this.actor_id = actor_id;
}
public String getPicOfPersonWhoPosted() {
return picOfPersonWhoPosted;
}
public void setPicOfPersonWhoPosted(String picOfPersonWhoPosted) {
this.picOfPersonWhoPosted = picOfPersonWhoPosted;
}
public String getNameOfPersonWhoPosted() {
return nameOfPersonWhoPosted;
}
public void setNameOfPersonWhoPosted(String nameOfPersonWhoPosted) {
this.nameOfPersonWhoPosted = nameOfPersonWhoPosted;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public int getLikesCount() {
return likesCount;
}
public void setLikesCount(int likesCount) {
this.likesCount = likesCount;
}
public String[] getComments() {
return comments;
}
public void setComments(String[] comments) {
this.comments = comments;
}
public int getTimeOfPost() {
return timeOfPost;
}
public void setTimeOfPost(int timeOfPost) {
this.timeOfPost = timeOfPost;
}
}

E - Exemple de Fichier JSON : sampleJSONFile.json

J'ai juste copié le JSON de l'échantillon dans ce fichier et de le mettre sous le dossier de projet.

{
"pageInfo": {
"pageName": "abc",
"pagePic": "http://example.com/content.jpg"
},
"posts": [
{
"post_id": "123456789012_123456789012",
"actor_id": "1234567890",
"picOfPersonWhoPosted": "http://example.com/photo.jpg",
"nameOfPersonWhoPosted": "Jane Doe",
"message": "Sounds cool. Can't wait to see it!",
"likesCount": "2",
"comments": [],
"timeOfPost": "1234567890"
}
]
}

F - Code De Démonstration

package com.levo.jsonex;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.levo.jsonex.model.Page;
import com.levo.jsonex.model.PageInfo;
import com.levo.jsonex.model.Post;
public class JSONDemo {
public static void main(String[] args) {
ObjectMapper objectMapper = new ObjectMapper();
try {
Page page = objectMapper.readValue(new File("sampleJSONFile.json"), Page.class);
printParsedObject(page);
} catch (IOException e) {
e.printStackTrace();
}
}
private static void printParsedObject(Page page) {
printPageInfo(page.getPageInfo());
System.out.println();
printPosts(page.getPosts());
}
private static void printPageInfo(PageInfo pageInfo) {
System.out.println("Page Info;");
System.out.println("**********");
System.out.println("\tPage Name : " + pageInfo.getPageName());
System.out.println("\tPage Pic  : " + pageInfo.getPagePic());
}
private static void printPosts(Post[] posts) {
System.out.println("Page Posts;");
System.out.println("**********");
for(Post post : posts) {
printPost(post);
}
}
private static void printPost(Post post) {
System.out.println("\tPost Id                   : " + post.getPost_id());
System.out.println("\tActor Id                  : " + post.getActor_id());
System.out.println("\tPic Of Person Who Posted  : " + post.getPicOfPersonWhoPosted());
System.out.println("\tName Of Person Who Posted : " + post.getNameOfPersonWhoPosted());
System.out.println("\tMessage                   : " + post.getMessage());
System.out.println("\tLikes Count               : " + post.getLikesCount());
System.out.println("\tComments                  : " + Arrays.toString(post.getComments()));
System.out.println("\tTime Of Post              : " + post.getTimeOfPost());
}
}

G - Démo De Sortie

Page Info;
****(*****
Page Name : abc
Page Pic  : http://example.com/content.jpg
Page Posts;
**********
Post Id                   : 123456789012_123456789012
Actor Id                  : 1234567890
Pic Of Person Who Posted  : http://example.com/photo.jpg
Name Of Person Who Posted : Jane Doe
Message                   : Sounds cool. Can't wait to see it!
Likes Count               : 2
Comments                  : []
Time Of Post              : 1234567890

OriginalL'auteur Levent Divilioglu

Vous pouvez utiliser Google Gson.

L'utilisation de cette bibliothèque vous avez seulement besoin de créer un modèle avec la même structure JSON. Ensuite, le modèle est automatiquement remplie. Vous appelez de vos variables comme votre JSON touches, ou utilisez @SerializedName si vous souhaitez utiliser des noms différents.

Pour votre exemple:

JSON:

{
"pageInfo": {
"pageName": "abc",
"pagePic": "http://example.com/content.jpg"
}
"posts": [
{
"post_id": "123456789012_123456789012",
"actor_id": "1234567890",
"picOfPersonWhoPosted": "http://example.com/photo.jpg",
"nameOfPersonWhoPosted": "Jane Doe",
"message": "Sounds cool. Can't wait to see it!",
"likesCount": "2",
"comments": [],
"timeOfPost": "1234567890"
}
]
}

Modèle:

class MyModel {
private PageInfo pageInfo;
private ArrayList<Post> posts = new ArrayList<>();
}
class PageInfo {
private String pageName;
private String pagePic;
}
class Post {
private String post_id;
@SerializedName("actor_id") //<- example SerializedName
private String actorId;
private String picOfPersonWhoPosted;
private String nameOfPersonWhoPosted;
private String message;
private String likesCount;
private ArrayList<String> comments;
private String timeOfPost;
}

Maintenant, vous pouvez analyser avec Gson bibliothèque:

MyModel model = gson.fromJson(jsonString, MyModel.class);

Vous pouvez générer le modèle de JSON automatiquement à l'aide d'outils en ligne tels cette.

OriginalL'auteur lubilis

Je crois que la meilleure pratique devrait être de passer par le fonctionnaire Java API JSON qui sont encore en cours.

OriginalL'auteur Giovanni Botta

Ce soufflé mon esprit avec la façon dont il était facile. Vous pouvez passer un String la tenue de votre JSON pour le constructeur d'un JSONObject dans le défaut org.json paquet.

JSONArray rootOfPage =  new JSONArray(JSONString);

Fait. Gouttes microphone.
Cela fonctionne avec JSONObjects. Après, vous pouvez simplement regarder à travers votre hiérarchie de Objects à l'aide de la get() méthodes sur vos objets.

OriginalL'auteur brainmurphy1

Il y a beaucoup de JSON bibliothèques disponibles dans Java.

Les plus notoires sont: Jackson, GSON, Genson, FastJson et org.json.

Il y a généralement trois choses que l'on devrait regarder pour le choix d'une bibliothèque:

1. Performance
2. La facilité d'utilisation (le code est simple à écrire et lisible) - qui va de pair avec des fonctionnalités.
3. Pour les applications mobiles: dépendance/taille du bocal

Spécifiquement pour JSON bibliothèques (et toute la sérialisation/désérialisation libs), la liaison de données est aussi, généralement, de l'intérêt qu'il supprime la nécessité de l'écriture de la chaudière-plaque de code à emballer/déballer les données.

Pour 1, voir ce test: https://github.com/fabienrenaud/java-json-benchmark je l'ai fait à l'aide de JMH qui compare (jackson, gson, genson, fastjson, org.json, jsonp) de la performance de sérialiseurs et deserializers à l'aide de flux et databind Api.
Pour 2, vous pouvez trouver de nombreux exemples sur Internet. L'indice de référence ci-dessus peut également être utilisé comme une source d'exemples...

Rapide à emporter de l'indice de référence: Jackson effectue 5 à 6 fois mieux que org.json et plus de deux fois mieux que GSON.

Pour votre exemple, le code suivant décode votre json avec jackson:

public class MyObj {
private PageInfo pageInfo;
private List<Post> posts;
static final class PageInfo {
private String pageName;
private String pagePic;
}
static final class Post {
private String post_id;
@JsonProperty("actor_id");
private String actorId;
@JsonProperty("picOfPersonWhoPosted")
private String pictureOfPoster;
@JsonProperty("nameOfPersonWhoPosted")
private String nameOfPoster;
private String likesCount;
private List<String> comments;
private String timeOfPost;
}
private static final ObjectMapper JACKSON = new ObjectMapper();
public static void main(String[] args) throws IOException {
MyObj o = JACKSON.readValue(args[0], MyObj.class); //assumes args[0] contains your json payload provided in your question.
}
}

Laissez-moi savoir si vous avez des questions.

OriginalL'auteur fabien

En plus d'autres réponses, je recommande cet en ligne open-source, service de jsonschema2pojo.org rapide pour générer des classes Java à partir de json ou json schema pour GSON, Jackson 1.x ou Jackson 2.x. Par exemple, si vous avez:

{
"pageInfo": {
"pageName": "abc",
"pagePic": "http://example.com/content.jpg"
}
"posts": [
{
"post_id": "123456789012_123456789012",
"actor_id": 1234567890,
"picOfPersonWhoPosted": "http://example.com/photo.jpg",
"nameOfPersonWhoPosted": "Jane Doe",
"message": "Sounds cool. Can't wait to see it!",
"likesCount": 2,
"comments": [],
"timeOfPost": 1234567890
}
]
}

La jsonschema2pojo.org pour GSON généré:

@Generated("org.jsonschema2pojo")
public class Container {
@SerializedName("pageInfo")
@Expose
public PageInfo pageInfo;
@SerializedName("posts")
@Expose
public List<Post> posts = new ArrayList<Post>();
}
@Generated("org.jsonschema2pojo")
public class PageInfo {
@SerializedName("pageName")
@Expose
public String pageName;
@SerializedName("pagePic")
@Expose
public String pagePic;
}
@Generated("org.jsonschema2pojo")
public class Post {
@SerializedName("post_id")
@Expose
public String postId;
@SerializedName("actor_id")
@Expose
public long actorId;
@SerializedName("picOfPersonWhoPosted")
@Expose
public String picOfPersonWhoPosted;
@SerializedName("nameOfPersonWhoPosted")
@Expose
public String nameOfPersonWhoPosted;
@SerializedName("message")
@Expose
public String message;
@SerializedName("likesCount")
@Expose
public long likesCount;
@SerializedName("comments")
@Expose
public List<Object> comments = new ArrayList<Object>();
@SerializedName("timeOfPost")
@Expose
public long timeOfPost;
}

OriginalL'auteur Viacheslav Vedenin

Gson est facile à apprendre et à mettre en œuvre, ce que nous avons besoin de savoir sont deux méthodes suivantes

• la méthode toJson() – Convertir en objet Java au format JSON

• fromJson() – Convertir en JSON en objet Java

`

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import com.google.gson.Gson;
public class GsonExample {
public static void main(String[] args) {
Gson gson = new Gson();
try {
BufferedReader br = new BufferedReader(
new FileReader("c:\\file.json"));
//convert the json string back to object
DataObject obj = gson.fromJson(br, DataObject.class);
System.out.println(obj);
} catch (IOException e) {
e.printStackTrace();
}
}
}

`

OriginalL'auteur venkat

Vous pouvez utiliser le Gson Bibliothèque pour analyser la chaîne JSON.

Gson gson = new Gson();
JsonObject jsonObject = gson.fromJson(jsonAsString, JsonObject.class);
String pageName = jsonObject.getAsJsonObject("pageInfo").get("pageName").getAsString();
String pagePic = jsonObject.getAsJsonObject("pageInfo").get("pagePic").getAsString();
String postId = jsonObject.getAsJsonArray("posts").get(0).getAsJsonObject().get("post_id").getAsString();

Vous pouvez également faire une boucle par les "posts" tableau de la manière suivante:

JsonArray posts = jsonObject.getAsJsonArray("posts");
for (JsonElement post : posts) {
String postId = post.getAsJsonObject().get("post_id").getAsString();
//do something
}

OriginalL'auteur LittleBigUllah

{
"pageInfo": {
"pageName": "abc",
"pagePic": "http://example.com/content.jpg"
},
"posts": [
{
"post_id": "123456789012_123456789012",
"actor_id": "1234567890",
"picOfPersonWhoPosted": "http://example.com/photo.jpg",
"nameOfPersonWhoPosted": "Jane Doe",
"message": "Sounds cool. Can't wait to see it!",
"likesCount": "2",
"comments": [],
"timeOfPost": "1234567890"
}
]
}
Java code :
JSONObject obj = new JSONObject(responsejsonobj);
String pageName = obj.getJSONObject("pageInfo").getString("pageName");
JSONArray arr = obj.getJSONArray("posts");
for (int i = 0; i < arr.length(); i++)
{
String post_id = arr.getJSONObject(i).getString("post_id");
......etc
}

OriginalL'auteur LReddy

Vous devez d'abord sélectionner un mise en œuvre de la bibliothèque de le faire.

La Java API JSON Traitement (JSR 353) portable fournit des Api pour analyser, produire, transformer, et de la requête JSON à l'aide du modèle objet et les Api en continu.

La l'implémentation de référence de est ici: https://jsonp.java.net/

Ici vous pouvez trouver une liste des implémentations de la JSR 353:

Quelles sont les API qui n'en œuvre de la JSR-353 (JSON)

Et pour vous aider à décider... j'ai trouvé cet article:

http://blog.takipi.com/the-ultimate-json-library-json-simple-vs-gson-vs-jackson-vs-json/

Si vous allez pour Jackson, voici un bon article sur la conversion entre JSON vers/à partir de Java à l'aide de Jackson: https://www.mkyong.com/java/how-to-convert-java-object-to-from-json-jackson/

Espère que cela aide!

OriginalL'auteur Jose Manuel Gomez Alvarez

J'ai JSON comme ceci:

{
"pageInfo": {
"pageName": "abc",
"pagePic": "http://example.com/content.jpg"
}
}

Classe Java

class PageInfo {
private String pageName;
private String pagePic;
//Getters and setters
}

Code pour la conversion de ce JSON à une classe Java.

    PageInfo pageInfo = JsonPath.parse(jsonString).read("$.pageInfo", PageInfo.class);

Maven

<dependency>
<groupId>com.jayway.jsonpath</groupId>
<artifactId>json-path</artifactId>
<version>2.2.0</version>
</dependency>

OriginalL'auteur Parth Solanki

Nous pouvons utiliser la JSONObject classe pour convertir une chaîne JSON à un objet JSON,
et pour itérer sur l'objet JSON. Utilisez le code suivant.

JSONObject jObj = new JSONObject(contents.trim());
Iterator<?> keys = jObj.keys();
while( keys.hasNext() ) {
String key = (String)keys.next();
if ( jObj.get(key) instanceof JSONObject ) {           
System.out.println(jObj.getString(String key));
}
}

OriginalL'auteur smith

On peut utiliser Apache @Modèle d'annotation pour créer Java classes du modèle représentant la structure de JSON fichiers et de les utiliser pour accéder à différents éléments dans le JSON arbre. Contrairement à d'autres solutions de ce un fonctionne complètement sans réflexion et est donc adapté pour les environnements où la réflexion est impossible ou est livré avec une surcharge importante.

Il y a un exemple de projet Maven montrant l'utilisation. Tout d'abord, il définit la structure:

@Model(className="RepositoryInfo", properties = {
@Property(name = "id", type = int.class),
@Property(name = "name", type = String.class),
@Property(name = "owner", type = Owner.class),
@Property(name = "private", type = boolean.class),
})
final class RepositoryCntrl {
@Model(className = "Owner", properties = {
@Property(name = "login", type = String.class)
})
static final class OwnerCntrl {
}
}

et ensuite, il utilise le générés RepositoryInfo et Propriétaire des classes pour analyser la condition de flux d'entrée et de choisir certaines informations tout en faisant que:

List<RepositoryInfo> repositories = new ArrayList<>();
try (InputStream is = initializeStream(args)) {
Models.parse(CONTEXT, RepositoryInfo.class, is, repositories);
}
System.err.println("there is " + repositories.size() + " repositories");
repositories.stream().filter((repo) -> repo != null).forEach((repo) -> {
System.err.println("repository " + repo.getName() + 
" is owned by " + repo.getOwner().getLogin()
);
})

C'est elle! En plus de ce qui est ici un vivre gist montrant un exemple similaire avec asynchrone de la communication réseau.

OriginalL'auteur Jaroslav Tulach