Что такое one-to-many?

One-to-Many в базах данных и ORM

One-to-Many (один-ко-многим) — это тип связи между сущностями в базе данных, где один объект может быть связан с несколькими объектами другого типа, а каждый из этих объектов связан только с одним первым объектом.

Концепция

Отношение один-ко-многим — одно из самых распространённых типов связей в реляционных базах данных. Например:

• Один автор может написать много книг
• Один заказ может содержать много товаров
• Один пользователь может оставить много комментариев
• Один отдел может иметь много сотрудников

Реализация в базе данных

В реляционной БД one-to-many реализуется через внешний ключ (Foreign Key):

// Таблица Author
CREATE TABLE author (
    id INT PRIMARY KEY,
    name VARCHAR(100)
);

// Таблица Book
CREATE TABLE book (
    id INT PRIMARY KEY,
    title VARCHAR(100),
    author_id INT,
    FOREIGN KEY (author_id) REFERENCES author(id)
);

Внешний ключ author_id в таблице book указывает на первичный ключ в таблице author. Так как много книг могут иметь одного и того же автора, получается отношение один-ко-многим.

Реализация в Java с JPA/Hibernate

// Класс Author (сторона "один")
@Entity
@Table(name = "author")
public class Author {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    
    // Сторона "много"
    @OneToMany(mappedBy = "author", cascade = CascadeType.ALL)
    private List<Book> books = new ArrayList<>();
    
    // Getters и setters
    public void addBook(Book book) {
        books.add(book);
        book.setAuthor(this);
    }
}

// Класс Book (сторона "многие")
@Entity
@Table(name = "book")
public class Book {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String title;
    
    // Сторона "один"
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "author_id", nullable = false)
    private Author author;
    
    // Getters и setters
}

Параметры аннотации @OneToMany

mappedBy — указывает на поле в другом классе, которое владеет отношением:

@OneToMany(mappedBy = "author")
private List<Book> books;
// "author" — это имя поля в класса Book

cascade — определяет, какие операции каскадировать:

@OneToMany(cascade = CascadeType.ALL)
// CascadeType.ALL: все операции (PERSIST, MERGE, REMOVE и т.д.)
// CascadeType.PERSIST: только сохранение
// CascadeType.REMOVE: только удаление

fetch — стратегия загрузки:

@OneToMany(fetch = FetchType.LAZY)  // Ленивая загрузка (по требованию)
@OneToMany(fetch = FetchType.EAGER) // Загрузка сразу

Практический пример

// Создание и сохранение
Author author = new Author();
author.setName("Лев Толстой");

Book book1 = new Book();
book1.setTitle("Война и мир");
author.addBook(book1);

Book book2 = new Book();
book2.setTitle("Анна Каренина");
author.addBook(book2);

// authorRepository.save(author); // Сохраняет и все книги

// Получение
Author savedAuthor = authorRepository.findById(1L).orElse(null);
List<Book> authorBooks = savedAuthor.getBooks(); // Список всех книг автора

Важные моменты

Обратная ссылка: Используй mappedBy на стороне "один", это предотвращает создание дополнительной таблицы связи.

N+1 проблема: Неправильное использование fetch = FetchType.EAGER приводит к N+1 запросам:

// Плохо: загружает автора, затем для каждого запрашивает книги
List<Author> authors = authorRepository.findAll();
for (Author author : authors) {
    System.out.println(author.getBooks()); // N дополнительных запросов
}

// Хорошо: явно загружаем с книгами
List<Author> authors = authorRepository.findAllWithBooks();

Двусторонние отношения: Всегда обновляй обе стороны при добавлении объекта:

author.addBook(book); // Это добавляет книгу И устанавливает автора
// Не делай: author.getBooks().add(book); без установки author в book

One-to-Many — фундаментальный паттерн в проектировании БД, часто встречающийся на собеседованиях.