如何解析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庫易於使用。

請記住（在轉換或使用諸如getJSONObject和getJSONArray類的方法時）以 JSON 表示法

• [ … ]表示一個數組，因此庫會將其解析為JSONArray
• { … }表示一個對象，因此庫會將其解析為JSONObject

下面的示例代碼：

import org.json.*;

String jsonString = ... ; //assign your JSON String here
JSONObject obj = new JSONObject(jsonString);
String pageName = obj.getJSONObject("pageInfo").getString("pageName");

JSONArray arr = obj.getJSONArray("posts"); // notice that `"posts": [...]`
for (int i = 0; i < arr.length(); i++)
{
    String post_id = arr.getJSONObject(i).getString("post_id");
    ......
}

您可以從以下位置找到更多示例： Parse JSON in Java

可下載的罐子：http: //mvnrepository.com/artifact/org.json/json

Answer 2

為了示例的目的，假設您有一個只有name的類Person 。

private class Person {
    public String name;

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

谷歌 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

組織.JSON ( Maven )

如果您不需要對象反序列化而只是簡單地獲取屬性，則可以嘗試 org.json （或查看上面的 GSON 示例！ ）

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

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

傑克遜（ 馬文）

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 這樣的規范。 有了這兩個罐子，我就可以解析 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 解析器非常簡單、靈活、快速且可定制。 試試看

特征：

• 符合 JSON 規范 (RFC4627)
• 高性能 JSON 解析器
• 支持靈活/可配置的解析方法
• 任何 JSON 層次結構的鍵/值對的可配置驗證
• 易於使用 # 占用空間非常小
• 提高對開發人員友好且易於跟蹤的異常
• 可插入的自定義驗證支持 - 可以通過在遇到時配置自定義驗證器來驗證鍵/值
• 驗證和非驗證解析器支持
• 支持兩種類型的配置 (JSON/XML) 以使用快速 JSON 驗證解析器
• 需要 JDK 1.5
• 不依賴外部庫
• 通過對象序列化支持 JSON 生成
• 支持解析過程中的集合類型選擇

它可以這樣使用：

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

Answer 5

你可以使用谷歌 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);

Gradle 導入

記得在 app Gradle 文件中導入庫

implementation 'com.google.code.gson:gson:2.8.6' // or earlier versions

自動模型生成

您可以使用這樣的在線工具從 JSON 自動生成模型。

Answer 6

A - 解釋

您可以使用Jackson庫將 JSON 字符串綁定到POJO （普通舊 Java 對象）實例。 POJO 只是一個只有私有字段和公共 getter/setter 方法的類。 Jackson 將遍歷方法（使用反射），並將 JSON 對象映射到 POJO 實例，因為類的字段名稱適合 JSON 對象的字段名稱。

在您的 JSON 對象（實際上是一個復合對象）中，主對象由兩個子對象組成。 因此，我們的 POJO 類應該具有相同的層次結構。 我將把整個 JSON 對象稱為Page對象。 Page對象由一個PageInfo對象和一個Post對象數組組成。

所以我們必須創建三個不同的 POJO 類；

• Page類， PageInfo類和Post實例數組的組合
• 頁面信息類
• 帖子類

我用過的唯一包是Jackson ObjectMapper，我們做的是綁定數據；

com.fasterxml.jackson.databind.ObjectMapper

需要的依賴，jar文件在下面列出；

• 傑克遜核心-2.5.1.jar
• jackson-databind-2.5.1.jar
• 傑克遜注釋-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 - 子 POJO 類：發布

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 7

幾乎所有給出的答案都需要在訪問感興趣的屬性中的值之前將 JSON 完全反序列化為 Java 對象。 另一種不走這條路線的替代方法是使用JsonPATH ，它類似於 JSON 的 XPath，並允許遍歷 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");

ETC...

查看 JsonPath 規范頁面以獲取有關橫向 JSON 的其他方式的更多信息。

Answer 8

使用最小的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

下面的示例顯示了如何閱讀問題中的文本，表示為“jsonText”變量。 此解決方案使用 Java EE7 javax.json API（在其他一些答案中提到）。 我將其添加為單獨答案的原因是以下代碼顯示了如何實際訪問問題中顯示的某些值。 需要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 或任何其他可用的第 3 方框架而對這個答案投反對票之前，它是解析所提供文本的每個問題的“必需代碼”示例。 我很清楚JDK 9 沒有考慮遵守當前的標准 JSR 353，因此JSR 353 規范應該與任何其他第 3 方 JSON 處理實現一樣對待。

Answer 10

由於還沒有人提到它，這里是使用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));
}

性能比較

我編寫的 JSON 內容包含三個數組，分別為 20、20 和 100 個元素。 我只想從第三個數組中獲取 100 個元素。 我使用以下 JavaScript 函數來解析和獲取我的條目。

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

使用Nashorn運行一百萬次調用需要 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，后者的性能比 org.json 好得多。 Nashorn API 比 org.json 或 Jackson 更難使用。 根據您的要求，Jackson 和 Nashorn 都是可行的解決方案。

Answer 11

我相信最佳實踐應該是通過仍在進行中的官方Java JSON API 。

Answer 12

這讓我大吃一驚，因為它是多么容易。 您可以將保存 JSON 的String傳遞給默認 org.json 包中 JSONObject 的構造函數。

JSONArray rootOfPage =  new JSONArray(JSONString);

完畢。 掉落麥克風。 這也適用於JSONObjects 。 之后，您可以使用Objects上的get()方法查看對象的層次結構。

Answer 13

Java 中有許多可用的 JSON 庫。

最臭名昭著的是：Jackson、GSON、Genson、FastJson 和 org.json。

在選擇任何庫時，通常應該考慮三件事：

1. 表現
2. 易於使用（代碼易於編寫且清晰易讀） - 與功能相得益彰。
3. 對於移動應用程序：依賴項/jar 大小

特別是對於 JSON 庫（以及任何序列化/反序列化庫），數據綁定通常也很有趣，因為它無需編寫樣板代碼來打包/解包數據。

對於 1，請參閱此基准： https ://github.com/fabienrenaud/java-json-benchmark 我使用JMH比較了（jackson、gson、genson、fastjson、org.json、jsonp）使用流的序列化器和反序列化器的性能和數據綁定 API。 對於 2，您可以在 Internet 上找到大量示例。 上面的基准也可以用作示例的來源......

快速了解基准： Jackson的性能比 org.json 好 5 到 6 倍，比 GSON 好兩倍多。

對於您的特定示例，以下代碼使用傑克遜解碼您的 json：

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

除了其他答案，我推薦這個在線開源服務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 15

如果你有一些 Java 類（比如 Message）代表 JSON 字符串（jsonString），你可以使用Jackson JSON 庫：

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

並且從消息對象中，您可以獲取其任何屬性。

Answer 16

Gson易於學習和實現，我們需要了解以下兩種方法

• 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 17

有許多開源庫可用於將 JSON 內容解析為對象或僅用於讀取 JSON 值。 您的要求只是讀取值並將其解析為自定義對象。 所以 org.json 庫在你的情況下就足夠了。

使用 org.json 庫對其進行解析並創建 JsonObject：

JSONObject jsonObj = new JSONObject(<jsonStr>);

現在，使用此對象獲取您的值：

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

你可以在這里看到一個完整的例子：

如何在 Java 中解析 JSON

Answer 18

閱讀以下博客文章， 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();
}

如需進一步參考，您可以參考以下鏈接。

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

我有這樣的 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 21

請做這樣的事情：

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

Answer 22

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

此頁面上的熱門答案使用了過於簡單的示例，例如具有一個屬性的對象（例如 {name: value}）。 我認為這個仍然簡單但真實的例子可以幫助某人。

這是谷歌翻譯 API 返回的 JSON：

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

我想使用 Google 的 Gson 檢索“translatedText”屬性的值，例如“Arbeit”。

兩種可能的方法：

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 和帖子之間的逗號。

第 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 處理的 Java API (JSR 353)提供可移植的 API 以使用對象模型和流 API 解析、生成、轉換和查詢 JSON。

參考實現在這里： 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 在 Java 與 JSON 之間進行轉換的好文章： https ://www.mkyong.com/java/how-to-convert-java-object-to-from-json- 傑克遜/

希望能幫助到你！

Answer 26

如果您有 maven 項目，則添加以下依賴項或普通項目添加 json-simple jar。

<dependency>
    <groupId>org.json</groupId>
    <artifactId>json</artifactId>
    <version>20180813</version>
</dependency>

在下面編寫將 JSON 字符串轉換為 JSON 數組的 java 代碼。

JSONArray ja = new JSONArray(String jsonString);

Answer 27

任何一種 json 陣列都可以解決問題。

1. 將您的 JSON object 轉換為 java object。
2. 您可以使用此鏈接或任何在線工具。
3. 另存為 java class ，例如Myclass.java 。
4. Myclass obj = new Gson().fromJson(JsonStr, Myclass.class);
5. 使用obj ，您可以獲得您的值。

Answer 28

可以使用Apache @Model 注解創建表示JSON文件結構的Java模型類，並使用它們訪問JSON樹中的各種元素。 與其他解決方案不同，此解決方案完全無需反射，因此適用於無法反射或需要大量開銷的環境。

有一個示例 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()
    );
})

這就對了！ 除此之外，這里還有一個實時要點，展示了類似的示例以及異步網絡通信。

Answer 29

jsoniter (jsoniterator) 是一個比較新的簡單的json庫，設計簡單快速。 反序列化 json 數據所需要做的就是

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

其中jsonData是一串 json 數據。

查看官方網站了解更多信息。

Answer 30

您可以將JsonNode用於 JSON 字符串的結構化樹表示。 它是無所不在的堅如磐石的傑克遜圖書館的一部分。

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

Answer 31

我們可以使用 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 32

您可以使用DSM流解析庫來解析復雜的json和XML文檔。 DSM僅解析一次數據，而不會將所有數據加載到內存中。

假設我們有Page類可以反序列化給定的json數據。

頁面類

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。