Как отключить ленивую загрузку в Hibernate

# Отключение ленивой загрузки в Hibernate

Основная проблема

По умолчанию Hibernate использует ленивую загрузку (lazy loading) для связанных сущностей. Это означает, что ассоциированные объекты загружаются только при первом обращении к ним. Это может привести к N+1 problem и многочисленным запросам к БД.

// Пример: N+1 problem
List<User> users = userRepository.findAll();  // 1 запрос
for (User user : users) {
    System.out.println(user.getProfile().getName());  // N запросов! По одному на каждого юзера
}

Решение 1: @OneToMany/ManyToOne с fetch = FetchType.EAGER

Самый простой способ — указать при определении связи, что нужна ранняя загрузка.

import jakarta.persistence.*;

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.UUID)
    private UUID id;
    
    private String username;
    
    // Ленивая загрузка (по умолчанию)
    @OneToMany(mappedBy = "user", fetch = FetchType.LAZY)
    private List<Post> posts;
    
    // Ранняя загрузка
    @ManyToOne(fetch = FetchType.EAGER)
    @JoinColumn(name = "profile_id")
    private Profile profile;
}

@Entity
@Table(name = "profiles")
public class Profile {
    @Id
    @GeneratedValue(strategy = GenerationType.UUID)
    private UUID id;
    
    private String name;
    
    // Ранняя загрузка — всегда загружаем страну
    @ManyToOne(fetch = FetchType.EAGER)
    @JoinColumn(name = "country_id")
    private Country country;
}

Решение 2: JPQL запрос с JOIN FETCH

При выполнении custom запросов используй JOIN FETCH для явной загрузки связей.

import org.springframework.data.jpa.repository.Query;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;
import java.util.UUID;

@Repository
public interface UserRepository extends JpaRepository<User, UUID> {
    
    // ❌ Плохо: вызывает N+1 problem
    List<User> findAll();
    
    // ✅ Хорошо: загружает posts и profile одним запросом
    @Query("SELECT DISTINCT u FROM User u " +
           "LEFT JOIN FETCH u.posts " +
           "LEFT JOIN FETCH u.profile")
    List<User> findAllWithAssociations();
    
    // Загрузить пользователя с его постами
    @Query("SELECT u FROM User u LEFT JOIN FETCH u.posts WHERE u.id = :id")
    Optional<User> findByIdWithPosts(@Param("id") UUID id);
}

Решение 3: EntityGraph (рекомендуется для Spring Data)

Используй @EntityGraph для определения графа загрузки.

import org.springframework.data.jpa.repository.EntityGraph;
import org.springframework.data.jpa.repository.JpaRepository;

@Repository
public interface UserRepository extends JpaRepository<User, UUID> {
    
    // Определяем граф загрузки
    @EntityGraph(
        attributePaths = {"profile", "posts"}
    )
    @Override
    List<User> findAll();
    
    // Для поиска по ID
    @EntityGraph(
        attributePaths = {"profile", "posts", "comments"}
    )
    Optional<User> findById(UUID id);
    
    // Для кастомного поиска
    @EntityGraph(attributePaths = {"profile"})
    List<User> findByUsernameContains(String username);
}

Решение 4: @NamedEntityGraph (для сложных структур)

Для более сложных графов загрузки определи @NamedEntityGraph в сущности.

import jakarta.persistence.*;
import java.util.List;

@Entity
@Table(name = "users")
@NamedEntityGraph(
    name = "User.withProfileAndPosts",
    attributeNodes = {
        @NamedAttributeNode("profile"),
        @NamedAttributeNode(
            value = "posts",
            subgraph = "posts-subgraph"
        )
    },
    subgraphs = {
        @NamedSubgraph(
            name = "posts-subgraph",
            attributeNodes = {
                @NamedAttributeNode("comments")
            }
        )
    }
)
public class User {
    @Id
    private UUID id;
    
    private String username;
    
    @ManyToOne(fetch = FetchType.LAZY)
    private Profile profile;
    
    @OneToMany(mappedBy = "user", fetch = FetchType.LAZY)
    private List<Post> posts;
}

// Использование
@Repository
public interface UserRepository extends JpaRepository<User, UUID> {
    @EntityGraph(value = "User.withProfileAndPosts")
    List<User> findAll();
}

Решение 5: Явное инициализирование в сервисе

Используй Hibernate.initialize() для явной инициализации.

import org.hibernate.Hibernate;
import org.springframework.stereotype.Service;

@Service
public class UserService {
    
    @Autowired
    private UserRepository userRepository;
    
    public User getUserWithProfile(UUID id) {
        User user = userRepository.findById(id).orElseThrow();
        
        // Явно инициализируем profile до закрытия сессии
        Hibernate.initialize(user.getProfile());
        Hibernate.initialize(user.getPosts());
        
        return user;
    }
}

Решение 6: Глобальное отключение ленивой загрузки (не рекомендуется)

В крайних случаях можно отключить ленивую загрузку глобально.

# application.yml
spring:
  jpa:
    properties:
      hibernate:
        enable_lazy_load_no_trans: false  # Строгая проверка
        default_batch_fetch_size: 20      # Batch loading для N+1
        
# Это может скрыть проблемы, не рекомендуется!

Решение 7: Projection (для оптимизации SELECT)

Для получения только нужных полей используй DTO/Projection.

// DTO для проекции
public class UserDTO {
    private UUID id;
    private String username;
    private String profileName;
    
    public UserDTO(UUID id, String username, String profileName) {
        this.id = id;
        this.username = username;
        this.profileName = profileName;
    }
}

// Запрос с проекцией
@Repository
public interface UserRepository extends JpaRepository<User, UUID> {
    
    @Query("SELECT new com.example.UserDTO(u.id, u.username, p.name) " +
           "FROM User u LEFT JOIN u.profile p")
    List<UserDTO> findAllDTOs();
}

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

Реальный пример: REST API

@RestController
@RequestMapping("/api/v1/users")
public class UserController {
    
    @Autowired
    private UserRepository userRepository;
    
    // ✅ Хорошо: загружает profile и posts сразу
    @GetMapping
    public List<UserDTO> getAllUsers() {
        return userRepository.findAll()
            .stream()
            .map(user -> new UserDTO(
                user.getId(),
                user.getUsername(),
                user.getProfile().getName(),
                user.getPosts().size()
            ))
            .toList();
    }
    
    // ✅ Лучше: использует EntityGraph
    @Repository
    public interface UserRepositoryOptimized extends JpaRepository<User, UUID> {
        @EntityGraph(attributePaths = {"profile", "posts"})
        @Override
        List<User> findAll();
    }
}

Диагностика N+1 Problem

# application.yml
spring:
  jpa:
    properties:
      hibernate:
        generate_statistics: true  # Включить статистику
        use_sql_comments: true     # Добавить комментарии в SQL

# Логирование SQL
logging:
  level:
    org.hibernate.SQL: DEBUG
    org.hibernate.type.descriptor.sql.BasicBinder: TRACE

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

1. Никогда не используй FetchType.EAGER для OneToMany — вызывает Cartesian product
2. По умолчанию LAZY — явно загружай только необходимое
3. Используй EntityGraph — это стандартный способ в Spring Data
4. Мониторь SQL запросы — включи логирование и проверь количество запросов
5. Батчинг для Many — используй batch_fetch_size для оптимизации

Вывод: для отключения ленивой загрузки используй @EntityGraph или JOIN FETCH в зависимости от контекста — это стандартные способы в современных приложениях Spring.