마카로닉스

2046 No

자바 ORM 표준 JPA 프로그래밍 - 5.다양한 연관관계 매핑

2023-02-23 13:47:48 By 라이트 0 283 댓글수 4 포스트 하기

5월 2024
일	월	화	수	목	금	토
			1	2	3	4
5	6	7	8	9	10	11
12	13	14	15	16	17	18
19	20	21	22	23	24	25
26	27	28	29	30	31

✍️
이런 걸
배워요!

JPA의 기본기를 탄탄하게 다질 수 있습니다.

JPA의 내부 동작 방식을 이해할 수 있습니다.

객체와 DB 테이블을 올바르게 설계하고 매핑할 수 있습니다.

실무에서 자신있게 JPA를 사용할 수 있습니다.

인프런 강의 : https://www.inflearn.com/course/ORM-JPA-Basic

강의 자료 :

https://github.com/braverokmc79/jpa-basic-lecture-file

소스 :

https://github.com/braverokmc79/jpa-shop

[5] 다양한 연관관계 매핑

17. 다대일 [N:1] ( ★대부분 다대일 관계로 설계한다)

강의:

https://www.inflearn.com/course/lecture?courseSlug=ORM-JPA-Basic&unitId=21700&tab=curriculum

목차
• 연관관계 매핑시 고려사항 3가지
• 다대일 [N:1]
• 일대다 [1:N]
• 일대일 [1:1]
• 다대다 [N:M]
• 실전 예제 - 3. 다양한 연관관계 매핑

연관관계 매핑시 고려사항 3가지
• 다중성
• 단방향, 양방향
• 연관관계의 주인

다중성
• 다대일: @ManyToOne
• 일대다: @OneToMany
• 일대일: @OneToOne
• 다대다: @ManyToMany

단방향, 양방향
• 테이블
• 외래 키 하나로 양쪽 조인 가능
• 사실 방향이라는 개념이 없음
• 객체
• 참조용 필드가 있는 쪽으로만 참조 가능
• 한쪽만 참조하면 단방향
• 양쪽이 서로 참조하면 양방향

연관관계의 주인
• 테이블은 외래 키 하나로 두 테이블이 연관관계를 맺음
• 객체 양방향 관계는 A->B, B->A 처럼 참조가 2군데
• 객체 양방향 관계는 참조가 2군데 있음. 둘중 테이블의 외래 키
를 관리할 곳을 지정해야함
• 연관관계의 주인: 외래 키를 관리하는 참조
• 주인의 반대편: 외래 키에 영향을 주지 않음, 단순 조회만 가능

다대일 단방향 정리

• 가장 많이 사용하는 연관관계

• 다대일의 반대는 일대다

다대일 양방향 정리

• 외래 키가 있는 쪽이 연관관계의 주인

• 양쪽을 서로 참조하도록 개발

Member

package jpashop.home.domain;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;

import lombok.Getter;
import lombok.Setter;

@Entity
@Getter
@Setter
public class Member {

	@Id @GeneratedValue
	private Long id;
	
	@Column(name="USERNAME")
	private String username;
	
	@ManyToOne
	@JoinColumn(name = "TEAM_ID")
	private Team team;

}

Team

package jpashop.home.domain;

import java.util.ArrayList;
import java.util.List;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToMany;

import lombok.Getter;
import lombok.Setter;

@Entity
@Getter
@Setter
public class Team {


	@Id @GeneratedValue
	@Column(name="TEAM_ID")
	private Long id;
	private String name;
	
	/**★★★외래키가 있는 곳을 주인으로 정해라!
	 * 객체와 테이블이 관계를 맺는 차이
	 * 객체 연관관계 =2개
	 * mappedBy 는 Many 테이블의 외래키값을 넣으면 된다.
	 * 여기서는 Member 테이블의 team 이 외래키이다.
	 * 
	 * 조회만 가능하고 외래키의 값의 업데이트는 member 의 team 에서 업데이트 가능하다.
	 */
	@OneToMany(mappedBy = "team")
	private List<Member> members=new ArrayList<Member>();
	

}

18. 일대다 [1:N]

강의:

https://www.inflearn.com/course/lecture?courseSlug=ORM-JPA-Basic&unitId=21701&tab=curriculum

일대다 단방향 정리

• 일대다 단방향은 일대다(1:N)에서 일(1)이 연관관계의 주인
• 테이블 일대다 관계는 항상 다(N) 쪽에 외래 키가 있음
• 객체와 테이블의 차이 때문에 반대편 테이블의 외래 키를 관리하
는 특이한 구조
• @JoinColumn을 꼭 사용해야 함. 그렇지 않으면 조인 테이블
방식을 사용함(중간에 테이블을 하나 추가함)

일대다 단방향 정리

• 일대다 단방향 매핑의 단점
• 엔티티가 관리하는 외래 키가 다른 테이블에 있음
• 연관관계 관리를 위해 추가로 UPDATE SQL 실행
• 일대다 단방향 매핑보다는 다대일 양방향 매핑을 사용하자

일대다 양방향 정리

• 이런 매핑은 공식적으로 존재X
• @JoinColumn(insertable=false, updatable=false)

• 읽기 전용 필드를 사용해서 양방향 처럼 사용하는 방법

• 다대일 양방향을 사용하자

19. 일대일 [1:1]

강의:

https://www.inflearn.com/course/lecture?courseSlug=ORM-JPA-Basic&unitId=21702&tab=curriculum

일대일 관계
• 일대일 관계는 그 반대도 일대일
• 주 테이블이나 대상 테이블 중에 외래 키 선택 가능
• 주 테이블에 외래 키
• 대상 테이블에 외래 키
• 외래 키에 데이터베이스 유니크(UNI) 제약조건 추가

일대일: 주 테이블에 외래 키 단방향 정리
• 다대일(@ManyToOne) 단방향 매핑과 유사

일대일: 주 테이블에 외래 키 양방향 정리
• 다대일 양방향 매핑 처럼 외래 키가 있는 곳이 연관관계의 주인
• 반대편은 mappedBy 적용

일대일: 대상 테이블에 외래 키 단방향 정리
• 단방향 관계는 JPA 지원X
• 양방향 관계는 지원

일대일: 대상 테이블에 외래 키 양방향
• 사실 일대일 주 테이블에 외래 키 양방향과 매핑 방법은 같음

일대일 정리

• 주 테이블에 외래 키
• 주 객체가 대상 객체의 참조를 가지는 것 처럼
주 테이블에 외래 키를 두고 대상 테이블을 찾음
• 객체지향 개발자 선호
• JPA 매핑 편리
• 장점: 주 테이블만 조회해도 대상 테이블에 데이터가 있는지 확인 가능
• 단점: 값이 없으면 외래 키에 null 허용

• 대상 테이블에 외래 키
• 대상 테이블에 외래 키가 존재
• 전통적인 데이터베이스 개발자 선호
• 장점: 주 테이블과 대상 테이블을 일대일에서 일대다 관계로 변경할 때 테이블 구조 유지
• 단점: 프록시 기능의 한계로 지연 로딩으로 설정해도 항상 즉시 로딩됨(프록시는 뒤에서 설명)

Member

package jpashop.home.domain;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.OneToOne;

import lombok.Getter;
import lombok.Setter;

@Entity
@Getter
@Setter
public class Member {

	@Id @GeneratedValue
	private Long id;
	
	@Column(name="USERNAME")
	private String username;
	
	@ManyToOne
	@JoinColumn(name = "TEAM_ID")
	private Team team;

	@OneToOne
	@JoinColumn(name = "LOCKER_ID")
	private Locker locker;
	
}

Locker

package jpashop.home.domain;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToOne;

@Entity
public class Locker {
	
	@Id @GeneratedValue
	private Long id;
	
	private String name;
	
	@OneToOne(mappedBy = "locker")
	private Member member;

}

20. 다대다 [N:M] (실무에서 상요하면 안된다.)

=> @OneToMany, @ManyToOne (일대 다 , 다대 일로 중간 테이블을 만들어서 사용해라 )

강의:

https://www.inflearn.com/course/lecture?courseSlug=ORM-JPA-Basic&unitId=21703&tab=curriculum

21. 실전 예제 3 - 다양한 연관관계 매핑

강의:

https://www.inflearn.com/course/lecture?courseSlug=ORM-JPA-Basic&unitId=21704&tab=curriculum

이미지 주소 :

https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgpC6HjQCdirAiSdDSrlNvO7t19EJFgep7tYOuBn4j3lMe-wwm4cmiTKM5wlezgzwx_BDaXZsjuU5_S69Za5qQbX2yXV5-d3bg7wt3xsxOFBlR6hehUOl7W4ltQf6kctcMxnYP8qvRVMQoB5WfGP1NTWnABzN4WUQlLku_ztqEhH78t7ywshi8vjaxU4g/s2368/2023-02-24%2011%2046%2013.png

Member

package jpashop.home.domain;

import java.util.ArrayList;
import java.util.List;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToMany;

import lombok.Getter;
import lombok.Setter;

@Entity
@Getter
@Setter
public class Member {

	@Id @GeneratedValue
	@Column(name="MEMBER_ID")
	private Long id;
	private String name;
	private String city;
	private String street;
	private String zipcode;
	
	
	//mappedBy 는 연관 관계의 주인은 누구? member
	@OneToMany(mappedBy = "member")
	private List<Order> orderList=new ArrayList<>();
	
	
}

Order

package jpashop.home.domain;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.EnumType;
import javax.persistence.Enumerated;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.OneToOne;
import javax.persistence.Table;

import lombok.Getter;
import lombok.Setter;

@Entity
@Getter
@Setter
@Table(name="ORDERS")  //ORDER DB 에서 예약어로 사용되는 경우 많아서 ORDERS 
public class Order {
  
	@Id @GeneratedValue
	@Column(name="ORDER_ID")
	private Long id;
	
	@ManyToOne
	@JoinColumn(name="MEMBER_ID")
	private Member member;	
	
	
	@OneToOne
	@JoinColumn(name="DELIVERY_ID")
	private Delivery delivery;
	
	
	
	@OneToMany(mappedBy = "order")
	private List<OrderItem> orderItems=new ArrayList<>();
	
	
	private LocalDateTime orderDate;
	
	//ORDINAL 숫자 타입으로 하면 순서가 꼬이므로 무저건 String 한다
	@Enumerated(EnumType.STRING)
	private OrderStatus status;

	//양방향 연관 관계 설정
	public void addOrderItem(OrderItem orderItem) {
		orderItems.add(orderItem);
		orderItem.setOrder(this);
	}
	
	
	
}

OrderItem

package jpashop.home.domain;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;

import lombok.Getter;
import lombok.Setter;

@Entity
@Getter
@Setter
public class OrderItem {

	@Id
	@GeneratedValue
	@Column(name="ORDER_ITEM_ID")
	private Long id;

	
	@ManyToOne
	@JoinColumn(name="ORDER_ID")
	private Order order;
	
	@ManyToOne
	@JoinColumn(name="ITEM_ID")
	private Item item;
	
	
	private int oderPrice;
	
	private int count;
	
}

Item

package jpashop.home.domain;

import java.util.ArrayList;
import java.util.List;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToMany;

import lombok.Getter;
import lombok.Setter;

@Entity
@Getter
@Setter
public class Item {

	@Id @GeneratedValue
	@Column(name="ITEM_ID")
	private Long id;
	
	private String name;
	private String price;
	private int stockQuantity;
	
	@ManyToMany(mappedBy = "items")
	private List<Cartegory> cartegories=new ArrayList<>();
	
}

Delivery

package jpashop.home.domain;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToOne;

@Entity
public class Delivery {
	
	@Id @GeneratedValue
	@Column(name="DELIVERY_ID")
	private Long id;

	private String city;
	private String street;
	private String zipcode;
	private DeliveryStatus status;
	
	@OneToOne(mappedBy = "delivery")
	private Order order;
	
	
}

Cartegory

package jpashop.home.domain;

import java.util.ArrayList;
import java.util.List;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;

@Entity
public class Cartegory {
	
	@Id @GeneratedValue
	@Column(name="CARTEGORY_ID")
	private Long id;
	
	private String name;
	
	@ManyToOne
	@JoinColumn(name="PARENT_ID")
	private Cartegory parent;

	@OneToMany(mappedBy = "parent")
	private List<Cartegory> child=new ArrayList<>();
	
	
	@ManyToMany
	//중간 테이블 생성
	@JoinTable(name="CATEGORY_ITEM",
			joinColumns = @JoinColumn(name="CATEGOYR_ID"),
			inverseJoinColumns = @JoinColumn(name="ITEM_ID")
		)
	private List<Item> items=new ArrayList<>();
	
}

    
    create table Cartegory (
       CARTEGORY_ID bigint not null,
        name varchar(255),
        PARENT_ID bigint,
        primary key (CARTEGORY_ID)
    )
Hibernate: 
    
    create table CATEGORY_ITEM (
       CATEGOYR_ID bigint not null,
        ITEM_ID bigint not null
    )
Hibernate: 
    
    create table Delivery (
       DELIVERY_ID bigint not null,
        city varchar(255),
        status integer,
        street varchar(255),
        zipcode varchar(255),
        primary key (DELIVERY_ID)
    )
Hibernate: 
    
    create table Item (
       ITEM_ID bigint not null,
        name varchar(255),
        price varchar(255),
        stockQuantity integer not null,
        primary key (ITEM_ID)
    )
Hibernate: 
    
    create table Member (
       MEMBER_ID bigint not null,
        city varchar(255),
        name varchar(255),
        street varchar(255),
        zipcode varchar(255),
        primary key (MEMBER_ID)
    )
Hibernate: