Что такое инициализация полей в Hibernate?

Инициализация полей в Hibernate

Инициализация полей в Hibernate — это процесс заполнения свойств объекта (entity) данными из базы данных. Это происходит при загрузке сущности и требует особого внимания к типам загрузки (eager vs lazy) и инициализации коллекций.

Когда и как инициализируются поля

Scenario 1: Простые поля (скалярные)

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    private String email;
    private int age;
}

Эти поля инициализируются сразу же при загрузке сущности:

User user = session.find(User.class, 1);
System.out.println(user.getName());   // инициализирована (готова)
System.out.println(user.getEmail());  // инициализирована (готова)

Scenario 2: Ассоциации (связи) — Eager loading

Eager loading: загружается сразу вместе с основным объектом

@Entity
public class User {
    @Id
    private Long id;
    
    @ManyToOne(fetch = FetchType.EAGER)
    @JoinColumn(name = "company_id")
    private Company company;  // загружается СРАЗУ
}

User user = session.find(User.class, 1);
System.out.println(user.getCompany().getName());  // уже инициализирована

Выполняется SQL:

SELECT u.*, c.* FROM users u
LEFT JOIN companies c ON u.company_id = c.id
WHERE u.id = 1

Scenario 3: Ассоциации — Lazy loading

Lazy loading: загружается только при первом обращении

@Entity
public class User {
    @Id
    private Long id;
    
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "company_id")
    private Company company;  // НЕ загружается сразу!
}

User user = session.find(User.class, 1);
System.out.println(user.getId());         // готово
System.out.println(user.getName());       // готово
System.out.println(user.getCompany().getName());  // СЕЙЧАС загрузится!
// Выполняется отдельный SELECT для Company

Проблема: Lazy initialization exception

User user = session.find(User.class, 1);
session.close();  // закрыли сессию

System.out.println(user.getCompany().getName());  
// LazyInitializationException: could not initialize proxy

Потому что Company был lazy loaded и требует открытую сессию.

Инициализация коллекций

Scenario 1: One-to-Many с Eager loading

@Entity
public class Company {
    @Id
    private Long id;
    
    @OneToMany(mappedBy = "company", fetch = FetchType.EAGER)
    private Set<User> employees;  // загружается сразу
}

Company company = session.find(Company.class, 1);
System.out.println(company.getEmployees().size());  // уже инициализирована

Проблема: N+1 запросы при множественных связях

@Entity
public class Company {
    @OneToMany(mappedBy = "company", fetch = FetchType.EAGER)
    private Set<User> employees;  // EAGER
    
    @OneToMany(mappedBy = "company", fetch = FetchType.EAGER)
    private Set<Project> projects;  // EAGER
}

List<Company> companies = session.createQuery("from Company").getResultList();
// 1 запрос для всех companies
// N запросов для employees каждой company
// N запросов для projects каждой company
// Итого: 2N+1 запросы!

Scenario 2: One-to-Many с Lazy loading

@Entity
public class Company {
    @Id
    private Long id;
    
    @OneToMany(mappedBy = "company", fetch = FetchType.LAZY)
    private List<User> employees;  // НЕ загружается сразу
}

Company company = session.find(Company.class, 1);
// SELECT company...

System.out.println(company.getEmployees().size());  // СЕЙЧАС загружается
// SELECT employees WHERE company_id = 1

Инициализация в открытой сессии

Правильный способ: инициализировать внутри транзакции

@Transactional
public void printUserAndCompany(Long userId) {
    User user = session.find(User.class, userId);
    
    // Пока сессия открыта, можно инициализировать lazy поля
    System.out.println(user.getName());
    System.out.println(user.getCompany().getName());  // OK
}

Явная инициализация (Eager)

Способ 1: Fetch join в JPQL

String jpql = "SELECT u FROM User u JOIN FETCH u.company WHERE u.id = :id";
Query query = session.createQuery(jpql);
query.setParameter("id", userId);
User user = (User) query.getSingleResult();

System.out.println(user.getCompany().getName());  // инициализирована

Способ 2: Hibernate.initialize()

User user = session.find(User.class, userId);
Hibernate.initialize(user.getCompany());  // явно инициализировать

System.out.println(user.getCompany().getName());  // готово

Способ 3: Entity Graph

@NamedEntityGraph(
    name = "User.full",
    attributeNodes = {@NamedAttributeNode("company")}
)
@Entity
public class User {
    // ...
}

EntityGraph<?> graph = entityManager.getEntityGraph("User.full");
Map<String, Object> hints = new HashMap<>();
hints.put("javax.persistence.loadgraph", graph);

User user = entityManager.find(User.class, userId, hints);
// company инициализирована благодаря graph

Инициализация вложенных коллекций

@Entity
public class Company {
    @OneToMany(mappedBy = "company")
    private List<User> employees;
}

@Entity
public class User {
    @OneToMany(mappedBy = "user")
    private List<Task> tasks;
}

// Загрузить company с её employees и их tasks
String jpql = "SELECT c FROM Company c " +
              "JOIN FETCH c.employees e " +
              "JOIN FETCH e.tasks";

List<Company> companies = session.createQuery(jpql).getResultList();

Инициализация и Proxy объекты

Hibernate создаёт proxy объекты для lazy loading:

@Entity
public class User {
    @ManyToOne(fetch = FetchType.LAZY)
    private Company company;
}

User user = session.find(User.class, 1);

System.out.println(user.getCompany().getClass());  
// Выведет: Company_$$_jvst123 (это proxy)

// Инициализировать proxy
Company company = user.getCompany();
Hibernate.initialize(company);  // теперь это реальный объект

Проблема: Cartesian Product

При JOIN FETCH нескольких коллекций:

@Entity
public class Company {
    @OneToMany
    private List<User> employees;
    
    @OneToMany
    private List<Project> projects;
}

// ПЛОХО: JOIN FETCH обеих коллекций
String jpql = "SELECT c FROM Company c " +
              "JOIN FETCH c.employees " +
              "JOIN FETCH c.projects";
// Cartesian product: 3 employees * 2 projects = 6 строк вместо 1!

// ХОРОШО: несколько запросов
String jpql = "SELECT c FROM Company c JOIN FETCH c.employees";
List<Company> companies = session.createQuery(jpql).getResultList();

// Потом отдельно
jpql = "SELECT c FROM Company c JOIN FETCH c.projects WHERE c.id IN (:ids)";

Лучшие практики

1. Используй LAZY по умолчанию для ассоциаций (@ManyToOne(fetch = FetchType.LAZY))
2. Явно загружай EAGER для часто используемых полей через JOIN FETCH
3. Избегай N+1 запросов — профилируй SQL
4. Инициализируй lazy поля внутри транзакции перед закрытием сессии
5. Используй Entity Graph для сложных сценариев загрузки
6. Не используй EAGER для коллекций (@OneToMany) — риск Cartesian product
7. Профилируй SQL с помощью Hibernate statistics

Вывод: Инициализация полей в Hibernate требует понимания lazy vs eager loading. Неправильная конфигурация приводит к N+1 проблемам и LazyInitializationException. Используй JOIN FETCH и Entity Graph для контроля над загрузкой данных.