단방향 @OneToMany의 문제점

개요

JPA를 학습하다 보면 @OneToMany를 사용할 때 단방향보다는 양방향 매핑을 사용하라는 말을 자주 듣게 된다.

왜 그런지 이해하기 위해 단방향 @OneToMany를 사용하는 두 가지 방법을 사용하여 문제점에 대해 살펴보고, 양방향을 사용했을 때 어떤 점이 개선되는지 알아보자

1. 매핑 테이블을 사용한 단방향 @OneToMany 동작 과정
2. @JoinColumn 사용한 단방향 @OneToMany  동작 과정
3. 양방향 @OneToMany를 사용했을 때의 동작 과정

 

1. 매핑 테이블 사용

매핑 테이블을 이용한 @OneToMany 엔티티 설계 예시는 다음과 같다.

@Entity
@NoArgsConstructor(access = lombok.AccessLevel.PROTECTED)
public class Book {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String title;
    private String isbn;
}

@Entity
@NoArgsConstructor(access = lombok.AccessLevel.PROTECTED)
public class Author {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private int age;

    @OneToMany(cascade = CascadeType.ALL, orphanRemoval = true)
    private List<Book> books = new ArrayList<>();
    
    public void addBook(Book book) {
        books.add(book);
    }
    
    public void removeBook(Book book) {
        books.remove(book);
    } 
}

그리고 테이블의 관계는 다음과 같이 정의될 것이다.

@OneToMany 테이블 관계

이 경우 연결 테이블(author_books)에는 두 개의 외래키(author_id, books_id)가 있다. 때문에 인덱싱 시 book 테이블에서 author의 id를 직접 참조하는 경우보다 더 많은 메모리를 사용한다. 또한 book, author_books, author 간의 3개의 조인이 필요하여 쿼리 작업에도 영향을 미친다.

이제 INSERT와 DELETE시 어떠한 과정이 일어나는지 살펴보자

1. 새로운 작가 데이터 등록

새로운 작가와 그 작가의 책을 등록하는 예시이다.

@Transactional
public void insertAuthorWithBooks() {
    Author author = new Author("JK 롤링", 42);

    Book book1 = new Book("해리포터와 마법사의 돌", "978-89-12345-00-1");
    Book book2 = new Book("해리포터와 비밀의 방", "978-89-12345-00-2");

    author.addBook(book1);
    author.addBook(book2);

    authorRepository.save(author);
}

위 메서드를 실행하면 다음과 같은 SQL 쿼리가 발생한다.

Hibernate: 
    insert into author (age, name) 
    values (?, ?) 
    returning id

Hibernate: 
    insert into book (isbn, title) 
    values (?, ?) 
    returning id

Hibernate: 
    insert into book (isbn, title) 
    values (?, ?) 
    returning id

-- 아래는 양방향 @OneToMany에서는 날라가지 않는 추가 insert 쿼리들
Hibernate: 
    insert into author_books (author_id, books_id) 
    values (?, ?)

Hibernate: 
    insert into author_books (author_id, books_id) 
    values (?, ?)

 

2. 기존 저자의 새로운 도서 등록

위에서 등록한 작가의 새로운 도서 데이터를 추가해 보자.

@Transactional
public void insertNewBook() {
    Author author = authorRepository.findByName("JK 롤링");
 
    Book newBook = new Book("해리포터와 아즈카반의 죄수", "978-89-12345-00-3");
    author.addBook(newBook);
    
    authorRepository.save(author);
}

위 메서드를 수행하면 다음과 같은 쿼리가 날라간다.

Hibernate: 
    select a1_0.id, a1_0.age, a1_0.name 
    from author a1_0 
    where a1_0.name=?

Hibernate: 
    select b1_0.author_id, b1_1.id, b1_1.isbn, b1_1.title 
    from author_books b1_0 
    join book b1_1 
    on b1_1.id=b1_0.books_id 
    where b1_0.author_id=?

Hibernate: 
    insert into book (isbn, title) 
    values (?, ?) 
    returning id

-- 아래 DML문들은 양방향 @OneToMany에서는 나타나지 않는다.
Hibernate: 
    delete from author_books 
    where author_id=?

Hibernate: 
    insert into author_books (author_id, books_id) 
    values (?, ?)

Hibernate: 
    insert into author_books (author_id, books_id) 
    values (?, ?)

Hibernate: 
    insert into author_books (author_id, books_id) 
    values (?, ?)

잘 보면 author_books에 delete쿼리 한 개가 날라가고, 한 개의 저서를 등록했음에도 불구하고 3개의 insert쿼리가 날라가는 것을 확인할 수 있다. 그 이유는 새 도서를 추가하고자 JPA는 연결 테이블에서 모든 연관 도서를 삭제한 후 메모리에 새 도서를 추가하고 결과를 다시 등록하기 때문이다.

 

3. 마지막 도서 삭제

다음은 저자와 연관된 도서 리스트에서 마지막 도서를 삭제하는 예시이다. 마지막 도서 삭제는 다음과 같이 저자와 연관된 List<Book>을 가져오고 이 리스트에서 마지막 도서를 삭제한다.

@Transactional
public void deleteLastBook() {
    Author author = authorRepository.findByName("JK 롤링");

    List<Book> books = author.getBooks();
    Book lastBook = books.get(books.size() - 1);

    author.removeBook(lastBook);
}

Hibernate: 
    select a1_0.id, a1_0.age, a1_0.name 
    from author a1_0 
    where a1_0.name=?

Hibernate: 
    select b1_0.author_id, b1_1.id, b1_1.isbn, b1_1.title 
    from author_books b1_0 
    join book b1_1 
    on b1_1.id=b1_0.books_id 
    where b1_0.author_id=?

Hibernate: 
    delete from author_books 
    where author_id=?

Hibernate: 
    insert into author_books (author_id, books_id) 
    values (?, ?)

Hibernate: 
    insert into author_books (author_id, books_id) 
    values (?, ?)

-- 양방향 @OneToMany에서 유일하게 필요한 DML
Hibernate: 
    delete from book 
    where id=?

마지막 도서를 삭제하고자 JPA는 연결 테이블(author_books)에서 모든 연관 도서를 삭제하고, 메모리에서 마지막 도서를 제거한 후 나머지 도서를 다시 삽입한다. 따라서 양방향 @OneToMany 연관관계와 비교했을 때 불필요한 DML문이 추가로 발생하게 되어 성능 저하를 초래할 수 있고, 특히 연관된 도서가 많을수록 위험성이 더욱 커진다.

 

4. 첫 번째 도서 삭제

다음은 저자와 연관된 도서 리스트에서 첫 번째 도서를 삭제하는 예시이다. 

@Transactional
public void deleteFirstBook() {
    Author author = authorRepository.findByName("JK 롤링");

    List<Book> books = author.getBooks();
    Book firstBook = books.get(0);

    author.removeBook(firstBook);
}

Hibernate: 
    select a1_0.id, a1_0.age, a1_0.name 
    from author a1_0 
    where a1_0.name=?

Hibernate: 
    select b1_0.author_id, b1_1.id, b1_1.isbn, b1_1.title 
    from author_books b1_0 
    join book b1_1 
    on b1_1.id=b1_0.books_id 
    where b1_0.author_id=?

Hibernate: 
    delete from author_books 
    where author_id=?

Hibernate: 
    insert into author_books (author_id, books_id) 
    values (?, ?)

Hibernate: 
    insert into author_books (author_id, books_id) 
    values (?, ?)

-- 양방향 @OneToMany에서 유일하게 필요한 DML
Hibernate: 
    delete from book 
    where id=?

첫 번째 도서를 삭제하는 작업도 마지막 도서를 삭제하는 것과 동일한 과정을 거치는 것을 확인할 수 있다. 

전체적으로 정리하면, 매핑 테이블을 사용한 단방향 @OneToMany 관계는 아래의 문제가 발생할 가능성이 존재한다.

• 추가 SQL 문의 동적 개수로 인한 성능 저하
• 연결 테이블의 외래키 컬럼과 관련된 인덱스 항목의 삭제 및 재추가로 인한 성능 저하 문제

대부분의 데이터베이스는 외래키에 인덱스를 사용하기 때문에, 데이터베이스가 연결 테이블에서 부모 엔티티와 연관된 모든 테이블 행을 삭제할 때 해당 인덱스 항목도 삭제되고, 연결 테이블에 다시 추가될 때 인덱스 항목이 추가된다.

 

2. @JoinColumn 사용

이제 @JoinColumn을 사용한 단방향 @OneToMany 관계에 대해 살펴보자.

@Entity
@NoArgsConstructor(access = lombok.AccessLevel.PROTECTED)
public class Book {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "author_id")
    private Long authorId; // authorId 추가

    private String title;
    private String isbn;
}

@Entity
@NoArgsConstructor(access = lombok.AccessLevel.PROTECTED)
public class Author {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private int age;

    @OneToMany(cascade = CascadeType.ALL, orphanRemoval = true)
    @JoinColumn(name = "author_id") // @JoinColumn 사용
    private List<Book> books = new ArrayList<>();
    
    public void addBook(Book book) {
        books.add(book);
    }
    
    public void removeBook(Book book) {
        books.remove(book);
    } 
}

@JoinColumn을 지정하면 @OneToMany 연관관계에서 자식 테이블의 외래키를 제어할 수 있음을 Hibernate에 지시할 수 있다. 이를 통해 연결 테이블이 없어지고, 테이블 수가 3개에서 2개로 줄어든다.

@JoinColumn을 추가하면 연결 테이블이 제거됨

이제 동일한 메서드들의 동작을 확인해 보자. 실행 코드는 이전과 동일하다.

1. 새로운 작가 데이터 등록

@Transactional
public void insertAuthorWithBooks() {
    Author author = new Author("JK 롤링", 42);

    Book book1 = new Book("해리포터와 마법사의 돌", "978-89-12345-00-1");
    Book book2 = new Book("해리포터와 비밀의 방", "978-89-12345-00-2");

    author.addBook(book1);
    author.addBook(book2);

    authorRepository.save(author);
}

Hibernate: 
    insert into author (age, name) 
    values (?, ?) 
    returning id

Hibernate: 
    insert into book (author_id, isbn, title) 
    values (?, ?, ?) 
    returning id

Hibernate: 
    insert into book (author_id, isbn, title) 
    values (?, ?, ?) 
    returning id

-- 양방향 @OneToMany에서는 필요 없는 추가 DML
Hibernate: 
    update book 
    set author_id=? 
    where id=?

Hibernate: 
    update book 
    set author_id=? 
    where id=?

매핑 테이블을 사용했을 때와 달리, @JoinColumn을 사용할 경우 등록되는 각 도서에 대해 Hibernate는 author_id를 설정하기 위해 추가적인 UPDATE 쿼리를 호출한다. 물론 이 부분도 양방향 @OneToMany 관계에서는 실행되지 않는 불필요한 쿼리들이다.

 

2. 기존 저자의 새로운 도서 등록

@Transactional
public void insertNewBook() {
    Author author = authorRepository.findByName("JK 롤링");

    Book newBook = new Book("해리포터와 아즈카반의 죄수", "978-89-12345-00-3");
    author.addBook(newBook);
    
    authorRepository.save(author);
}

Hibernate: 
    select a1_0.id, a1_0.age, a1_0.name 
    from author a1_0 
    where a1_0.name=?

Hibernate: 
    select b1_0.author_id, b1_0.id, b1_0.isbn, b1_0.title 
    from book b1_0 
    where b1_0.author_id=?

Hibernate: 
    insert into book (author_id, isbn, title) 
    values (?, ?, ?) 
    returning id

-- 양방향 @OneToMany에서는 필요 없는 추가 DML
Hibernate: 
    update book 
    set author_id=? 
    where id=?

Hibernate는 새로 등록된 도서에 대해 author_id를 설정하기 위해 추가적인 UPDATE를 호출한다. 일단 기존의 매핑 테이블을 활용한 단방향 @OneToMany 연관관계에 비해 쿼리의 개수가 줄어들어 나쁘지는 않지만, 여전히 @OneToMany 연관관계에서는 필요하지 않은 UPDATE문이 처리된다.

 

3. 마지막 도서 삭제

@Transactional
public void deleteLastBook() {
    Author author = authorRepository.findByName("JK 롤링");

    List<Book> books = author.getBooks();
    Book lastBook = books.get(books.size() - 1);

    author.removeBook(lastBook);
}

Hibernate: 
    select a1_0.id, a1_0.age, a1_0.name 
    from author a1_0 
    where a1_0.name=?

Hibernate: 
    select b1_0.author_id, b1_0.id, b1_0.isbn, b1_0.title 
    from book b1_0 
    where b1_0.author_id=?

Hibernate: 
    update book 
    set author_id=null 
    where author_id=? 
    and id=?

-- 양방향 @OneToMany에서 필요한 유일한 DML
Hibernate: 
    delete from book 
    where id=?

Hibernate는 author_id를 null로 설정해 저자로부터 도서 연관관계를 끊는다. 그런 다음 orphanRemoval = true 덕분에 연관이 해제된 도서가 삭제된다. 이것 또한 매핑 테이블을 활용했을 때보다는 쿼리의 개수가 줄어들지만, 여전히 양방향 @OneToMany를 사용했을 때보다는 비효율적이다.

 

4. 첫 번째 도서 삭제

@Transactional
public void deleteFirstBook() {
    Author author = authorRepository.findByName("JK 롤링");

    List<Book> books = author.getBooks();
    Book firstBook = books.get(0);

    author.removeBook(firstBook);
}

Hibernate: 
    select a1_0.id, a1_0.age, a1_0.name 
    from author a1_0 
    where a1_0.name=?

Hibernate: 
    select b1_0.author_id, b1_0.id, b1_0.isbn, b1_0.title 
    from book b1_0 
    where b1_0.author_id=?

-- 양방향 @OneToMany에서 필요한 유일한 DML
Hibernate: 
    update book 
    set author_id=null 
    where author_id=? 
    and id=?

Hibernate: 
    delete from book 
    where id=?

UPDATE가 여전히 존재한다. 

정리하면, @JoinColumn을 추가하면 매핑 테이블을 활용한 단방향 @OneToMany보다는 이점을 제공할 수 있지만, 여전히 양방향 @OneToMany 연관관계보다는 낫지 않으며, 추가 UPDATE문을 통해 여전히 성능 저하 문제가 존재한다.

 

 

양방향 @OneToMany

이제 양방향 @OneToMany를 사용했을 때 얼마나 효율적인지 살펴보자. 아래는 양방향 @OneToMany 관계를 맺은 예시 코드이다.

@Entity
@NoArgsConstructor(access = lombok.AccessLevel.PROTECTED)
public class Book {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "author_id")
    private Author author;

    private String title;
    private String isbn;
}

@Entity
@NoArgsConstructor(access = lombok.AccessLevel.PROTECTED)
public class Author {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private int age;

    @OneToMany(cascade = CascadeType.ALL, mappedBy = "author", orphanRemoval = true)
    private List<Book> books = new ArrayList<>();
    
    public void addBook(Book book) {
        books.add(book);
        book.setAuthor(this);
    }

    public void removeBook(Book book) {
        books.remove(book);
        book.setAuthor(null);
    }
}

양방향 관계에서는 mappedBy 속성이 중요한 역할을 하는데, 부모 측에 설정되는 mappedBy 속성은 양방향 연관관계의 특성을 부여한다. 다시 말해 양방향 @OneToMany 연관관계에서 부모 측 @OneToMany에 mappedBy가 지정되고, mappedBy에 의해 참조되는 자식 측에 @ManyToOne이 지정된다.

이제 동일한 메서드를 수행했을 때 어떻게 쿼리가 수행되는지 빠르게 살펴보자.

1. 새로운 작가 데이터 등록

@Transactional
public void insertAuthorWithBooks() {
    Author author = new Author("JK 롤링", 42);

    Book book1 = new Book("해리포터와 마법사의 돌", "978-89-12345-00-1");
    Book book2 = new Book("해리포터와 비밀의 방", "978-89-12345-00-2");

    author.addBook(book1);
    author.addBook(book2);

    authorRepository.save(author);
}

Hibernate: 
    insert into author (age, name) 
    values (?, ?) 
    returning id

Hibernate: 
    insert into book (author_id, isbn, title) 
    values (?, ?, ?) 
    returning id

Hibernate: 
    insert into book (author_id, isbn, title) 
    values (?, ?, ?) 
    returning id

 

2. 기존 저자의 새로운 도서 등록

@Transactional
public void insertNewBook() {
    Author author = authorRepository.findByName("JK 롤링");

    Book newBook = new Book("해리포터와 아즈카반의 죄수", "978-89-12345-00-3");
    author.addBook(newBook);

    authorRepository.save(author);
}

Hibernate: 
    select a1_0.id, a1_0.age, a1_0.name 
    from author a1_0 
    where a1_0.name=?

Hibernate: 
    insert into book (author_id, isbn, title) 
    values (?, ?, ?) 
    returning id

 

3. 마지막 도서 삭제

@Transactional
public void deleteLastBook() {
    Author author = authorRepository.findByName("JK 롤링");

    List<Book> books = author.getBooks();
    Book lastBook = books.get(books.size() - 1);

    author.removeBook(lastBook);
}

Hibernate: 
    select a1_0.id, a1_0.age, a1_0.name 
    from author a1_0 
    where a1_0.name=?

Hibernate: 
    select b1_0.author_id, b1_0.id, b1_0.isbn, b1_0.title 
    from book b1_0 
    where b1_0.author_id=?

Hibernate: 
    delete from book 
    where id=?

 

4. 첫 번째 도서 삭제

@Transactional
public void deleteFirstBook() {
    Author author = authorRepository.findByName("JK 롤링");

    List<Book> books = author.getBooks();
    Book firstBook = books.get(0);

    author.removeBook(firstBook);
}

Hibernate: 
    select a1_0.id, a1_0.age, a1_0.name 
    from author a1_0 
    where a1_0.name=?

Hibernate: 
    select b1_0.author_id, b1_0.id, b1_0.isbn, b1_0.title 
    from book b1_0 
    where b1_0.author_id=?

Hibernate: 
    delete from book 
    where id=?

잘 보면 단방향 @OneToMany에서 보였던 불필요한 INSERT나 UPDATE문이 수행되지 않는 것을 확인할 수 있다. 그리고 전체적으로 양방향일 때는 코드를 봤을 때 직관적으로 딱 예상되는 쿼리들만 수행되는 것을 확인할 수 있다.

 

정리

@JoinColumn을 추가한 단방향 @OneToMany 연관관계는 매핑 테이블을 활용한 단방향 @OneToMany보다는 이점을 제공하지만, 여전히 양방향 @OneToMany 연관관계보다는 비효율적이다. 추가 UPDATE문이 발생하여 성능 저하 문제가 존재한다.

양방향 @OneToMany 연관관계를 사용하면 데이터 읽기, 쓰기, 삭제 작업에서 더 효율적이다. 따라서 단방향 @OneToMany보다는 양방향 매핑을 사용하는 것이 성능 및 효율성 측면에서 권장된다.