SpringBoot Part4(3)

연관관계 매핑

객체 연관관계 VS 테이블 연관관계

테이블은 외래키로 연관 관계를 맺는다.

객체는 참조(주소)로 연관 관계를 맺는다.

핵심 키워드

방향성 (단방향, 양방향)

테이블에서 관계는 향상 양방향이다.

외래키를 이용해서 양방향으로 조인이 가능

SELECT * FROM orders AS o JOIN member AS m
ON o.member._id = m.id

객체에서의 단,양방향 관계

// 회원 -> 주문 단방향 매핑 경우. 회원에서 주문만 참조가 가능하다.
class Member {
	private long id;
	private List<Order> orders; // 회원 -> 주문
}

class Order {
	private String id;
}

Member member = new Member();
Order order = meber.getOrders().get(0);

// 주문 -> 회원 단방향 매핑
class Member {
	private long id;
}

class Order {
	private String id;
	private Member member;
}

// 회원 -> 주문, 주문 -> 회원 모두 참조가 가능한 양방향 매핑
class Member {
	private long id;
	private List<Order> orders;
}

class Order {
	private String id;
	private Member member; 
}

다중성 (다대다, 일대다, 다대다)

회원은 여러 주문을 할 수 있기 때문에, 회원(1)과 주문(N)은 일대다 관계
주문은 여러 회원에 의해 발생할 수 있기 때문에, 주문(N)과 회원(1)은 다대일 관계이다.

연관관계 주인 (mappedBy)

객체를 양방향 연관관계로 만들면, 연관관계의 주인을 정해야 한다.
외래키를 관리할 객체를 지정한다. (INSERT, UPDATE, DELETE)
연관관계 주인만이, 외래키를 등록 수정 삭제 할 수 있다. (주인이 아닌쪽은 읽기 SELECT만 가능하다.)
@OneToMany(mappedBy = 연관관계 주인 객체의 매핑 필드명)
@ManyToOne은 항상 연관관계의 주인이 되므로 mappedBy를 설정할 수 없습니다.

// Order_Item 테이블은 order_id를 외래키로 갖는다. 자신이 연관관계의 주인
@Entity
@Table
public class OrderItem extends BaseEntity{
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private int id;

    @ManyToOne
    private Order order;
}

// 양방향 연관관계 처럼 보이지만 실제 2개의 단방향 연관관계
// 테이블은 단방향 매핑이기에 실제 Order 테이블에는 orderItem 정보가 없다. 
// 연관관계의 주인 orderItem.order의 필드명을 mappedBy에 기재해준다. 
@Entity
@Table(name = "orders")
public class Order extends BaseEntity{

    @Id
    @Column(name = "id")
    private String uuid;

    @OneToMany(mappedBy = "Order")
    private List<OrderItem> orderItems;
}

객체 그래프 탐색

객체의 참조를 통해 객체를 가져온다.

class Member {
	private long id;
	private List<Order> orders;
}

class Order {
	private String id;
	private Member member;
}

... 
@Test
void graph() {
	Member member1 = new Mebmer(1);
	Order order1 = new Order(1)

	member1.setOrders(Lists.newArrayList(order1));

	Order findOrder= member1.getOrders().get(o); // 객체 그래프 탐색이라 한다.
	findOrder.getMember();
}

단방향 연관 관계

@Entity
@Table(name = "orders")
@Getter
@Setter
public class Order {
    @Id
    @Column(name = "id")
    private String uuid;

    @Column(name = "order_datetime", columnDefinition = "TIMESTAMP")
    private LocalDateTime orderDatetime;

    @Enumerated(EnumType.STRING)
    private OrderStatus orderStatus;

    @Lob
    private String memo;

    @Column(name = "member_id", insertable = false, updatable = false) // fk
    private Long memberId;

    @ManyToOne // 회원 한명에게 여러 주문
    @JoinColumn(name = "member_id", referencedColumnName = "id") // 명시하지 않을경우 해당필드명_PK필드명
    private Member member;
}

양방향 연관 관계

@Entity
@Table(name = "member")
@Getter
@Setter
public class Member {

    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE)
    private Long id;

    @Column(name = "name", nullable = false, length = 30)
    private String name;

    @Column(nullable = false, length = 30, unique = true)
    private String nickName;

    @Column
    private int age;

    @Column(name = "address", nullable = false)
    private String address;

    @Column(name = "description")
    private String description;

    @OneToMany(mappedBy = "member") // 연관관계 주인 설정 -> 연관관계 주인 객체의 필드값
    private List<Order> orders = new ArrayList<>();
}

확인

@Test
void 연관관계_테스트(){

    EntityManager entityManager = emf.createEntityManager();
    EntityTransaction transaction = entityManager.getTransaction();
    transaction.begin();

    Member member = new Member();
    member.setName("kanghonggu");
    member.setAddress("서울시 동작구(만) 움직이면 쏜다.");
    member.setAge(33);
    member.setNickName("guppy.kang");

    entityManager.persist(member);

    Order order = new Order();
    order.setUuid(UUID.randomUUID().toString());
    order.setOrderDatetime(LocalDateTime.now());
    order.setOrderStatus(OPENED);
    order.setMemo("부재시 전화주세요.");
    order.setMember(member); // setMemberId를 하지않아도 테이블에 FK가 매핑됨.

    entityManager.persist(order);

    transaction.commit();

		entityManager.clear();
    Order entity = entityManager.find(Order.class, order.getUuid());

    log.info("{}", entity.getMember().getName());  // 객체 그래프 탐색을 통해 member 가져오기
    log.info("{}", entity.getMember().getOrders().size());

		 log.info("{}", order.getMember().getOrders().size()); 
			// 0 -> 코드레벨 memder에는 setOrders를 안해줘서 사이즈가 0이 나온다.
			// 해당 작업이 번거로우니 연관관계 편의 메소드를 만들수 있다. 
}

쿼리 확인

Hibernate: insert into member (address, age, description, name, nickName, id) values (?, ?, ?, ?, ?, ?)
Hibernate: insert into orders (member_id, memo, order_datetime, orderStatus, id) values (?, ?, ?, ?, ?)
Hibernate: select o1_0.id,m1_0.id,m1_0.address,m1_0.age,m1_0.description,m1_0.name,m1_0.nickName,o1_0.member_id,o1_0.memo,o1_0.order_datetime,o1_0.orderStatus from orders o1_0 left join member m1_0 on m1_0.id=o1_0.member_id where o1_0.id=?

연관관계 편의 메소드

: 연관관계 편의 메소드를 만들어서 놓칠 수 있는 부분을 최소화한다.

@Entity
@Table(name = "orders")
@Getter
@Setter
public class Order {
    @Id
    @Column(name = "id")
    private String uuid;

    @Column(name = "order_datetime", columnDefinition = "TIMESTAMP")
    private LocalDateTime orderDatetime;

    @Enumerated(EnumType.STRING)
    private OrderStatus orderStatus;

    @Lob
    private String memo;

    @ManyToOne // 회원 한명에게 여러 주문
    @JoinColumn(name = "member_id", referencedColumnName = "id") // 명시하지 않을경우 해당필드명_PK필드명
    private Member member;

    public void setMember(Member member){
        if(Objects.nonNull(this.member)){
            this.member.getOrders().remove(this);
        }
        this.member = member;
        member.getOrders().add(this);
    }
}

@Entity
@Table(name = "member")
public class Member {

    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE)
    private Long id;

    @Column(name = "name", nullable = false, length = 30)
    private String name;

    @Column(nullable = false, length = 30, unique = true)
    private String nickName;

    @Column
    private int age;

    @Column(name = "address", nullable = false)
    private String address;

    @Column(name = "description")
    private String description;

    @OneToMany(mappedBy = "member") // 연관관계 주인 설정 -> 연관관계 주인 객체의 필드값
    private List<Order> orders = new ArrayList<>();

    public void addOrder(Order order){
        order.setMember(this);
    }
}

고급 매핑

JPA는 RDB 테이블과 미핑된 객체(Entity)를 객체답게 사용할 수 있도록 여러가지 고급 매핑 전략을 제공해준다. → 상속 관계 매핑, 식별자 클래스 (복합키) 등

상속관계매핑

조인테이블 전략 (InheritanceType.JOINED)

Item.class

@Entity
@Table(name = "item")
@Getter
@Setter
@Inheritance(strategy = InheritanceType.JOINED)
public abstract class Item { // 추상 class
    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE)
    private Long id;
    private int price;
    private int stockQuantity;
}

Food.class

@Entity
@Getter
@Setter
public class Food extends Item {
    private String chef;
}

확인

@Test
void inheritance_test() {
    EntityManager entityManager = emf.createEntityManager();
    EntityTransaction transaction = entityManager.getTransaction();

    transaction.begin();

    Food food = new Food();
    food.setPrice(5000);
    food.setStockQuantity(100);
    food.setChef("백종원");

    entityManager.persist(food);
    transaction.commit();
    entityManager.clear();
    entityManager.find(Food.class, food.getId());

}

→ item 테이블을 만들고 food 테이블을 만든다.

→ join을 해서 find를 한다.

싱글테이블 전략, 단일테이블 전략(InheritanceType.SINGLE_TABLE)

Item.class

@Entity
@Table(name = "item")
@Getter
@Setter
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name = "DTYPE") // 어떤 컬럼을 구분자로 사용할지
public abstract class Item { // 추상 class
    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE)
    private Long id;
    private int price;
    private int stockQuantity;
}

Food.class

@Entity
@Getter
@Setter
@DiscriminatorValue("FOOD")
public class Food extends Item {
    private String chef;
}

확인

create table item(
	DTYPE varchar(31) not null,
	id bigint not null, 
	price integer not null, 
	stockQuantity integer not null, 
	power integer, 
	chef varchar(255), 
	height integer, 
	width integer, 
	primary key (id)
)

→ item table만 생성됨

: 단일 table이 생성되고 DiscriminatorColumn 컬럼 값으로 구분을 해준다.

: 자식 엔티티가 매핑한 컬럼은 모두 null 을 허용해야한다는 단점이 있다.

: 여러 테이블이 생성되면 관리해야할 테이블이 많아지고 객체지향스럽지않아, 현업에선는 싱글테이블 전략을 많이 사용한다.

MappedSuperClass

부모 class가 실제 Entity가 되는 class는 아니지만 상속을 하면 자식 clss에서 부모 class의 필드가 컬럼 값으로 추가 mapping된다.

공통으로 사용된 필드가 있을 때 자주 사용된다.

@MappedSuperclass
@Getter
@Setter
public class BaseEntity {
    @Column(name = "created_by")
    private String createdBy;
    @Column(name = "created_at", columnDefinition = "TIMESTAMP")
    private LocalDateTime cratedAt;
}

//--------

@Entity
@Table(name = "orders")
@Getter
@Setter
public class Order extends BaseEntity{
    @Id
    @Column(name = "id")
    private String uuid;

    @Column(name = "order_datetime", columnDefinition = "TIMESTAMP")
    private LocalDateTime orderDatetime;

    @Enumerated(EnumType.STRING)
    private OrderStatus orderStatus;

    @Lob
    private String memo;

    @Column(name = "member_id", insertable = false, updatable = false) // fk
    private Long memberId;

    @ManyToOne // 회원 한명에게 여러 주문
    @JoinColumn(name = "member_id", referencedColumnName = "id") // 명시하지 않을경우 해당필드명_PK필드명
    private Member member;

    public void setMember(Member member){
        if(Objects.nonNull(this.member)){
            member.getOrders().remove(this);
        }
        this.member = member;
        member.getOrders().add(this);
    }
}

식별자 클래스

JPA에서 시별자를 둘 이상 사용하려면 별도의 식별자 클래스를 만들어야한다.

복합키 관리를 위한 2가지 전략 제공한다.

@Id 2개를 사용한는건 왜 안될까?

→ JPA는 영속성 컨텍스트에서 엔티티를 비교할때, Id를 key 값으로 보관한다. 해당 key는 Equals & hashCode를 이용하여 동등성 비교를 한다. 그렇기때문에 2개의 필드를 따로 지정하면 runtime error발생.

실별자 클래스 사용시

Serializable 인터페이스를 구현해야 한다.
eqauls, hashCode를 구현해야 한다.
기본 생성자가 있어야 한다.
식별자 클래스는 public 이어야 한다.

@IdClass

@EqualsAndHashCode
@NoArgsConstructor
@AllArgsConstructor
public class ParentId implements Serializable {
    private String id1;
    private String id2;
}

// ---

@Entity
@Getter
@Setter
@IdClass(ParentId.class)
public class Parent {
    @Id
    private String id1;
    @Id
    private String id2;
}

조회

Parent parent = new Parent();
parent.setId1("id1");
parent.setId2("id2");
entityManager.persist(parent);
transaction.commit();

Parent entity = entityManager.find(Parent.class, new ParentId("id1", "id2"));
log.info("{}, {}", entity.getId1(), entity.getId2());

@Embeddedld (추천)

식별자 자체를 명시. 더 많이 사용하는 방식이다.

@Getter
@Setter
@EqualsAndHashCode
@NoArgsConstructor
@AllArgsConstructor
@Embeddable
public class ParentId implements Serializable {
    private String id1;
    private String id2;
}

// ---

@Entity
@Getter
@Setter
public class Parent {
    @EmbeddedId
    private ParentId id;
}

조회

Parent parent = new Parent();
parent.setId(new ParentId("id1","id2"));
entityManager.persist(parent);
transaction.commit();

Parent entity = entityManager.find(Parent.class, new ParentId("id1", "id2"));
log.info("{}, {}", entity.getId().getId2(), entity.getId().getId1());

프록시 객체

객체 그래프 탐색

객체는 객체 그래프로 연관된 객체를 탐색한다. (order.getMember(), member.getOrders())

Entity는 객체가 RDS와 매핑되어 있어 자유롭게 객체를 탐색하는데 제한이 있다.

JPA는 프록시 객체라는 기술을 상용하여 연관된 객체를 처음부터 조회하지않고, 실제 사용하는 시점에 조회할 수 있다.

프록시 객체

@Entity
@Table(name = "member")
public class Member extends BaseEntity {
		...

    @OneToMany(mappedBy = "member", fetch = FetchType.LAZY)
    private List<Order> orders = new ArrayList<>(); // proxy

    ...
}

@Entity
@Table(name = "orders")
public class Order extends BaseEntity {
   ...

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "member_id", referencedColumnName = "id")
    private Member member;

    ...
}

테스트

@Test
void proxy(){
    EntityManager entityManager = emf.createEntityManager();

    Order order = entityManager.find(Order.class,uuid);

    Member member = order.getMember();
    log.info("Member use before is-Loaded : {}",emf.getPersistenceUnitUtil().isLoaded(member)); // 사용하기전 member 객체는 proxy 객체 - false

    var orders = member.getOrders();
    log.info("Member use after is-Loaded : {}",emf.getPersistenceUnitUtil().isLoaded(member));
    log.info(orders.toString());
}

프록시의 특징

프록시 객체는 Entity class를 상속 받아 만들어진다. (jpa가 내부적으로 상속을 받아 만듬)
실제 클래스와 겉 모양이 같다. (사용자 입장에서 진짜 객체인지 프록시 객체인지 구분하지 않고 사용)

프록시 객체는 실제 객체의 참조를 보관한다.(target)
프록시 객체를 호출하면 프록시 객체는 실제 객체의 메소드를 호출한다.

초기화

프록시 객체는 처음 사용할때 한번만 초기화 된다. (초기화전에는 target값이 존재하지않는다.)
프록시 객체가 초기화되면, 프록시 객체를 통해 실제 Entity에 접근할 수 있다.
영속성 컨텍스트의 도움을 받아 초기화한다. 따라서 준영속 상태의 프록시를 초기화하면 (트랜잭션 밖에서 프록시 객체를 조회할 경우) LazyInitializationException 예외가 발생한다. - OSIV

지연로딩(Lazy) vs 즉시로딩(EAGER)

지연 로딩 → 연관된 Entity는 실제 사용할때 조회한다.
@OneToMany, @ManyToMany처럼 Many로 끝나는 것들은 기본값이 지연 로딩이다.

즉시 로딩 → 엔티티를 조회할때, 연관된 Entity도 함께 조회한다.
@ManyToOne, @OneToOne처럼 One으로 끝나는 것들은 기본값이 즉시 로딩이다.

프록시 관련 util 메소드

PersistenceUnitUtil.isLoaded(Object entity) → 프록시 인스턴스 초기화 여부 확인
entity.getClass().getName() 출력 → 프록시 클래스 확인

추가 학습 → n+1 문제, 지연 로딩과 페치 조인

영속성 전이(CASCADE)

특정 엔티티를 영속 상태로 만들 때, 연관된 엔티티도 함께 영속상태로 만들고 싶을때, 사용한다.

public enum CascadeType {
    ALL,      // 모두 적용
    PERSIST,  // 영속
    MERGE,    // 병합
    REMOVE,   // 삭제
    REFRESH,  // REFRESH
    DETACH;   // DETACH  

    private CascadeType() {
    }
}

@Test
void move_persist(){
    EntityManager entityManager = emf.createEntityManager();
    EntityTransaction transaction = entityManager.getTransaction();

    transaction.begin();
    Order order = entityManager.find(Order.class,uuid);

    OrderItem item = new OrderItem();
    item.setQuantity(10);
    item.setPrice(10000);

    order.addOrderItem(item);
    transaction.commit();
}

영속성 전이를 하지 않았을 경우

→ Order은 영속성 상태이지만, OrderItem은 영속상태가 되지 못하였다.

→ addOrderItem를 했지만 OrderItem에 insert 쿼리가 날라가지 않음.

영속성 전이 추가

@Entity
@Table(name = "orders")
public class Order extends BaseEntity {
    ...

    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL) 
    private List<OrderItem> orderItems = new ArrayList<>();
		...
}

보통 식별관계(identifying)에 있는 Entity들 중 @OneToMany옵션에 건다.

고아객체

@Test
void orphan() {
    EntityManager entityManager = emf.createEntityManager();

    // 회원 조회 -> 회원의 주문 까지 조회
    Order order = entityManager.find(Order.class, uuid);
    order.getOrderItems().remove(0); // orderItem를 제거한다. (고아객체 발생)

    EntityTransaction transaction = entityManager.getTransaction();

    transaction.begin();
    transaction.commit();
}

delete 쿼리가 날라가지 않고 고아객체 발생

@Entity
@Table(name = "orders")
public class Order extends BaseEntity {
    ...

		// 고아객체를 flush 순간 RDS에서도 삭제하겠다.
    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL, orphanRemoval = true) 
    private List<OrderItem> orderItems = new ArrayList<>();
		...
}

delete 쿼리가 날라가게된다.

orphanRemoval=true와 Cascade.REMOVE 차이

https://tecoble.techcourse.co.kr/post/2021-08-15-jpa-cascadetype-remove-vs-orphanremoval-true/

Cascade.REMOVE는 one에 해당하는 엔티티가 remove 될때, many에 해당되는 엔티티들도 모두 삭제되는것. orphanRemoval=true는 위의 경우 포함, one의 list의 요소들을 삭제하기만 해도(즉, 관계를 제거하기만 해도) 해당 엔티티까지 삭제되는 기능.

→ 즉 부모 entity가 자식의 생명주기를 관리 하게된다. 이럴 경우 자식 요소의 repository가 아예 필요없게도 된다.

출처 - backend dev course 강홍구님

'Back-end 데브코스 > week 08 TIL (Jpa)' 카테고리의 다른 글

[TIL] 221209 - JPA : REST-API, API 문서화 (0)	2022.12.20
[TIL] 221208 - JPA : SpringDataJPA (0)	2022.12.14
[TIL] 221206 - JPA : 영속성 컨텍스트 (0)	2022.12.07
[TIL] 221205 - JPA : JPA 소개 (0)	2022.12.07

📎 clip code 📎

[TIL] 221207 - JPA : 연관관계 매핑, 고급 매핑, 프록시

SpringBoot Part4(3)

연관관계 매핑

객체 연관관계 VS 테이블 연관관계

핵심 키워드

객체 그래프 탐색

고급 매핑

상속관계매핑

MappedSuperClass

식별자 클래스

프록시 객체

프록시 객체

프록시의 특징

지연로딩(Lazy) vs 즉시로딩(EAGER)

영속성 전이(CASCADE)

고아객체

'Back-end 데브코스 > week 08 TIL (Jpa)' 카테고리의 다른 글

댓글

티스토리툴바

[TIL] 221207 - JPA : 연관관계 매핑, 고급 매핑, 프록시

SpringBoot Part4(3)

연관관계 매핑

객체 연관관계 VS 테이블 연관관계

핵심 키워드

객체 그래프 탐색

고급 매핑

상속관계매핑

MappedSuperClass

식별자 클래스

프록시 객체

프록시 객체

프록시의 특징

지연로딩(Lazy) vs 즉시로딩(EAGER)

영속성 전이(CASCADE)

고아객체

'Back-end 데브코스 > week 08 TIL (Jpa)' 카테고리의 다른 글

관련글

댓글

티스토리툴바