Парсинг JSON в Java: техники преобразования в объекты и назад

{
"name": "John Doe",
"age": 30,
"isEmployed": true,
"skills": ["Java", "Spring", "MongoDB"],
"address": {
"city": "San Francisco",
"zipCode": "94105"
}
}

<dependency>
<groupId>org.json</groupId>
<artifactId>json</artifactId>
<version>20230618</version>
</dependency>

import org.json.JSONObject;

public class SimpleJsonParser {
public static void main(String[] args) {
String jsonString = "{\"name\":\"John\", \"age\":30, \"city\":\"New York\"}";

JSONObject jsonObject = new JSONObject(jsonString);

String name = jsonObject.getString("name");
int age = jsonObject.getInt("age");
String city = jsonObject.getString("city");

System.out.println("Name: " + name);
System.out.println("Age: " + age);
System.out.println("City: " + city);
}
}

import org.json.JSONArray;
import org.json.JSONObject;

public class JsonArrayExample {
public static void main(String[] args) {
String jsonString = "{\"employees\":[" +
"{\"name\":\"John\", \"title\":\"Developer\"}," +
"{\"name\":\"Anna\", \"title\":\"Designer\"}," +
"{\"name\":\"Peter\", \"title\":\"Manager\"}]}";

JSONObject jsonObject = new JSONObject(jsonString);
JSONArray employees = jsonObject.getJSONArray("employees");

for (int i = 0; i < employees.length(); i++) {
JSONObject employee = employees.getJSONObject(i);
System.out.println(employee.getString("name") + ": " + 
employee.getString("title"));
}
}
}

import org.json.JSONObject;
import org.json.JSONArray;

public class JsonBuilderExample {
public static void main(String[] args) {
JSONObject person = new JSONObject();

person.put("name", "Alice");
person.put("age", 28);
person.put("isEmployed", true);

JSONArray hobbies = new JSONArray();
hobbies.put("reading");
hobbies.put("traveling");
hobbies.put("photography");

person.put("hobbies", hobbies);

JSONObject address = new JSONObject();
address.put("street", "123 Tech Lane");
address.put("city", "San Francisco");
address.put("zipCode", "94107");

person.put("address", address);

System.out.println(person.toString(2)); // С отступом для читаемости
}
}

<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.15.2</version>
</dependency>

import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;

public class JacksonExample {

public static class User {
private String name;
private int age;
private String email;

// Геттеры и сеттеры (обязательны для Jackson)
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public int getAge() { return age; }
public void setAge(int age) { this.age = age; }
public String getEmail() { return email; }
public void setEmail(String email) { this.email = email; }

@Override
public String toString() {
return "User{name='" + name + "', age=" + age + ", email='" + email + "'}";
}
}

public static void main(String[] args) throws IOException {
String json = "{\"name\":\"Alice\",\"age\":30,\"email\":\"alice@example.com\"}";

ObjectMapper mapper = new ObjectMapper();
User user = mapper.readValue(json, User.class);

System.out.println(user);

// Сериализация обратно в JSON
String serializedJson = mapper.writeValueAsString(user);
System.out.println(serializedJson);
}
}

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Date;
import java.io.IOException;

@JsonIgnoreProperties(ignoreUnknown = true) // Игнорировать неизвестные поля
public class Product {
@JsonProperty("product_name") // Маппинг имени поля
private String name;

private double price;

@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd") // Формат даты
private Date releaseDate;

// Геттеры и сеттеры
// ...
}

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.JsonNode;
import java.io.IOException;

public class JacksonTreeModel {
public static void main(String[] args) throws IOException {
String json = "{"
+ "\"name\":\"John\","
+ "\"address\":{"
+ " \"street\":\"21 2nd Street\","
+ " \"city\":\"New York\","
+ " \"zipCode\":\"10021\""
+ "},"
+ "\"phoneNumbers\":[\"212-555-1234\",\"646-555-4567\"]"
+ "}";

ObjectMapper mapper = new ObjectMapper();
JsonNode rootNode = mapper.readTree(json);

// Доступ к простым полям
String name = rootNode.get("name").asText();
System.out.println("Name: " + name);

// Доступ к вложенным объектам
JsonNode addressNode = rootNode.get("address");
String city = addressNode.get("city").asText();
System.out.println("City: " + city);

// Доступ к элементам массива
JsonNode phoneArray = rootNode.get("phoneNumbers");
for (int i = 0; i < phoneArray.size(); i++) {
System.out.println("Phone " + i + ": " + phoneArray.get(i).asText());
}
}
}

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.DeserializationFeature;

public class CustomizedObjectMapper {
public static void main(String[] args) {
ObjectMapper mapper = new ObjectMapper()
// Настройки сериализации
.enable(SerializationFeature.INDENT_OUTPUT) // Форматированный вывод
.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS) // Даты как строки
// Настройки десериализации
.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES) // Игнорировать неизвестные поля
.enable(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY); // Одиночные значения как массивы

// Использование настроенного маппера...
}
}

<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.10.1</version>
</dependency>

import com.google.gson.Gson;

public class GsonBasicExample {

public static class Person {
private String name;
private int age;
private boolean isEmployed;

// Конструктор, геттеры и сеттеры не обязательны для Gson!
// Gson работает напрямую с приватными полями
}

public static void main(String[] args) {
String json = "{\"name\":\"John\",\"age\":35,\"isEmployed\":true}";

Gson gson = new Gson();
Person person = gson.fromJson(json, Person.class);

System.out.println("Name: " + person.name);
System.out.println("Age: " + person.age);
System.out.println("Employed: " + person.isEmployed);

// Сериализация обратно в JSON
Person newPerson = new Person();
newPerson.name = "Alice";
newPerson.age = 28;
newPerson.isEmployed = false;

String newJson = gson.toJson(newPerson);
System.out.println(newJson);
}
}

import com.google.gson.Gson;
import java.util.List;
import java.util.Arrays;

public class GsonNestedExample {

public static class Address {
private String street;
private String city;
private String zipCode;
}

public static class Employee {
private String name;
private int id;
private Address address;
private List<String> skills;
}

public static void main(String[] args) {
String json = "{"
+ "\"name\":\"Sarah Johnson\","
+ "\"id\":1001,"
+ "\"address\":{"
+ " \"street\":\"123 Tech Lane\","
+ " \"city\":\"San Francisco\","
+ " \"zipCode\":\"94107\""
+ "},"
+ "\"skills\":[\"Java\",\"Spring\",\"Microservices\",\"AWS\"]"
+ "}";

Gson gson = new Gson();
Employee employee = gson.fromJson(json, Employee.class);

System.out.println("Employee: " + employee.name);
System.out.println("City: " + employee.address.city);
System.out.println("Skills: " + employee.skills);
}
}

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import java.util.Date;

public class GsonBuilderExample {

public static class Event {
private String name;
private Date date;
}

public static void main(String[] args) {
Gson gson = new GsonBuilder()
.setPrettyPrinting() // Форматированный вывод
.serializeNulls() // Сериализовать null-поля
.setDateFormat("yyyy-MM-dd HH:mm:ss") // Формат даты
.create();

Event event = new Event();
event.name = "Conference";
event.date = new Date();

String json = gson.toJson(event);
System.out.println(json);
}
}

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.annotations.Expose;
import com.google.gson.annotations.SerializedName;

public class GsonAnnotationsExample {

public static class User {
@Expose(serialize = true, deserialize = true)
@SerializedName("user_name")
private String name;

@Expose(serialize = false, deserialize = true)
private String password;

@SerializedName("contact_email")
private String email;

// Это поле будет игнорироваться при использовании @Expose
private int internalId;

// Геттеры и сеттеры...
}

public static void main(String[] args) {
String json = "{"
+ "\"user_name\":\"john_doe\","
+ "\"password\":\"secret123\","
+ "\"contact_email\":\"john@example.com\","
+ "\"internalId\":12345"
+ "}";

GsonBuilder builder = new GsonBuilder()
.excludeFieldsWithoutExposeAnnotation(); // Учитывать только поля с @Expose
Gson gson = builder.create();

User user = gson.fromJson(json, User.class);

// При сериализации пароль будет исключен
String newJson = gson.toJson(user);
System.out.println(newJson);
}
}

{
"users": {
"user123": {"name": "John", "role": "admin"},
"user456": {"name": "Alice", "role": "editor"},
"user789": {"name": "Bob", "role": "viewer"}
}
}

import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;

public class DynamicKeysExample {

public static class UserInfo {
private String name;
private String role;

// Геттеры и сеттеры...
}

public static class UserData {
private Map<String, UserInfo> users;

// Геттеры и сеттеры...
}

public static void main(String[] args) throws Exception {
String json = "{\"users\":{" +
"\"user123\":{\"name\":\"John\",\"role\":\"admin\"}," +
"\"user456\":{\"name\":\"Alice\",\"role\":\"editor\"}," +
"\"user789\":{\"name\":\"Bob\",\"role\":\"viewer\"}" +
"}}";

ObjectMapper mapper = new ObjectMapper();
UserData userData = mapper.readValue(json, UserData.class);

// Доступ к данным пользователя по ID
UserInfo user123 = userData.users.get("user123");
System.out.println("User123: " + user123.name + ", role: " + user123.role);

// Перебор всех пользователей
for (Map.Entry<String, UserInfo> entry : userData.users.entrySet()) {
String userId = entry.getKey();
UserInfo userInfo = entry.getValue();
System.out.println(userId + ": " + userInfo.name + " (" + userInfo.role + ")");
}
}
}

import com.fasterxml.jackson.annotation.JsonSubTypes;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.databind.ObjectMapper;

public class PolymorphicJsonExample {

@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, property = "type")
@JsonSubTypes({
@JsonSubTypes.Type(value = Car.class, name = "car"),
@JsonSubTypes.Type(value = Bicycle.class, name = "bicycle")
})
public static abstract class Vehicle {
private String manufacturer;

// Геттеры и сеттеры...
}

public static class Car extends Vehicle {
private int numberOfDoors;
private String fuelType;

// Геттеры и сеттеры...
}

public static class Bicycle extends Vehicle {
private int numberOfGears;
private boolean hasBell;

// Геттеры и сеттеры...
}

public static void main(String[] args) throws Exception {
// JSON с разными типами транспортных средств
String json = "[" +
"{\"type\":\"car\",\"manufacturer\":\"Toyota\",\"numberOfDoors\":4,\"fuelType\":\"hybrid\"}," +
"{\"type\":\"bicycle\",\"manufacturer\":\"Trek\",\"numberOfGears\":21,\"hasBell\":true}" +
"]";

ObjectMapper mapper = new ObjectMapper();
Vehicle[] vehicles = mapper.readValue(json, Vehicle[].class);

for (Vehicle vehicle : vehicles) {
System.out.println("Vehicle type: " + vehicle.getClass().getSimpleName());
System.out.println("Manufacturer: " + vehicle.manufacturer);

if (vehicle instanceof Car) {
Car car = (Car) vehicle;
System.out.println("Doors: " + car.numberOfDoors);
System.out.println("Fuel: " + car.fuelType);
} else if (vehicle instanceof Bicycle) {
Bicycle bicycle = (Bicycle) vehicle;
System.out.println("Gears: " + bicycle.numberOfGears);
System.out.println("Has bell: " + bicycle.hasBell);
}

System.out.println();
}
}
}

import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonToken;
import java.io.File;

public class JsonStreamingExample {
public static void main(String[] args) throws Exception {
File jsonFile = new File("large_data.json"); // Большой JSON-файл

JsonFactory factory = new JsonFactory();
int userCount = 0;

try (JsonParser parser = factory.createParser(jsonFile)) {
// Ищем массив "users"
while (parser.nextToken() != null) {
if (parser.currentToken() == JsonToken.FIELD_NAME && 
"users".equals(parser.getCurrentName())) {

// Переходим к началу массива
parser.nextToken();

// Перебираем элементы массива
while (parser.nextToken() == JsonToken.START_OBJECT) {
userCount++;
String userName = null;

// Обрабатываем объект пользователя
while (parser.nextToken() != JsonToken.END_OBJECT) {
if (parser.currentToken() == JsonToken.FIELD_NAME) {
String fieldName = parser.getCurrentName();
parser.nextToken(); // Переход к значению

if ("name".equals(fieldName)) {
userName = parser.getValueAsString();
// После извлечения нужных данных можно пропустить остальные поля
break;
}
}
}

System.out.println("Found user: " + userName);

// Пропуск оставшихся полей объекта пользователя (если break выше)
parser.skipChildren();
}
}
}
}

System.out.println("Total users processed: " + userCount);
}
}

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonDeserializationContext;
import com.google.gson.JsonDeserializer;
import com.google.gson.JsonElement;
import com.google.gson.JsonParseException;
import com.google.gson.JsonPrimitive;
import com.google.gson.JsonSerializationContext;
import com.google.gson.JsonSerializer;

import java.lang.reflect.Type;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class CustomSerializationExample {

public static class Event {
private String name;
private Date eventDate;
private long participants;

// Геттеры и сеттеры...
}

// Кастомный обработчик для дат
public static class DateTypeAdapter implements JsonSerializer<Date>, JsonDeserializer<Date> {
private final SimpleDateFormat format = new SimpleDateFormat("dd-MM-yyyy HH:mm");

@Override
public JsonElement serialize(Date src, Type typeOfSrc, JsonSerializationContext context) {
return new JsonPrimitive(format.format(src));
}

@Override
public Date deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) 
throws JsonParseException {
try {
return format.parse(json.getAsString());
} catch (ParseException e) {
throw new JsonParseException(e);
}
}
}

// Кастомный обработчик для чисел в строках
public static class StringToLongAdapter implements JsonDeserializer<Long> {
@Override
public Long deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) 
throws JsonParseException {
try {
return Long.parseLong(json.getAsString());
} catch (NumberFormatException e) {
throw new JsonParseException(e);
}
}
}

public static void main(String[] args) {
String json = "{"
+ "\"name\":\"Tech Conference\","
+ "\"eventDate\":\"15-06-2023 09:30\","
+ "\"participants\":\"1200\""
+ "}";

GsonBuilder builder = new GsonBuilder();
builder.registerTypeAdapter(Date.class, new DateTypeAdapter());
builder.registerTypeAdapter(Long.class, new StringToLongAdapter());

Gson gson = builder.create();
Event event = gson.fromJson(json, Event.class);

System.out.println("Event: " + event.name);
System.out.println("Date: " + event.eventDate);
System.out.println("Participants: " + event.participants);
}
}

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.networknt.schema.JsonSchema;
import com.networknt.schema.JsonSchemaFactory;
import com.networknt.schema.SpecVersion;
import com.networknt.schema.ValidationMessage;
import java.util.Set;

public class JsonValidationExample {
public static void main(String[] args) throws Exception {
// Схема JSON (обычно хранится в отдельном файле)
String schemaString = "{"
+ "\"$schema\": \"http://json-schema.org/draft-07/schema#\","
+ "\"type\": \"object\","
+ "\"properties\": {"
+ " \"name\": {\"type\": \"string\"},"
+ " \"age\": {\"type\": \"integer\", \"minimum\": 0},"
+ " \"email\": {\"type\": \"string\", \"format\": \"email\"}"
+ "},"
+ "\"required\": [\"name\", \"email\"]"
+ "}";

// JSON для валидации
String jsonString = "{"
+ "\"name\": \"John Doe\","
+ "\"age\": -5,"
+ "\"email\": \"invalid-email\""
+ "}";

ObjectMapper mapper = new ObjectMapper();
JsonNode jsonNode = mapper.readTree(jsonString);
JsonNode schemaNode = mapper.readTree(schemaString);

// Создание схемы для валидации
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(SpecVersion.VersionFlag.V7);
JsonSchema schema = factory.getSchema(schemaNode);

// Валидация
Set<ValidationMessage> validationResult = schema.validate(jsonNode);

if (validationResult.isEmpty()) {
System.out.println("JSON валиден, можно парсить");
// Парсинг JSON...
} else {
System.out.println("JSON не прошел валидацию:");
for (ValidationMessage message : validationResult) {
System.out.println(message);
}
}
}
}