原文：http://zetcode.com/java/jsonp/

Java JSON 处理教程展示了如何使用 JSON-P 库来处理 JSON。 这些示例将 Java 对象写入 JSON 文件，并将 JSON 数据读取到 Java 对象。 在作者的 Github 仓库中提供了代码示例。

JSON-P

用于 JSON 处理的 Java API（JSON-P）提供可移植的 API，以使用对象模型和流式 API 来解析，生成，转换和查询 JSON。 JSON-P 中使用 JSON 的两种方式有两种：流式 API 和对象模型 API。

JSON-P 流式 API

流式 API 将解析和生成控制移交给程序员。 流式 API 提供了基于事件的解析器，并允许应用开发者请求下一个事件，而不是在回调中处理该事件。 这称为拉方法。

名称 描述
Json 包含用于创建 JSON 解析器，生成器及其工厂的静态方法。
JsonParser 表示一个基于事件的解析器，它从流中读取 JSON 数据。
JsonGenerator 将 JSON 数据一次写入一个值。

JSON-P 对象模型 API

对象模型 API 创建一个树形结构，表示内存中的 JSON 数据。 可以灵活地导航和查询树。 另一方面，对象模型 API 的效率通常不如流模型，并且需要更多的内存。

名称 描述
Json 包含用于创建 JSON 解析器，生成器及其工厂的静态方法。
JsonObjectBuilder 通过添加应用代码中的值在内存中创建对象模型。
JsonArrayBuilder 通过添加应用代码中的值在内存中创建数组模型。
JsonReader 从输入源读取JsonObject或JsonArray。
JsonWriter 将JsonObject或JsonArray写入输出源。

JsonValue，JsonObject，JsonArray，JsonString和JsonNumber是 JSON 数据类型。

在我们的示例中，我们使用 JDK 11 和 Maven 创建我们的应用。

  1. <dependencies>
  2.     <dependency>
  3.         <groupId>javax.json</groupId>
  4.         <artifactId>javax.json-api</artifactId>
  5.         <version>1.1</version>
  6.     </dependency>
  8.     <dependency>
  9.         <groupId>org.glassfish</groupId>
  10.         <artifactId>javax.json</artifactId>
  11.         <version>1.1</version>
  12.     </dependency>
  13. </dependencies>

在项目中，我们使用javax.json-api和javax.json依赖项。

JSON-P JsonObjectBuilder示例

在第一个示例中，我们使用对象生成器创建 JSON 字符串。

JsonObjectBuilderEx.java

  1. package com.zetcode;
  3. import javax.json.Json;
  4. import java.time.LocalDate;
  6. public class JsonObjectBuilderEx {
  8.     public static void main(String[] args) {
  10.         var born = LocalDate.of(1992, 3, 2).toString();
  12.         var json = Json.createObjectBuilder()
  13.                 .add("name", "John Doe")
  14.                 .add("occupation", "gardener")
  15.                 .add("born", born).build();
  17.         var result = json.toString();
  19.         System.out.println(result);
  20.     }
  21. }

JSON 字符串被打印到控制台。

  1. var json = Json.createObjectBuilder()
  2.     .add("name", "John Doe")
  3.     .add("occupation", "gardener")
  4.     .add("born", born).build();

用createObjectBuilder()创建一个JsonObjectBuilder。 新的对将插入add()。 最后，使用build()结束字符串。

  1. var result = json.toString();

我们使用toString()将JsonObject转换为字符串。

  1. {"name":"John Doe","occupation":"gardener","born":"1992-03-02"}

这是输出。

PRETTY_PRINTING

通过JsonGenerator.PRETTY_PRINTING配置设置，我们可以设置写入器进行漂亮的打印。

JsonPrettyPrintEx.java

  1. package com.zetcode;
  3. import javax.json.Json;
  4. import javax.json.stream.JsonGenerator;
  5. import java.io.StringWriter;
  6. import java.time.LocalDate;
  7. import java.util.HashMap;
  9. public class JsonPrettyPrintEx {
  11.     public static void main(String[] args) {
  13.         var born = LocalDate.of(1992, 3, 2).toString();
  15.         var json = Json.createObjectBuilder()
  16.                 .add("name", "John Doe")
  17.                 .add("occupation", "gardener")
  18.                 .add("born", born).build();
  20.         var config = new HashMap<String, Boolean>();
  21.         config.put(JsonGenerator.PRETTY_PRINTING, true);
  23.         var jwf = Json.createWriterFactory(config);
  24.         var sw = new StringWriter();
  26.         try (var jsonWriter = jwf.createWriter(sw)) {
  28.             jsonWriter.writeObject(json);
  29.             System.out.println(sw.toString());
  30.         }
  31.     }
  32. }

在示例中，我们创建一个 JSON 对象并将其打印到控制台。 输出打印精美。

  1. var config = new HashMap<String, Boolean>();
  2. config.put(JsonGenerator.PRETTY_PRINTING, true);
  4. var jwf = Json.createWriterFactory(config);

配置文件被传递到JsonWriterFactory。

  1. {
  2.     "name": "John Doe",
  3.     "occupation": "gardener",
  4.     "born": "1992-03-02"
  5. }

这是输出。

JSON-P JsonArrayBuilder

JsonArrayBuilder是用于创建和修改JsonArray对象的构建器。

JsonArrayBuilderEx.java

  1. package com.zetcode;
  3. import javax.json.Json;
  4. import javax.json.stream.JsonGenerator;
  5. import java.io.StringWriter;
  6. import java.time.LocalDate;
  7. import java.util.HashMap;
  8. import java.util.List;
  10. public class JsonArrayBuilderEx {
  12.     public static void main(String[] args) {
  14.         var ab = Json.createArrayBuilder();
  16.         var users = createUsers();
  18.         users.forEach(user -> {
  20.             var ob = Json.createObjectBuilder();
  21.             ob.add("name", user.getName());
  22.             ob.add("occupation", user.getOccupation());
  23.             ob.add("born", user.getBorn().toString());
  25.             ab.add(ob);
  26.         });
  28.         var config = new HashMap<String, Boolean>();
  29.         config.put(JsonGenerator.PRETTY_PRINTING, true);
  31.         var jwf = Json.createWriterFactory(config);
  32.         var sw = new StringWriter();
  34.         try (var jsonWriter = jwf.createWriter(sw)) {
  36.             jsonWriter.writeArray(jsonArray);
  38.             System.out.println(sw);
  39.         }
  40.     }
  42.     public static List<User> createUsers() {
  44.         var born1 = LocalDate.of(1992, 3, 2);
  45.         var u1 = new User("John Doe", "gardener", born1);
  47.         var born2 = LocalDate.of(1967, 11, 22);
  48.         var u2 = new User("Brian Flemming", "teacher", born2);
  50.         var born3 = LocalDate.of(1995, 4, 7);
  51.         var u3 = new User("Lucy Black", "accountant", born3);
  53.         var born4 = LocalDate.of(1972, 8, 30);
  54.         var u4 = new User("John Doe", "gardener", born4);
  56.         return List.of(u1, u2, u3, u4);
  57.     }
  58. }

在该示例中，我们创建了一个用户对象列表，并将其转换为JsonArray。

  1. var ab = Json.createArrayBuilder();

用createArrayBuilder()创建一个JsonArrayBuilder。

  1. users.forEach(user -> {
  3.     var ob = Json.createObjectBuilder();
  4.     ob.add("name", user.getName());
  5.     ob.add("occupation", user.getOccupation());
  6.     ob.add("born", user.getBorn().toString());
  8.     ab.add(ob);
  9. });

在此for循环中，我们创建 JSON 对象并将其添加到构建器中。

  1. var jsonArray = ab.build();

build()方法从构建器创建JsonArray。

  1. jsonWriter.writeArray(jsonArray);

JsonArray被写入写入器。

  1. [
  2.     {
  3.         "name": "John Doe",
  4.         "occupation": "gardener",
  5.         "born": "1992-03-02"
  6.     },
  7.     {
  8.         "name": "Brian Flemming",
  9.         "occupation": "teacher",
  10.         "born": "1967-11-22"
  11.     },
  12.     {
  13.         "name": "Lucy Black",
  14.         "occupation": "accountant",
  15.         "born": "1995-04-07"
  16.     },
  17.     {
  18.         "name": "John Doe",
  19.         "occupation": "gardener",
  20.         "born": "1972-08-30"
  21.     }
  22. ]

这是输出。

JSON-P JsonParser

JsonParser使用请求解析编程模型解析 JSON。 在此模型中，客户端代码控制线程并在处理每个元素之后调用方法next()将解析器前进到下一个状态。

解析器生成以下事件之一：START_OBJECT，END_OBJECT，START_ARRAY，END_ARRAY，KEY_NAME，VALUE_STRING，VALUE_NUMBER，VALUE_TRUE，VALUE_FALSE和VALUE_NULL。

users.json

  1. [
  2.   {
  3.     "name": "John Doe",
  4.     "occupation": "gardener",
  5.     "born": "1992-03-02"
  6.   },
  7.   {
  8.     "name": "Brian Flemming",
  9.     "occupation": "teacher",
  10.     "born": "1967-11-22"
  11.   },
  12.   {
  13.     "name": "Lucy Black",
  14.     "occupation": "accountant",
  15.     "born": "1995-04-07"
  16.   },
  17.   {
  18.     "name": "William Bean",
  19.     "occupation": "pilot",
  20.     "born": "1977-10-31"
  21.   }
  22. ]

我们将解析users.json文件。

JsonParserSimpleEx.java

  1. package com.zetcode;
  3. import javax.json.Json;
  4. import javax.json.stream.JsonParser;
  5. import java.io.FileInputStream;
  6. import java.io.FileNotFoundException;
  7. import java.nio.charset.StandardCharsets;
  9. public class JsonParserSimpleEx {
  11.     public static void main(String[] args) throws FileNotFoundException {
  13.         var is = new FileInputStream("src/main/resources/users.json");
  15.         var factory = Json.createParserFactory(null);
  16.         var parser = factory.createParser(is, StandardCharsets.UTF_8);
  18.         if (!parser.hasNext() && parser.next() != JsonParser.Event.START_ARRAY) {
  20.             return;
  21.         }
  23.         // looping over object attributes
  24.         while (parser.hasNext()) {
  26.             var event = parser.next();
  28.             // starting object
  29.             if (event == JsonParser.Event.START_OBJECT) {
  31.                 while (parser.hasNext()) {
  33.                     event = parser.next();
  35.                     if (event == JsonParser.Event.KEY_NAME) {
  37.                         var key = parser.getString();
  39.                         switch (key) {
  41.                             case "name":
  42.                                 parser.next();
  44.                                 System.out.printf("Name: %s%n", parser.getString());
  45.                                 break;
  47.                             case "occupation":
  48.                                 parser.next();
  50.                                 System.out.printf("Occupation: %s%n", parser.getString());
  51.                                 break;
  53.                             case "born":
  54.                                 parser.next();
  56.                                 System.out.printf("Born: %s%n%n", parser.getString());
  57.                                 break;
  58.                         }
  59.                     }
  60.                 }
  61.             }
  62.         }
  63.     }
  64. }

在示例中，我们使用 JSON-P 流式 API 解析users.json文件。

  1. var is = new FileInputStream("src/main/resources/users.json");
  3. var factory = Json.createParserFactory(null);
  4. var parser = factory.createParser(is, StandardCharsets.UTF_8);

从JsonParserFactory创建一个JsonParser。

  1. if (!parser.hasNext() && parser.next() != JsonParser.Event.START_ARRAY) {
  3.     return;
  4. }

首先，我们传递数组的开头。

  1. // looping over object attributes
  2. while (parser.hasNext()) {
  4.     var event = parser.next();
  6.     // starting object
  7.     if (event == JsonParser.Event.START_OBJECT) {
  8. ...

然后，我们在while循环中遍历数组。 当我们到达数组末尾时，解析器的hasNext()方法返回false。 我们使用next()拉下一个解析事件。

  1. while (parser.hasNext()) {
  3.     event = parser.next();
  5.     if (event == JsonParser.Event.KEY_NAME) {
  6. ...

在另一个while循环中，我们遍历当前对象的键。

  1. var key = parser.getString();
  3. switch (key) {
  5.     case "name":
  6.         parser.next();
  8.         System.out.printf("Name: %s%n", parser.getString());
  9.         break;
  10. ...

在switch语句中，我们检查键名称，并通过getString()获得其值。

  1. Name: John Doe
  2. Occupation: gardener
  3. Born: 1992-03-02
  5. Name: Brian Flemming
  6. Occupation: teacher
  7. Born: 1967-11-22
  9. Name: Lucy Black
  10. Occupation: accountant
  11. Born: 1995-04-07
  13. Name: William Bean
  14. Occupation: pilot
  15. Born: 1977-10-31

这是输出。

在第二个示例中，我们连接到网站并从路径获取 JSON 数据。

JsonParserEx.java

  1. package com.zetcode;
  3. import javax.json.Json;
  4. import javax.json.stream.JsonParser;
  5. import java.io.IOException;
  6. import java.net.URL;
  8. public class JsonParserEx {
  10.     public static void main(String[] args) throws IOException {
  12.         var url = new URL("https://jsonplaceholder.typicode.com/posts");
  14.         try (var in = url.openStream(); var parser = Json.createParser(in)) {
  16.             // starting array
  17.             parser.next();
  19.             while (parser.hasNext()) {
  21.                 // starting object
  22.                 var event1 = parser.next();
  24.                 if (event1 == JsonParser.Event.START_OBJECT) {
  26.                     while (parser.hasNext()) {
  28.                         var event = parser.next();
  30.                         if (event == JsonParser.Event.KEY_NAME) {
  32.                             switch (parser.getString()) {
  34.                                 case "userId":
  35.                                     parser.next();
  37.                                     System.out.printf("User Id: %d%n", parser.getInt());
  38.                                     break;
  40.                                 case "id":
  41.                                     parser.next();
  43.                                     System.out.printf("Post Id: %d%n", parser.getInt());
  44.                                     break;
  46.                                 case "title":
  47.                                     parser.next();
  49.                                     System.out.printf("Post title: %s%n", parser.getString());
  50.                                     break;
  52.                                 case "body":
  53.                                     parser.next();
  55.                                     System.out.printf("Post body: %s%n%n", parser.getString());
  56.                                     break;
  57.                             }
  58.                         }
  59.                     }
  60.                 }
  61.             }
  62.         }
  63.     }
  64. }

该示例处理了 jsonplaceholder.typicode.com 网站上的一百个帖子，该网站是用于测试和原型制作的虚假在线 REST API。

JSON-P JsonGenerator

JsonGenerator以流方式将 JSON 数据写入输出源。 JsonGeneratorFactory包含创建JsonGenerator实例的方法。

JsonGeneratorEx.java

  1. package com.zetcode;
  3. import javax.json.Json;
  4. import javax.json.stream.JsonGenerator;
  5. import java.io.IOException;
  6. import java.nio.charset.StandardCharsets;
  7. import java.nio.file.Files;
  8. import java.nio.file.Paths;
  9. import java.time.LocalDate;
  10. import java.util.HashMap;
  11. import java.util.List;
  13. public class JsonGeneratorEx {
  15.     public static void main(String[] args) throws IOException {
  17.         var myPath = Paths.get("src/main/resources/users.json");
  19.         var config = new HashMap<String, Boolean>();
  20.         config.put(JsonGenerator.PRETTY_PRINTING, true);
  22.         var factory = Json.createGeneratorFactory(config);
  23.         var generator = factory.createGenerator(Files.newBufferedWriter(myPath,
  24.                 StandardCharsets.UTF_8));
  26.         generator.writeStartArray();
  28.         var users = generateUsers();
  30.         users.forEach(user -> {
  32.             generator.writeStartObject();
  34.             generator.write("name", user.getName());
  35.             generator.write("occupation", user.getOccupation());
  36.             generator.write("born", user.getBorn().toString());
  38.             generator.writeEnd();
  39.         });
  41.         generator.writeEnd();
  43.         generator.flush();
  44.     }
  46.     public static List<User> generateUsers() {
  48.         var born1 = LocalDate.of(1992, 3, 2);
  49.         var u1 = new User("John Doe", "gardener", born1);
  51.         var born2 = LocalDate.of(1967, 11, 22);
  52.         var u2 = new User("Brian Flemming", "teacher", born2);
  54.         var born3 = LocalDate.of(1995, 4, 7);
  55.         var u3 = new User("Lucy Black", "accountant", born3);
  57.         var born4 = LocalDate.of(1977, 10, 31);
  58.         var u4 = new User("William Bean", "pilot", born4);
  60.         return List.of(u1, u2, u3, u4);
  61.     }
  62. }

该示例从用户列表创建users.json文件。

  1. var myPath = Paths.get("src/main/resources/users.json");
  3. var config = new HashMap<String, Boolean>();
  4. config.put(JsonGenerator.PRETTY_PRINTING, true);
  6. var factory = Json.createGeneratorFactory(config);
  7. var generator = factory.createGenerator(Files.newBufferedWriter(myPath,
  8.         StandardCharsets.UTF_8));

用JsonGeneratorFactory创建一个JsonGenerator。 工厂接收配置数据，从而可以进行漂亮的打印。

  1. generator.writeStartArray();

数组从writeStartArray()开始。 稍后以writeEnd()结束。

  1. users.forEach(user -> {
  3.     generator.writeStartObject();
  5.     generator.write("name", user.getName());
  6.     generator.write("occupation", user.getOccupation());
  7.     generator.write("born", user.getBorn().toString());
  9.     generator.writeEnd();
  10. });

JSON 对象写在forEach循环中。 JSON 对象以writeStartObject()开头，以writeEnd()结束。 键/值对使用write()编写。

  1. generator.flush();

使用flush()将数据从缓冲区刷新到数据源。

在本教程中，我们已经使用 Java JSON-P 读写了 JSON 文件。 您可能也对相关教程感兴趣： Gson 教程， Java DOM 教程， Java SAX 教程和或 Java 教程。