😀
fistkim TECH BLOG
  • Intro
  • 강의
    • Reactive Programming in Modern Java using Project Reactor
      • Reactor execution model 1
      • Reactor execution model 2
      • Reactor execution model 3 - parallelism
      • Reactor execution model 4 - overview
      • Transform
      • Combine
      • Side Effect Methods
      • Exception/Error handling
      • retry, retryWhen, repeat
      • BackPressure
      • Cold & Hot Streams
    • NEXTSTEP 클린코드 with java 9기
      • 정리노트
    • NEXTSTEP DDD 세레나데 2기
      • CH01 도메인 주도 설계 이해
      • CH02 크게 소리 내어 모델링 하기
      • CH03 도메인 주도 설계 기본 요소
      • CH04 도메인 주도 설계 아키텍처
      • CH05 도메인 이벤트
    • NEXTSTEP 인프라 공방 1기
      • 망 분리하기
      • 통신 확인하기
      • 도커 컨테이너 이해하기
      • [미션 1] 서비스 구성하기 실습
      • [미션 2] 서비스 배포하기 실습
      • 서버 진단하기
      • 어플리케이션 진단하기
      • [미션 3] 서비스 운영하기
      • 웹 성능 진단하기
      • 부하 테스트
      • k6
      • [미션 4] 성능 테스트
      • 리버스 프록시 개선하기
      • 캐싱 활용하기
      • [미션 5] 화면 응답 개선하기
      • Redis Annotation 및 설정
      • 인덱스 이해하기 & DB 튜닝
      • [미션 6-1] 조회 성능 개선하기
      • [미션 6-2] DB 이중화 적용
    • NEXTSTEP 만들면서 배우는 Spring 3기
      • CH01 올바른 방향 바라보기
      • CH02 HTTP 이해 - 웹 서버 구현
        • HTTP 파싱
        • HTTP 웹 서버 구현
      • CH03 MVC - @MVC 프레임워크 구현
        • Servlet 다시 짚기
        • Cookie, Session 다시 짚기
        • MVC 프레임워크 구현
      • CH04 나만의 라이브러리 구현
      • CH05 DI - DI 프레임워크 구현
      • CH06 Aspect OP
    • 스프링 시큐리티
      • 스프링 시큐리티 아키텍처
      • WebAsyncManagerIntegrationFilter
      • SecurityContextPersistenceFilter
      • HeaderWriterFilter
      • CsrfFilter
      • (+) 스프링 시큐리티 + JWT
      • (+) 마치며
    • 더 자바, 코드를 조작하는 다양한 방법
      • CH01 JVM 이해하기
      • (+) 클래스 로더 이해하기
      • CH02 바이트 코드 분석 및 조작
      • (+) jacoco
      • CH03 리플렉션
      • CH04 다이나믹 프록시
      • CH05 애노테이션 프로세서
    • 더 자바, 애플리케이션을 테스트하는 다양한 방법
      • CH01 JUnit 5
      • CH02 Mockito
      • (+) Spy vs Mock
      • CH03 도커와 테스트
      • CH04 성능 테스트
      • (+) VisualVM
      • (+) 테스트 자동화
      • CH05 운영 이슈 테스트
      • CH06 아키텍처 테스트
    • 모든 개발자를 위한 HTTP 웹 기본 지식
      • CH01 인터넷 네트워크
      • CH02 HTTP 기본
      • CH03 HTTP 메서드 속성
      • CH04 HTTP 메서드 활용
      • CH05 HTTP 상태코드
      • CH06 HTTP 헤더1 - 일반 헤더
      • CH07 HTTP 헤더2 - 캐시와 조건부 요청
      • (+) HTTPS 원리
    • 스프링 프레임워크 핵심 기술
      • CH01 IOC 컨테이너
      • CH02 AOP
      • (+) 스프링 의존성 관리
      • (+) 생성자 주입 장점
    • 코딩으로 학습하는 GoF의 디자인 패턴
      • 객체 생성
        • 싱글톤 패턴
        • 팩토리 메소드 패턴
        • 추상 팩토리 패턴
        • 빌더 패턴
        • 프로토타입 패턴
      • 구조
        • 어댑터 패턴
        • 브릿지 패턴
        • 컴포짓 패턴
      • 행동
        • (작성중)
    • 실전 Querydsl
      • CH01 프로젝트 환경구성
      • CH02 예제 도메인 모델
      • CH03 기본문법
      • CH04 중급 문법
      • CH05 실무활용 (스프링 데이터 JPA와 Querydsl)
      • CH06 스프링데이터JPA 가 제공하는 Querydsl 기능
      • (+) 별칭(alias)
      • (+) Slice 쿼리
    • 스프링 데이터 JPA
      • CH01 핵심개념이해 1
      • CH02 핵심개념이해 2
      • CH03 핵심개념이해 3
      • CH04 Spring Data Common
      • CH05 Spring Data JPA
    • 실전! 스프링 부트와 JPA 활용2 - API 개발과 성능 최적화
      • CH01 지연 로딩과 조회 성능 최적화
      • CH02 컬렉션 조회 최적화
      • CH03 전체 정리
    • 초보를 위한 쿠버네티스 안내서
      • CH01 쿠버네티스 시작하기
      • CH02 쿠버네티스 알아보기
      • CH03 쿠버네티스 실습 준비
      • CH04 쿠버네티스 기본 실습
    • Flutter Provider Essential
      • CH01 Introduction
      • CH02 Provider Overview
      • CH03 TODO App
      • CH04 Weather App
      • CH05 Firebase Authentication App
    • Flutter Bloc Essential
      • CH01 Introduction
      • CH02 Bloc Overview
      • CH03 TODO App
      • CH04 Weather App
      • CH05 Firebase Authentication App
    • Flutter Advanced Course - Clean Architecture With MVVM
      • CH01 Introduction
      • CH02 Clean Architecture 4 Layer
      • CH03 MVVM
      • CH04 Data Layer
      • (+) Data Layer - response to model
      • (+) Data Layer - Network
      • CH05 Domain Layer
      • CH06 Presentation Layer
      • CH07 Application Layer
      • (+) Application Layer - l10n
      • (+) Application Layer - DI
      • (+) Application Layer - environment
    • 자바 알고리즘 입문
      • CH01 문자열
      • CH02 Array(1, 2 차원 배열)
      • CH03 Two pointers, Sliding window[효율성: O(n^2)-->O(n)]
      • CH04 HashMap, TreeSet (해쉬, 정렬지원 Set)
      • CH05 Stack, Queue(자료구조)
      • CH06 Sorting and Searching(정렬, 이분검색과 결정알고리즘)
      • CH07 Recursive, Tree, Graph(DFS, BFS 기초)
      • CH08 DFS, BFS 활용
      • CH09 Greedy Algorithm
      • CH10 dynamic programming(동적계획법)
  • 도서
    • 만들면서 배우는 클린 아키텍처
      • 학습목표
      • CH01 계층형 아키텍처의 문제는 무엇일까?
      • CH02 의존성 역전하기
      • CH03 코드 구성하기
      • CH04 유스케이스 구현하기
      • CH05 웹 어댑터 구현하기
      • CH06 영속성 어댑터 구현하기
      • CH07 아키텍처 요소 테스트하기
      • CH08 경계 간 매핑하기
      • CH09 어플리케이션 조립하기
      • CH10 아키텍처 경계 강제하기
      • CH11 의식적으로 지름길 사용하기
      • CH12 아키텍처 스타일 결정하기
    • 클린 아키텍처
      • 들어가며
      • 1부 소개
        • 1장 설계와 아키텍처란?
        • 2장 두 가지 가치에 대한 이야기
      • 2부 벽돌부터 시작하기: 프로그래밍 패러다임
        • 3장 패러다임 개요
        • 4장 구조적 프로그래밍
        • 5장 객체 지향 프로그래밍
        • 6장 함수형 프로그래밍
      • 3부 설계 원칙
        • 7장 SRP: 단일 책임 원칙
        • 8장 OCP: 개방-폐쇄 원칙
        • 9장 LSP: 리스코프 치환 원칙
        • 10장 ISP: 인터페이스 분리 원칙
        • 11장 DIP: 의존성 역전 원칙
      • 4부 컴포넌트 원칙
        • 12장 컴포넌트
        • 13장 컴포넌트 응집도
        • 14장 컴포넌트 결합
      • 5부
        • 15장 아키텍처란?
    • 스프링 입문을 위한 자바 객체 지향의 원리와 이해
      • CH01 사람을 사랑한 기술
      • CH02 자바와 절차적/구조적 프로그래밍
      • CH03 자바와 객체 지향
      • (+) 자바 코드 실행에 따른 메모리 적재과정
      • CH04 자바가 확장한 객체 지향
      • CH05 객체 지향 설계 5 원칙 - SOLID
      • CH06 스프링이 사랑한 디자인 패턴
      • CH07 스프링 삼각형과 설정 정보
      • (부록) 람다(lambda)
    • 객체지향의 사실과 오해
      • CH01 협력하는 객체들의 공동체
      • CH02 이상한 나라의 객체
      • CH03 타입과 추상화
      • CH04 역할, 책임, 협력
      • CH05 책임과 메시지
      • CH06 객체 지도
      • CH07 함께 모으기
      • (+) 인터페이스 개념 바로잡기
    • 도메인 주도 개발 시작하기
      • CH01 도메인 모델 시작하기
      • CH02 아키텍처 개요
      • CH03 애그리거트
      • CH04 리포지터리와 모델 구현
      • CH05 스프링 데이터 JPA를 이용한 조회 기능
      • CH06 응용 서비스와 표현 영역
      • CH07 도메인 서비스
      • CH08 애그리거트 트랜잭션 관리
      • CH09 도메인 모델과 바운디드 컨텍스트
      • CH10 이벤트
      • CH11 CQRS
    • 자바 ORM 표준 JPA 프로그래밍
      • CH01 JPA 소개
      • CH02 JPA 시작
      • CH03 영속성 관리
      • CH04 엔티티 매핑
      • CH05 연관관계 매핑 기초
      • CH06 다양한 연관관계 매핑
      • CH07 고급 매핑
      • CH08 프록시와 연관관계 관리
      • CH09 값 타입
      • CH10 객체지향 쿼리 언어
      • CH11 웹 애플리케이션 제작
      • CH12 스프링 데이터 JPA
      • CH13 웹 애플리케이션과 영속성 관리
      • CH14 컬렉션과 부가 기능
      • CH15 고급 주제와 성능 최적화
      • CH16 트랜잭션과 락, 2차 캐시
    • 소프트웨어 세상을 여는 컴퓨터과학
      • CH01 컴퓨터 과학 소개
      • CH02 데이터 표현과 디지털 논리
    • 이펙티브 자바
      • 1 장 들어가기
      • 2장 객체 생성과 파괴
        • [01] 생성자 대신 정적 팩터리 메서드를 고려하라
        • [02] 생성자에 매개변수가 많다면 빌더를 고려하라
        • [03] private 생성자나 열거 타입으로 싱글턴임을 보증하라
        • [04] 인스턴스화를 막으려거든 private 생성자를 사용하라
        • [05] 자원을 직접 명시하지 말고 의존 객체 주입을 사용하라
        • [06] 불필요한 객체 생성을 피하라
        • [07] 다 쓴 객체 참조를 해제하라
        • [08] finalizer 와 cleaner 사용을 피하라
        • [09] try-finally 보다는 try-with-resources 를 사용하라
      • 3장 모든 객체의 공통 메서드
        • [10] equals는 일반 규약을 지켜 재정의하라
        • [11] equals 를 재정의하려거든 hashCode도 재정의하라
        • [12] toString 을 항상 재정의하라
        • [13] clone 재정의는 주의해서 진행하라
        • [14] Comparable 을 구현할지 고려하라
      • 4장 클래스와 인터페이스
        • [15] 클래스와 멤버의 접근 권한을 최소화하라
  • 토픽
    • 서버 모니터링
      • CPU 사용량
      • 메모리 사용량
      • 스레드 풀
    • Spring Boot Monitoring
      • Spring actuator
      • Spring eureka
      • Prometheus
      • grafana
      • Spring actuator + Prometheus + grafana
    • JAVA 데일리 토픽
      • 메모리 누수(memory leak)
      • 객체 참조의 유형
      • 커스텀 스레드 풀
      • Mark And Compact
      • serialVersionUID 이해하기
      • 함수형 인터페이스
      • 메소드 참조
      • equals()와 hashCode()가 무엇이고 역할이 무엇인지
      • StringBuffer vs StringBuilder
      • String vs StringBuilder, StringBuffer
      • String interning
    • JAVA GC
    • 프로그래머스 문제 풀기
      • 해시
      • 스택/큐
      • 힙(Heap)
      • 정렬
      • 완전탐색
      • DFS/BFS
    • 데이터베이스 구성 및 작동 흐름
    • 데이터베이스 JOIN 원리
    • 객체지향생활체조 원칙
    • 상태(state), 상속(inheritance), 합성(composition) 의 상관관계
    • java enum은 메모리에 언제, 어떻게 할당되는가
    • Checked Exception vs UnChecked Exception
    • Reactive Streams 원리탐구 - 간단한 예제 직접 작성해보기
    • Flutter Basic
    • Flutter StatefulWidget 생명주기
    • Flutter 가 위젯을 그리는 원리
    • Flutter 클린 아키텍처
      • application layer
        • 패키지 구조 및 레이어 설명
        • environment
        • dependency injection
        • go_router
        • foreground & background
        • 다국어처리 (l10n, i18n)
        • Global 처리(시스템 점검, fore->back 등)
        • connection_manager
        • permission_manager
        • push_notification_manager
        • firebase 연동
      • data layer
        • 패키지 구조 및 레이어 설명
        • network
        • repository
      • domain layer
        • 패키지 구조 및 레이어 설명
      • presentation layer
        • 패키지 구조 및 레이어 설명
        • resources
    • 기술 관련 포스팅 읽기
  • 기타
    • 작업일지
      • 2023. 10
      • 2023. 09
      • 2023. 08
      • 2023. 07
      • 2023. 06
      • 2023. 05
      • 2023. 04
      • 2023. 03
      • 2023. 02
      • 2023. 01
      • 2022. 12
    • Business Model
      • 아이디어 불패의 법칙
      • 린 모바일 앱 개발
      • 린 스타트업
      • 제로투원
      • MIT 스타트업 바이블
      • 린치핀
    • 백로그 종합
Powered by GitBook
On this page
  • 연관관계
  • 방향(direction)
  • 다중성(multiplicity)
  • 관계의 주인(owner)
  • @JoinColumn 자세히 알아보기
  • mappedby 자세히 알아보기(ex. @OneToMany(mappedBy = ...))
  • 관계의 주인의 역할
  • 양방향 연관 관계 주의점
  • 관계의 주인 뿐만이 아니라 반대편에도 데이터를 맞춰주어야 한다
  • Entity 를 그대로 반환하지 말라
  1. 도서
  2. 자바 ORM 표준 JPA 프로그래밍

CH05 연관관계 매핑 기초

4장에서 엔티티의 매핑을 알아봤다면 이번 장에서는 Relational 에서 가지는 연관관계들을 Object 에서 어떻게 표현하는가에 대한 내용이다. 그래서 '연관관개 매핑' 이라는 용어가 사용되고 있다. 책의 목차 순서와는 조금 다르게 예전에 정리한 순서대로 정리를 다시 하면서 약간의 내용을 추가했다.

연관관계

복잡한 비즈니스 상에서는 여러 엔티티가 설계되고 엔티티간에 상관관계가 존재할 수 있다. 이를 테이블의 세계에서는 외래키라는 개념으로 연관관계를 설정한다. ORM 에서 이 외래키 및 연관관계의 개념을 어떻게 설정하고 사용하는지에 관한 것이 ‘연관관계’ 이다.

연관관계 설정시 아래 세 가지 개념이 핵심이다.

방향(direction)

Relational 의 세계에서는 외래키 하나만 있으면 두 쪽 다 조회가 가능하다.

테이블의 세계에서는 외래키 라는 개념으로 테이블간의 연관관계를 설계한다. 그리고 테이블에서는 하나의 외래키를 이용해서 연관관계가 있는 두 테이블 모두 조회가 가능하다.

예를 들어서 team 과 member가 있고 member에 외래키가 존재하는 경우 특정 teamId를 통해서 memeber들을 조회할 수 있으며, 반대로 특정 member들의 team 을 조회할 수 있다. 즉, 두 테이블 모두 하나의 외래키로 조회가 가능하다.

Object 의 세계에서는 참조를 하려면 반드시 필드로 해당 객체를 가지고 있어야 한다.

하지만 객체의 경우 해당 필드를 가지고 있어야만 조회가 가능하다. 즉, memeber 에서 team 을 조회하려면 member 는 team 을 필드로 갖고 있어야하며, 반대로 team 에서 member를 조회하고 싶은 경우 member 들을 필드로 갖고 있어야 한다. 그래야 참조를 할 수 있다.

이렇게 테이블의 세계에서는 외래키 하나로 member -> team, team -> member 모두 조회가 가능하지만 객체의 세계에서는 ‘객체 그래프 탐색’의 방향이 제한된다. 한쪽만 가능한 경우를 두고 ‘단방향’이라고 하며 양쪽 모두에서 서로 참조가 가능한 경우를 ‘양방향’ 이라고 한다.

양방향은 결국 단방향을 양쪽 모두에 걸어준 것일 뿐이다.

객체 그래프 탐색이 양방향 모두 가능하게 설정해주는 것의 장점은(=단방향과 비교하여 양방향의 장점) 그래프 탐색이 서로 참조가 가능하다는 것 뿐이다. 그리고 사실 양방향이란 단방향을 서로에게 걸어주는 것일 뿐이다.

즉, 단방향 대비 양방향의 장점은 그저 객체 그래프 탐색의 방향이 일방적이지 않고 서로 참조가 가능하다는 것 뿐이다.

다중성(multiplicity)

엔티티간의 관계에서 갖게 되는 수적인 관계에 관한 개념이다. 일대다, 다대다, 다대일, 일대일과 같은 연관성에서 포함되는 수의 개념을 의미한다.

관계의 주인(owner)

궁극적으로 객체 지향 프로그래밍을 통해서 데이터베이스 세계와 소통하는 것이 ORM의 목적인데, 테이블의 세계에서는 외래키 하나만 있으면 된다. 그런데 만약 객체의 세계에서 양방향 설정을 하게 되면 외래키는 하나인데 외래키를 누가 관리해야할 것인가의 이슈가 발생한다.

즉, 관계의 주인이란 양방향 설정시 고려해야할 개념이며 ‘외래키를 관리하는 객체’가 관계의 주인이 된다. 외래키를 관리하는 자가 곧 두 관계를 정의하는 자이고 이것이 관계의 주인이다.

@JoinColumn 자세히 알아보기

너무 기계적으로 써온 것 같아서 이번 기회에 다시 좀 정리를 한다. 일단 기본적으로 @Column 과 역할은 동일한데 속성이 더 확장되었다고 보면 된다.

/**
 * Specifies a column for joining an entity association or element
 * collection.  If the <code>JoinColumn</code> annotation itself is
 * defaulted, a single join column is assumed and the default values
 * apply.
 *
 * <pre>
 *   Example:
 *
 *   &#064;ManyToOne
 *   &#064;JoinColumn(name="ADDR_ID")
 *   public Address getAddress() { return address; }
 *
 *
 *   Example: unidirectional one-to-many association using a foreign key mapping
 * 
 *   // In Customer class
 *   &#064;OneToMany
 *   &#064;JoinColumn(name="CUST_ID") // join column is in table for Order
 *   public Set&#060;Order&#062; getOrders() {return orders;}
 * </pre>
 *
 * @see ManyToOne
 * @see OneToMany
 * @see OneToOne
 * @see JoinTable
 * @see CollectionTable
 * @see ForeignKey
 *
 * @since 1.0
 */
@Repeatable(JoinColumns.class)
@Target({METHOD, FIELD})
@Retention(RUNTIME)
public @interface JoinColumn {
 Specifies a column for joining an entity association or element collection.

joining an entity 를 하는 column 을 Specifiy 한댄다. 명확하게 나와있다. 이름 부터가 JoinColumn 이다. 외래키인 컬럼이라는 뜻이다.

    /** 
     * (Optional) The name of the foreign key column.
     * The table in which it is found depends upon the
     * context. 
     * <ul>
     * <li>If the join is for a OneToOne or ManyToOne
     *  mapping using a foreign key mapping strategy, 
     * the foreign key column is in the table of the
     * source entity or embeddable. 
     * <li> If the join is for a unidirectional OneToMany mapping
     * using a foreign key mapping strategy, the foreign key is in the
     * table of the target entity.  
     * <li> If the join is for a ManyToMany mapping or for a OneToOne
     * or bidirectional ManyToOne/OneToMany mapping using a join
     * table, the foreign key is in a join table.  
     * <li> If the join is for an element collection, the foreign 
     * key is in a collection table.
     *</ul>
     *
     * <p> Default (only applies if a single join column is used):
     * The concatenation of the following: the name of the 
     * referencing relationship property or field of the referencing 
     * entity or embeddable class; "_"; the name of the referenced 
     * primary key column. 
     * If there is no such referencing relationship property or 
     * field in the entity, or if the join is for an element collection,
     * the join column name is formed as the 
     * concatenation of the following: the name of the entity; "_"; 
     * the name of the referenced primary key column.
     */
    String name() default "";
The name of the foreign key column.

더 설명이 필요가 없다. name 속성 자체가 외래키의 이름이다. 위에 썼듯이 @Column 과 유사한데 외래키 컬럼에 사용하는 메타데이터라고 보자.

    /**
     * (Optional) The name of the column referenced by this foreign
     * key column. 
     * <ul>
     * <li> When used with entity relationship mappings other
     * than the cases described here, the referenced column is in the
     * table of the target entity. 
     * <li> When used with a unidirectional OneToMany foreign key
     * mapping, the referenced column is in the table of the source
     * entity.  
     * <li> When used inside a <code>JoinTable</code> annotation,
     * the referenced key column is in the entity table of the owning
     * entity, or inverse entity if the join is part of the inverse
     * join definition.  
     * <li> When used in a <code>CollectionTable</code> mapping, the
     * referenced column is in the table of the entity containing the
     * collection.
     * </ul>
     *
     * <p> Default (only applies if single join column is being 
     * used): The same name as the primary key column of the 
     * referenced table.
     */
    String referencedColumnName() default "";
The name of the column referenced by this foreign key column. 

이 외래키로 참조하는 컬럼의 이름이다. 반드시 일치 해야한다. 당연한 이야기이지만 이 속성, 더 크게는 이 어노테이션 자체가 Object 에 Releational 의 무엇을 참조할지를 알려주는 메타데이터이기 때문이다.

이번 기회에 알게된 사실인데 인텔리제이에 DataSource 를 설정해주면 실제 Relational 까지 살펴보고 해당 속성에 대해서 존재하지 않는 컬럼명을 설정할 경우 경고를 준다.

보통 DataGrip 을 따로 써서 인텔리제이에는 데이터소스 할당을 하지 않는데, 생각보다 좋은 것 같다.

mappedby 자세히 알아보기(ex. @OneToMany(mappedBy = ...))

@JoinColumn 은 컬럼에 붙여주는 어노테이션이고 mappedby 는 연관관계 설정시 사용하는 어노테이션의 속성일 뿐이다. 하지만 @JoinColumn 과 연결된 개념이라 이어서 정리한다.

@OneToMany(fetch = FetchType.LAZY, mappedBy = "user", cascade = CascadeType.ALL)
private List<Meal> meals = new ArrayList<>();
    /** 
     * The field that owns the relationship. Required unless 
     * the relationship is unidirectional.
     */
    String mappedBy() default "";

앞서 정리했듯이 관계의 주인은 외래키를 가지고 있는 엔티티이다. 따라서 mappedby 가 선언되는 엔티티는 관계의 주인이 아니다. 그리고 mappedby 의 값은 주석에 잘 적혀있듯이 Relational 의 값이 아니라 Object 의 값이다.

더 정확히는 관계의 주인 엔티티와 매핑되는 Object(@Entity 로 선언된 클래스) 에서 외래키이자 객체 참조로 활용되고 있는 객체 필드의 '필드명' 이다.

위에 내가 실제로 프로젝트에 사용한 코드 일부를 가져왔는데 Meal 클래스에서 User 를 'user' 라는 필드명으로 선언해서 참조하고 있기 때문에 "user" 를 mappedBy 에 잡아주었다.

관계의 주인의 역할

책에는 다른 목차 이름으로 적혀있는데 내가 일부러 '관계의 주인의 역할' 이라는 이름으로 바꿨다. 상식적으로 외래키를 관리하는 곳이 관계의 주인이기 때문에 결국 실제 Relational 과의 관계를 위한 Object 의 데이터 싱크도 관계의 주인에 잡아줘야 한다.

Member와 Team 간의 관계에서 Member 가 관계의 주인이라면 Member 의 team 필드에 연관된 Team 을 세팅해줘야 한다는 뜻이다. Team 이 주인이 아닌데도 Team 에 Member 를 세팅해줘봤자 소용이 없다. 주인이 아닌 쪽에서는 객체 그래프 탐색을 통한 조회 밖에 할 수 없다.

양방향 연관 관계 주의점

관계의 주인 뿐만이 아니라 반대편에도 데이터를 맞춰주어야 한다

백기선님 강의때도 다뤘던 주제인데 연관관계를 가진 두 객체의 일관성을 유지해줘야 하는 것이 중요하다. 편의 메소드를 통해서 해결하도록 한다.

편의 메소드에 관해서 공식 문서 같은 것에서 서술하고 있는 레퍼런스를 찾고 싶은데 나오질 않아서 링크 첨부가 불가능 하다. 편의 메소드란 연관관계를 가진 두 엔티티의 싱크를 맞춰주는 메소드이다. 편의 메소드 작성시 서로 참조에 의한 무한 루프에 빠지지 않도록 유의해야 한다. 양 쪽에 다 작성할 수 있지만 그냥 한 쪽에만 작성하도록 하자.

예를 들어 Team, Member 사이에서 연관관계의 주인인 Member에 Team 을 세팅해주고 insert 를 하면 테이블에는 데이터가 들어가지만 Team 의 Memeber 에는 해당 Memeber 가 들어가 있지 않을 것이므로 버그 방지를 위해서 Object 에서의 참조관계도 신경써서 처리해줘야 한다는 것이다.

추가 뿐만이 아니라 삭제 등 참조관계의 변경에서도 마찬가지다.

Entity 를 그대로 반환하지 말라

entity 를 그대로 반환하는 경우 두 가지 문제가 생길 수 있다.

첫째, 양방향 참조하는 entity 를 json 으로 변환하는 과정에서 서로 참조하고 있는 객체를 변환하면서 무한 루프에 빠지는 문제가 있다.

둘째, entity 변경이 발생하면 API 스펙이 바뀌어버리게 된다.

따라서 위와 같은 문제점들 때문에 entity 를 dto 로 변환해서 반환하여야 한다.

PreviousCH04 엔티티 매핑NextCH06 다양한 연관관계 매핑

Last updated 1 year ago