主页 / 问题 / 745094
Accepted
Алексей Шиманский
Asked:2020-11-15 21:35:36 +0800 CST2020-11-15 21:35:36 +0800 CST

在 Java 中如何以及如何解析 Json？

  • 772

通常需要使用Json，特别是它的读取和解析。在Java中，您通常知道您正在使用什么类型的变量，但是在解析 Json时，字段的类型可以是任何类型，这是令人困惑的。

解析Json的方法有哪些？怎么做？

在这里，我们说，如何从下面的Json中获取数据？

{
    "firstName": "Json",
    "lastName": "Smith",
    "age": 30,
    "address": {
        "streetAddress": "666 1nd Street",
        "city": "New York",
        "state": "NY",
        "postalCode": 10021
    },
    "phoneNumbers": [
        {
            "type": "home",
            "number": "542 666-1234"
        },
        {
            "type": "fax",
            "number": "653 666-4567" 
        }
    ],
    "friends": [
        {
            "firstName": "Test",
            "lastName": "Snow",
            "age": 20,
            "phoneNumbers": [
                {
                    "type": "home",
                    "number": "141 111-1234"
                }
            ],
            "friends": [
                {
                    "firstName": "UnknownFirstName",
                    "lastName": "UnknownLastName",
                    "age": 999,
                    "phoneNumbers": [
                        {
                            "type": "home",
                            "number": "000 000-0000"
                        }
                    ]
                }
            ]
        },
        {
            "firstName": "Flash",
            "lastName": "Tompson",
            "age": 23,
            "phoneNumbers": [
                {
                    "type": "home",
                    "number": "999 111-1234"
                }
            ]
        }
    ]
}
java

4 个回答

  1. Best Answer

    您可以通过不同的方式获取数据，当然，这取决于任务。我将尝试考虑一些解析Json的选项。

    注意：对于每个解析的例子，都会从问题中取出Json，以免在答案中徒劳地复制它。

    简单的json

    从哪里获得： 这里/ github 上的存储库/ 或通过Maven等。

    这是最原始的方式。事实上，这里只有JSONObject和JSONArray。

    • JSONArray可以包含多个对象JSONObject，它可以在每次迭代时循环获取一个对象JSONObject。
    • JSONObject- 您可以从中获取其各个属性的对象。

    我会将它用于小型Json字符串，在这种情况下您不必费心，或者如果您不太懒得根据下面显示的代码编写自己的处理程序类：

    // Считываем json
Object obj = new JSONParser().parse(jsonString); // Object obj = new JSONParser().parse(new FileReader("JSONExample.json"));
// Кастим obj в JSONObject
JSONObject jo = (JSONObject) obj;
// Достаём firstName and lastName
String firstName = (String) jo.get("firstName"); 
String lastName = (String) jo.get("lastName");
System.out.println("fio: " + firstName + " " + lastName);
// Достаем массив номеров
JSONArray phoneNumbersArr = (JSONArray) jo.get("phoneNumbers");
Iterator phonesItr = phoneNumbersArr.iterator();
System.out.println("phoneNumbers:");
// Выводим в цикле данные массива
while (phonesItr.hasNext()) {
    JSONObject test = (JSONObject) phonesItr.next();
    System.out.println("- type: " + test.get("type") + ", phone: " + test.get("number"));
}

    嵌套数组的其余工作类似。可以添加到List、Map等。

    GSON

    从哪里获得： 这里/ github 上的存储库/ 或通过Maven等。

    文档： http: //www.studytrails.com/java/json/java-google-json-introduction/

    允许您以与Json-simple相同的方式解析 Json，即 使用and （请参阅文档），但具有更强大的解析工具。创建重复Json 'a 结构的类就足够了。要从问题中解析Json，让我们创建类：JSONObjectJSONArray

    class Person {
    public String firstName;
    public String lastName;
    public int age;
    public Address address;
    public List<Phones> phoneNumbers;
    public List<Person> friends;
}

class Address {
    public String streetAddress;
    public String city;
    public String state;
    public int postalCode;
}

class Phones {
    public String type;
    public String number;
}

    现在写就足够了：

    Gson g = new Gson();
Person person = g.fromJson(jsonString, Person.class);

    一切！魔法！奇迹！现在有person一个 type 的对象Person，它包含的数据与创建的类中指定的类型完全相同！现在您可以使用任何类型，就像您过去经常做的那样：String、Integer、List、Map 和其他所有类型。

    // Выведет фамилии всех друзей с их телефонами
for (Person friend : person.friends) {
    System.out.print(friend.lastName);
    for (Phones phone : friend.phoneNumbers) {
        System.out.println(" - phone type: " + phone.type + ", phone number : " + phone.number);
    }
}

// output:
// Snow - phone type: home, phone number : 141 111-1234
// Tompson - phone type: home, phone number : 999 111-1234


    解析示例Map：

    ...... JSON解析：

    {  
	"2":{  
		"sessions":[  
			{  
				"time":"13:00",
				"price":"410"
			},
			{  
				"time":"06:40",
				"price":"340"
			},
			{  
				"time":"16:50",
				"price":"370"
			}
		],
		"name":"Кинокис-L",
		"locate":"Москва, Садовая-Спасская ул., 21, 56",
		"metro":"Красные ворота"
	},
	"7":{  
		"sessions":[  
			{  
				"time":"06:35",
				"price":"190"
			},
			{  
				"time":"00:05",
				"price":"410"
			}
		],
		"name":"Кинокис-V",
		"locate":"Павелецкая пл., 2, строение 1",
		"metro":"Павелецкая"
	},
	"8":{  
		"sessions":[  
			{  
				"time":"15:10",
				"price":"330"
			}
		],
		"name":"Кинокис-J",
		"locate":"ул. Пречистенка, 40/2",
		"metro":"Кропоткинская"
	},
	"9":{  
		"sessions":[  
			{  
				"time":"13:00",
				"price":"600"
			},
			{  
				"time":"08:30",
				"price":"300"
			},
			{  
				"time":"04:00",
				"price":"510"
			},
			{  
				"time":"13:15",
				"price":"340"
			}
		],
		"name":"Кинокис-U",
		"locate":"Шарикоподшипниковская ул., 24",
		"metro":"Дубровка"
	}
}

    ......类（POJO）：

    class Seanse {
    public String name;
    public String locate
    public String metro;
    public List<Sessions> sessions;
}

class Sessions {
    public String time;
    public double price;
}

    ...... 分析本身是这样的：

    Gson g = new Gson();
Type type = new TypeToken<Map<String, Seanse>>(){}.getType();
Map<String, Seanse> myMap = g.fromJson(json, type);

    一切。

    此外，可以在GSON中使用注解 ，例如：在解析时排除指定字段、更改变量名称（例如 not personFirstName、 but fName）等等。有关详细信息，请参阅文档。

    杰克逊

    从哪里获得： 这里/ github 上的存储库/ 或通过Maven等。

    文档和示例： https ://github.com/FasterXML/jackson-docs

    与GSON一样，它还允许您使用JSONObjectandJSONArray如果需要，还可以根据提供的类进行解析（参见下面的示例）。

    类似地，由于注解，它可以指定额外的要求，例如：不解析指定的字段、使用自定义类构造函数、更改变量名称（例如，not firstName、but fName）等等。有关详细信息，请参阅文档。

    ObjectMapper mapper = new ObjectMapper();
Person person = mapper.readValue(jsonString, Person.class);

System.out.println("My fio: " + person.firstName + " " + person.lastName + " and my friends are: ");
for (Person friend : person.friends) {
    System.out.print(friend.lastName);
    for (Phones phone : friend.phoneNumbers) {
        System.out.println(" - phone type: " + phone.type + ", phone number : " + phone.number);
    }
}

// output:
// My fio: Json Smith and my friends are: 
// Snow - phone type: home, phone number : 141 111-1234
// Tompson - phone type: home, phone number : 999 111-1234

    JsonPath

    从哪里获得它：通过Maven和其他构建器/ github 存储库

    指的是所谓的XPath库。其本质与xmlxpath类似，即很容易从json 'a 中获取一些信息，沿着指定的路径。它还允许您按条件过滤。

    // Выведет все фамилии друзей
List<String> friendsLastnames = JsonPath.read(jsonString, "$.friends[*].lastName");
for (String lastname : friendsLastnames) {
    System.out.println(lastname);
}

// output:
// Snow
// Tompson

    按条件选择的示例：

    // Поиск друга, которому больше 22 лет
List<String> friendsWithAges = JsonPath
.using(Configuration.defaultConfiguration())
.parse(jsonString)
.read("$.friends[?(@.age > 22)].lastName", List.class);

for (String lastname : friendsWithAges) {
    System.out.println(lastname);
}

// output:  
// Tompson
    • 55

  2. 更多选择

    洛根广场

    LoganSquare - 基于Jackson的流 API。根据演示的测试，它比GSON和Jackson运行得更快。因此对安卓有好处。

    从哪里获得： github 上的存储库/或通过Maven / Gradle等。

    用法： https ://github.com/bluelinelabs/LoganSquare#usage

    Простенький пример:

    @JsonObject
public class Person {
    @JsonField(name="firstName")
    public String firstName;
    @JsonField(name="age")
    public int age;

    public void say() {
        System.out.println();
        System.out.println("My name is " + firstName + " , I'm " + age + " years old!");
    }
}

    разбор:

    String jsonString = "{\"age\":15,\"firstName\":\"Adam\"}";
Person person = LoganSquare.parse(jsonString, Person.class);
person.say(); // My name is Adam , I'm 18 years old!

    Moshi

    Moshi is a modern JSON library for Android and Java.

    Хорош, как утверждают разработчики, для работы с Android.

    Где взять: репозиторий на github / или через Maven / Gradle и пр.

    • Пример разбора Json строки в объект Person:

      Moshi moshi = new Moshi.Builder().build();
JsonAdapter<Person> jsonAdapter = moshi.adapter(Person.class);
Person person = jsonAdapter.fromJson(jsonStringPerson);  // В person будут все данные

    • Пример парсинга в Map: 

      class Seanse {
    public String name;
    public String locate
    public String metro;
    public List<Sessions> sessions;
}

class Sessions {
    public String time;
    public double price;
}

public class Main {
    public static void main(String[] args) throws IOException { 
        String jsonStringForMap = "{\"2\":{\"sessions\":[{\"time\":\"13:00\",\"price\":\"410\"},{ \"time\":\"06:40\",\"price\":\"340\"},{  \"time\":\"16:50\",\"price\":\"370\"}],\"name\":\"Кинокис-L\",\"locate\":\"Москва, Садовая-Спасская ул., 21, 56\",\"metro\":\"Красные ворота\"},\"7\":{  \"sessions\":[  {  \"time\":\"06:35\",\"price\":\"190\"},{  \"time\":\"00:05\",\"price\":\"410\"}],\"name\":\"Кинокис-V\",\"locate\":\"Павелецкая пл., 2, строение 1\",\"metro\":\"Павелецкая\"},\"8\":{  \"sessions\":[  {  \"time\":\"15:10\",\"price\":\"330\"}],\"name\":\"Кинокис-J\",\"locate\":\"ул. Пречистенка, 40/2\",\"metro\":\"Кропоткинская\"},\"9\":{  \"sessions\":[  {  \"time\":\"13:00\",\"price\":\"600\"},{  \"time\":\"08:30\",\"price\":\"300\"},{  \"time\":\"04:00\",\"price\":\"510\"},{  \"time\":\"13:15\",\"price\":\"340\"}],\"name\":\"Кинокис-U\",\"locate\":\"Шарикоподшипниковская ул., 24\",\"metro\":\"Дубровка\"}}";

        Moshi moshi = new Moshi.Builder().build();
        Type map = Types.newParameterizedType(Map.class, String.class, Seanse.class);
        JsonAdapter<Map<String, Seanse>> jsonAdapter = moshi.adapter(map);
        Map<String, Seanse> seanseMap = jsonAdapter.fromJson(jsonStringForMap);
    }
}

    Genson

    Где взять: здесь / репозиторий на github / или через Maven и пр.

    Документация: http://owlike.github.io/genson/Documentation/UserGuide/

    За счет создания POJO (создаются классы, которые повторяют структуру Json'а) - парсится объект из строки, распихивая по нужным полям объектов. Есть возможность фильтровать свойства, включить или исключить поля при парсинге, переименовать, возможность работы с аннотациями и пр. Подробнее в документации.

    • Простой парсинг:

      Genson genson = new Genson();
Person person = genson.deserialize(jsonString, Person.class); // В person будут все данные

    • Разбор в список:

      List<Object> persons = genson.deserialize("[{\"age\":28,\"name\":\"Foo\"}, {\"age\":30,\"name\":\"Bar\"}]", List.class);    
// persons - список с данными объектов

    • Пример парсинга в Map:

    ...... JSON для разбора:

    {  
	"2":{  
		"sessions":[  
			{  
				"time":"13:00",
				"price":"410"
			},
			{  
				"time":"06:40",
				"price":"340"
			},
			{  
				"time":"16:50",
				"price":"370"
			}
		],
		"name":"Кинокис-L",
		"locate":"Москва, Садовая-Спасская ул., 21, 56",
		"metro":"Красные ворота"
	},
	"7":{  
		"sessions":[  
			{  
				"time":"06:35",
				"price":"190"
			},
			{  
				"time":"00:05",
				"price":"410"
			}
		],
		"name":"Кинокис-V",
		"locate":"Павелецкая пл., 2, строение 1",
		"metro":"Павелецкая"
	},
	"8":{  
		"sessions":[  
			{  
				"time":"15:10",
				"price":"330"
			}
		],
		"name":"Кинокис-J",
		"locate":"ул. Пречистенка, 40/2",
		"metro":"Кропоткинская"
	},
	"9":{  
		"sessions":[  
			{  
				"time":"13:00",
				"price":"600"
			},
			{  
				"time":"08:30",
				"price":"300"
			},
			{  
				"time":"04:00",
				"price":"510"
			},
			{  
				"time":"13:15",
				"price":"340"
			}
		],
		"name":"Кинокис-U",
		"locate":"Шарикоподшипниковская ул., 24",
		"metro":"Дубровка"
	}
}

    ...... Классы (POJO):

    class Seanse {
    public String name;
    public String locate
    public String metro;
    public List<Sessions> sessions;
}

class Sessions {
    public String time;
    public double price;
}

    ...... Сам парсинг:

    String jsonStringForMap = "ТУТ JSON СТРОКА, ОПИСАННАЯ ВЫШЕ";
Genson genson = new Genson();
Map<String, Seanse> seansesMap = genson.deserialize(jsonStringForMap, Map.class);

    FastJson

    Где взять: через Maven и другие сборщики / репозиторий на github. Непосредственно описание работы с xpath. Осторожно,   ̶н̶е̶н̶о̶р̶м̶а̶т̶и̶в̶н̶а̶я̶ ̶л̶е̶к̶с̶и̶к̶а̶   китайский язык.

    Относится к XPath аналогам.

    Обычный способ:

    Person person = JSON.parseObject(jsonString, Person.class);
int age = person.age;
System.out.println(age); // 30

    Применение XPpath

    // Выведет все фамилии друзей
List<String> friendsLastnames = (List<String>) JSONPath.eval(person, "$.friends.lastName");
for (String lastname : friendsLastnames) {
    System.out.println(lastname);  // Snow  Tompson
}

// Поиск друга, которому больше 22 лет
List<String> friendsWithAges = (List<String>) JSONPath.eval(person, "$.friends[?(@.age > 22)].lastName");
for (String lastname : friendsWithAges) {
    System.out.println(lastname); // Tompson
}
    • 10

  3. JSON-P

    支持 JSON 序列化和解析，无需在类中进行预映射：

    行家：

    <dependency>
    <groupId>javax.json</groupId>
    <artifactId>javax.json-api</artifactId>
    <version>1.1.2</version>
</dependency>
<dependency>
    <groupId>org.glassfish</groupId>
    <artifactId>javax.json</artifactId>
    <version>1.1.2</version>
</dependency>

    解析 JSON 字符串的示例：

    public static void main(String[] args) throws IOException {
    JsonReader reader = Json.createReader(new StringReader(jsonString));
    JsonObject jsonObject = reader.readObject();
}

    将对象输出到 JSON 字符串的示例：

    public static void main(String[] args) throws IOException {
    System.out.println(prettyPrintJson(jsonObject, 0));
}

public static String prettyPrintJson(JsonObject jsonObject, int indent) {

    String indentStr = getIndentStr(indent);
    String prettyJson = indentStr + "{";

    for (String key : jsonObject.keySet()) {
        prettyJson += "\n";
        prettyJson += indentStr + "  \"" + key + "\": ";
        try {
            JsonArray jsonArray = jsonObject.get(key).asJsonArray();
            prettyJson += "\n" + indentStr + "  [";
            for (JsonValue element : jsonArray) {
                prettyJson += "\n" + prettyPrintJson(element.asJsonObject(), indent + 4);
                prettyJson += ",";
            }
            prettyJson = prettyJson.substring(0, prettyJson.length() - 1);
            prettyJson += "\n" + indentStr + "  ]";
        } catch (Exception e) {
            try {
                prettyJson += "\n" + prettyPrintJson(jsonObject.get(key).asJsonObject(), indent + 2);
            } catch (Exception ee) {
                prettyJson += jsonObject.get(key).toString();
            }
        }
        prettyJson += ",";
    }
    prettyJson = prettyJson.substring(0, prettyJson.length() - 1);
    prettyJson += "\n" + indentStr + "}";
    return prettyJson;
}

public static String getIndentStr(int indent) {
    String indentStr = "";
    for (int i = 0; i < indent; i++) {
        indentStr += " ";
    }
    return indentStr;
}

    结论：

    {
  "firstName": "Json",
  "lastName": "Smith",
  "age": 30,
  "address":
  {
    "streetAddress": "666 1nd Street",
    "city": "New York",
    "state": "NY",
    "postalCode": 10021
  },
  "phoneNumbers":
  [
    {
      "type": "home",
      "number": "542 666-1234"
    },
    {
      "type": "fax",
      "number": "653 666-4567"
    }
  ],
  "friends":
  [
    {
      "firstName": "Test",
      "lastName": "Snow",
      "age": 20,
      "phoneNumbers":
      [
        {
          "type": "home",
          "number": "141 111-1234"
        }
      ],
      "friends":
      [
        {
          "firstName": "UnknownFirstName",
          "lastName": "UnknownLastName",
          "age": 999,
          "phoneNumbers":
          [
            {
              "type": "home",
              "number": "000 000-0000"
            }
          ]
        }
      ]
    },
    {
      "firstName": "Flash",
      "lastName": "Tompson",
      "age": 23,
      "phoneNumbers":
      [
        {
          "type": "home",
          "number": "999 111-1234"
        }
      ]
    }
  ]
}
    • 5

  4. Здесь расположена общая информация о парсерах, которая может помочь при выборе и понять, что он умеет. Текст и таблица, представленные ниже, взяты из публикации на Habrahabr: Шпаргалка Java программиста 8. Библиотеки для работы с Json, автор статьи @ВеденинВячеслав

    Существует следующие способы сериализации и десериализации среди указанных библиотек (от самого простого к самому сложному):

    1. Data bind
    2. Tree Model
    3. Streaming API
    4. Аналоги XPath (дополнительный способ)

    Data bind

    Самый популярный и простой способ - вы просто указываете класс, который нужно преобразовать в json, может быть часть полей отмечаете аннотациями (а зачастую даже это необязательно), а библиотека сама превращает этот класс и всю его иерархию классов в json.

    Плюсы: наиболее простой из всех

    Минусы: скорость и память. Большинство библиотек использует рефлексию и т.п. методы работы с Java классами (хотя не все), что очевидно не очень быстро. К тому же, весь json файл сразу превращается в Java объекты, что может просто исчерпать всю доступную память, если вы попытаетесь обработать очень большой json.

    Вывод: если нет проблем с производительностью, памятью и вы не собираетесь обрабатывать многогигабайтные json'ы скорее всего самый лучший способ.

    Tree Model

    Данный парсер представляет json в виде Java классов таких как Node или `JsonElement c иерархической структурой, а уже сам программист их обходит и получает из них информацию.

    Плюсы: обычно быстрее первого способа и проще третьего

    Минусы: уступает Data bind по простоте, плюс ряд библиотек способен генерить классы при Data bind, а не использовать рефлексию, в этом случае то что Tree Model будет быстрее не очевидно, к тому же не решается проблема огромных файлов и ограничения памяти.

    Streaming API

    Самый низкоуровневый способ, по сути программист сам вручную разбирает токены json'a. Зато никаких ограничений по памяти и в теории максимальная производительность.

    Плюсы: производительность и минимальное потребление памяти

    Минусы: сложность использования

    Аналоги XPath

    Не очень подходит, если нужно получит всю информацию из json'a, зато позволяет написав выражение, например $.store.book[*].author получить список всех авторов всех книг из json'a магазина. То есть легко получать часть информации из json'а.

    Плюсы: позволяет быстро получить информацию из json'а по сложным критериям

    Минусы: не очень подходит, когда нужна все информация из json'а, не работает в обратную сторону на формирования json'ов

    Таблица библиотек и способы парсинга, которые они поддерживают:

    Способ\Hазвание  Fastjson  Gson  LoganSquare  JSONjava  Moshi  Jackson  Genson  JsonPath SimpleJson

Data bind          Да       Да       Да         -        Да       Да      Да       -         -
Tree Model         -        Да       -          Да       -        Да      -        -         Да
Streaming API      -        Да       -          -        -        Да      -        -         -
Аналоги XPath      Да       -        -          -        -        -       -        Да        -

Генерация классов  -        -        Да         -        -        -       -        -
 для Data bind*

Работает со        Да       Да       Нет        -        Да       Да      Да       -
static inner class**

Обязательность     Нет      Нет      Да         -        Нет      Нет     Нет      -
 аннотаций***

    * — Генерация классов для Data bind позволяет сгенерировать классы на стадии компиляции, что в теории должно давать значительный прирост производительности библиотеки,

    ** — Работает со static inner class имеет смысл только для случая Data bind, возможно ли сериализация и десериализация для случая статических внутренних классов (не статические внутренние классы сериализовать не рекомендуется),

    *** — тоже только для случая Data bind можно ли не использовать аннотации или их использование крайне рекомендуется,

    • 2

相关问题