【问题标题】:How to parse JSON in Java如何在 Java 中解析 JSON
【发布时间】:2022-08-18 21:31:47
【问题描述】:

我有以下 JSON 文本。我如何解析它以获得pageNamepagePicpost_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"
    }
  ]
}

【问题讨论】:

  • java 内置的 JSON 库是最快的方法,但根据我的经验,GSON 是将 JSON 轻松解析为 POJO 的最佳库。
  • java中有很多臭名昭著的java库:jackson、gson、org.json、genson等,选择一个应该考虑它们的相对性能和特性集。这是使用 JMH 进行的基准测试,比较了 java 中最流行的 json 库的性能:github.com/fabienrenaud/java-json-benchmark。有关更多信息,请参阅下面的帖子。
  • @JaysonMinard 同意。要求 mod 干预。这真的应该关闭。我最初(错误地)假设在问题受到保护时我不能这样做,所以我取消保护它并做了我的事情。现在重新保护它以防止在等待 mod 时出现低代表答案等问题。
  • 这个问题是discussed on Meta

标签: java json parsing


【解决方案1】:

org.json 库易于使用。

请记住(在转换或使用 getJSONObjectgetJSONArray 等方法时)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

可下载的jar:http://mvnrepository.com/artifact/org.json/json

【讨论】:

  • 我同意@StaxMan。我刚试过 org.json,它非常麻烦。例如,它真的不能与标准的 Java Collection 类型一起玩。
  • @StaxMan 我会选择org.json而不是其他库来进行简单的 JSON 解析,甚至不看。它是 Douglas Crockford(JSON 发现者)创建的参考库。
  • @OmarIthawi 这太傻了。这是一个概念验证,API 笨拙,实施效率低下。我认为最好根据库本身的优点来考虑库,而不是试图从其作者的可见性中推断出质量——Doug 已经取得了很多成就,但这并没有真正改变特定库的质量。 10 年前,这是镇上唯一的游戏,但从那时起,已经取得了很大的积极进展。这就像 json 库的 Struts。
  • org.json 是最糟糕的 json 库之一。在选择之前,应该查看可用 json 库的功能集和性能。这是我使用 JMH 比较 jackson、gson、org.json、genson 的基准:github.com/fabienrenaud/java-json-benchmark。杰克逊显然是这里的赢家。
  • 该许可证不包括任何常用的开源许可证,它还拥有版权。
【解决方案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

Jackson (Maven)

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

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

【讨论】:

  • 好答案。一个小改进的建议:GSON 和 Jackson 都支持使用 JSON 树表示(对于 Jackson,这些是JsonNodes,GSON 有类似的东西)。显示 sn-ps 可能很好,因为这类似于 org.json 提供的唯一方式。
  • 另外两个库值得一提(为了完整性):json-simpleOracle's JSONP
  • @NeonWarge,为什么?在我看来,这个答案假设已经定义了一个 Java 类,它包含与 JSON 字符串完全相同的字段,仅此而已。这是一个相当有力的假设。
  • json-simple 和 oracle 的 jsonp 表现非常糟糕:github.com/fabienrenaud/java-json-benchmark 为了性能,选择 jackson 或 dsljson。
  • 对于 GSON,我注意到(您的示例)new JsonParser().parse() 已弃用 (v2.8.6+) - 请参阅stackoverflow.com/a/60771740/1265200 以了解 JsonParser.parseString() 的替代用法
【解决方案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");
    

【讨论】:

  • @nondescript 如果我不得不猜测我会说它被否决了,因为它没有回答原始海报的问题:“所需的代码是什么?”被赞成的答案提供了代码 sn-ps。
  • 注意:Jackson 和 GSON 都支持树型和/或地图/列表绑定,因此无需使用 Java EE (javax.json) 包。除了 Jackson 或 GS​​ON 之外,javax.json 几乎没有什么可提供的。
  • 我建议添加到 JavaEE 库的链接。
【解决方案4】:

quick-json parser 非常简单、灵活、非常快速且可定制。试试看

特征:

  • 符合 JSON 规范 (RFC4627)
  • 高性能 JSON 解析器
  • 支持灵活/可配置的解析方法
  • 任何 JSON 层次结构的键/值对的可配置验证
  • 易于使用 # 占用空间非常小
  • 引发开发人员友好且易于跟踪的异常
  • 可插入的自定义验证支持 - 键/值可以通过配置自定义验证器来验证,当遇到时
  • 验证和非验证解析器支持
  • 支持两种类型的配置(JSON/XML)以使用快速 JSON 验证解析器
  • 需要 JDK 1.5
  • 不依赖外部库
  • 支持通过对象序列化生成 JSON
  • 支持在解析过程中选择集合类型

它可以这样使用:

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

【讨论】:

  • 有可用的 javadoc 吗?
  • 此包在解析时无法处理空值。例如: ... "description":"" ... 抛出异常
  • 我已经在 code.google.com/p/quick-json/issues/detail?id=11 中修复了这个问题(以及许多其他问题)我希望作者能花时间在正式版本中修复它。
  • 在列出的功能中,与其他选项相比,没有什么是独一无二的——并且没有任何东西支持高性能的说法;与更成熟的库(Gson、Jackson、Genson、Boon)不同,它们包含在基准测试中,如 github.com/eishay/jvm-serializersgithub.com/novoj/JavaJsonPerformanceTestdeveloper.com/lang/jscript/…——我没有看到这个库包含在测试中,也没有提到它被广泛使用.
  • 这个项目似乎已经死了并且似乎不再托管在中央 Maven 存储库中。
【解决方案5】:

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

摇篮导入

记得在app Gradle文件中导入库

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

自动模型生成

您可以使用this 等在线工具自动从 JSON 生成模型。

【讨论】:

    【解决方案6】:

    几乎所有给出的答案都需要在访问感兴趣的属性中的值之前将 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 的其他方法的更多信息。

    【讨论】:

    【解决方案7】:

    A - 解释

    您可以使用杰克逊库,用于将 JSON 字符串绑定到POJO(普通旧 Java 对象) 实例。 POJO 只是一个只有私有字段和公共 getter/setter 方法的类。杰克逊将遍历这些方法(使用反射),并将 JSON 对象映射到 POJO 实例,因为类的字段名称适合 JSON 对象的字段名称。

    在您的 JSON 对象中,它实际上是一个合成的对象,主对象由两个子对象组成。因此,我们的 POJO 类应该具有相同的层次结构。我将整个 JSON 对象称为目的。对象由一个页面信息对象和一个邮政对象数组。

    所以我们必须创建三个不同的 POJO 类;

    • 类,复合的页面信息类和数组邮政实例
    • 页面信息班级
    • 帖子班级

    我使用的唯一包是 Jackson ObjectMapper,我们所做的是绑定数据;

    com.fasterxml.jackson.databind.ObjectMapper
    

    所需的依赖项,jar 文件列在下面;

    • 杰克逊核心-2.5.1.jar
    • 杰克逊-databind-2.5.1.jar
    • 杰克逊-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 - 子 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("	Page Name : " + pageInfo.getPageName());
            System.out.println("	Page 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("	Post Id                   : " + post.getPost_id());
            System.out.println("	Actor Id                  : " + post.getActor_id());
            System.out.println("	Pic Of Person Who Posted  : " + post.getPicOfPersonWhoPosted());
            System.out.println("	Name Of Person Who Posted : " + post.getNameOfPersonWhoPosted());
            System.out.println("	Message                   : " + post.getMessage());
            System.out.println("	Likes Count               : " + post.getLikesCount());
            System.out.println("	Comments                  : " + Arrays.toString(post.getComments()));
            System.out.println("	Time 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
    

    【讨论】:

    • 有支持JDK的版本吗?
    【解决方案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>
    

    【讨论】:

    • pojo 会是什么样子?
    • 对于 Pojo 使用 gson。这个库不支持。
    【解决方案9】:

    下面的示例显示了如何读取问题中的文本,表示为“jsonText”变量。该解决方案使用 Java EE7 javax.json API(在其他一些答案中提到)。我将其添加为单独答案的原因是以下代码显示了如何实际上访问问题中显示的一些值。需要 implementation of the javax.json API 才能运行此代码。因为我不想声明“导入”语句,所以包含了每个所需类的完整包。

    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 方框架而对这个答案投反对票之前,它是每个问题解析所提供文本的“必需代码”示例。我很清楚 adherence to the current standard JSR 353 was not being considered for JDK 9JSR 353 spec 应该与任何其他第 3 方 JSON 处理实现一样对待。

    【讨论】:

      【解决方案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};
      

      使用调用一百万次纳肖恩耗时7.5~7.8秒

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

      组织.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 都是可行的解决方案。

      【讨论】:

      • "”的单位是什么?不是英寸?是秒吗?分钟?
      • @PeterMortensen 这意味着秒。由于似乎不清楚我会改变它。感谢您的评论。
      • 不幸的是,Nashorn 在 Java 11 中被弃用了。JEP 335
      • 我知道 Nashorn 已被弃用,但我喜欢这个答案,因为我不想要任何依赖;但是,我不得不稍微修改一下示例:ScriptEngine engine = new ScriptEngineManager().getEngineByName("JavaScript"); engine.eval("var fun = function(raw) { return JSON.parse(raw); };"); Map&lt;String, Object&gt; json = (Map&lt;String, Object&gt;) ((Invocable) engine).invokeFunction("fun", jsonString);
      • @kgibm 太棒了!您知道如何访问返回的Objects 中的数组元素吗?该课程是ScriptObjectMirror,但无法访问...
      【解决方案11】:

      我认为最好的做法应该是通过仍在进行中的官方Java JSON API

      【讨论】:

      • 自从我回复后,我开始使用Jackson,我认为它是目前最好的 JSON 反序列化库之一。
      • 为什么他们重​​复使用 JSONP 来表示与 JSON with Padding 不同的含义?...
      • @ChrisWesseling 你是什么意思?
      • “用于 JSON 处理的 Java API (JSON-P)”是您链接到的文档的标题。这让我很困惑,因为我知道 JSONP 有别的意思。
      • @ChrisWesseling 哦,这令人困惑。这就是他们为规范选择的内容。但是正如我所说,我会直接去杰克逊。
      【解决方案12】:

      这让我大吃一惊,因为它是多么容易。您可以将保存 JSON 的 String 传递给默认 org.json 包中的 JSONObject 的构造函数。

      JSONArray rootOfPage =  new JSONArray(JSONString);
      

      完毕。滴话筒. 这也适用于JSONObjects。之后,您可以使用对象上的 get() 方法查看 Objects 的层次结构。

      【讨论】:

      • JSONArray 类型不是 J2SE JDK API 的一部分,您也没有说哪个 API 或第三方库提供了这种类型。
      • 并不是说我会推荐使用它,但我认为这是指来自json.org/java 的“org.json”包。它曾经在优秀的 Java 库可用之前被使用,但这是几年前的事了(2008 年或之前)
      • 或者 brainmurphy1 在 Android 中的意思是 JSONArray
      【解决方案13】:

      Java 中有许多可用的 JSON 库。

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

      选择任何库时通常应考虑三件事:

      1. 性能
      2. 易于使用(代码易于编写且清晰易读)- 与功能相辅相成。
      3. 对于移动应用程序:依赖项/jar 大小

        特别是对于 JSON 库(以及任何序列化/反序列化库),数据绑定通常也很有趣,因为它消除了编写样板代码来打包/解包数据的需要。

        对于 1,请参阅此基准:https://github.com/fabienrenaud/java-json-benchmark 我确实使用了 JMH,它比较了使用流和数据绑定 API 的序列化器和反序列化器的(jackson、gson、genson、fastjson、org.json、jsonp)性能。 对于 2,您可以在 Internet 上找到大量示例。上面的基准也可以用作示例的来源......

        基准测试的快速总结:杰克逊性能比 org.json 好 5 到 6 倍,比 GSON 好两倍以上。

        对于您的特定示例,以下代码使用 jackson 解码您的 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.
            }
        }
        

        如果您有任何问题,请告诉我。

      【讨论】:

        【解决方案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;
        }
        

        【讨论】:

          【解决方案15】:

          如果您有一些代表 JSON 字符串 (jsonString) 的 Java 类(比如 Message),您可以使用 Jackson JSON 库:

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

          从消息对象中,您可以获取它的任何属性。

          【讨论】:

            【解决方案16】:

            格森很容易学习和实现,我们需要知道的是以下两种方法

            • toJson()– 将 Java 对象转换为 JSON 格式

            • 来自Json()– 将 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();
                }
            
                }
            }
            

            `

            【讨论】:

            【解决方案17】:

            有许多开源库可将 JSON 内容解析为对象或仅读取 JSON 值。您的要求只是读取值并将其解析为自定义对象。所以 org.json 库就足够了。

            使用 org.json 库解析它并创建 JsonObject:

            JSONObject jsonObj = new JSONObject(<jsonStr>);
            

            现在,使用此对象获取您的值:

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

            你可以在这里看到一个完整的例子:

            How to parse JSON in Java

            【讨论】:

            • 似乎您的所有答案都包含指向该站点的链接。如果是垃圾邮件,请停止。如果不是,很抱歉造成混淆,但我认为没有必要在您的所有答案中发布链接。
            • 很难给出答案,您可以在其中解释所有情况。就像在这种情况下,如何读取 json 数组或多个 json 对象。即使我这样做,答案也会很长,人们可能会感到困惑。所以我给出了一个链接,其中给出了正确的解释,并附有适当的例子。他可以选择访问或只能使用我的解释。
            • 在我看来,您提供的链接仅演示了如何读取 JSON。我在哪里也可以找到有关如何使用 JSON 的信息?
            • 抱歉,但我不明白你的问题:-“关于如何使用 JSON”
            【解决方案18】:

            您可以使用 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
            }
            

            【讨论】:

              【解决方案19】:

              阅读以下博文,JSON in Java

              这篇文章有点老了,但我还是想回答你的问题。

              第 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

              【讨论】:

                【解决方案20】:

                您可以使用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
                

                【讨论】:

                  【解决方案21】:

                  我有这样的 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>
                  

                  【讨论】:

                    【解决方案22】:

                    请做这样的事情:

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

                    【讨论】:

                    • 呃,这是哪个图书馆?
                    • 我认为他正在使用 org.json.simple
                    • 在最后一行应该是 ne String product = (String) obj.get("productId");
                    【解决方案23】:
                    {
                       "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
                    }
                    

                    【讨论】:

                    【解决方案24】:

                    首先你需要选择一个实现库要做到这一点。

                    用于 JSON 处理的 Java API (JSR 353)提供可移植的 API,以使用对象模型和流式 API 来解析、生成、转换和查询 JSON。

                    参考实现在这里:https://jsonp.java.net/

                    在这里你可以找到一个实施清单JSR 353:

                    What are the API that does implement JSR-353 (JSON)

                    帮助你决定...我也找到了这篇文章:

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

                    如果你选择 Jackson,这里有一篇关于使用 Jackson 在 JSON 与 Java 之间转换的好文章:https://www.mkyong.com/java/how-to-convert-java-object-to-from-json-jackson/

                    希望能帮助到你!

                    【讨论】:

                    • 您指向 Jackson 库的版本 1。强烈建议使用当前版本的 Jackson 库。
                    【解决方案25】:

                    此页面上的最佳答案使用了过于简单的示例,例如具有一个属性的对象(例如 {name: value})。我认为这个仍然简单但真实的例子可以帮助某人。

                    这是 Google Translate API 返回的 JSON:

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

                    我想检索“translatedText”属性的值,例如“Arbeit”使用谷歌的 Gson。

                    两种可能的方法:

                    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;
                      

                    【讨论】:

                      【解决方案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);
                      

                      【讨论】:

                        【解决方案27】:

                        任何类型的 json 数组 解决问题的步骤。

                        1. 将您的 JSON 对象转换为 java 对象。
                        2. 您可以使用此link 或任何在线工具。
                        3. 另存为 java 类,如 Myclass.java
                        4. Myclass obj = new Gson().fromJson(JsonStr, Myclass.class);
                        5. 使用obj,您可以获得您的值。

                        【讨论】:

                          【解决方案28】:

                          可以使用Apache @Model annotation来创建爪哇表示结构的模型类JSON文件并使用它们来访问中的各种元素JSON树。与其他解决方案不同,这个完全没有反射地工作因此适用于反射不可能或开销很大的环境。

                          有一个 sample Maven project 显示了用法。首先它定义了结构:

                          @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 显示了类似的示例以及异步网络通信。

                          【讨论】:

                            【解决方案29】:

                            jsoniter(jsoniterator)是一个比较新的简单的json库,设计的目的是简单快速。反序列化 json 数据所需要做的就是

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

                            其中 jsonData 是一串 json 数据。

                            查看official website 了解更多信息。

                            【讨论】:

                              【解决方案30】:

                              您可以使用 JsonNode 作为 JSON 字符串的结构化树表示。它是无所不在的坚如磐石jackson library 的一部分。

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

                              【讨论】:

                                猜你喜欢
                                • 1970-01-01
                                • 1970-01-01
                                • 1970-01-01
                                • 1970-01-01
                                • 2010-12-05
                                • 1970-01-01
                                • 2015-03-31
                                • 1970-01-01
                                • 1970-01-01
                                相关资源
                                最近更新 更多