Java JSON с Jackson | W3Docs Learn Java

Jackson — де-факто стандартная JSON-библиотека для Java. В JDK нет собственного JSON API, поэтому почти каждое приложение на Spring, Quarkus или Micronaut использует Jackson для преобразования Java-объектов в JSON-текст и обратно. Точкой входа служит единственный универсальный класс — ObjectMapper — который выполняет две задачи, необходимые всегда: сериализацию (Java-объект → JSON) и десериализацию (JSON → Java-объект).

Если вы только начинаете работать с JSON в Java, начните с введения в JSON; для более лёгкой альтернативной библиотеки смотрите главу о Gson. На этой странице рассматриваются: подключение Jackson, три уровня его API, привязка данных, древовидная модель и аннотации, управляющие маппингом.

Добавление Jackson в проект

Jackson не входит в JDK, поэтому его нужно объявить как зависимость. Артефакт jackson-databind транзитивно подтягивает два других базовых модуля (jackson-core и jackson-annotations).

<!-- Maven -->
<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.17.1</version>
</dependency>

// Gradle
implementation 'com.fasterxml.jackson.core:jackson-databind:2.17.1'

Три способа работы с JSON

Jackson предоставляет доступ к одним и тем же данным тремя разными способами. Выбирайте уровень, подходящий для задачи:

Подход	Основной тип	Используется когда
Привязка данных	`ObjectMapper.readValue` / `writeValue`	Есть POJO или record, отражающий структуру JSON — наиболее распространённый случай
Древовидная модель	`JsonNode` через `readTree`	Структура динамическая или нужны лишь несколько полей
Потоковая	`JsonParser` / `JsonGenerator`	Огромные документы, которые нельзя целиком держать в памяти

Привязка данных используется в 90% случаев; остальные два подхода — запасные варианты.

Привязка данных: объекты на входе, JSON на выходе

ObjectMapper.writeValueAsString сериализует любой Java-объект, читая его геттеры (или компоненты record); readValue выполняет обратную операцию, сопоставляя имена полей JSON с полями вашего класса. record — наиболее чистая цель: Jackson 2.12+ автоматически привязывается к его каноническому конструктору, поэтому геттеры и конструктор без аргументов не нужны.

import com.fasterxml.jackson.databind.ObjectMapper;

record User(String name, int age, boolean active) {}

ObjectMapper mapper = new ObjectMapper();

// serialize: Java -> JSON
User ada = new User("Ada", 36, true);
String json = mapper.writeValueAsString(ada);
// {"name":"Ada","age":36,"active":true}

// deserialize: JSON -> Java
User back = mapper.readValue(json, User.class);
System.out.println(back.name()); // Ada

Для коллекций и обобщённых типов передайте Jackson TypeReference, чтобы тип элемента не стёрся при erasure:

import com.fasterxml.jackson.core.type.TypeReference;

List<User> users = mapper.readValue(jsonArray, new TypeReference<List<User>>() {});

Древовидная модель: когда структура неизвестна

Если у вас нет (или вы не хотите создавать) соответствующего класса, разберите JSON в обобщённое дерево JsonNode и перемещайтесь по нему по ключам. Это похоже на ручной разбор в Map/List, но с типизированными методами доступа, такими как asInt() и asText().

import com.fasterxml.jackson.databind.JsonNode;

JsonNode root = mapper.readTree(json);
String name = root.get("name").asText();
int age     = root.get("age").asInt();
JsonNode first = root.get("languages").get(0); // array access by index

Управление маппингом с помощью аннотаций

Имена полей JSON редко точно совпадают с соглашениями Java. Несколько аннотаций устраняют этот разрыв без изменения имён полей:

Аннотация	Эффект
`@JsonProperty("user_name")`	Сопоставить поле с другим ключом JSON
`@JsonIgnore`	Исключить поле в обоих направлениях
`@JsonInclude(NON_NULL)`	Убрать `null`-поля из вывода
`@JsonCreator` / `@JsonFormat`	Пользовательское создание / форматирование дат

record Account(
    @JsonProperty("user_name") String userName,
    @JsonIgnore String passwordHash) {}

Полный пример: сериализация, разбор и ручная привязка

Jackson недоступен в classpath этого исполнителя, поэтому программа ниже реализует те же концепции — генератор JSON, рекурсивно-нисходящий парсер в дерево Map/List и привязку в record — используя только java.util. Это именно то, что ObjectMapper делает за вас под капотом: обходит граф объектов для генерации текста и токенизирует текст для восстановления дерева.

java— editable, runs on the server

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.List;
import java.util.ArrayList;

public class JacksonDemo {
  // A tiny JSON model: objects are Map<String,Object>, arrays are List<Object>.
  // Real code uses Jackson's ObjectMapper; here we model the same data binding by hand.

public static void main(String[] args) {
    // 1. SERIALIZE: build an object graph, then render it as JSON text.
    Map<String, Object> user = new LinkedHashMap<>();
    user.put("name", "Ada");
    user.put("age", 36);
    user.put("active", true);
    List<Object> langs = new ArrayList<>();
    langs.add("Java");
    langs.add("Ada");
    user.put("languages", langs);

String json = writeJson(user);
    System.out.println("serialized   : " + json);

// 2. PARSE: read JSON text back into the same Map/List tree (tree model).
    String input = "{\"name\":\"Grace\",\"age\":42,\"active\":false,\"languages\":[\"COBOL\",\"Java\"]}";
    Object tree = new Parser(input).parse();
    System.out.println("parsed type  : " + tree.getClass().getSimpleName());

// 3. NAVIGATE the tree, the way ObjectMapper.readTree() + JsonNode.get() do.
    @SuppressWarnings("unchecked")
    Map<String, Object> parsed = (Map<String, Object>) tree;
    System.out.println("name field   : " + parsed.get("name"));
    System.out.println("age field    : " + parsed.get("age") + " (" + parsed.get("age").getClass().getSimpleName() + ")");

// 4. BIND into a typed record, the way ObjectMapper.readValue(json, User.class) does.
    @SuppressWarnings("unchecked")
    List<Object> plist = (List<Object>) parsed.get("languages");
    List<String> typed = new ArrayList<>();
    for (Object o : plist) typed.add((String) o);
    User bound = new User((String) parsed.get("name"), (int) parsed.get("age"), typed);
    System.out.println("bound record : " + bound);

// 5. ROUND-TRIP: re-serialize the parsed tree and confirm it survives.
    System.out.println("round-trip   : " + writeJson(parsed));
  }

record User(String name, int age, List<String> languages) {}

// ---- minimal JSON writer ----
  static String writeJson(Object value) {
    StringBuilder sb = new StringBuilder();
    write(value, sb);
    return sb.toString();
  }

@SuppressWarnings("unchecked")
  static void write(Object value, StringBuilder sb) {
    if (value == null) { sb.append("null"); return; }
    if (value instanceof String s) { sb.append('"').append(s).append('"'); return; }
    if (value instanceof Boolean || value instanceof Number) { sb.append(value); return; }
    if (value instanceof Map<?, ?> m) {
      sb.append('{');
      boolean first = true;
      for (Map.Entry<?, ?> e : m.entrySet()) {
        if (!first) sb.append(',');
        first = false;
        sb.append('"').append(e.getKey()).append("\":");
        write(e.getValue(), sb);
      }
      sb.append('}');
      return;
    }
    if (value instanceof List<?> list) {
      sb.append('[');
      for (int i = 0; i < list.size(); i++) {
        if (i > 0) sb.append(',');
        write(list.get(i), sb);
      }
      sb.append(']');
      return;
    }
    throw new IllegalArgumentException("unsupported: " + value.getClass());
  }

// ---- minimal recursive-descent JSON parser ----
  static class Parser {
    private final String s;
    private int i = 0;
    Parser(String s) { this.s = s; }

Object parse() { skip(); return value(); }

private Object value() {
      skip();
      char c = s.charAt(i);
      return switch (c) {
        case '{' -> object();
        case '[' -> array();
        case '"' -> string();
        case 't', 'f' -> bool();
        case 'n' -> nul();
        default -> number();
      };
    }

private Map<String, Object> object() {
      Map<String, Object> m = new LinkedHashMap<>();
      i++; // {
      skip();
      if (s.charAt(i) == '}') { i++; return m; }
      while (true) {
        skip();
        String key = string();
        skip();
        i++; // :
        m.put(key, value());
        skip();
        char c = s.charAt(i++);
        if (c == '}') break;
      }
      return m;
    }

private List<Object> array() {
      List<Object> list = new ArrayList<>();
      i++; // [
      skip();
      if (s.charAt(i) == ']') { i++; return list; }
      while (true) {
        list.add(value());
        skip();
        char c = s.charAt(i++);
        if (c == ']') break;
      }
      return list;
    }

private String string() {
      StringBuilder sb = new StringBuilder();
      i++; // opening quote
      while (s.charAt(i) != '"') sb.append(s.charAt(i++));
      i++; // closing quote
      return sb.toString();
    }

private Object number() {
      int start = i;
      while (i < s.length() && "-+.eE0123456789".indexOf(s.charAt(i)) >= 0) i++;
      String num = s.substring(start, i);
      if (num.contains(".") || num.contains("e") || num.contains("E"))
        return Double.parseDouble(num);
      return Integer.parseInt(num);
    }

private Boolean bool() {
      if (s.charAt(i) == 't') { i += 4; return Boolean.TRUE; }
      i += 5; return Boolean.FALSE;
    }

private Object nul() { i += 4; return null; }

private void skip() { while (i < s.length() && Character.isWhitespace(s.charAt(i))) i++; }
  }
}

Что следует вынести из этого запуска:

Сериализация обходит граф объектов и генерирует текст. Строка serialized показывает вложенный Map/List, преобразованный в {"name":"Ada",...,"languages":["Java","Ada"]} — массив внутри объекта. ObjectMapper.writeValueAsString выполняет такой же рекурсивный обход геттеров POJO или компонентов record.
Разбор сначала восстанавливает обобщённое дерево. Тип значения во время выполнения — LinkedHashMap, а не User — это в точности древовидная модель Jackson, где readTree возвращает JsonNode, по которому можно перемещаться по ключу до того, как в игру вступает какой-либо класс.
Числа JSON становятся числами Java с выбором типа. Поле age вернулось как Integer (42), потому что в тексте не было десятичной точки; парсер выбрал Integer вместо Double. Jackson принимает идентичное решение, поэтому поле int привязывается чисто, а 3.14 попало бы как Double.
Доступ к полям осуществляется по имени, и порядок сохраняется. Использование LinkedHashMap сохранило ключи в порядке вставки, так что name возвращается раньше age. Jackson таким же образом сохраняет порядок ключей объекта, поэтому JSON после «туда-обратно» выглядит как оригинал.
Цикл «туда-обратно» не теряет данные, если модель соответствует. Последняя строка повторно сериализовала разобранное дерево в тот же JSON, из которого оно было получено, а типизированный record User правильно привязал name, age и languages — в этом и есть весь смысл привязки данных: текст на входе, объект на выходе, снова текст, без потерь.

Практика

С помощью Jackson вы получаете JSON-ответ, структуру которого не контролируете, и вам нужно прочитать лишь два поля из большого, глубоко вложенного документа. Какой подход подходит лучше всего?

Разобрать в дерево 'JsonNode' с помощью 'ObjectMapper.readTree' и извлечь два поля через 'get(...)'Создать полный Java-класс, отражающий каждое поле документа, и использовать 'readValue' для привязки данныхКонкатенировать сырые JSON-строки и извлечь значения с помощью 'String.substring'Использовать 'DatagramSocket' для потоковой передачи JSON и читать поля из потока