JPA 연관 관계

런던행·2022년 3월 21일
0

스프링부트

목록 보기
3/4

대다일 관계 이해하기

  • 게시판과 회원이 있다.
  • 한명의 회원은 여러개의 게시글을 작성할 수 있다.
  • 게시판과 회원은 다대일 관계다.
  • 게시 글을 통해서 게시 글을 작성한 회원 정보를 조회할 수 있다.

Board <----> Member

Board 엔티티

package com.example.study.domain;

import lombok.Getter;
import lombok.Setter;

import javax.persistence.*;
import java.util.Date;

@Getter
@Setter
@Entity
@Table(name = "study_board")
public class Board {
   @Id
   @GeneratedValue
   private Long seq;
   private String title;
//    private String writer;
   private String content;
   @Temporal(value = TemporalType.TIMESTAMP)
   private Date createDate;
   private Long cnt;

   @ManyToOne
   @JoinColumn(name = "MEMBER_ID")
   private Member member;
}

Memeber 엔티티

package com.example.study.domain;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

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

@Getter
@Setter
@Entity
@ToString
public class Member {
   @Id
   @Column(name="MEMBER_ID")
   private String id;
   private String password;
   private String name;
   private String role;
}

BoardRepository

package com.example.study.persistence;

import com.example.study.domain.Board;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.CrudRepository;
import org.springframework.data.repository.query.Param;

import java.util.List;

public interface BoardRepository extends CrudRepository<Board, Long> {

    List<Board> findByTitle(String keyword);

    // like
    List<Board> findByContentContaining(String keyword);

    // 여러 조건
    List<Board> findByTitleContainingOrContentContaining(String title, String content);

    // 데이터 정렬
    List<Board> findByTitleContainingOrderBySeqDesc(String keyword);

    // 페이징 처리
//    List<Board> findByTitleContaining(String searchkeyword, Pageable paing);

    // 페이지 타입 사용하기
    Page<Board> findByTitleContaining(String searchkeyword, Pageable paing);
}

MemberRepository

package com.example.study.persistence;

import org.springframework.data.repository.CrudRepository;

public interface MemberRepository extends CrudRepository {
}

다대일 테스트 코드

package com.example.study;

import com.example.study.domain.Board;
import com.example.study.domain.Member;
import com.example.study.persistence.BoardRepository;
import com.example.study.persistence.MemberRepository;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Date;

@SpringBootTest
public class RelationMappingTest {
   @Autowired
   private BoardRepository boardRepo;

   @Autowired
   private MemberRepository memberRepo;

   @Test
   public void testManyToOneInsert() {
       Member member1 = new Member();
       member1.setId("member1");
       member1.setPassword("aaaa");
       member1.setName("둘리");
       member1.setRole("User");
       memberRepo.save(member1);

       for (int i = 0; i <= 3; i++) {
           Board board = new Board();
           board.setTitle("title" + i);
           board.setContent("둘리가 작성한 내용 + " + i);
           board.setCreateDate(new Date());
           board.setMember(member1);
           boardRepo.save(board);
       }
   }
}

일대일 관계 이해하기

  • 주소와 회원이 있다.

  • 한명의 회원은 하나의 주소를 가지고 있다.

  • 주소와 회원은 일대일 관계다.

  • 회원을 통해서 주소 정보를 가져올 수 있다.

    Address 엔티티

 package com.example.study.domain;

import lombok.Getter;
import lombok.Setter;

import javax.persistence.*;

@Getter
@Setter
@Entity
@Table(name = "address")
public class Address {
    @Id
    @GeneratedValue
    @Column(name = "id")
    private Long id;

    @OneToOne(mappedBy = "address")
    private Member member;
}

Member 엔티티

 package com.example.study.domain;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

import javax.persistence.*;

@Getter
@Setter
@Entity
@ToString
public class Member {
    @Id
    @Column(name="MEMBER_ID")
    private String id;
    private String password;
    private String name;
    private String role;

    @OneToOne(cascade = CascadeType.ALL)
    @JoinColumn(name = "address_id", referencedColumnName = "id")
    private Address address;
}

Address 레파지토리

package com.example.study.persistence;

import com.example.study.domain.Address;
import org.springframework.data.repository.CrudRepository;

public interface AddressRepository extends CrudRepository<Address, Long> {
}

일대일 테스트코드

    @Test
    public void testOneToOneFind() {
        Address ad = new Address();

        System.out.println("address id : "+ ad.getId());
        Member member1 = new Member();
        member1.setId("member2");
        member1.setPassword("aaaa");
        member1.setName("둘리22");
        member1.setRole("User");
        member1.setAddress(ad);
        memberRepo.save(member1);

        System.out.println(addressRepo.findById(ad.getId()).get().getMember().getName());
    }

다대다 관계 이해하기

  • 학생과 과목이 있다.
  • 학생과 과목은 서로 여러개를 가질 수 있다.
  • 학생과 과목은 다대다 관계다.
  • 학생을 통해서 과목 정보들를 가져올 수 있다.

Student 엔티티

package com.example.study.domain;

import lombok.Getter;
import lombok.Setter;

import javax.persistence.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;

@Entity
@Setter
@Getter
public class Student {
    @Id
    @GeneratedValue
    Long id;

    @ManyToMany
    @JoinTable(
            name = "course_like",
            joinColumns = @JoinColumn(name = "student_id"),
            inverseJoinColumns = @JoinColumn(name = "course_id"))
    List<Course> likedCourses;

    public boolean addCourse(Course cs) {
        if (likedCourses == null) {
            likedCourses = new ArrayList<Course>();
        }
        return likedCourses.add(cs);
    }
}

Course 엔티티

package com.example.study.domain;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import java.util.List;
import java.util.Set;

@Entity
public class Course {
    @Id
    @GeneratedValue
    Long id;

    @ManyToMany(mappedBy = "likedCourses")
    List<Student> likes;
}

다대다 테스트코드

   @Test
    public void testManyToMany() {
        Student st = new Student();

        Course cs1 = new Course();
        Course cs2 = new Course();

        st.addCourse(cs1);
        st.addCourse(cs2);

        for (Course cs : st.getLikedCourses()) {
            System.out.println(cs.toString());
        }
    }
profile
unit test, tdd, bdd, laravel, django, android native, vuejs, react, embedded linux, typescript

0개의 댓글