Обзор

@OneToMany и @ManyToOne — самые распространённые аннотации для связей в JPA. Правильное их использование критически важно для производительности и корректности работы с базой данных.

---

🟢 Junior Level

Что такое @ManyToOne и @OneToMany

@ManyToOne — много заказов к одному пользователю.

@OneToMany — один пользователь к многим заказам.

@Entity
public class Order {
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "user_id")
    private User user;
}

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

Важные правила

1. mappedBy — указывает, что связь управляется на другой стороне
2. @JoinColumn — указывает колонку с foreign key
3. LAZY — используйте для обеих сторон

Пример

// Order — owner side (содержит FK)
@Entity
public class Order {
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "user_id")
    private User user;
}

// User — inverse side (не содержит FK)
@Entity
public class User {
    @OneToMany(mappedBy = "user", fetch = FetchType.LAZY)
    private List<Order> orders = new ArrayList<>();
}

---

🟡 Middle Level

Bidirectional связь

// Owner side — Order (содержит FK column)
@Entity
public class Order {
    @Id
    private Long id;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "user_id")
    private User user;
}

// Inverse side — User
@Entity
public class User {
    @Id
    private Long id;

    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<Order> orders = new ArrayList<>();

    // Helper method — обязательно!
    public void addOrder(Order order) {
        orders.add(order);
        order.setUser(this);  // важно!
    }

    public void removeOrder(Order order) {
        orders.remove(order);
        order.setUser(null);  // важно!
    }
}

Почему helper methods обязательны

// ❌ Без helper method
User user = new User();
Order order = new Order();
user.getOrders().add(order);
// order.getUser() = null! → FK не установится

// ✅ С helper method
User user = new User();
Order order = new Order();
user.addOrder(order);  // установит обе стороны
// order.getUser() == user ✅

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

// ✅ mappedBy на inverse side (User — inverse, Order — owner):
@OneToMany(mappedBy = "user")  // ✅ правильно: User — inverse side
private List<Order> orders;

// ❌ mappedBy на owner side (Order) — БЕСПОЛЕЗНО:
// @ManyToOne(mappedBy = ...) — такого атрибута нет у @ManyToOne

// ❌ Без инициализации коллекции
private List<Order> orders;  // ❌ NullPointerException при add
private List<Order> orders = new ArrayList<>();  // ✅

// ❌ EAGER для коллекции
@OneToMany(fetch = FetchType.EAGER)  // ❌ N+1 проблема
private List<Order> orders;

// Что происходит в SQL при EAGER на коллекции:
// SELECT * FROM users;                    -- 1 запрос
// SELECT * FROM orders WHERE user_id = 1; -- N запросов (по одному на пользователя)
// -- Итого: 1 + N запросов вместо 1 JOIN

---

🔴 Senior Level

Внутренняя реализация

@ManyToOne — FK column в таблице Order
@OneToMany(mappedBy) — нет FK column, это inverse side

Owner side (@ManyToOne):
- Управляет FK column
- persist(order) → INSERT с user_id
- merge(order) → UPDATE user_id

Inverse side (@OneToMany(mappedBy)):
- Не управляет FK
- mappedBy = имя поля на owner side
- Только для навигации в обратном направлении

Unidirectional vs Bidirectional

// Unidirectional @ManyToOne (только Order → User)
@Entity
public class Order {
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "user_id")
    private User user;
}

// Unidirectional @OneToMany (только User → Orders)
@Entity
public class User {
    @OneToMany
    @JoinColumn(name = "user_id")  // FK на стороне Order
    private List<Order> orders;
}

// Bidirectional — оба направления
// Order знает о User, User знает о Orders
// Требуется синхронизация обеих сторон

Когда что использовать

Unidirectional @ManyToOne:
- ✅ Проще, нет синхронизации
- ✅ Когда не нужна навигация User → Orders
- ✅ Меньше кода

Bidirectional:
- ✅ Когда нужна навигация в обе стороны
- ✅ Когда нужно cascade с orphanRemoval
- ❌ Требует helper methods

Оптимизация

// @JoinColumn на unidirectional @OneToMany (Hibernate 6+)
@Entity
public class User {
    @OneToMany
    @JoinColumn(name = "user_id",
                foreignKey = @ForeignKey(name = "fk_user_orders"),
                referencedColumnName = "id")
    private List<Order> orders;
}
// Hibernate 6+: не создаётся join table

Best Practices

✅ LAZY для обеих сторон
✅ Helper methods для синхронизации
✅ mappedBy на inverse side
✅ Инициализировать коллекции
✅ @JoinColumn на owner side
✅ orphanRemoval для composite children

❌ EAGER для коллекций
❌ Без helper methods
❌ mappedBy на owner side
❌ Без инициализации коллекции
❌ Unidirectional @OneToMany с join table

---

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

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

• @ManyToOne — owner side (содержит FK), @OneToMany(mappedBy) — inverse side (нет FK)
• LAZY для обеих сторон — золотое правило
• Helper methods обязательны для bidirectional: addOrder/removeOrder синхронизируют обе стороны
• mappedBy указывает на поле owner side — без этого Hibernate создаст join table
• Коллекции всегда инициализировать: new ArrayList<>() — иначе NullPointerException
• Unidirectional @OneToMany создаёт join table (до Hibernate 6), в Hibernate 6+ можно @JoinColumn

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

• Почему helper methods обязательны? Добавление только в collection без setUser() → FK = null, рассинхронизация
• Что если без mappedBy? Hibernate создаёт лишнюю join table — дополнительный overhead
• EAGER для коллекции почему плохо? N+1 проблема: загрузка всех child для каждого parent
• Unidirectional @OneToMany когда использовать? Когда не нужна навигация User → Orders, проще

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

• «EAGER для @OneToMany» — N+1 проблема гарантирована
• «Без helper methods для bidirectional» — рассинхронизация, FK не установится
• «mappedBy на owner side» — такого атрибута нет у @ManyToOne
• «Коллекция без инициализации» — NullPointerException при add

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

• [[24. В чём особенности bidirectional relationships]]
• [[22. Что такое orphan removal]]
• [[2. В чём разница между Lazy и Eager загрузкой]]
• [[1. Что такое проблема N+1 и как её решить]]