🐘 Вопросы интервью по Hibernate

Ответ: Hibernate — это фреймворк объектно-реляционного отображения (ORM) для Java, который связывает объекты Java-классов с таблицами реляционной базы данных. Он решает проблему несоответствия объектной и реляционной моделей (object-relational impedance mismatch): в объектной модели есть наследование, ассоциации и коллекции, а реляционная модель оперирует только таблицами, строками и внешними ключами.

• Избавляет от написания большого количества шаблонного JDBC-кода
• Автоматически преобразует объекты в записи таблиц и обратно
• Предоставляет кэширование, ленивую загрузку и управление транзакциями
• Позволяет писать запросы на HQL, не завязываясь на конкретный диалект SQL

Ответ: JDBC — это низкоуровневый API для работы с базой данных, где разработчик вручную пишет SQL-запросы и сам преобразует результаты в объекты. Hibernate работает поверх JDBC, но берёт эту работу на себя.

Ответ: Архитектура Hibernate строится вокруг нескольких ключевых компонентов, которые взаимодействуют друг с другом при выполнении операций с базой данных.

• Configuration: Читает конфигурацию (hibernate.cfg.xml или свойства) и настройки маппинга, на основе которых строится SessionFactory
• SessionFactory: Тяжеловесный потокобезопасный объект, создаваемый один раз на приложение; фабрика для создания объектов Session
• Session: Лёгкий, не потокобезопасный объект, представляющий одно соединение с базой данных и единицу работы (unit of work)
• Transaction: Абстракция над транзакцией базы данных, управляет коммитом и откатом изменений
• Query / Criteria: Объекты для выполнения запросов на HQL или через Criteria API

Configuration configuration = new Configuration().configure();
SessionFactory sessionFactory = configuration.buildSessionFactory();

Session session = sessionFactory.openSession();
Transaction transaction = session.beginTransaction();

session.save(new User("Alice"));

transaction.commit();
session.close();
                

Ответ: SessionFactory и Session решают разные задачи и имеют разный жизненный цикл.

Ответ: Hibernate использует набор аннотаций (стандарт JPA), чтобы связать класс Java с таблицей базы данных.

• @Entity: Помечает класс как сущность, которой Hibernate должен управлять
• @Table(name = "..."): Указывает имя таблицы, если оно отличается от имени класса
• @Id: Помечает поле как первичный ключ сущности
• @GeneratedValue: Задаёт стратегию автогенерации значения первичного ключа
• @Column(name = "..."): Настраивает соответствие поля и столбца таблицы

@Entity
@Table(name = "users")
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "full_name", nullable = false)
    private String name;

    // геттеры и сеттеры
}
                

Ответ: Каждый объект сущности в Hibernate находится в одном из четырёх состояний, и Session отвечает за отслеживание этих состояний.

• Transient (временное): Объект создан через new, но ещё не связан с Session и не имеет представления в базе данных
• Persistent (постоянное): Объект связан с активной Session; любые изменения полей автоматически синхронизируются с базой данных при коммите
• Detached (отсоединённое): Объект был persistent, но его Session закрыта; изменения больше не отслеживаются автоматически
• Removed (удалённое): Объект помечен на удаление вызовом session.delete() и будет удалён из базы данных при коммите

User user = new User("Bob");      // transient

session.save(user);               // persistent

session.close();                  // detached

session2.update(user);            // снова persistent
session2.delete(user);            // removed
                

Ответ: Эти стратегии определяют, когда Hibernate загружает связанные сущности или коллекции относительно основной сущности.

@OneToMany(mappedBy = "author", fetch = FetchType.LAZY)
private List<Book> books;

@ManyToOne(fetch = FetchType.EAGER)
private Publisher publisher;
                

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

• Кэш первого уровня (First-Level Cache): Привязан к объекту Session, включён по умолчанию и не может быть отключён. Действует только в рамках одной сессии
• Кэш второго уровня (Second-Level Cache): Привязан к SessionFactory, разделяется между всеми сессиями приложения. Не включён по умолчанию, требует подключения провайдера кэша (например, Ehcache) и явной настройки

Ответ: Hibernate предоставляет три способа выполнения запросов, каждый со своими сценариями применения.

• HQL (Hibernate Query Language): Похож на SQL, но оперирует именами классов и полей сущностей, а не именами таблиц и столбцов. Не зависит от конкретной СУБД
• Criteria API: Позволяет строить запросы программно, через цепочки вызовов методов, что удобно для динамических запросов, собираемых по условию
• Native SQL: Обычный SQL конкретной СУБД, используется, когда нужны возможности, которых нет в HQL (специфичные функции базы данных, сложные оптимизации)

String hql = "FROM User u WHERE u.name = :name";
List<User> users = session.createQuery(hql, User.class)
    .setParameter("name", "Alice")
    .list();
                

Ответ: Hibernate поддерживает все основные типы связей реляционной модели через аннотации JPA.

• @OneToOne: Связь один к одному, например, User и Passport
• @OneToMany: Связь один ко многим, например, Author и его Book'и
• @ManyToOne: Обратная сторона @OneToMany — множество Book ссылаются на одного Author
• @ManyToMany: Связь многие ко многим, например, Student и Course

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

    @OneToMany(mappedBy = "author", cascade = CascadeType.ALL)
    private List<Book> books;
}

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

    @ManyToOne
    @JoinColumn(name = "author_id")
    private Author author;
}
                

Ответ: Стратегия задаётся через @GeneratedValue(strategy = ...) и определяет, как Hibernate получает значение первичного ключа для новой сущности.

Ответ: Проблема N+1 возникает, когда Hibernate выполняет один запрос для получения списка из N сущностей, а затем ещё N отдельных запросов, чтобы лениво подгрузить связанные данные для каждой из них — итого N+1 запрос вместо одного оптимального.

List<Author> authors = session.createQuery("FROM Author", Author.class).list();

for (Author author : authors) {
    // при lazy-загрузке каждый вызов books.size()
    // порождает отдельный SQL-запрос
    System.out.println(author.getBooks().size());
}
                

• Использовать JOIN FETCH в HQL, чтобы загрузить связанные данные одним запросом
• Настроить @BatchSize для пакетной подгрузки коллекций
• Использовать Entity Graph для явного указания, какие связи загружать

String hql = "FROM Author a JOIN FETCH a.books";
                

Ответ: JPA (Java Persistence API) — это спецификация, набор интерфейсов и правил для ORM в Java, а Hibernate — одна из её реализаций (наряду с EclipseLink, OpenJPA и другими).