В чем разница между JSON и XML?

# Разница между JSON и XML

Это фундаментальный вопрос о форматах обмена данными. За 10+ лет видел эволюцию от XML к JSON в большинстве приложений.

Структура и синтаксис

XML (eXtensible Markup Language)

<?xml version="1.0" encoding="UTF-8"?>
<users>
    <user>
        <id>1</id>
        <name>Alice</name>
        <email>alice@example.com</email>
        <active>true</active>
    </user>
    <user>
        <id>2</id>
        <name>Bob</name>
        <email>bob@example.com</email>
        <active>false</active>
    </user>
</users>

JSON (JavaScript Object Notation)

{
  "users": [
    {
      "id": 1,
      "name": "Alice",
      "email": "alice@example.com",
      "active": true
    },
    {
      "id": 2,
      "name": "Bob",
      "email": "bob@example.com",
      "active": false
    }
  ]
}

Размер файла

JSON значительно меньше:

XML пример выше:  476 байт
JSON пример:      268 байт  (43% меньше)

Для большого объёма данных это существенно:

Если отправить 1 млн записей:
XML:   ~400 MB
JSON:  ~200 MB
Время трансмиссии: разница в 10+ минут на медленном интернете

Парсинг в Java

XML парсинг (DOM парсер)

import javax.xml.parsers.DocumentBuilder;
import org.w3c.dom.Document;

public class XMLParser {
    public static void parseXML(String xmlString) throws Exception {
        DocumentBuilder builder = DocumentBuilderFactory.newInstance()
            .newDocumentBuilder();
        Document doc = builder.parse(
            new ByteArrayInputStream(xmlString.getBytes())
        );
        
        NodeList users = doc.getElementsByTagName("user");
        for (int i = 0; i < users.getLength(); i++) {
            Element user = (Element) users.item(i);
            String name = user.getElementsByTagName("name")
                .item(0).getTextContent();
            System.out.println(name);
        }
    }
}

JSON парсинг (Jackson библиотека)

import com.fasterxml.jackson.databind.ObjectMapper;

public class JSONParser {
    public static void parseJSON(String jsonString) throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        Users users = mapper.readValue(jsonString, Users.class);
        
        for (User user : users.getUsers()) {
            System.out.println(user.getName());
        }
    }
}

class Users {
    private List<User> users;
    // getters/setters
}

class User {
    private int id;
    private String name;
    private String email;
    private boolean active;
    // getters/setters
}

JSON парсинг проще и быстрее благодаря прямому соответствию структурам данных.

Поддержка типов

JSON имеет встроенные типы

{
  "id": 1,              // number
  "name": "Alice",      // string
  "active": true,       // boolean
  "balance": 123.45,    // float
  "roles": ["admin"],   // array
  "metadata": null,     // null
  "profile": {}         // object
}

XML - всё строки

<user>
    <id>1</id>              <!-- строка -->
    <name>Alice</name>      <!-- строка -->
    <active>true</active>   <!-- строка (нужно парсить вручную) -->
    <balance>123.45</balance>  <!-- строка -->
</user>

Для типизирования в XML нужны XML Schema (XSD) или Relax NG - это усложняет кодирование.

Атрибуты vs элементы

XML имеет неоднозначность:

<!-- Способ 1: атрибуты -->
<user id="1" name="Alice" email="alice@example.com"/>

<!-- Способ 2: элементы -->
<user>
    <id>1</id>
    <name>Alice</name>
    <email>alice@example.com</email>
</user>

<!-- Способ 3: смешанный -->
<user id="1">
    <name>Alice</name>
    <email>alice@example.com</email>
</user>

В JSON нет такой неоднозначности - всё свойства:

{
  "id": 1,
  "name": "Alice",
  "email": "alice@example.com"
}

Производительность

JSON - быстрее

// Тест парсинга 10 млн записей

// XML (DOM парсер)
long start = System.currentTimeMillis();
parseXML(largeXMLData);
System.out.println("XML: " + (System.currentTimeMillis() - start) + "ms");
// Результат: ~5000ms

// JSON
long start = System.currentTimeMillis();
parseJSON(largeJSONData);
System.out.println("JSON: " + (System.currentTimeMillis() - start) + "ms");
// Результат: ~1500ms

JSON обычно в 3-5x раз быстрее.

Валидация

XML - мощная валидация через XSD

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
    <xs:element name="user">
        <xs:complexType>
            <xs:sequence>
                <xs:element name="id" type="xs:integer"/>
                <xs:element name="name" type="xs:string"/>
                <xs:element name="email" type="xs:string"/>
            </xs:sequence>
        </xs:complexType>
    </xs:element>
</xs:schema>

JSON - JSON Schema

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "id": { "type": "integer" },
    "name": { "type": "string" },
    "email": { "type": "string", "format": "email" },
    "active": { "type": "boolean" }
  },
  "required": ["id", "name", "email"]
}

JSON Schema проще и удобнее для web API.

Комментарии

<!-- XML поддерживает комментарии -->
<user>
    <!-- Идентификатор пользователя -->
    <id>1</id>
</user>

// JSON НЕ поддерживает комментарии стандартно
{
  "id": 1  // Это вызовет ошибку парсинга
}

// Нужно использовать JSONC (JSON with Comments) или другие варианты

Когда использовать XML?

1. SOAP веб-сервисы - XML обязателен
2. Конфигурационные файлы - Maven pom.xml, Spring configuration.xml
3. Документ-ориентированные данные - Word, Excel, SVG
4. Enterprise интеграция - старые системы
5. Когда нужна мощная валидация - XSD/Relax NG

<!-- pom.xml - Maven конфигурация -->
<project>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
        </dependency>
    </dependencies>
</project>

Когда использовать JSON?

1. REST API - стандарт де-факто
2. Web приложения - родной формат для JavaScript
3. Мобильные приложения - маленький размер
4. No-SQL БД - MongoDB, Firestore
5. Когда нужна простота - меньше boilerplate

// REST API response
{
  "status": "success",
  "data": {
    "user": {
      "id": 1,
      "name": "Alice",
      "email": "alice@example.com"
    }
  }
}

Таблица сравнения

Особенность          XML          JSON
────────────────────────────────────────
Размер              Большой      Маленький
Парсинг             Медленно      Быстро
Читаемость          Хорошо        Отличная
Типизация           Через XSD    Встроенная
Комментарии         Да            Нет
Шкемирование        XSD/Relax    JSON Schema
Web API             Редко         Стандарт
Конфигурация        Да (Spring)   Растет
Производит.         Средняя       Высокая

Практический опыт

В моей карьере:

• 2005-2010: XML везде (SOAP, конфигурация, документы)
• 2010-2015: Миграция с XML на JSON для API
• 2015-2025: JSON везде, XML только для legacy систем и документов

Выводы:

• JSON победил XML в web приложениях
• XML остался для конфигураций и документов
• Оба формата имеют право на существование
• Выбирай JSON по умолчанию для новых проектов
• XML используй только если есть веская причина

Для Java разработчика важно уметь работать с обоими, но акцент в 2024 году - на JSON.