Как не получать исключения при работе с Lazy объектами без жадного подключения

# LazyInitializationException: работа с Lazy загрузкой в Hibernate

Это частая проблема при работе с Hibernate и JPA. Рассмотрю различные подходы к её решению.

Что такое LazyInitializationException?

Проблема:

@Entity
public class User {
    @Id
    private Long id;
    private String name;
    
    @OneToMany(mappedBy = "user", fetch = FetchType.LAZY) // Lazy by default
    private List<Order> orders; // Загружается при обращении
}

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    @Transactional // Сессия закрывается после метода
    public User getUser(Long id) {
        return userRepository.findById(id).orElse(null);
    }
}

// В контроллере/тесте:
User user = userService.getUser(1L); // Сессия закрыта
System.out.println(user.getOrders().size()); // LazyInitializationException!
// "could not initialize proxy - no Session"

Решение 1: Eager Loading (FETCH JOIN)

Правильный подход:

public interface UserRepository extends JpaRepository<User, Long> {
    
    @Query("""
        SELECT DISTINCT u FROM User u
        LEFT JOIN FETCH u.orders
        WHERE u.id = :id
    """)
    Optional<User> findByIdWithOrders(@Param("id") Long id);
}

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    @Transactional(readOnly = true)
    public User getUser(Long id) {
        return userRepository.findByIdWithOrders(id).orElse(null);
    }
}

// Теперь это работает:
User user = userService.getUser(1L);
System.out.println(user.getOrders().size()); // OK! Загружены в одном запросе

Решение 2: Расширение @Transactional scope

Оставить транзакцию открытой:

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    @Transactional(readOnly = true) // Сессия остаётся открытой
    public User getUserWithOrders(Long id) {
        User user = userRepository.findById(id).orElse(null);
        if (user != null) {
            // Доступ к Lazy полям ещё в рамках транзакции
            user.getOrders().size(); // Инициализирует коллекцию
        }
        return user;
    }
}

// В контроллере:
User user = userService.getUserWithOrders(1L);
System.out.println(user.getOrders().size()); // OK!

Решение 3: OpenSessionInView (осторожно!)

В Spring Boot (НЕ рекомендуется для production):

spring:
  jpa:
    properties:
      hibernate:
        enable_lazy_load_no_trans: true # Опасно!

Это позволяет ленивую загрузку вне транзакции, но имеет проблемы:

• N+1 queries
• Непредсказуемое поведение
• Сложнее отчитываться в performance проблемах

Лучше не использовать в production.

Решение 4: Явная инициализация через Hibernate.initialize()

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    @Transactional(readOnly = true)
    public User getUser(Long id) {
        User user = userRepository.findById(id).orElse(null);
        if (user != null) {
            // Явная инициализация в рамках транзакции
            Hibernate.initialize(user.getOrders());
        }
        return user;
    }
}

// Контроллер:
User user = userService.getUser(1L);
System.out.println(user.getOrders().size()); // OK!

Решение 5: DTO проекция (ЛУЧШИЙ подход!)

public record UserDTO(
    Long id,
    String name,
    List<OrderDTO> orders
) {}

public record OrderDTO(
    Long id,
    BigDecimal amount
) {}

public interface UserRepository extends JpaRepository<User, Long> {
    
    @Query("""
        SELECT new com.example.dto.UserDTO(
            u.id, u.name,
            CAST(LIST(new com.example.dto.OrderDTO(o.id, o.amount)) AS java.util.List)
        )
        FROM User u
        LEFT JOIN u.orders o
        WHERE u.id = :id
    """)
    Optional<UserDTO> findDtoById(@Param("id") Long id);
}

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    public UserDTO getUser(Long id) {
        return userRepository.findDtoById(id).orElse(null);
        // Не нужна @Transactional
        // Загружены только нужные поля
        // Никаких LazyInitializationException
    }
}

Решение 6: Graph Query (Spring Data JPA 2.0+)

@Entity
public class User {
    @Id
    private Long id;
    private String name;
    
    @OneToMany(mappedBy = "user", fetch = FetchType.LAZY)
    private List<Order> orders;
}

// Определить EntityGraph
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    
    @EntityGraph(attributePaths = {"orders"})
    Optional<User> findById(Long id);
    
    @EntityGraph(
        attributePaths = {"orders", "orders.items"},
        type = EntityGraphType.FETCH
    )
    List<User> findAll();
}

Решение 7: Правильный дизайн — избегать Lazy для простых полей

@Entity
public class User {
    @Id
    private Long id;
    
    private String name; // EAGER, так как это простое поле
    
    @OneToMany(mappedBy = "user", fetch = FetchType.LAZY) // LAZY для коллекций
    private List<Order> orders;
    
    @ManyToOne(fetch = FetchType.LAZY) // LAZY, но часто используется в JOIN
    private Company company;
}

// Для company всегда использовать JOIN:
@Query("""
    SELECT u FROM User u
    LEFT JOIN FETCH u.company
    WHERE u.id = :id
""")
Optional<User> findByIdWithCompany(@Param("id") Long id);

Решение 8: Batch Loading (для N+1 optimization)

spring:
  jpa:
    properties:
      hibernate:
        default_batch_fetch_size: 20 # Загружать батчами по 20

@Entity
public class User {
    @Id
    private Long id;
    private String name;
    
    @OneToMany(mappedBy = "user", fetch = FetchType.LAZY)
    @BatchSize(size = 20) // Загружать по 20 заказов за раз
    private List<Order> orders;
}

// Теперь:
List<User> users = userRepository.findAll(); // 1 запрос
users.forEach(u -> System.out.println(u.getOrders().size()));
// Вместо N+1, будет 1 + ceil(N/20) запросов

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

Best Practice Рекомендация

// 1. Используй FETCH JOIN как основной подход
@Query("SELECT DISTINCT u FROM User u LEFT JOIN FETCH u.orders")
List<User> findAllWithOrders();

// 2. Для сложных случаев — DTO проекция
Optional<UserDTO> findDtoById(Long id);

// 3. EntityGraph для переиспользуемых случаев
@EntityGraph(attributePaths = {"orders"})
Optional<User> findById(Long id);

// 4. Избегай полагаться на @Transactional для инициализации Lazy полей
// 5. Никогда не используй OpenSessionInView в production
// 6. Профилируй N+1 queries через Hibernate логирование

Профилирование

logging:
  level:
    org.hibernate.SQL: DEBUG
    org.hibernate.type.descriptor.sql.BasicBinder: TRACE
spring:
  jpa:
    properties:
      hibernate:
        show_sql: false
        format_sql: true
        use_sql_comments: true
        generate_statistics: true

Посмотреть статистику:

SessionFactory sessionFactory = entityManagerFactory.unwrap(SessionFactory.class);
SessionFactoryImpl impl = (SessionFactoryImpl) sessionFactory;
Statistics stats = impl.getStatistics();
stats.logSummary();

Правильное использование Lazy loading требует понимания того, когда и как Hibernate загружает данные. FETCH JOIN и DTO проекция — самые надёжные подходы.