JavaでJSONを解析する方法

Question

以下のJSONテキストがあります。 pageName、pagePic、post_idなどの値を取得するためにそれを解析する方法を教えてください。

{
   "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"
         }
    ]
}

Answer 1

org.json ライブラリは使いやすいです。以下のコード例：

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

あなたはより多くの例を見つけることができます： JavaでJSONを解析します

ダウンロード可能なjarファイル： http://mvnrepository.com/artifact/org.json/json

Answer 2

例のために、クラスPersonを持つクラスnameがあるとしましょう。

private class Person {
    public String name;

    public Person(String name) {
        this.name = name;
    }
}

Google GSON （ Maven ）

私の個人的なお気に入りは、オブジェクトの素晴らしいJSONシリアライゼーション/デシリアライゼーションです。

Gson g = new Gson();

Person person = g.fromJson("{\"name\": \"John\"}", Person.class);
System.out.println(person.name); //John

System.out.println(g.toJson(person)); // {"name":"John"}

更新

単一の属性を取得したい場合は、Googleライブラリでも簡単にできます。

JsonObject jsonObject = new JsonParser().parse("{\"name\": \"John\"}").getAsJsonObject();

System.out.println(jsonObject.get("name").getAsString()); //John

Org.JSON （ Maven ）

オブジェクトのデシリアライゼーションが不要で属性を取得するだけの場合は、org.jsonを試すことができます（ または上記のGSONの例を見てください！ ）。

JSONObject obj = new JSONObject("{\"name\": \"John\"}");

System.out.println(obj.getString("name")); //John

ジャクソン （ Maven ）

ObjectMapper mapper = new ObjectMapper();
Person user = mapper.readValue("{\"name\": \"John\"}", Person.class);

System.out.println(user.name); //John

Answer 3

1. JSONからJavaオブジェクトを作成したい場合、またはその逆の場合は、GSONまたはJACKSONのサードパーティ製のjarなどを使用してください。

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

2. しかし、単にJSON文字列を解析して値を取得したい場合（またはJSON文字列を最初から作成してネットワークに送信する場合）、JsonReader、JsonArray、JsonObjectなどを含むJaveEE jarを使用するだけです。 javax.jsonのようなスペック。これら2つのjarファイルを使用して、JSONを解析して値を使用することができます。

   これらのAPIは実際にはXMLのDOM/SAX構文解析モデルに従います。

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

Answer 4

quick-json parser は非常に簡単で、柔軟で、非常に速くカスタマイズ可能です。それを試してみてください

特徴：

• JSON仕様（RFC4627）に準拠
• 高性能JSONパーサー
• 柔軟で構成可能な構文解析アプローチをサポート
• 任意のJSON階層のキー/値ペアの設定可能な検証
• 非常に小さいフットプリント
• 開発者にやさしい例外の追跡を容易にします
• プラガブルカスタムバリデーションのサポート - 発生したときにカスタムバリデータを設定することでキー/値をバリデートできます。
• 検証パーサーと非検証パーサーのサポート
• クイックJSON検証パーサーを使用するための2種類の構成（JSON/XML）のサポート
• JDK 1.5が必要
• 外部ライブラリに依存しない
• オブジェクト直列化によるJSON生成のサポート
• 解析プロセス中のコレクションタイプ選択のサポート

それはこのように使用することができます：

JsonParserFactory factory=JsonParserFactory.getInstance();
JSONParser parser=factory.newJsonParser();
Map jsonMap=parser.parseJson(jsonString);

Answer 5

A - 説明

JSON Stringを _ pojo _ （ Plain Old Java Object ）インスタンスにバインドするには、 Jackson ライブラリを使用できます。 POJOは、プライベートフィールドとパブリックなgetter/setterメソッドだけを持つクラスです。 Jacksonはメソッドをトラバースし（ reflection を使用）、クラスのフィールド名がJSONオブジェクトのフィールド名に合うようにJSONオブジェクトをPOJOインスタンスにマップします。

実際の composite オブジェクトであるJSONオブジェクトでは、メインオブジェクトは2つのサブオブジェクトで構成されています。したがって、私たちのPOJOクラスは同じ階層を持つべきです。 JSONオブジェクト全体を Page objectと呼びます。 Page objectは PageInfo objectと Post objectの配列からなる。

だから私たちは3つの異なるPOJOクラスを作成しなければなりません。

• Page Class、 PageInfo Class、および Post Instancesの配列
• PageInfo クラス
• 投稿 クラス

私が使った唯一のパッケージはJackson ObjectMapperです。私たちがしているのはデータのバインディングです。

com.fasterxml.jackson.databind.ObjectMapper

必要な依存関係、jarファイルは以下のとおりです。

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

これが必要なコードです。

B - メインPOJOクラス：ページ

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 - 子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 - チャイルドポジョクラス：ポスト

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 - サンプルJSONファイル：sampleJSONFile.json

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

F - デモコード

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 - デモ出力

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

Answer 6

与えられた答えのほとんどすべては、興味のあるプロパティの値にアクセスする前に、JSONをJavaオブジェクトに完全に逆シリアル化する必要があります。この方法では行かないもう1つの方法は、 JsonPATH を使用することです。これは、XPath for JSONに似ており、JSONオブジェクトのトラバースを可能にします。

それは仕様であり、JayWayの良い人々はあなたがここで見つけることができる仕様のためのJava実装を作成しました： https://github.com/jayway/JsonPath

基本的にそれを使うために、それをあなたのプロジェクトに追加してください。例えば：

<dependency>
    <groupId>com.jayway.jsonpath</groupId>
    <artifactId>json-path</artifactId>
    <version>${version}</version>
</dependency>

そして使用する：

String pageName = JsonPath.read(yourJsonString, "$.pageInfo.pageName");
String pagePic = JsonPath.read(yourJsonString, "$.pageInfo.pagePic");
String post_id = JsonPath.read(yourJsonString, "$.pagePosts[0].post_id");

等...

JSONを横断する他の方法の詳細については、JsonPathの仕様ページを確認してください。

Answer 7

Google Gson を使用できます。

このライブラリを使用すると、同じJSON構造を持つモデルを作成するだけで済みます。モデルは自動的に埋められます。変数をJSONキーとして呼び出すか、別の名前を使用する場合は@SerializedNameを使用する必要があります。

あなたの例では：

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

モデル：

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

これでGsonライブラリを使ってパースできます。

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

this のようなオンラインツールを使用してJSONからモデルを自動的に生成できます。

Answer 8

minimal-json を使用します。これは非常に高速で使いやすいものです。 String objとStreamから解析できます。

サンプルデータ：

{
  "order": 4711,
  "items": [
    {
      "name": "NE555 Timer IC",
      "cat-id": "645723",
      "quantity": 10,
    },
    {
      "name": "LM358N OpAmp IC",
      "cat-id": "764525",
      "quantity": 2
    }
  ]
}

構文解析

JsonObject object = Json.parse(input).asObject();
int orders = object.get("order").asInt();
JsonArray items = object.get("items").asArray();

JSONを作成する：

JsonObject user = Json.object().add("name", "Sakib").add("age", 23);

メイヴン：

<dependency>
  <groupId>com.eclipsesource.minimal-json</groupId>
  <artifactId>minimal-json</artifactId>
  <version>0.9.4</version>
</dependency>

Answer 9

私はベストプラクティスは、まだ進行中の公式の Java JSON API を通過することであるべきだと思います。

Answer 10

以下の例は、 "jsonText"変数として表される、質問内のテキストの読み方を示しています。このソリューションではJava EE7 javax.json AP​​Iを使用します（これについては他の回答で説明しています）。私がそれを別の答えとして追加したのは、次のコードが質問に示された値のいくつかに 実際に アクセスする方法を示しているからです。このコードを実行するには javax.json APIの実装 が必要です。 "import"ステートメントを宣言したくないので、必要な各クラスのフルパッケージを含めました。

javax.json.JsonReader jr = 
    javax.json.Json.createReader(new StringReader(jsonText));
javax.json.JsonObject jo = jr.readObject();

//Read the page info.
javax.json.JsonObject pageInfo = jo.getJsonObject("pageInfo");
System.out.println(pageInfo.getString("pageName"));

//Read the posts.
javax.json.JsonArray posts = jo.getJsonArray("posts");
//Read the first post.
javax.json.JsonObject post = posts.getJsonObject(0);
//Read the post_id field.
String postId = post.getString("post_id");

GSON、org.json、Jackson、その他のサードパーティ製フレームワークを使用していないために、誰かがこの答えを批判する前に、提供されたテキストを解析するための質問ごとの「必須コード」の例です。 現在の標準JSR 353への準拠はJDK 9では考慮されていませんでした それ自体 JSR 353 spec は他のサードパーティのJSON処理と同じように扱うべきである実装。

Answer 11

これは、それがどれほど簡単であるかということで私の心を吹き飛ばしました。あなたのJSONを保持しているStringをデフォルトのorg.jsonパッケージのJSONObjectのコンストラクタに渡すことができます。

JSONArray rootOfPage =  new JSONArray(JSONString);

完了しました。 マイクを落とす 。これはJSONObjectsでも動作します。その後は、オブジェクトのget()メソッドを使ってObjectsの階層を見てみるだけです。

Answer 12

まだ誰も言及していないので、これは Nashorn （Java 8のJavaScriptランタイム部分ですが、Java 11では非推奨）を使用したソリューションの始まりです。

解決策

private static final String EXTRACTOR_SCRIPT =
    "var fun = function(raw) { " +
    "var json = JSON.parse(raw); " +
    "return [json.pageInfo.pageName, json.pageInfo.pagePic, json.posts[0].post_id];};";

public void run() throws ScriptException, NoSuchMethodException {
    ScriptEngine engine = new ScriptEngineManager().getEngineByName("nashorn");
    engine.eval(EXTRACTOR_SCRIPT);
    Invocable invocable = (Invocable) engine;
    JSObject result = (JSObject) invocable.invokeFunction("fun", JSON);
    result.values().forEach(e -> System.out.println(e));
}

パフォーマンス比較

それぞれ20、20、100の要素からなる3つの配列を含むJSONコンテンツを書きました。 3番目の配列から100個の要素を取得したいだけです。私は自分のエントリを解析して取得するために次のJavaScript関数を使います。

var fun = function(raw) {JSON.parse(raw).entries};

Nashorn を使用して呼び出しを100万回実行するには、7.5〜7.8秒かかります。

(JSObject) invocable.invokeFunction("fun", json);

org.json 20〜21秒かかります

new JSONObject(JSON).getJSONArray("entries");

ジャクソン 6.5〜7秒かかります

mapper.readValue(JSON, Entries.class).getEntries();

この場合、JacksonはNashornよりもパフォーマンスがよく、Nashornはorg.jsonよりもはるかに優れています。 Nashorn APIはorg.jsonやJacksonのものよりも使いにくいです。あなたの要求に応じて、JacksonとNashornはどちらも実行可能な解決策になり得ます。

Answer 13

Javaでは多くのJSONライブラリを利用できます。

最も悪名高いものは、Jackson、GSON、Genson、FastJsonおよびorg.jsonです。

通常、ライブラリを選択する際に注意すべき点が3つあります。

1. パフォーマンス
2. 使いやすさ（コードを書くのは簡単で読みやすい） - それは機能と一緒に行きます。
3. モバイルアプリの場合：依存関係/ jarサイズ

特にJSONライブラリ（および任意のシリアル化/逆シリアル化ライブラリ）の場合、データをパック/アンパックするための定型コードを記述する必要がなくなるため、データバインディングも通常重要です。

1については、このベンチマークを参照してください。 https://github.com/fabienrenaud/Java-json-benchmark_ jmh _ を使用して比較しました（jackson、gson、genson、fastjson、org.json 、jsonp）ストリームおよびデータバインドAPIを使用したシリアライザおよびデシリアライザのパフォーマンス2の場合は、インターネット上で多数の例を見つけることができます。上記のベンチマークは、例のソースとしても使用できます。

ベンチマークの簡単なまとめ： Jackson は、org.jsonよりも5から6倍、GSONよりも2倍以上優れています。

具体的な例として、次のコードはjsonを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.
    }
}

質問があれば教えてください。

Answer 14

JSONコンテンツをオブジェクトに解析するため、または単にJSON値を読み取るために、多数のオープンソースライブラリが存在します。あなたの要件は単に値を読み、それをカスタムオブジェクトにパースすることです。だからあなたの場合はorg.jsonライブラリで十分です。

それを解析してJsonObjectを作成するためにorg.jsonライブラリを使用してください：

JSONObject jsonObj = new JSONObject(<jsonStr>);

今、あなたの値を取得するためにこのオブジェクトを使用します。

String id = jsonObj.getString("pageInfo");

あなたはここで完全な例を見ることができます：

JavaでJSONを解析する方法

Answer 15

他の答えに加えて、私はこのオンラインオープンソースサービス jsonschema2pojo.org をGSON、Jackson 1.xまたはJackson 2.xのためのjsonまたはjsonスキーマからJavaクラスを素早く生成するために推奨します。たとえば、次のようになります。

{
   "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
         }
    ]
}

GSON用の jsonschema2pojo.org が生成されます。

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

Answer 16

JSON文字列（jsonString）を表すJavaクラス（Messageなど）がある場合は、 Jackson JSONライブラリを次のように使用します。

Message message= new ObjectMapper().readValue(jsonString, Message.class);

そしてメッセージオブジェクトから、その任意の属性を取得することができます。

Answer 17

Gson は習得が簡単で実装が簡単です。知っておくべきことは2つの方法があります。

• toJson（） - JavaオブジェクトをJSON形式に変換する

• fromJson（） - JSONを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();
    }

    }
}

`

Answer 18

このようなことをしてください。

JSONParser jsonParser = new JSONParser();
JSONObject obj = (JSONObject) jsonParser.parse(contentString);
String product = (String) jsonObject.get("productId");

Answer 19

Gsonライブラリを使って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();

次のように "posts"配列をループすることもできます。

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

Answer 20

次のブログ投稿、 JavaのJSON を読んでください。

この記事は少し古いですが、それでも私はあなたの質問に答えたいと思います。

ステップ1：データのPOJOクラスを作成してください。

ステップ2：今度はJSONを使用してオブジェクトを作成します。

Employee employee = null;
ObjectMapper mapper = new ObjectMapper();
try{
    employee =  mapper.readValue(newFile("/home/sumit/employee.json"), Employee.class);
} 
catch (JsonGenerationException e){
    e.printStackTrace();
}

さらに参照するには、次の link を参照してください。

Answer 21

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

Answer 22

それにはまず最初に 実装ライブラリ を選択する必要があります。

JSON処理用のJava API（JSR 353） は、オブジェクトモデルとストリーミングAPIを使用してJSONを解析、生成、変換、および照会するための移植可能なAPIを提供します。

リファレンス実装 はこちら： https://jsonp.Java.net/

ここで、JSR 353の 実装のリスト を見つけることができます。

JSR-353（JSON）を実装するAPIは何ですか？

そして あなたが決めるのを助けるために ...私もこの記事を見つけました：

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

あなたがJacksonに行くなら、Jacksonを使ったJSONからJavaへ/からのJSONの変換についての良い記事がここにあります： https://www.mkyong.com/Java/how-to-convert-Java-object-to-from- json-jackson/

それが役に立てば幸い！

Answer 23

このページのトップの回答では、1つのプロパティを持つオブジェクト（{name：value}など）のような単純すぎる例を使用しています。それでも単純だが実生活の例が誰かを助けることができると思います。

つまり、これはGoogle Translate APIによって返されるJSONです。

{
  "data": 
     {
        "translations": 
          [
            {
              "translatedText": "Arbeit"
             }
          ]
     }
}

私は "translationText"属性の値を取得したい。 GoogleのGsonを使った「Arbeit」。

2つの可能なアプローチ：

1. 必要な属性を1つだけ取り出す

   String json  = callToTranslateApi("work", "de");
   JsonObject jsonObject = new JsonParser().parse(json).getAsJsonObject();
   return jsonObject.get("data").getAsJsonObject()
           .get("translations").getAsJsonArray()
           .get(0).getAsJsonObject()
           .get("translatedText").getAsString();
   

2. JSONからJavaオブジェクトを作成する

   class ApiResponse {
       Data data;      
       class Data {
           Translation[] translations;         
           class Translation {
               String translatedText;
           }
        }
    }
   

   ...

    Gson g = new Gson();
    String json =callToTranslateApi("work", "de");
    ApiResponse response = g.fromJson(json, ApiResponse.class);
    return response.data.translations[0].translatedText;
   

Answer 24

Jayway JsonPath を使用できます。以下は、ソースコード、pomの詳細、および優れたドキュメントを含むGitHubのリンクです。

https://github.com/jayway/JsonPath

以下の手順に従ってください。

ステップ1 ：Mavenを使用してjayway JSONパス依存関係をクラスパスに追加するか、JARファイルをダウンロードして手動で追加します。

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

ステップ2 ：この例では、入力JSONをファイルとして保存してください。私の場合、私はあなたのJSONをsampleJson.txtとして保存しました。 pageInfoとpostsの間にコンマが欠けていたことに注意してください。

ステップ3 ：bufferedReaderを使用して上記のファイルからJSONの内容を読み取り、それをStringとして保存します。

BufferedReader br = new BufferedReader(new FileReader("D:\\sampleJson.txt"));

        StringBuilder sb = new StringBuilder();
        String line = br.readLine();

        while (line != null) {
            sb.append(line);
            sb.append(System.lineSeparator());
            line = br.readLine();
        }
        br.close();
        String jsonInput = sb.toString();

ステップ4 ：jayway JSONパーサーを使ってJSON文字列を解析します。

Object document = Configuration.defaultConfiguration().jsonProvider().parse(jsonInput);

ステップ5 ：以下のように詳細を読んでください。

String pageName = JsonPath.read(document, "$.pageInfo.pageName");
String pagePic = JsonPath.read(document, "$.pageInfo.pagePic");
String post_id = JsonPath.read(document, "$.posts[0].post_id");

System.out.println("$.pageInfo.pageName " + pageName);
System.out.println("$.pageInfo.pagePic " + pagePic);
System.out.println("$.posts[0].post_id " + post_id);

出力は になります。

$.pageInfo.pageName = abc
$.pageInfo.pagePic = http://example.com/content.jpg
$.posts[0].post_id  = 123456789012_123456789012

Answer 25

私はこのようなJSONを持っています：

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

Javaクラス

class PageInfo {

    private String pageName;
    private String pagePic;

    // Getters and setters
}

このJSONをJavaクラスに変換するためのコード。

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

メイブン

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

Answer 26

jsoniter（jsoniterator）は比較的新しくてシンプルなjsonライブラリで、シンプルで速いように設計されています。 JSONデータを逆シリアル化するために必要なのは、

JsonIterator.deserialize(jsonData, int[].class);

jsonDataはjsonデータの文字列です。

公式ウェブサイト をチェックしてください。

Answer 27

JSONObjectクラスを使用して、JSON文字列をJSONオブジェクトに変換したり、JSONオブジェクトを反復処理したりできます。次のコードを使用してください。

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

Answer 28

JSON文字列の構造化ツリー表現にJsonNodeを使用できます。これは、しっかりした jackson library の一部です。

ObjectMapper mapper = new ObjectMapper();
JsonNode yourObj = mapper.readTree("{\"k\":\"v\"}");

Answer 29

複雑なjsonとXML文書を解析するために _ dsm _ stream解析ライブラリを使用できます。 DSMはデータを1回だけ解析し、すべてのデータをメモリにロードするわけではありません。

与えられたjsonデータをデシリアライズする Page クラスがあるとしましょう。

ページクラス

public class Page {
    private String pageName;
    private String pageImage;
    private List<Sting> postIds;

    // getter/setter

}

YAMLマッピングファイルを作成します。

result:
  type: object     # result is array
  path: /posts
  fields:
    pageName:
        path: /pageInfo/pageName
    pageImage:
        path: /pageInfo/pagePic
    postIds:
      path: post_id
      type: array

DSMを使用してフィールドを抽出します。

DSM dsm=new DSMBuilder(new File("path-to-yaml-config.yaml")).create(Page.class);
Page page= (Page)dsm.toObject(new path-to-json-data.json");

ページ jsonにシリアル化された変数：

{
  "pageName" : "abc",
  "pageImage" : "http://example.com/content.jpg",
  "postIds" : [ "123456789012_123456789012" ]
}

DSMは複雑なjsonとxmlに非常に適しています。

Answer 30

_json _ ファイルの構造を表す Java モデルクラスを作成し、 _ json _のさまざまな要素にアクセスするために Apache @Modelアノテーション を使用できます。 ツリー。他のソリューションとは異なり、これは{リフレクションなしで完全に機能しますであり、リフレクションが不可能であるか、またはかなりのオーバーヘッドが伴う環境に適しています。

使い方を示す sample Mavenプロジェクト があります。まず第一に、それは構造を定義します。

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

そして、生成されたRepositoryInfoクラスとOwnerクラスを使用して、提供された入力ストリームを解析し、その際に特定の情報を取得します。

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

それだ！これに加えて、非同期ネットワーク通信と同様の例を示す live Gist があります。