JPA-mapping

 

 

---

엔티티와 매핑

1. @Entity와 @Table의 차이점을 설명해주세요.
2. @Id와 @GeneratedValue의 차이점과 사용 방법을 설명해주세요.
3. JPA에서 지원하는 연관관계 매핑 종류를 설명하고, 각 연관관계의 차이점을 설명해주세요.
4. FetchType.LAZY와 FetchType.EAGER의 차이점은 무엇인가요? 어떤 상황에서 각각을 사용하는 것이 적합한가요?
5. JPA에서 @JoinColumn과 @MappedBy의 차이를 설명해주세요.

---

 

@Entity와 @Table의 차이점을 설명해주세요.

 

@Entity

jpa에서 entity class 임을 선언하는 어노테이션

테이블과 매핑되는 class에 반드시 선언

 

@Table

db table 이름과 mapping을 지정하는 어노테이션

 

• name: 매핑할 테이블 이름을 지정합니다.
• schema: 매핑할 스키마 이름을 지정합니다.
• uniqueConstraints: 유니크 제약 조건을 지정할 수 있습니다.

 

@Entity
@Table(name = "user_table", schema = "public")
public class UserEntity {
    @Id
    private Long id;
    private String name;
}

 

---

@Id와 @GeneratedValue의 차이점과 사용 방법을 설명해주세요.

 

@Id

primary key를 지정

필수

 

@GeneratedValue

기본 키의 값을 설정

선택 사항

 

• GenerationType.AUTO: JPA가 데이터베이스에 맞는 기본 전략을 선택.
• GenerationType.IDENTITY: 데이터베이스의 AUTO_INCREMENT를 사용.
• GenerationType.SEQUENCE: 시퀀스를 사용하며, Oracle과 같은 데이터베이스에서 사용.
• GenerationType.TABLE: 별도의 키 생성 테이블을 사용.

@Entity
public class UserEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
}

 

 

 

---

JPA에서 지원하는 연관관계 매핑 종류를 설명하고, 각 연관관계의 차이점을 설명해주세요.

 

 

1. OneToOne (1:1 관계)

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @OneToOne(cascade = CascadeType.ALL)// 부모
    @JoinColumn(name = "profile_id") // 외래 키
    private Profile profile;

    // Getters and Setters
}

@Entity
public class Profile {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String bio;

    // Getters and Setters
}


// 데이터 삽입
public void insertOneToOneData(EntityManager em) {
    Profile profile = new Profile();
    profile.setBio("Software Developer");
    em.persist(profile);

    User user = new User();
    user.setName("Alice");
    user.setProfile(profile); // 1:1 관계 설정
    em.persist(user);
}

// 데이터 조회
public void fetchOneToOneData(EntityManager em) {
    User user = em.find(User.class, 1L);
    System.out.println("User Name: " + user.getName());
    System.out.println("Profile Bio: " + user.getProfile().getBio());
}

 

 

2. OneToMany (1:N 관계)

@Entity
public class Team {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    
    //자식, 노출 안됨
    @OneToMany(mappedBy = "team", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<Member> members = new ArrayList<>();
}

@Entity
public class Member {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @ManyToOne
    @JoinColumn(name = "team_id") // 외래 키, 부모
    private Team team;
}

 

 

 

 

3. ManyToOne (N:1 관계)

@Entity
public class Customer {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @OneToMany(mappedBy = "customer", cascade = CascadeType.ALL)// 자식, 노출 안됨
    private List<Order> orders = new ArrayList<>();
}

@Entity
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String product;

    @ManyToOne
    @JoinColumn(name = "customer_id") // 외래 키, 부모
    private Customer customer;
}

 

 

 

4. ManyToMany (N:M 관계)

@Entity
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @ManyToMany
    @JoinTable(
        name = "student_course", // 중간 테이블
        joinColumns = @JoinColumn(name = "student_id"),
        inverseJoinColumns = @JoinColumn(name = "course_id")
    )
    private List<Course> courses = new ArrayList<>();
}

@Entity
public class Course {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String title;

    @ManyToMany(mappedBy = "courses")
    private List<Student> students = new ArrayList<>();
}

 

 

 

---

FetchType.LAZY와 FetchType.EAGER의 차이점은 무엇인가요? 어떤 상황에서 각각을 사용하는 것이 적합한가요?

@Entity
public class Member {
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "team_id")
    private Team team;
}

 

FetchType.LAZY

연관된 데이터를 지연로딩 한다

- 실제로 사용될때 쿼리가 실행

장점

- 성능 최적화

- 필요할때만 data load

필요한 상황

- 대량의 연관 data

- 특정 entity만 필요할때

 

 

FetchType.EAGER

연관된 data를 즉시 로딩

- entity 조회시 연관된 모든 table, data 조회함

단점

- 불필요한 데이터 load -> 성능저하

필요한 상황

- 항상 연관 entity가 필요한 경우

 

 

 

 

---

JPA에서 @JoinColumn과 @MappedBy의 차이를 설명해주세요.

 

@JoinColumn

foreign key를 매핑할때 사용

소유자에서 선언(부모)

 

@MappedBy

양방향 관계에서 주인이 아님을 선언

자식이라고 선언

db에 영향을 주지 않으며, 엄마가 foreign key를 관리

@Entity
public class Team {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @OneToMany(mappedBy = "team")// 한 Team(1)이 여러 Member(N)를 가질 수 있는 관계
    private List<Member> members = new ArrayList<>();
}

@Entity
public class Member {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    
//  Member(다수)는 하나의 Team에만 속할 수 있으므로, Member와 Team 간의 관계는 N:1(다대일)입니다.
    @ManyToOne
    @JoinColumn(name = "team_id") // 외래 키 관리
    private Team team;
}

// 데이터 삽입 코드
public void insertData(EntityManager em) {
    // Team A 생성
    Team teamA = new Team();
    teamA.setName("Team A");
    em.persist(teamA);

    // Team B 생성
    Team teamB = new Team();
    teamB.setName("Team B");
    em.persist(teamB);

    // Member 생성 및 Team 연결
    Member member1 = new Member();
    member1.setName("Alice");
    member1.setTeam(teamA); // Alice는 Team A에 속함
    em.persist(member1);

    Member member2 = new Member();
    member2.setName("Bob");
    member2.setTeam(teamA); // Bob도 Team A에 속함
    em.persist(member2);

    Member member3 = new Member();
    member3.setName("Carol");
    member3.setTeam(teamB); // Carol은 Team B에 속함
    em.persist(member3);
}

 

Member 테이블:
---------------------
id   | name   | team_id
---------------------
1    | Alice  | 101
2    | Bob    | 101
3    | Carol  | 102

Team 테이블:
----------------
id   | name
----------------
101  | Team A
102  | Team B