Java for Beginner

Jackson

Tree Model и Streaming API в Jackson: когда нужна гибкость и производительность

Jackson предлагает не только стандартную POJO-сериализацию, но и более гибкие модели работы с JSON. Среди них — Tree Model и Streaming API.
Tree Model даёт полную свободу при работе с JSON-структурой, а Streaming API — максимальную производительность при чтении/записи больших файлов.

Tree Model (JsonNode): работа с JSON как с деревом

Иногда структура JSON заранее неизвестна или слишком сложна, чтобы описывать её через Java-классы. В таких случаях удобно использовать дерево узлов — JsonNode.

Пример: чтение JSON как дерева

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

String json = "{ \"user\": { \"name\": \"Alice\", \"age\": 30 } }";

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

String name = rootNode.path("user").path("name").asText();
int age = rootNode.path("user").path("age").asInt();

System.out.println("Имя: " + name + ", Возраст: " + age);

Tree Model позволяет легко:
— обходить структуру вручную
— проверять наличие полей
— работать с вложенностью и массивами
— модифицировать JSON "на лету"

Когда использовать Tree Model

Когда структура JSON может меняться
Когда нужно читать только часть данных
При разработке универсальных парсеров
Когда сложно заранее описать модель через классы

Streaming API (JsonParser/JsonGenerator)

Для огромных JSON-файлов (например, логов, экспорта из БД) загрузка всего файла в память может быть невозможной. Здесь пригодится стриминговый API — он читает JSON по частям, как поток.

Пример: чтение JSON через JsonParser

import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonToken;

JsonFactory factory = new JsonFactory();
JsonParser parser = factory.createParser(new File("data.json"));

while (!parser.isClosed()) {
    JsonToken token = parser.nextToken();

    if (JsonToken.FIELD_NAME.equals(token) && "name".equals(parser.getCurrentName())) {
        parser.nextToken();
        System.out.println("Имя: " + parser.getValueAsString());
    }
}
parser.close();

Когда использовать Streaming API

Работа с большими JSON-файлами, которые нельзя загрузить полностью
Требуется максимальная производительность
Необходимо читать JSON "по частям"
Парсинг в системах с ограниченной памятью (например, embedded)

Сравнение подходов

POJO-модель — просто, типобезопасно, но требует классов
Tree Model — гибко, удобно для анализа/модификации
Streaming API — быстро и экономно, но требует ручного контроля

#Java #Training #Medium #Jackson #Tree_Model #Streaming_API

👍3

140 views14:59

Java for Beginner

После проведенного голосования, определилась тема для рассмотрения в выходные - Optional

Несмотря на то, что на канале уже публиковались ранее подобные статьи, я подготовил для вас еще одну, для расширения темы 🤫

Ну читаем'с статейку

Optional в Java: Глубокое погружение

Optional — это класс, введенный в Java 8, представляющий собой контейнер для значений, который может содержать значение или быть пустым. Его основная цель — минимизировать вероятность возникновения NullPointerException (NPE), обеспечивая явное указание на возможность отсутствия значения. Optional побуждает разработчиков к более безопасной и выразительной обработке потенциально отсутствующих данных.

Основы Optional

Optional — это обертка, которая может содержать либо одно значение, либо быть пустой. Вместо возврата null, методы могут возвращать экземпляр Optional, что сигнализирует о возможном отсутствии результата. Это позволяет явно обрабатывать случаи отсутствия значения, избегая NPE.

Пример базового использования

import java.util.Optional;

public class OptionalExample {
    public static void main(String[] args) {
        Optional<String> possibleValue = Optional.of("Hello, World!");
        possibleValue.ifPresent(System.out::println); // Выведет "Hello, World!"

        Optional<String> emptyValue = Optional.empty();
        System.out.println(emptyValue.isPresent()); // Выведет "false"
    }
}

В этом примере possibleValue содержит строку, которая выводится на консоль, если значение присутствует. emptyValue является пустым, и метод isPresent() возвращает false.

Внутреннее устройство Optional

Optional реализован как финальный класс с двумя основными полями:
value — содержит значение, если оно присутствует (может быть null только в случае пустого Optional).
EMPTY — статическое поле, представляющее пустой Optional, реализованное как синглтон.

Конструктор Optional приватный, и создание экземпляров осуществляется через статические фабричные методы:
of(T value): Создает Optional, содержащий переданное значение. Если значение null, выбрасывается NullPointerException.
ofNullable(T value): Создает Optional, который может быть пустым, если переданное значение null.
empty(): Возвращает пустой Optional.

Пример внутренней структуры

public final class Optional<T> {
    private static final Optional<?> EMPTY = new Optional<>();

    private final T value;

    private Optional() {
        this.value = null;
    }

    private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }

    public static <T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }

    public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }

    public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }

    // Другие методы...
}

Этот код демонстрирует, как Optional хранит значение и реализует фабричные методы. Использование синглтона EMPTY минимизирует создание лишних объектов для пустых Optional.

#Java #Training #Medium #Optional

Please open Telegram to view this post

VIEW IN TELEGRAM

👍2

87 views07:59

Java for Beginner

Ключевые методы Optional

Optional предоставляет множество методов для работы с данными:
isPresent(): Возвращает true, если значение присутствует.
isEmpty() (добавлен в Java 11): Возвращает true, если значение отсутствует.
ifPresent(Consumer<? super T> consumer): Выполняет действие, если значение присутствует.
orElse(T other): Возвращает значение, если оно присутствует, или other, если отсутствует.
orElseGet(Supplier<? extends T> supplier): Возвращает значение или результат выполнения Supplier, если значение отсутствует.
orElseThrow(Supplier<? extends X> exceptionSupplier): Возвращает значение или выбрасывает исключение, если значение отсутствует.
map(Function<? super T, ? extends U> mapper): Преобразует значение, если оно присутствует, возвращая новый Optional.
flatMap(Function<? super T, Optional<U>> mapper): Преобразует значение, возвращая Optional, результат которого не оборачивается в дополнительный Optional.
filter(Predicate<? super T> predicate): Возвращает Optional, содержащий значение, если оно удовлетворяет предикату, или пустой Optional.
or(Supplier<? extends Optional<? extends T>> supplier) (добавлен в Java 9): Возвращает текущий Optional, если значение присутствует, или результат Supplier.

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

Optional<String> name = Optional.ofNullable(getName()); // Может вернуть null
String result = name
    .map(String::toUpperCase)
    .filter(s -> s.length() > 3)
    .orElse("DEFAULT");
System.out.println(result); // Выведет преобразованное значение или "DEFAULT"

Этот пример демонстрирует цепочку вызовов, характерную для функционального программирования, где Optional используется для обработки значения с возможностью отсутствия.

Преимущества Optional
Безопасность от NPE: Optional явно указывает на возможность отсутствия значения, заставляя разработчика обрабатывать этот случай.
Читаемость кода: Код с Optional более выразителен, так как сигнализирует о потенциальном отсутствии значения.
Избежание явного null: Уменьшает использование проверок if (value != null), делая код чище.
Интеграция с функциональным программированием: Методы map, flatMap и filter позволяют использовать Optional в цепочках обработки данных, интегрируясь с Stream API.

Практическое использование Optional

Интеграция со Stream API
Optional часто используется в связке со Stream API для обработки данных, которые могут отсутствовать. Например:

Optional<User> user = findUserById(123);
Stream<User> userStream = user.stream(); // Преобразует Optional в Stream
userStream.forEach(System.out::println);

Метод stream() (добавлен в Java 9) позволяет преобразовать Optional в Stream, содержащий либо одно значение, либо пустой.

Обработка вложенных объектов
Optional особенно полезен при работе с цепочками объектов, где каждое звено может быть null. Без Optional код выглядел бы так:

String city = null;
if (user != null && user.getAddress() != null && user.getAddress().getCity() != null) {
    city = user.getAddress().getCity();
}

С использованием Optional код становится более компактным:

String city = Optional.ofNullable(user)
    .map(User::getAddress)
    .map(Address::getCity)
    .orElse("Unknown");

Метод flatMap полезен, если методы возвращают Optional:

Optional<String> city = Optional.ofNullable(user)
    .flatMap(u -> Optional.ofNullable(u.getAddress()))
    .flatMap(a -> Optional.ofNullable(a.getCity()));

Использование в API
Optional часто применяется в публичных API для возврата значений, которые могут отсутствовать. Например, метод Map.getOrDefault может быть заменен на Optional:

Map<String, String> map = new HashMap<>();
Optional<String> value = Optional.ofNullable(map.get("key"));

#Java #Training #Medium #Optional

👍2

88 views07:59

Java for Beginner

Антипаттерны и ограничения

Использование Optional для полей класса: Optional не предназначен для хранения состояния в полях класса, так как он не сериализуем (Optional не реализует Serializable). Вместо этого используйте null для полей или коллекции.

// Антипаттерн
public class User {
    private Optional<String> name; // Не рекомендуется
}

Чрезмерное использование isPresent(): Проверки isPresent() с последующим вызовом get() сводят на нет преимущества Optional:

// Антипаттерн
if (optional.isPresent()) {
    return optional.get();
}

Вместо этого используйте orElse, orElseGet или map:

return optional.orElse(defaultValue);

Передача Optional в методы: Передача Optional в качестве аргумента метода может усложнить API. Лучше передавать значение или null:

// Антипаттерн
void process(Optional<String> value) { ... }

// Лучше
void process(String value) { ... }

Производительность: Создание объектов Optional в циклах или в высокопроизводительных системах может привести к накладным расходам. В таких случаях рассмотрите использование null или оптимизируйте код.
Сериализация: Optional не реализует Serializable, что делает его непригодным для использования в сериализуемых классах. Если сериализация необходима, преобразуйте Optional в null или значение перед сохранением.
Потокобезопасность: Optional не является потокобезопасным, так как он не предназначен для конкурентного доступа. Если значение внутри Optional изменяется в многопоточной среде, используйте синхронизацию или потокобезопасные альтернативы.

Производительность и оптимизация
Создание объектов: Каждый вызов Optional.of или ofNullable создает новый объект (кроме empty(), который использует синглтон). В критически важных участках кода минимизируйте создание Optional.
Кэширование: Если Optional возвращается часто используемым методом, рассмотрите кэширование результата, чтобы избежать повторного создания объектов.
Ленивые вычисления: Используйте orElseGet вместо orElse, если альтернативное значение требует вычислений:

// Менее эффективно
String result = optional.orElse(computeExpensiveDefault());

// Более эффективно
String result = optional.orElseGet(() -> computeExpensiveDefault());

Рекомендации

- Используйте Optional только там, где это имеет смысл: Применяйте Optional для возвращаемых значений методов, где отсутствие значения — это ожидаемый сценарий. Не используйте его для всех случаев, чтобы избежать ненужной сложности.
- Интеграция с функциональными API: Максимально используйте методы map, flatMap и filter для обработки данных в функциональном стиле. Это улучшает читаемость и поддерживаемость кода.
- Проверка на обратную совместимость: Если вы разрабатываете публичное API, учитывайте, что клиенты на Java 7 и ниже не смогут использовать Optional. В таких случаях предоставляйте альтернативные методы, возвращающие null.
- Тестирование: Убедитесь, что тесты покрывают оба случая — присутствие и отсутствие значения в Optional. Это гарантирует корректную обработку всех сценариев.
- Рефакторинг старого кода: При рефакторинге кода, использующего null, заменяйте проверки на Optional, но только если это улучшает читаемость и безопасность. Не заменяйте null на Optional механически.

Пример реального сценария

Предположим, у нас есть сервис, который возвращает информацию о пользователе:

public class UserService {
    public Optional<User> findUserById(long id) {
        // Имитация поиска в базе данных
        return id == 123 ? Optional.of(new User("Alice")) : Optional.empty();
    }

    public Optional<String> getUserCity(long id) {
        return findUserById(id)
            .flatMap(user -> Optional.ofNullable(user.getAddress()))
            .flatMap(address -> Optional.ofNullable(address.getCity()));
    }
}

Этот код демонстрирует, как Optional используется для безопасной обработки цепочки объектов, где каждое звено может быть отсутствующим.

#Java #Training #Medium #Optional

👍2

100 views07:59

About

Blog

Apps

Platform