如何在Java中解析JSON


How to parse JSON in Java

我有以下JSON文本。如何解析得到pageName、pagePic、post_id等的值？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
{
  "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"
         }
    ]
}
相关讨论

org.json库易于使用。示例代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
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

相关讨论

为了这个例子，我们假设您有一个类Person，只有一个name。

1
2
3
4
5
6
7
private class Person {
    public String name;

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

谷歌GSON(Maven)

我个人最喜欢的是伟大的JSON对象序列化/反序列化。

1
2
3
4
5
6
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"}

更新

如果你想得到一个单一的属性，你也可以用谷歌图书馆轻松做到：

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

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

org.json(马文)

如果您不需要对象去序列化，只需要简单地获取一个属性，您可以尝试org.json(或者查看上面的gson示例！)

1
2
3
JSONObject obj = new JSONObject("{"name": "John"}");

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

杰克逊(Maven)

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

System.out.println(user.name); //John
相关讨论

  • 如果想要从JSON创建Java对象，反之亦然，则使用GSON或Jackson第三方JAR等。

    1
    2
    3
    4
    5
    6
    //from object to JSON
    Gson gson = new Gson();
    gson.toJson(yourObject);

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

  • 但是，如果您只想解析一个JSON字符串并获取一些值(或者从头开始创建一个JSON字符串以便通过网络发送)，那么只需使用包含JSONreader、JSONarray、JSONObject等的Javeee JAR。您可能需要下载该规范的实现，如javax.json。有了这两个jar，我就能够解析JSON并使用这些值。

    这些API实际上遵循XML的DOM/SAX解析模型。

    1
    2
    3
    4
    5
    6
    7
    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");
    • 相关讨论

    快速JSON解析器非常简单、灵活、快速和可定制。试试看

    特征：

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

    它可以这样使用：

    1
    2
    3
    JsonParserFactory factory=JsonParserFactory.getInstance();
    JSONParser parser=factory.newJsonParser();
    Map jsonMap=parser.parseJson(jsonString);
    相关讨论

    一个解释

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

    在实际上是复合对象的JSON对象中，主对象由两个子对象组成。因此，我们的pojo类应该具有相同的层次结构。我将把整个JSON对象称为页面对象。页面对象由pageinfo对象和post对象数组组成。

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

    • page类，pageinfo类和post实例数组的组合
    • PaGeFipe类
    • 职位类别

    我使用的唯一包是Jackson Objectmapper，我们所做的就是绑定数据；

    1
    com.fasterxml.jackson.databind.ObjectMapper

    所需的依赖项，jar文件如下所示；

    • 杰克逊-core-2.5.1.jar
    • 杰克逊-databind-2.5.1.jar
    • 杰克逊注释-2.5.0.jar

    这是所需的代码；

    B-主POJO类：第页

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    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-child pojo类：pageinfo

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    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课程：岗位

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    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文件：sample json file.json

    我刚刚将您的JSON示例复制到这个文件中，并将其放在项目文件夹下。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    {
      "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"
             }
        ]
    }

    演示代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    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());
        }

    }

    演示输出

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    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

    几乎所有给出的答案都需要将JSON完全反序列化为Java对象，然后才能访问感兴趣的属性中的值。另一种选择是使用jsonpath，它类似于json的xpath，允许遍历json对象。

    它是一个规范，JayWayle的好朋友已经为规范创建了一个Java实现，您可以在这里找到：HTTPS://Github. COM/JayWay/JSONPATH

    所以基本上要使用它，把它添加到你的项目中，例如：

    1
    2
    3
    4
    5
    <dependency>
        <groupId>com.jayway.jsonpath</groupId>
        json-path</artifactId>
        <version>${version}</version>
    </dependency>

    并使用：

    1
    2
    3
    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规范页。

    你可以使用谷歌GSON。

    使用这个库，您只需要创建具有相同JSON结构的模型。然后自动填充模型。您必须将变量调用为JSON键，如果要使用不同的名称，则必须使用@serializedname。

    例如：

    杰森：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    {
       "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"
            }
        ]
    }

    模型：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    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库进行解析：

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

    您可以使用这样的在线工具从JSON自动生成模型。

    使用最小的JSON，这是非常快速和容易使用。可以从字符串obj和stream进行分析。

    样本数据：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    {
     "order": 4711,
     "items": [
        {
         "name":"NE555 Timer IC",
         "cat-id":"645723",
         "quantity": 10,
        },
        {
         "name":"LM358N OpAmp IC",
         "cat-id":"764525",
         "quantity": 2
        }
      ]
    }

    解析：

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

    创建JSON：

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

    Maven：

    1
    2
    3
    4
    5
    <dependency>
      <groupId>com.eclipsesource.minimal-json</groupId>
      minimal-json</artifactId>
      <version>0.9.4</version>
    </dependency>
    相关讨论

    我相信最好的实践应该是通过正在进行中的正式Java JSONAPI。

    相关讨论

    下面的示例显示如何读取问题中的文本，该文本表示为"jContext"变量。这个解决方案使用JavaEE7 JavaX.JSONAPI(在一些其他的答案中提到)。我将它作为一个单独的答案添加的原因是下面的代码显示了如何实际访问问题中显示的一些值。运行此代码需要javax.json API的实现。包含了所需每个类的完整包，因为我不想声明"import"语句。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    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或任何其他可用的第三方框架而对这个答案投反对票之前，它是每个问题的"必需代码"的一个示例来解析所提供的文本。我很清楚，JDK9没有考虑遵守现行标准JSR 353，因此，JSR 353规范应与任何其他第三方JSON处理实现相同。

    因为没有人提到它，这里是使用NASHORN(Java 8的JavaScript运行时部分，但在Java 11中被弃用)的解决方案的开始。

    解决方案

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    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函数来解析和获取我的条目。

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

    使用Nashorn进行100万次通话需要7.5~7.8秒

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

    org.json需要20~21秒

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

    杰克逊需要6.5~7秒

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

    在这种情况下，杰克逊的表现比Nashorn好，后者比org.json好得多。Nashorn API比org.json或Jackson更难使用。根据您的要求，Jackson和Nashorn都是可行的解决方案。

    相关讨论

    这件事太容易了，使我大吃一惊。您只需将持有JSON的String传递给缺省org.json包中JSONObject的构造函数即可。

    1
    JSONArray rootOfPage =  new JSONArray(JSONString);

    完成。放下麦克风。这也适用于JSONObjects。之后，您可以在对象上使用get()方法查看Objects的层次结构。

    相关讨论

    Java中有许多JSON库可用。

    最臭名昭著的是：杰克逊，格森，根森，法斯森和org.json。

    在选择任何库时，通常需要注意三件事：

  • 性能
  • 易用性(代码编写简单，易读)-与功能配套。
  • 对于移动应用程序：依赖项/jar大小

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

    有关1，请参阅此基准：https://github.com/fabienrenaud/java-json-benchm i did using jmh，其中比较了使用流和数据绑定API的序列化程序和反序列化程序的性能(jackson、gson、genson、fastjson、org.json、jsonp)。对于2，您可以在互联网上找到许多例子。以上基准也可作为实例来源。

    快速获得基准：杰克逊的表现是org.json的5到6倍，是gson的两倍多。

    对于您的特定示例，以下代码使用Jackson解码您的JSON：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    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.
        }
    }

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

    除了其他的答案，我还可以从JSON或JSON模式快速生成JSON或JSON模式的JavaSchema2POJ.ORG的在线资源服务JSON 1，X或杰克逊2。X.例如，如果你有：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    {
      "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生成：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    @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;
    }

    如果您有代表JSON字符串(JSONString)的Java类(例如消息)，则可以使用Jackson JSON库：

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

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

    存在许多开放源码库，用于将JSON内容解析到对象或仅仅读取JSON值。您的需求只是读取值并将其解析为自定义对象。所以在您的案例中，org.json库就足够了。

    使用org.json库解析它并创建jsonObject：

    1
    JSONObject jsonObj = new JSONObject(<jsonStr>);

    现在，使用此对象获取值：

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

    您可以在这里看到一个完整的示例：

    如何在Java中解析JSON

    相关讨论

    GSON易于学习和实现，我们需要知道的是以下两种方法

    • TojScript()-将Java对象转换为JSON格式

    • 从JSON()转换JSON到Java对象

    `

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    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();
        }

        }
    }

    `

    相关讨论

    请这样做：

    1
    2
    3
    JSONParser jsonParser = new JSONParser();
    JSONObject obj = (JSONObject) jsonParser.parse(contentString);
    String product = (String) jsonObject.get("productId");
    相关讨论

    可以使用gson库来解析JSON字符串。

    1
    2
    3
    4
    5
    6
    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"数组进行循环，如下所示：

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

    阅读下面的博客文章，Java中的JSON。

    这篇文章有点旧，但我还是想回答你的问题。

    步骤1：创建数据的POJO类。

    步骤2：现在使用JSON创建一个对象。

    1
    2
    3
    4
    5
    6
    7
    8
    Employee employee = null;
    ObjectMapper mapper = new ObjectMapper();
    try{
        employee =  mapper.readValue(newFile("/home/sumit/employee.json"), Employee.class);
    }
    catch (JsonGenerationException e){
        e.printStackTrace();
    }

    如需进一步参考，请参阅以下链接。

    本页的顶部答案使用了太简单的示例，例如具有一个属性的对象(例如，名称：值)。我认为这个仍然简单但真实的例子可以帮助一个人。

    这是Google Translate API返回的JSON：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    {
     "data":
         {
           "translations":
              [
                {
                 "translatedText":"Arbeit"
                 }
              ]
         }
    }

    我想使用谷歌的GSON检索"translatedtext"属性的值，例如"arbeit"。

    两种可能的方法：

  • 只检索一个需要的属性

    1
    2
    3
    4
    5
    6
    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();

  • 从JSON创建Java对象

    1
    2
    3
    4
    5
    6
    7
    8
    9
    class ApiResponse {
        Data data;      
        class Data {
            Translation[] translations;        
            class Translation {
                String translatedText;
            }
         }
     }

    …

    1
    2
    3
    4
     Gson g = new Gson();
     String json =callToTranslateApi("work","de");
     ApiResponse response = g.fromJson(json, ApiResponse.class);
     return response.data.translations[0].translatedText;
    • 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    {
      "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
    }
    相关讨论

    首先，您需要选择一个实现库来完成这项工作。

    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/

    如果您选择杰克逊，这里有一篇关于使用Java/JavaNo./www. MkyUn.COM/Java/Word-to Java-对象到FROM JSON-JSONSON/JAVA的JSON到Java之间转换的好文章。

    希望它有帮助！

    相关讨论

    您可以使用jayway jsonpath。下面是一个带有源代码、POM详细信息和良好文档的Github链接。

    https://github.com/jayway/json路径

    请遵循以下步骤。

    步骤1：使用maven在类路径中添加jayway-json路径依赖项，或者下载jar文件并手动添加。

    1
    2
    3
    4
    5
    <dependency>
                <groupId>com.jayway.jsonpath</groupId>
                json-path</artifactId>
                <version>2.2.0</version>
    </dependency>

    步骤2：请将输入的JSON保存为本例中的一个文件。在我的例子中，我将您的JSON保存为samplejson.txt。注意，在pageinfo和posts之间漏掉了一个逗号。

    步骤3：使用bufferedreader从上述文件中读取JSON内容，并将其保存为字符串。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    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字符串。

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

    步骤5：阅读下面的详细信息。

    1
    2
    3
    4
    5
    6
    7
    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);

    输出将是：

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

    我有这样的JSON：

    1
    2
    3
    4
    5
    6
    {
      "pageInfo": {
            "pageName":"abc",
            "pagePic":"http://example.com/content.jpg"
        }
    }

    Java类

    1
    2
    3
    4
    5
    6
    7
    class PageInfo {

        private String pageName;
        private String pagePic;

        // Getters and setters
    }

    将JSON转换为Java类的代码。

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

    马文

    1
    2
    3
    4
    5
    <dependency>
        <groupId>com.jayway.jsonpath</groupId>
        json-path</artifactId>
        <version>2.2.0</version>
    </dependency>

    jsoniter是一个相对较新、简单的JSON库，设计简单、快速。反序列化JSON数据需要做的就是

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

    其中jsonData是一组JSON数据。

    查看官方网站更多信息。

    我们可以使用JSONObject类将JSON字符串转换为JSON对象，迭代JSON对象。使用以下代码。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    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));
      }
    }
    相关讨论

    您可以使用JsonNode来表示JSON字符串的结构化树。这是一个坚如磐石的杰克逊图书馆的一部分，无所不在。

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

    您可以使用DSM流分析库来分析复杂的JSON和XML文档。DSM只分析一次数据，而不将所有数据加载到内存中。

    假设我们有页面类来反序列化给定的JSON数据。

    页类

    1
    2
    3
    4
    5
    6
    7
    8
    public class Page {
        private String pageName;
        private String pageImage;
        private List<Sting> postIds;

        // getter/setter

    }

    创建yaml映射文件。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    result:
      type: object     # result is array
      path: /posts
      fields:
        pageName:
            path: /pageInfo/pageName
        pageImage:
            path: /pageInfo/pagePic
        postIds:
          path: post_id
          type: array

    使用DSM提取字段。

    1
    2
    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的页变量：

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

    DSM非常适合于复杂的JSON和XML。

    可以使用Apache @ Model注释来创建表示JSON文件结构的Java模型类，并使用它们来访问JSON树中的各种元素。与其他解决方案不同，此解决方案完全不需要反射，因此适用于反射不可能或具有显著开销的环境。

    有一个示例Maven项目显示了用法。首先，它定义了结构：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    @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类来解析提供的输入流，并在执行此操作时获取某些信息：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    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()
        );
    })

    就是这样！除此之外，这里还有一个实时的gist，显示了类似的例子以及异步网络通信。

    您需要使用Jackson库中的jsonnode和objectmapper类来获取JSON树的节点。在pom.xml中添加以下依赖项以获得对Jackson类的访问权。

    1
    2
    3
    4
    5
    6
    <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        jackson-databind</artifactId>
        <version>2.9.5</version>
    </dependency>

    您应该尝试一下下面的代码，这是可行的：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    import com.fasterxml.jackson.core.JsonGenerationException;
    import com.fasterxml.jackson.databind.JsonMappingException;
    import com.fasterxml.jackson.databind.JsonNode;
    import com.fasterxml.jackson.databind.ObjectMapper;

    Class JsonNodeExtractor{

    public void convertToJson(){


    String filepath ="c:\\data.json";
    ObjectMapper mapper = new ObjectMapper();
    JsonNode node =  mapper.readTree(filepath);

    // create a JsonNode for every root or subroot element in the Json String
    JsonNode pageInfoRoot = node.path("pageInfo");

    // Fetching elements under 'pageInfo'
    String pageName =  pageInfoRoot.path("pageName").asText();
    String pagePic = pageInfoRoot.path("pagePic").asText();

    // Now fetching elements under posts
    JsonNode  postsNode = node.path("posts");
    String post_id = postsNode .path("post_id").asText();
    String nameOfPersonWhoPosted = postsNode
    .path("nameOfPersonWhoPosted").asText();

    }
    }
    相关讨论