Обзор

При сериализации bidirectional связей (например, в JSON для REST API) возникает бесконечная рекурсия, ведущая к StackOverflowError. Существует несколько подходов к решению этой проблемы.

---

🟢 Junior Level

Проблема

При сериализации bidirectional связей возникает бесконечная рекурсия:

@Entity
public class Order {
    @ManyToOne
    private User user;
}

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

// JSON сериализация:
// Order → User → Orders → User → Orders → ... → StackOverflowError

Решения

1. @JsonIgnore — игнорировать поле
2. @JsonManagedReference / @JsonBackReference — разорвать цикл
3. DTO projection — использовать DTO вместо entity

Это Jackson-специфичные аннотации (не JPA!). Работают только при сериализации через Jackson в Spring Boot REST-контроллерах.

// Решение 1: @JsonIgnore
@Entity
public class User {
    @OneToMany(mappedBy = "user")
    @JsonIgnore  // не сериализовать
    private List<Order> orders;
}

// Решение 2: Managed/BackReference
@Entity
public class Order {
    @ManyToOne
    @JsonBackReference  // не сериализовать
    private User user;
}

@Entity
public class User {
    @OneToMany(mappedBy = "user")
    @JsonManagedReference  // сериализовать
    private List<Order> orders;
}

---

🟡 Middle Level

Детальные решения

@JsonIgnore

@Entity
public class User {
    @OneToMany(mappedBy = "user")
    @JsonIgnore  // полностью игнорировать при сериализации
    private List<Order> orders;
}

// GET /users/1
// { "id": 1, "name": "John" }  // без orders

@JsonManagedReference / @JsonBackReference

@Entity
public class User {
    @OneToMany(mappedBy = "user")
    @JsonManagedReference  // сериализовать эту сторону
    private List<Order> orders;
}

@Entity
public class Order {
    @ManyToOne
    @JsonBackReference  // НЕ сериализовать эту сторону
    private User user;
}

// GET /users/1
// { "id": 1, "name": "John", "orders": [
//     { "id": 1, "status": "new" },  // user не включён
//     { "id": 2, "status": "shipped" }
// ]}

DTO (лучшее решение)

// DTO — полный контроль над сериализацией
public record OrderDto(
    Long id,
    String status,
    String userName,
    LocalDateTime createdAt
) {}

// Маппинг
@Query("""
    SELECT new com.example.OrderDto(
        o.id, o.status, u.name, o.createdAt
    )
    FROM Order o JOIN o.user u
    WHERE o.id = :id
    """)
OrderDto findOrderDto(@Param("id") Long id);

// GET /orders/1
// { "id": 1, "status": "new", "userName": "John", "createdAt": "..." }

Типичные ошибки

// ❌ Сериализация entity напрямую
@RestController
public class OrderController {
    @GetMapping("/orders/{id}")
    public Order getOrder(@PathVariable Long id) {
        return service.getOrder(id);  // ❌ StackOverflowError
    }
}

// ✅ DTO вместо entity
@GetMapping("/orders/{id}")
public OrderDto getOrder(@PathVariable Long id) {
    return service.getOrderDto(id);  // ✅
}

---

🔴 Senior Level

@JsonIdentityInfo

@Entity
@JsonIdentityInfo(
    generator = ObjectIdGenerators.PropertyGenerator.class,
    property = "id"
)
public class User {
    @OneToMany(mappedBy = "user")
    private List<Order> orders;
}

// JSON: User с ID, Orders ссылаются на User ID
// {
//     "id": 1,
//     "name": "John",
//     "orders": [
//         { "id": 1, "status": "new", "user": 1 },
//         { "id": 2, "status": "shipped", "user": 1 }
//     ]
// }
// Механизм: первое появление объекта сериализуется полностью (с "@id": 1).
// Последующие ссылки — только ID: {"@id": 1}. Это предотвращает бесконечный цикл.

Архитектурный подход

Правило: Никогда не сериализуйте JPA entities напрямую.

Почему:
1. Бесконечная рекурсия
2. Загрузка lazy полей вне транзакции
3. Раскрытие внутренней структуры БД
4. Невозможность контроля контракта API
5. Проблемы с производительностью

**LazyInitializationException при сериализации:** когда REST-контроллер возвращает entity,
сериализатор Jackson пытается обратиться к LAZY-полю вне транзакции → exception.
Это одна из самых частых проблем в production.

Решение: DTO pattern

DTO маппинг

// Pattern 1: Record constructor в JPQL
@Query("""
    SELECT new com.example.UserDto(
        u.id, u.name, u.email,
        (SELECT COUNT(o) FROM Order o WHERE o.user.id = u.id)
    )
    FROM User u
    """)
List<UserDto> findAllUsers();

// Pattern 2: MapStruct
@Mapper(componentModel = "spring")
public interface OrderMapper {
    @Mapping(source = "user.name", target = "userName")
    @Mapping(source = "items", target = "items")
    OrderDto toDto(Order order);
}

// Pattern 3: Метод в entity
@Entity
public class Order {
    public OrderDto toDto() {
        return new OrderDto(id, status, user.getName(), createdAt);
    }
}

Best Practices

✅ DTO projection (лучшее решение)
✅ @JsonManagedReference/BackReference (быстрое решение)
✅ @JsonIgnore для одной стороны
✅ @JsonIdentityInfo для циклических ссылок
✅ Никогда не сериализовать entities напрямую

❌ Без аннотаций (StackOverflowError)
❌ EAGER + сериализация
❌ Прямой возврат entity из REST controller
❌ Игнорирование lazy loading при сериализации

---

🎯 Шпаргалка для интервью

Обязательно знать:

• Bidirectional связи → бесконечная рекурсия при JSON сериализации → StackOverflowError
• 4 решения: @JsonIgnore, @JsonManagedReference/@JsonBackReference, @JsonIdentityInfo, DTO projection
• DTO projection — лучшее решение: полный контроль над API, нет lazy проблем, contract isolation
• @JsonManagedReference сериализует parent → child, @JsonBackReference пропускает child → parent
• Никогда не возвращать entities из REST controller напрямую
• LazyInitializationException при сериализации — Jackson обращается к LAZY вне транзакции

Частые уточняющие вопросы:

• Почему DTO лучше аннотаций? Изоляция контракта API, нет lazy проблем, контроль полей, производительность
• @JsonIdentityInfo как работает? Первое появление — полный объект с “@id”, последующие — только ID
• Что такое LazyInitializationException при сериализации? Jackson пытается прочитать LAZY поле вне @Transactional
• MapStruct зачем? Автоматический маппинг entity → DTO, меньше boilerplate кода

Красные флаги (НЕ говорить):

• «Возвращаю entity из REST controller» — StackOverflowError + LazyInitializationException
• «EAGER чтобы избежать проблем с сериализацией» — создаёт N+1, не решает корень
• «Без аннотаций — надеюсь на лучшее» — StackOverflowError гарантирован
• «Сериализую entity напрямую для простоты» — technical debt, раскрывает структуру БД

Связанные темы:

• [[24. В чём особенности bidirectional relationships]]
• [[29. Что такое projection в JPA]]
• [[4. Что такое LazyInitializationException и как её избежать]]
• [[23. Как правильно использовать @OneToMany и @ManyToOne]]