Аннотация @Any в Spring

Аннотация @Any относится к пакету org.hibernate.annotations (Hibernate, не Spring), но часто используется в Spring-приложениях, работающих с JPA/Hibernate. Она применяется для обозначения полиморфных ассоциаций, когда сущность может ссылаться на разные типы объектов.

@Any позволяет моделировать связь, где поле может содержать экземпляр любой сущности (из заданного набора), а не только строго определённого типа (как в @ManyToOne или @OneToOne).

Параметры и настройки

Аннотация @Any сама по себе не принимает параметров, но требует дополнительных аннотаций для корректной работы:

@AnyMetaDef (или @AnyMetaDefs для нескольких определений) – определяет метаданные для полиморфной связи:

name (обязательный) – уникальное имя определения, которое используется в @Any.
metaType (по умолчанию String) – тип идентификатора, хранящего информацию о классе (обычно String или Integer).
idType (обязательный) – тип первичного ключа связанных сущностей (например, Long).
metaValues – массив @MetaValue, где каждое значение связывает идентификатор класса с конкретной сущностью.

Пример:

@AnyMetaDef(
    name = "animalMetaDef",
    metaType = "string",
    idType = "long",
    metaValues = {
        @MetaValue(value = "DOG", targetEntity = Dog.class),
        @MetaValue(value = "CAT", targetEntity = Cat.class)
    }
)

@JoinColumn – указывает столбец в БД, хранящий ID связанной сущности.
@Column (опционально) – указывает столбец, хранящий тип сущности (если метаданные используют отдельный столбец).

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

@Entity
public class Zoo {
    @Id
    private Long id;

    @Any(metaDef = "animalMetaDef", metaColumn = @Column(name = "animal_type"))
    @JoinColumn(name = "animal_id")
    private Animal animal;  // Может быть Dog или Cat
}

Жизненный цикл @Any

Загрузка (@PostLoad)
Hibernate определяет тип сущности по значению в metaColumn и загружает соответствующий объект.

Сохранение (@PrePersist/@PreUpdate)
перед сохранением Hibernate записывает:
ID сущности в animal_id.
Класс сущности (например, "DOG") в animal_type.

Удаление
каскадное удаление не поддерживается автоматически, нужно обрабатывать вручную.

Механизмы Spring и Spring Boot, связанные с @Any

Поскольку @Any – это аннотация Hibernate, её работа зависит от:
spring.jpa.hibernate.ddl-auto (в application.properties/application.yml) – если стоит update или create, Hibernate автоматически создаст таблицы с полями animal_id и animal_type.
spring.jpa.show-sql – полезно для отладки запросов, связанных с полиморфными ассоциациями.
EntityManager – Spring Boot автоматически настраивает его, и через него происходят все операции с @Any.

Ограничения и альтернативы
Нет встроенной поддержки в Spring Data JPA – репозитории не могут автоматически генерировать запросы для @Any.

Альтернативы:
@OneToMany + наследование (@Inheritance(strategy = InheritanceType.SINGLE_TABLE)) – если типы известны заранее.
@ElementCollection + Map<String, Object> – если полиморфизм нужен только для хранения данных.

#Java #Training #Hard #Spring #Hibernate #Any

Аннотация @BatchSize в Spring (Hibernate)

Аннотация @BatchSize принадлежит пакету org.hibernate.annotations и используется для оптимизации загрузки коллекций или прокси-объектов в Hibernate. Она позволяет загружать элементы пакетно (batch), уменьшая количество SQL-запросов (проблема N+1).

Применяется в двух случаях:
Для коллекций (@OneToMany, @ManyToMany) – загружает несколько связанных коллекций одним запросом.
Для лениво загружаемых сущностей (@ManyToOne, @OneToOne) – загружает несколько прокси-объектов партиями.

Параметры и настройки
У аннотации есть один обязательный параметр - size: размер пакета (сколько элементов загружать за один SQL-запрос), обычно 10, 20, 50.

Примеры использования
Пакетная загрузка коллекций (N+1 Problem Fix)

@Entity
public class Author {
    @Id
    private Long id;

    @OneToMany(mappedBy = "author")
    @BatchSize(size = 10)  // Загружает до 10 книг за один запрос
    private List<Book> books;
}

Как работает:
Если загружается 100 авторов, без @BatchSize Hibernate выполнит 100+1 запрос (1 для авторов + 100 для книг каждого).
С @BatchSize(size=10) Hibernate сделает 1 запрос для авторов + 10 запросов для книг (каждый запрос загружает книги для 10 авторов).

Пакетная загрузка ленивых сущностей

@Entity
public class Book {
    @Id
    private Long id;

    @ManyToOne(fetch = FetchType.LAZY)
    @BatchSize(size = 5)  // Загружает авторов пачками по 5
    private Author author;
}

Как работает:
При обращении к book.getAuthor(), Hibernate не загружает автора сразу, а ждёт, пока не потребуются несколько авторов.
Когда накопятся 5 ленивых прокси, Hibernate выполнит один запрос вида:

SELECT * FROM author WHERE id IN (1, 2, 3, 4, 5)

Жизненный цикл

Инициализация прокси/коллекции – Hibernate откладывает загрузку до первого обращения.
Пакетная загрузка – при достижении size или принудительной инициализации (например, Hibernate.initialize()).
Кэширование – загруженные объекты помещаются в кэш первого уровня (Session).

Настройки Hibernate в Spring Boot

@BatchSize работает на уровне Hibernate, но Spring Boot позволяет управлять его поведением через:
spring.jpa.properties.hibernate.default_batch_fetch_size (в application.properties)

spring.jpa.properties.hibernate.default_batch_fetch_size=20
Устанавливает глобальный размер пакета для всех ленивых загрузок.

Если @BatchSize указан на поле, он имеет приоритет.

Оптимизация запросов

JOIN FETCH (в JPQL) загружает данные одним запросом, но может привести к Cartesian Product.
@BatchSize даёт баланс между количеством запросов и объёмом данных.
@BatchSize можно комбинировать с @EntityGraph, но обычно @EntityGraph полностью отключает ленивую загрузку.

#Java #Training #Hard #Spring #Hibernate #BatchSize

Аннотации @Cache и @Cacheable в Hibernate

Аннотации @Cache и @Cacheable относятся к кешированию сущностей и коллекций в Hibernate. Они позволяют оптимизировать производительность за счёт хранения часто используемых данных в памяти, уменьшая количество обращений к базе данных.

@Cache (org.hibernate.annotations.Cache) – настраивает стратегию кеширования для сущности или коллекции.
@Cacheable (javax.persistence.Cacheable / jakarta.persistence.Cacheable) – указывает, что сущность может быть кеширована (используется вместе с @Cache).

@Cache (Hibernate)

Параметры:
usage (CacheConcurrencyStrategy) – стратегия кеширования:

READ_ONLY – только для чтения (если сущность не изменяется).
NONSTRICT_READ_WRITE – кеш обновляется асинхронно при изменениях.
READ_WRITE – гарантирует согласованность через мягкие блокировки.
TRANSACTIONAL – полная поддержка транзакций (для JTA).

region (опционально) – имя региона кеша (если используется несколько кешей, например, Ehcache, Hazelcast).

include (CacheInclude) – указывает, включать ли ленивые поля в кеш (ALL или NON_LAZY).

Пример:

@Entity
@Cacheable
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE, region = "employees")
public class Employee { ... }

@Cacheable (JPA)

Указывает, что сущность поддерживает кеширование.
Работает в паре с @Cache (Hibernate) или настройками JPA-провайдера.
Если @Cacheable(false), сущность игнорируется кешем, даже если кеширование включено глобально.

Пример:

@Entity
@Cacheable(true)  // Включено кеширование (по умолчанию true)
public class Product { ... }

Механизмы кеширования в Hibernate

Уровни кеширования

Кеш первого уровня (Session)
Автоматический, живет в рамках одной сессии (EntityManager).
Не требует @Cache.

Кеш второго уровня (SessionFactory)
Общий для всех сессий.
Требует явного объявления (@Cache + @Cacheable).

Кеш запросов (Query Cache)
Кеширует результаты JPQL/HQL-запросов.

Включается отдельно:

spring.jpa.properties.hibernate.cache.use_query_cache=true

Настройка в Spring Boot

Включение кеша второго уровня

spring.jpa.properties.hibernate.cache.use_second_level_cache=true
spring.jpa.properties.hibernate.cache.region.factory_class=org.hibernate.cache.ehcache.EhCacheRegionFactory
(Пример для Ehcache; также поддерживаются Infinispan, Hazelcast, Redis.)

Указание кешируемых сущностей

Через @Cache + @Cacheable.

Или глобально в application.properties:

spring.jpa.properties.javax.persistence.sharedCache.mode=ALL
(Варианты: ALL, NONE, ENABLE_SELECTIVE, DISABLE_SELECTIVE.)

Настройка поставщика кеша

Например, для Ehcache:

<dependency>
    <groupId>org.ehcache</groupId>
    <artifactId>ehcache</artifactId>
</dependency>

И файл ehcache.xml в resources/.

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

@Cache + @Cacheable – для часто читаемых, редко изменяемых данных (справочники, настройки).
READ_ONLY – если сущности никогда не обновляются (например, Country, City).
READ_WRITE – если данные изменяются, но требуется высокая скорость чтения.
Избегать для часто изменяемых данных (кеш будет постоянно инвалидироваться).

#Java #Training #Hard #Spring #Hibernate #Cache #Cacheable

Аннотация @Cascade в Hibernate

Аннотация @Cascade (org.hibernate.annotations.Cascade) управляет каскадными операциями (сохранение, обновление, удаление) для ассоциаций между сущностями. Она дополняет или заменяет стандартные каскадные операции JPA (CascadeType).

Отличается от javax.persistence.CascadeType тем, что поддерживает специфичные для Hibernate каскады, например, CascadeType.LOCK или CascadeType.REPLICATE.

Параметры

Принимает одно или несколько значений из перечисления org.hibernate.annotations.CascadeType:
PERSIST – сохраняет связанную сущность при сохранении родителя (аналог CascadeType.PERSIST).
MERGE – обновляет связанную сущность при обновлении родителя (аналог CascadeType.MERGE).
REMOVE – удаляет связанную сущность при удалении родителя (аналог CascadeType.REMOVE).
REFRESH – обновляет связанную сущность при обновлении родителя (аналог CascadeType.REFRESH).
DETACH – отключает связанную сущность от контекста (аналог CascadeType.DETACH).
SAVE_UPDATE – сохраняет или обновляет связанную сущность при сохранении/обновлении родителя (устарело в Hibernate 6+, вместо этого используйте PERSIST + MERGE).
LOCK – блокирует связанную сущность при блокировке родителя (специфично для Hibernate).
REPLICATE – реплицирует связанную сущность при репликации родителя (специфично для Hibernate).
DELETE – удаляет связанную сущность при удалении родителя (аналог REMOVE, но работает в некоторых случаях иначе).
DELETE_ORPHAN – удаляет связанную сущность, если она больше не связана с родителем (работает только для коллекций).

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

Каскадное сохранение и удаление

@Entity
public class Parent {
    @Id
    private Long id;

    @OneToMany(mappedBy = "parent")
    @Cascade({CascadeType.PERSIST, CascadeType.REMOVE})
    private List<Child> children;
}

Что делает:
При сохранении Parent автоматически сохраняются все Child.
При удалении Parent автоматически удаляются все Child.

Каскадное обновление и управление "сиротами"

@Entity
public class Author {
    @Id
    private Long id;

    @OneToMany(mappedBy = "author")
    @Cascade({CascadeType.MERGE, CascadeType.DELETE_ORPHAN})
    private List<Book> books;
}

Что делает:
При обновлении Author обновляются все связанные Book.
Если книга удаляется из списка books, она автоматически удаляется из БД (orphanRemoval).

Специфичные каскады Hibernate (LOCK, REPLICATE)

@Entity
public class Order {
    @Id
    private Long id;

    @OneToMany(mappedBy = "order")
    @Cascade({CascadeType.LOCK, CascadeType.REPLICATE})
    private List<Item> items;
}

Что делает:
При блокировке Order блокируются все Item.
При репликации Order реплицируются все Item.

Разница между @Cascade и cascade в JPA

JPA (javax.persistence.CascadeType)

@OneToMany(mappedBy = "parent", cascade = {javax.persistence.CascadeType.PERSIST, javax.persistence.CascadeType.REMOVE})

Стандартный механизм JPA.
Поддерживает только базовые операции (PERSIST, MERGE, REMOVE, REFRESH, DETACH, ALL).

Hibernate (@Cascade)

@OneToMany(mappedBy = "parent")
@Cascade({org.hibernate.annotations.CascadeType.SAVE_UPDATE, org.hibernate.annotations.CascadeType.DELETE_ORPHAN})

Расширенный функционал (например, DELETE_ORPHAN, LOCK, REPLICATE).
Работает только в Hibernate.

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

Если нужны специфичные для Hibernate каскады (LOCK, REPLICATE).
Если требуется удаление "сирот" (DELETE_ORPHAN).
В остальных случаях лучше использовать стандартный cascade из JPA.

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

Каскадные операции могут приводить к неожиданным DELETE/UPDATE.

Рекомендуется:
Использовать orphanRemoval только там, где это необходимо.
Избегать CascadeType.ALL (может привести к неявным удалениям).

#Java #Training #Hard #Spring #Hibernate #Cascade