Сталкивался ли в Hibernate с FetchType Lazy

FetchType.LAZY в Hibernate - проблемы и решения

FetchType.LAZY - это оптимизация для загрузки связанных данных по требованию, а не все сразу. Это очень полезно, но требует осторожности.

Основная идея

@Entity
public class User {
  @Id
  private Long id;
  
  private String name;
  
  // Безопасно - EAGER по умолчанию для OneToOne
  @OneToOne(fetch = FetchType.EAGER)
  private Profile profile;
  
  // Опасно - LAZY по умолчанию для OneToMany
  @OneToMany(fetch = FetchType.LAZY, mappedBy = "user")
  private List<Order> orders;  // Загружается только при доступе
}

@Service
public class UserService {
  
  @Autowired
  private UserRepository userRepository;
  
  @Transactional
  public void demonstrateLazy() {
    // 1. SELECT user (orders ещё не загружены)
    User user = userRepository.findById(1L).orElse(null);
    
    // 2. user.getOrders() - если LAZY, здесь генерируется SELECT
    List<Order> orders = user.getOrders();
    
    // Проблема: если выход из @Transactional, сессия закроется
    // и доступ к orders вызовет LazyInitializationException
  }
}

Проблема 1: LazyInitializationException

Механизм Lazy работает только внутри активной сессии Hibernate.

@Service
public class LazyProblemService {
  
  @Autowired
  private UserRepository userRepository;
  
  // ❌ ПРОБЛЕМА - LazyInitializationException
  public User getUserWithOrders(Long id) {
    User user = null;
    
    // Сессия 1 - загружаем пользователя
    user = userRepository.findById(id).orElse(null);
    
    // Сессия 1 заканчивается (конец @Transactional блока если есть)
    
    // Пытаемся доступить к lazy коллекции без сессии
    // ERROR: org.hibernate.LazyInitializationException:
    // could not initialize proxy - no Session
    Integer orderCount = user.getOrders().size();
    
    return user;
  }
  
  // ✅ РЕШЕНИЕ 1: @Transactional
  @Transactional
  public User getUserWithOrdersFixed(Long id) {
    // Сессия открыта на весь метод
    User user = userRepository.findById(id).orElse(null);
    
    // Обращение к lazy коллекции работает (сессия еще активна)
    Integer orderCount = user.getOrders().size();
    
    return user;
  }
}

Решение 1: Явная инициализация (Eager fetch)

@Service
public class EagerFetchService {
  
  @Autowired
  private UserRepository userRepository;
  
  @Transactional
  public User getUserWithOrders(Long id) {
    // JPQL с FETCH JOIN - загружает одновременно
    User user = userRepository.findByIdWithOrders(id);
    return user;
  }
}

// Repository
public interface UserRepository extends JpaRepository<User, Long> {
  
  @Query("SELECT u FROM User u LEFT JOIN FETCH u.orders WHERE u.id = :id")
  User findByIdWithOrders(@Param("id") Long id);
  
  // Или несколько associations
  @Query("SELECT u FROM User u " +
         "LEFT JOIN FETCH u.orders " +
         "LEFT JOIN FETCH u.profile " +
         "WHERE u.id = :id")
  User findByIdWithAllData(@Param("id") Long id);
}

Решение 2: Hibernate.initialize()

@Service
public class InitializeService {
  
  @Autowired
  private UserRepository userRepository;
  
  @Transactional
  public User getUserWithOrders(Long id) {
    User user = userRepository.findById(id).orElse(null);
    
    // Явно инициализировать lazy коллекцию
    Hibernate.initialize(user.getOrders());
    
    return user;  // Теперь безопасно использовать orders
  }
  
  @Transactional
  public List<User> getUsersWithAllOrders(List<Long> ids) {
    List<User> users = userRepository.findAllById(ids);
    
    // Инициализировать все коллекции
    for (User user : users) {
      Hibernate.initialize(user.getOrders());
    }
    
    return users;
  }
}

Решение 3: EntityGraph

public interface UserRepository extends JpaRepository<User, Long> {
  
  // Определить граф загружаемых данных
  @EntityGraph(attributePaths = {"orders", "profile"})
  @Query("SELECT u FROM User u WHERE u.id = :id")
  User findByIdWithGraph(@Param("id") Long id);
  
  // Или используя @NamedEntityGraph
  @NamedEntityGraph(
    name = "User.withOrders",
    attributeNodes = {"orders", "profile"}
  )
}

// Использование
@Service
public class EntityGraphService {
  
  @Autowired
  private UserRepository userRepository;
  
  public User getUser(Long id) {
    // EntityGraph управляет что загружать
    return userRepository.findByIdWithGraph(id);
  }
}

Проблема 2: N+1 Query

Загрузка LAZY коллекции в цикле создает множество запросов.

// ❌ ПРОБЛЕМА - N+1
@Service
public class NPlus1Service {
  
  @Autowired
  private UserRepository userRepository;
  
  @Transactional
  public List<Integer> getUserOrderCounts() {
    // 1 query - SELECT всех пользователей
    List<User> users = userRepository.findAll();
    
    List<Integer> counts = new ArrayList<>();
    for (User user : users) {
      // N queries - для каждого пользователя SELECT orders
      // Итого: 1 + N запросов
      counts.add(user.getOrders().size());
    }
    
    return counts;
  }
  
  // ✅ РЕШЕНИЕ - FETCH JOIN
  @Transactional
  public List<Integer> getUserOrderCountsFixed() {
    List<User> users = userRepository.findAllWithOrders();
    
    // Все orders уже загружены
    return users.stream()
      .map(u -> u.getOrders().size())
      .collect(Collectors.toList());
  }
}

public interface UserRepository extends JpaRepository<User, Long> {
  
  @Query("SELECT DISTINCT u FROM User u LEFT JOIN FETCH u.orders")
  List<User> findAllWithOrders();
}

Проблема 3: Open Session In View

Шаблон OSIV - спорный подход.

// application.properties
spring.jpa.open-in-view=true  // По умолчанию true в Spring Boot

// Это позволяет использовать LAZY в view слое
@RestController
public class UserController {
  
  @Autowired
  private UserService userService;
  
  @GetMapping("/users/{id}")
  public UserDTO getUser(@PathVariable Long id) {
    User user = userService.getUser(id);
    
    // OSIV позволяет доступить к lazy коллекции
    List<OrderDTO> orders = user.getOrders().stream()
      .map(this::convertToDTO)
      .collect(Collectors.toList());
    
    return new UserDTO(user, orders);
  }
}

Минусы OSIV:

• Сессия остается открытой дольше (slow queries)
• Может привести к UnintendedAffectedException
• Плохо для производительности

Лучший подход: Отключить OSIV и явно загружать в сервисе.

# application.properties
spring.jpa.open-in-view=false  # Отключить

Проблема 4: LazyCollection в Multi-threading

// ❌ ПРОБЛЕМА
@Service
public class AsyncService {
  
  @Transactional
  public CompletableFuture<List<Order>> getOrdersAsync(Long userId) {
    User user = userRepository.findById(userId).orElse(null);
    
    return CompletableFuture.supplyAsync(() -> {
      // ERROR: LazyInitializationException
      // Сессия была в главном потоке, а здесь другой поток
      return user.getOrders();
    });
  }
  
  // ✅ РЕШЕНИЕ
  @Transactional
  public CompletableFuture<List<Order>> getOrdersAsyncFixed(Long userId) {
    User user = userRepository.findById(userId).orElse(null);
    
    // Инициализировать ДО выхода из @Transactional
    List<Order> orders = new ArrayList<>(user.getOrders());
    
    return CompletableFuture.supplyAsync(() -> orders);
  }
}

Best Practices для FetchType.LAZY

1. Используй @Transactional правильно

@Service
public class ProperLazyService {
  
  // ✅ Правильно - вся логика в @Transactional
  @Transactional
  public UserDTO getUserData(Long id) {
    User user = userRepository.findById(id).orElse(null);
    
    // Все lazy загрузки здесь
    List<Order> orders = user.getOrders();
    
    // Преобразовать в DTO
    return new UserDTO(user, orders);
  }
}

2. Используй FETCH JOIN для коллекций

public interface UserRepository extends JpaRepository<User, Long> {
  
  // Явно загрузить связанные данные
  @Query("SELECT DISTINCT u FROM User u " +
         "LEFT JOIN FETCH u.orders o " +
         "LEFT JOIN FETCH u.profile p")
  List<User> findAllWithRelations();
}

3. Преобразуй в DTO рано

@Service
public class DTOService {
  
  @Transactional
  public List<UserDTO> getUsers() {
    List<User> users = userRepository.findAllWithRelations();
    
    // Преобразовать в DTO ДО выхода из @Transactional
    return users.stream()
      .map(this::toDTO)
      .collect(Collectors.toList());
  }
  
  private UserDTO toDTO(User user) {
    return new UserDTO(
      user.getId(),
      user.getName(),
      user.getOrders().stream()
        .map(o -> new OrderDTO(o.getId(), o.getAmount()))
        .collect(Collectors.toList())
    );
  }
}

4. Профилируй запросы

# application.properties
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.use_sql_comments=true
logging.level.org.hibernate.SQL=DEBUG
logging.level.org.hibernate.type.descriptor.sql.BasicBinder=TRACE

5. Кэшируй если часто используется

@Entity
@Cacheable
public class User {
  @OneToMany(fetch = FetchType.LAZY)
  @Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
  private List<Order> orders;
}

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

Итоговый паттерн

// Entity
@Entity
public class User {
  @Id
  private Long id;
  
  // LAZY по умолчанию - хорошо
  @OneToMany(fetch = FetchType.LAZY, mappedBy = "user")
  private List<Order> orders;
}

// Repository
public interface UserRepository extends JpaRepository<User, Long> {
  
  // Явно указать что загружать
  @Query("SELECT u FROM User u LEFT JOIN FETCH u.orders WHERE u.id = :id")
  User findByIdWithOrders(@Param("id") Long id);
}

// Service
@Service
public class UserService {
  
  @Transactional  // Сессия активна
  public UserDTO getUser(Long id) {
    // Загрузить с нужными данными
    User user = userRepository.findByIdWithOrders(id);
    
    // Преобразовать в DTO (все данные загружены)
    return convertToDTO(user);
  }
}

FetchType.LAZY - это мощный инструмент оптимизации, но требует понимания как Hibernate работает. Правило: явно указывай что загружать, и обработка будет правильной!