본문 바로가기

공부/Spring

JPA + JPQL

by JERO__ 2021. 9. 24.

도메인 모델. 예제

용어 이해

방향 : 단방향, 양방향
다중성 : 1:1, 1:N, N:1, N:M
1. 사용 : 외래키 있는 곳이 연관관계 주인
  - 다대일(N:1)
  - 일대일(1:1) : UNIQUE 사용
2. 사용X
  - 일대다(1:N) : UPDATE SQL 추가실행, 외래키가 다른 테이블에 존재
  - 다대다(N:M) : N:1, 1:N 으로 변경하여 사용
연관관계의 주인 : 객체 양방향 관계는 관리필요
- 외래키가 있는 곳이 주인
- 주인에 값을 입력하기 + 객체상태를 고려해 양쪽에 값을 설정

상속관계 매핑

관계형 DB는 상속관계 X
슈퍼타입, 서브타입 관계라는 모델링 기법이 객체 상속과 유사
주요 어노테이션
- @Inheritance(strategy = InheritanceType.XXX)
  - JOINED : 조인
  - SINGLE_TABLE : 단일테이블
  - TABLE_PER_CLASS : 구현 클래스마다 테이블
- @DiscriminatorColumn(name = "DTYPE") : 부모
- @DiscriminatorValue("XXX") : 자식(구분가능)

조인
2. 단일테이블
3. 구현 클래스마다 테이블 : 사용X

공통수퍼클래스 ( @MappedSuperclass )

→ 공통매핑정보가 사용될 때

추상클래스 권장
검색, 조회 불가

프록시 em.find() vs em.getReferene()

실제 클래스를 상속받아 만들어짐. 겉모양이 같음. → 사용자 입장에서는 구분하지 않고 사용.
값이 사용될 때 ← 초기화됨. 1번만
원본 엔티티를 상속받음. 타입체크시 비교 실패(==). instanceof 사용
이미, 영속성 컨테스트에 있으면 → 해당 인스턴스 그대로 가져옴m2 = em.getReference // member 클래스 2. m1 = em.getReference // member.hibernateproxy 클래스 m2 = em.find // member.hibernateproxy 클래스
ex) 1. m1 = em.find // member 클래스

즉시로딩 vs 지연로딩 ★ → 실무에서 모두 지연로딩 설정

→ Member를 조회할 때 Team도 조회를 해야할까?

지연로딩 (fetch = FetchType.LAZY) // 가급적 지연로딩만 사용
- m.getTeam() 할때 초기화됨.
- ManyToOne, OneToOne → LAZY설정
즉시로딩 (fetch = FetchType.EAGER) // N+1 문제
- 예상치 못한 SQL 에러

CASCADE : 영속성 전이

ALL, PERSIST, REMOVE
1개의 부모와 자식들을 관리할때 사용
CASCADE는 연관관계를 매핑하는 것과 아무 관련이 없음
엔티티를 영속화할 때 연관된 엔티티도 함께 영속화하는 편리함을 제공할 뿐

임베디드 타입

String 시티, 거리, 위치 → Address 클래스
장점
- 재사용
- 높은 응집도
- 값타입(int, String...)
사용법
- 정의 : @Embeddable
- 사용 : @Embedded

값 타입 비교

동일성(==) : 참조값 비교
동등성(equals()) : 인스턴스 값 비교

값 타입 컬렌션

: Entity의 List, Set → 새로운 Table (하나의 테이블에 여러 값 넣을 수 없기에)

사용법
- @ElementCollection
- @CollectionTable(name = "테이블명", joinColumns = @JoinColumn(name = "MEMBER_ID"))
- @Column(name = "FOOD_NAME")
실무에서는 일대다 엔티티를 만들고 값타입 적용

객체지향쿼리(JPQL) - 기본문법

실무 → QueryDSL 사용

특징
- 엔티티와 속성은 대소문자 구분 (Member, age...)
- JPQL 키워드는 대소문자 구분X
- 엔티티 이름 사용(테이블 이름X)
- 별칭은 필수(m)
TypeQuery, Query
- TypeQuery : 반환타입이 명확할 때
- Query : 반환 타입이 명확하지 않을 때
페이징쿼리

//페이징 쿼리 String jpql = "select m from Member m order by m.name desc"; List<Member> resultList = em.createQuery(jpql, Member.class) .setFirstResult(10) .setMaxResults(20) .getResultList();

서브쿼리
1. 종류
  - EXISTS (서브쿼리) : 결과가 존재하면 참
  - ALL, ANY, SOME (서브쿼리)
    - ALL : 모두 만족
    - ANY=SOME : 1개라도 만족하면 참
  - IN (서브쿼리)
2. 한계
  - 현재 JPQL의 from 절에서는 서브쿼리 불가

// m, m2 <- 다르게 구분해야함 select m from Member m where m.age > (select avg(m2.age) from Member m2

조건식

// CASE식 select case when m.age <= 10 then '학생요금' when m.age >= 60 then '경로요금' else '일반요금' end from Member m

조인

명시적 조인 : 사용하기
묵시적 조인 : 사용X

fetch join ★
- (left) join fetch
select m from Member m join fetch m.team
- 컬렉션(list)을 fetch join할 경우 @batchSize로 한번에 넘겨줌도메인 모델. 예제
  - 방향 : 단방향, 양방향
  - 다중성 : 1:1, 1:N, N:1, N:M
    1. 사용 : 외래키 있는 곳이 연관관계 주인
      - 다대일(N:1)
      - 일대일(1:1) : UNIQUE 사용
    2. 사용X
      - 일대다(1:N) : UPDATE SQL 추가실행, 외래키가 다른 테이블에 존재
      - 다대다(N:M) : N:1, 1:N 으로 변경하여 사용
  - 연관관계의 주인 : 객체 양방향 관계는 관리필요
    - 외래키가 있는 곳이 주인
    - 주인에 값을 입력하기 + 객체상태를 고려해 양쪽에 값을 설정
  상속관계 매핑
  - 관계형 DB는 상속관계 X
  - 슈퍼타입, 서브타입 관계라는 모델링 기법이 객체 상속과 유사
  - 주요 어노테이션
    - @Inheritance(strategy = InheritanceType.XXX)
      - JOINED : 조인
      - SINGLE_TABLE : 단일테이블
      - TABLE_PER_CLASS : 구현 클래스마다 테이블
    - @DiscriminatorColumn(name = "DTYPE") : 부모
    - @DiscriminatorValue("XXX") : 자식(구분가능)
  1. 조인
  1. 단일테이블
  1. 구현 클래스마다 테이블 : 사용X
  - 추상클래스 권장
  - 검색, 조회 불가
  프록시 em.find() vs em.getReferene()
  - 실제 클래스를 상속받아 만들어짐. 겉모양이 같음. → 사용자 입장에서는 구분하지 않고 사용.
  - 값이 사용될 때 ← 초기화됨. 1번만
  - 원본 엔티티를 상속받음. 타입체크시 비교 실패(==). instanceof 사용
  - 이미, 영속성 컨테스트에 있으면 → 해당 인스턴스 그대로 가져옴m2 = em.getReference // member 클래스 2. m1 = em.getReference // member.hibernateproxy 클래스 m2 = em.find // member.hibernateproxy 클래스
  - ex) 1. m1 = em.find // member 클래스
  즉시로딩 vs 지연로딩 ★ → 실무에서 모두 지연로딩 설정
  - 지연로딩 (fetch = FetchType.LAZY) // 가급적 지연로딩만 사용
    - m.getTeam() 할때 초기화됨.
    - ManyToOne, OneToOne → LAZY설정
  - 즉시로딩 (fetch = FetchType.EAGER) // N+1 문제
    - 예상치 못한 SQL 에러
  CASCADE : 영속성 전이
  - ALL, PERSIST, REMOVE
  - 1개의 부모와 자식들을 관리할때 사용
  - CASCADE는 연관관계를 매핑하는 것과 아무 관련이 없음
  - 엔티티를 영속화할 때 연관된 엔티티도 함께 영속화하는 편리함을 제공할 뿐
  임베디드 타입
  - String 시티, 거리, 위치 → Address 클래스
  - 장점
    - 재사용
    - 높은 응집도
    - 값타입(int, String...)
  - 사용법
    - 정의 : @Embeddable
    - 사용 : @Embedded
  값 타입 비교
  1. 동일성(==) : 참조값 비교
  2. 동등성(equals()) : 인스턴스 값 비교
  값 타입 컬렌션
  - 사용법
    - @ElementCollection
    - @CollectionTable(name = "테이블명", joinColumns = @JoinColumn(name = "MEMBER_ID"))
    - @Column(name = "FOOD_NAME")
  - 실무에서는 일대다 엔티티를 만들고 값타입 적용
  객체지향쿼리(JPQL) - 기본문법
  1. 특징
    - 엔티티와 속성은 대소문자 구분 (Member, age...)
    - JPQL 키워드는 대소문자 구분X
    - 엔티티 이름 사용(테이블 이름X)
    - 별칭은 필수(m)
  2. TypeQuery, Query
    - TypeQuery : 반환타입이 명확할 때
    - Query : 반환 타입이 명확하지 않을 때
  3. 페이징쿼리
  //페이징 쿼리 String jpql = "select m from Member m order by m.name desc"; List<Member> resultList = em.createQuery(jpql, Member.class) .setFirstResult(10) .setMaxResults(20) .getResultList();
  1. 서브쿼리
    1. 종류
      - EXISTS (서브쿼리) : 결과가 존재하면 참
      - ALL, ANY, SOME (서브쿼리)
        
        ALL : 모두 만족
        
        ANY=SOME : 1개라도 만족하면 참
      - IN (서브쿼리)
    2. 한계
      - 현재 JPQL의 from 절에서는 서브쿼리 불가
  // m, m2 <- 다르게 구분해야함 select m from Member m where m.age > (select avg(m2.age) from Member m2
  1. 조건식
  // CASE식 select case when m.age <= 10 then '학생요금' when m.age >= 60 then '경로요금' else '일반요금' end from Member m조인
  - 명시적 조인 : 사용하기
  - 묵시적 조인 : 사용X
  1. fetch join ★
    - (left) join fetch
    select m from Member m join fetch m.team
    - 컬렉션(list)을 fetch join할 경우 @batchSize로 한번에 넘겨줌도메인 모델. 예제
      - 방향 : 단방향, 양방향
      - 다중성 : 1:1, 1:N, N:1, N:M
        
        사용 : 외래키 있는 곳이 연관관계 주인
        
        다대일(N:1)
        
        일대일(1:1) : UNIQUE 사용
        
        사용X
        
        일대다(1:N) : UPDATE SQL 추가실행, 외래키가 다른 테이블에 존재
        
        다대다(N:M) : N:1, 1:N 으로 변경하여 사용
      - 연관관계의 주인 : 객체 양방향 관계는 관리필요
        
        외래키가 있는 곳이 주인
        
        주인에 값을 입력하기 + 객체상태를 고려해 양쪽에 값을 설정
      상속관계 매핑
      - 관계형 DB는 상속관계 X
      - 슈퍼타입, 서브타입 관계라는 모델링 기법이 객체 상속과 유사
      - 주요 어노테이션
        
        @Inheritance(strategy = InheritanceType.XXX)
        
        JOINED : 조인
        
        SINGLE_TABLE : 단일테이블
        
        TABLE_PER_CLASS : 구현 클래스마다 테이블
        
        @DiscriminatorColumn(name = "DTYPE") : 부모
        
        @DiscriminatorValue("XXX") : 자식(구분가능)
      1. 조인
      1. 단일테이블
      1. 구현 클래스마다 테이블 : 사용X
      - 추상클래스 권장
      - 검색, 조회 불가
      프록시 em.find() vs em.getReferene()
      - 실제 클래스를 상속받아 만들어짐. 겉모양이 같음. → 사용자 입장에서는 구분하지 않고 사용.
      - 값이 사용될 때 ← 초기화됨. 1번만
      - 원본 엔티티를 상속받음. 타입체크시 비교 실패(==). instanceof 사용
      - 이미, 영속성 컨테스트에 있으면 → 해당 인스턴스 그대로 가져옴m2 = em.getReference // member 클래스 2. m1 = em.getReference // member.hibernateproxy 클래스 m2 = em.find // member.hibernateproxy 클래스
      - ex) 1. m1 = em.find // member 클래스
      즉시로딩 vs 지연로딩 ★ → 실무에서 모두 지연로딩 설정
      - 지연로딩 (fetch = FetchType.LAZY) // 가급적 지연로딩만 사용
        
        m.getTeam() 할때 초기화됨.
        
        ManyToOne, OneToOne → LAZY설정
      - 즉시로딩 (fetch = FetchType.EAGER) // N+1 문제
        
        예상치 못한 SQL 에러
      CASCADE : 영속성 전이
      - ALL, PERSIST, REMOVE
      - 1개의 부모와 자식들을 관리할때 사용
      - CASCADE는 연관관계를 매핑하는 것과 아무 관련이 없음
      - 엔티티를 영속화할 때 연관된 엔티티도 함께 영속화하는 편리함을 제공할 뿐
      임베디드 타입
      - String 시티, 거리, 위치 → Address 클래스
      - 장점
        
        재사용
        
        높은 응집도
        
        값타입(int, String...)
      - 사용법
        
        정의 : @Embeddable
        
        사용 : @Embedded
      값 타입 비교
      1. 동일성(==) : 참조값 비교
      2. 동등성(equals()) : 인스턴스 값 비교
      값 타입 컬렌션
      - 사용법
        
        @ElementCollection
        
        @CollectionTable(name = "테이블명", joinColumns = @JoinColumn(name = "MEMBER_ID"))
        
        @Column(name = "FOOD_NAME")
      - 실무에서는 일대다 엔티티를 만들고 값타입 적용
      객체지향쿼리(JPQL) - 기본문법
      1. 특징
        
        엔티티와 속성은 대소문자 구분 (Member, age...)
        
        JPQL 키워드는 대소문자 구분X
        
        엔티티 이름 사용(테이블 이름X)
        
        별칭은 필수(m)
      2. TypeQuery, Query
        
        TypeQuery : 반환타입이 명확할 때
        
        Query : 반환 타입이 명확하지 않을 때
      3. 페이징쿼리
      //페이징 쿼리 String jpql = "select m from Member m order by m.name desc"; List<Member> resultList = em.createQuery(jpql, Member.class) .setFirstResult(10) .setMaxResults(20) .getResultList();
      1. 서브쿼리
        
        종류
        
        EXISTS (서브쿼리) : 결과가 존재하면 참
        
        ALL, ANY, SOME (서브쿼리)
        
        ALL : 모두 만족
        
        ANY=SOME : 1개라도 만족하면 참
        
        IN (서브쿼리)
        
        한계
        
        현재 JPQL의 from 절에서는 서브쿼리 불가
      // m, m2 <- 다르게 구분해야함 select m from Member m where m.age > (select avg(m2.age) from Member m2
      1. 조건식
      // CASE식 select case when m.age <= 10 then '학생요금' when m.age >= 60 then '경로요금' else '일반요금' end from Member m조인
      - 명시적 조인 : 사용하기
      - 묵시적 조인 : 사용X
      1. fetch join ★
        
        (left) join fetch
        
        select m from Member m join fetch m.team
        
        컬렉션(list)을 fetch join할 경우 @batchSize로 한번에 넘겨줌도메인 모델. 예제
        
        방향 : 단방향, 양방향
        
        다중성 : 1:1, 1:N, N:1, N:M
        
        사용 : 외래키 있는 곳이 연관관계 주인
        
        다대일(N:1)
        
        일대일(1:1) : UNIQUE 사용
        
        사용X
        
        일대다(1:N) : UPDATE SQL 추가실행, 외래키가 다른 테이블에 존재
        
        다대다(N:M) : N:1, 1:N 으로 변경하여 사용
        
        연관관계의 주인 : 객체 양방향 관계는 관리필요
        
        외래키가 있는 곳이 주인
        
        주인에 값을 입력하기 + 객체상태를 고려해 양쪽에 값을 설정
        
        상속관계 매핑
        
        관계형 DB는 상속관계 X
        
        슈퍼타입, 서브타입 관계라는 모델링 기법이 객체 상속과 유사
        
        주요 어노테이션
        
        @Inheritance(strategy = InheritanceType.XXX)
        
        JOINED : 조인
        
        SINGLE_TABLE : 단일테이블
        
        TABLE_PER_CLASS : 구현 클래스마다 테이블
        
        @DiscriminatorColumn(name = "DTYPE") : 부모
        
        @DiscriminatorValue("XXX") : 자식(구분가능)
        
        조인
        
        단일테이블
        
        구현 클래스마다 테이블 : 사용X
        
        추상클래스 권장
        
        검색, 조회 불가
        
        프록시 em.find() vs em.getReferene()
        
        실제 클래스를 상속받아 만들어짐. 겉모양이 같음. → 사용자 입장에서는 구분하지 않고 사용.
        
        값이 사용될 때 ← 초기화됨. 1번만
        
        원본 엔티티를 상속받음. 타입체크시 비교 실패(==). instanceof 사용
        
        이미, 영속성 컨테스트에 있으면 → 해당 인스턴스 그대로 가져옴m2 = em.getReference // member 클래스 2. m1 = em.getReference // member.hibernateproxy 클래스 m2 = em.find // member.hibernateproxy 클래스
        
        ex) 1. m1 = em.find // member 클래스
        
        즉시로딩 vs 지연로딩 ★ → 실무에서 모두 지연로딩 설정
        
        지연로딩 (fetch = FetchType.LAZY) // 가급적 지연로딩만 사용
        
        m.getTeam() 할때 초기화됨.
        
        ManyToOne, OneToOne → LAZY설정
        
        즉시로딩 (fetch = FetchType.EAGER) // N+1 문제
        
        예상치 못한 SQL 에러
        
        CASCADE : 영속성 전이
        
        ALL, PERSIST, REMOVE
        
        1개의 부모와 자식들을 관리할때 사용
        
        CASCADE는 연관관계를 매핑하는 것과 아무 관련이 없음
        
        엔티티를 영속화할 때 연관된 엔티티도 함께 영속화하는 편리함을 제공할 뿐
        
        임베디드 타입
        
        String 시티, 거리, 위치 → Address 클래스
        
        장점
        
        재사용
        
        높은 응집도
        
        값타입(int, String...)
        
        사용법
        
        정의 : @Embeddable
        
        사용 : @Embedded
        
        값 타입 비교
        
        동일성(==) : 참조값 비교
        
        동등성(equals()) : 인스턴스 값 비교
        
        값 타입 컬렌션
        
        사용법
        
        @ElementCollection
        
        @CollectionTable(name = "테이블명", joinColumns = @JoinColumn(name = "MEMBER_ID"))
        
        @Column(name = "FOOD_NAME")
        
        실무에서는 일대다 엔티티를 만들고 값타입 적용
        
        객체지향쿼리(JPQL) - 기본문법
        
        특징
        
        엔티티와 속성은 대소문자 구분 (Member, age...)
        
        JPQL 키워드는 대소문자 구분X
        
        엔티티 이름 사용(테이블 이름X)
        
        별칭은 필수(m)
        
        TypeQuery, Query
        
        TypeQuery : 반환타입이 명확할 때
        
        Query : 반환 타입이 명확하지 않을 때
        
        페이징쿼리
        
        //페이징 쿼리 String jpql = "select m from Member m order by m.name desc"; List<Member> resultList = em.createQuery(jpql, Member.class) .setFirstResult(10) .setMaxResults(20) .getResultList();
        
        서브쿼리
        
        종류
        
        EXISTS (서브쿼리) : 결과가 존재하면 참
        
        ALL, ANY, SOME (서브쿼리)
        
        ALL : 모두 만족
        
        ANY=SOME : 1개라도 만족하면 참
        
        IN (서브쿼리)
        
        한계
        
        현재 JPQL의 from 절에서는 서브쿼리 불가
        
        // m, m2 <- 다르게 구분해야함 select m from Member m where m.age > (select avg(m2.age) from Member m2
        
        조건식
        
        // CASE식 select case when m.age <= 10 then '학생요금' when m.age >= 60 then '경로요금' else '일반요금' end from Member m조인
        
        명시적 조인 : 사용하기
        
        묵시적 조인 : 사용X
        
        fetch join ★
        
        (left) join fetch
        
        select m from Member m join fetch m.team
        
        컬렉션(list)을 fetch join할 경우 @batchSize로 한번에 넘겨줌도메인 모델. 예제
        
        방향 : 단방향, 양방향
        
        다중성 : 1:1, 1:N, N:1, N:M
        
        사용 : 외래키 있는 곳이 연관관계 주인
        
        다대일(N:1)
        
        일대일(1:1) : UNIQUE 사용
        
        사용X
        
        일대다(1:N) : UPDATE SQL 추가실행, 외래키가 다른 테이블에 존재
        
        다대다(N:M) : N:1, 1:N 으로 변경하여 사용
        
        연관관계의 주인 : 객체 양방향 관계는 관리필요
        
        외래키가 있는 곳이 주인
        
        주인에 값을 입력하기 + 객체상태를 고려해 양쪽에 값을 설정
        
        상속관계 매핑
        
        관계형 DB는 상속관계 X
        
        슈퍼타입, 서브타입 관계라는 모델링 기법이 객체 상속과 유사
        
        주요 어노테이션
        
        @Inheritance(strategy = InheritanceType.XXX)
        
        JOINED : 조인
        
        SINGLE_TABLE : 단일테이블
        
        TABLE_PER_CLASS : 구현 클래스마다 테이블
        
        @DiscriminatorColumn(name = "DTYPE") : 부모
        
        @DiscriminatorValue("XXX") : 자식(구분가능)
        
        조인
        
        단일테이블
        
        구현 클래스마다 테이블 : 사용X
        
        추상클래스 권장
        
        검색, 조회 불가
        
        프록시 em.find() vs em.getReferene()
        
        실제 클래스를 상속받아 만들어짐. 겉모양이 같음. → 사용자 입장에서는 구분하지 않고 사용.
        
        값이 사용될 때 ← 초기화됨. 1번만
        
        원본 엔티티를 상속받음. 타입체크시 비교 실패(==). instanceof 사용
        
        이미, 영속성 컨테스트에 있으면 → 해당 인스턴스 그대로 가져옴m2 = em.getReference // member 클래스 2. m1 = em.getReference // member.hibernateproxy 클래스 m2 = em.find // member.hibernateproxy 클래스
        
        ex) 1. m1 = em.find // member 클래스
        
        즉시로딩 vs 지연로딩 ★ → 실무에서 모두 지연로딩 설정
        
        지연로딩 (fetch = FetchType.LAZY) // 가급적 지연로딩만 사용
        
        m.getTeam() 할때 초기화됨.
        
        ManyToOne, OneToOne → LAZY설정
        
        즉시로딩 (fetch = FetchType.EAGER) // N+1 문제
        
        예상치 못한 SQL 에러
        
        CASCADE : 영속성 전이
        
        ALL, PERSIST, REMOVE
        
        1개의 부모와 자식들을 관리할때 사용
        
        CASCADE는 연관관계를 매핑하는 것과 아무 관련이 없음
        
        엔티티를 영속화할 때 연관된 엔티티도 함께 영속화하는 편리함을 제공할 뿐
        
        임베디드 타입
        
        String 시티, 거리, 위치 → Address 클래스
        
        장점
        
        재사용
        
        높은 응집도
        
        값타입(int, String...)
        
        사용법
        
        정의 : @Embeddable
        
        사용 : @Embedded
        
        값 타입 비교
        
        동일성(==) : 참조값 비교
        
        동등성(equals()) : 인스턴스 값 비교
        
        값 타입 컬렌션
        
        사용법
        
        @ElementCollection
        
        @CollectionTable(name = "테이블명", joinColumns = @JoinColumn(name = "MEMBER_ID"))
        
        @Column(name = "FOOD_NAME")
        
        실무에서는 일대다 엔티티를 만들고 값타입 적용
        
        객체지향쿼리(JPQL) - 기본문법
        
        특징
        
        엔티티와 속성은 대소문자 구분 (Member, age...)
        
        JPQL 키워드는 대소문자 구분X
        
        엔티티 이름 사용(테이블 이름X)
        
        별칭은 필수(m)
        
        TypeQuery, Query
        
        TypeQuery : 반환타입이 명확할 때
        
        Query : 반환 타입이 명확하지 않을 때
        
        페이징쿼리
        
        //페이징 쿼리 String jpql = "select m from Member m order by m.name desc"; List<Member> resultList = em.createQuery(jpql, Member.class) .setFirstResult(10) .setMaxResults(20) .getResultList();
        
        서브쿼리
        
        종류
        
        EXISTS (서브쿼리) : 결과가 존재하면 참
        
        ALL, ANY, SOME (서브쿼리)
        
        ALL : 모두 만족
        
        ANY=SOME : 1개라도 만족하면 참
        
        IN (서브쿼리)
        
        한계
        
        현재 JPQL의 from 절에서는 서브쿼리 불가
        
        // m, m2 <- 다르게 구분해야함 select m from Member m where m.age > (select avg(m2.age) from Member m2
        
        조건식
        
        // CASE식 select case when m.age <= 10 then '학생요금' when m.age >= 60 then '경로요금' else '일반요금' end from Member m조인
        
        명시적 조인 : 사용하기
        
        묵시적 조인 : 사용X
        
        fetch join ★
        
        (left) join fetch
        
        select m from Member m join fetch m.team
        
        컬렉션(list)을 fetch join할 경우 @batchSize로 한번에 넘겨줌도메인 모델. 예제
        
        방향 : 단방향, 양방향
        
        다중성 : 1:1, 1:N, N:1, N:M
        
        사용 : 외래키 있는 곳이 연관관계 주인
        
        다대일(N:1)
        
        일대일(1:1) : UNIQUE 사용
        
        사용X
        
        일대다(1:N) : UPDATE SQL 추가실행, 외래키가 다른 테이블에 존재
        
        다대다(N:M) : N:1, 1:N 으로 변경하여 사용
        
        연관관계의 주인 : 객체 양방향 관계는 관리필요
        
        외래키가 있는 곳이 주인
        
        주인에 값을 입력하기 + 객체상태를 고려해 양쪽에 값을 설정
        
        상속관계 매핑
        
        관계형 DB는 상속관계 X
        
        슈퍼타입, 서브타입 관계라는 모델링 기법이 객체 상속과 유사
        
        주요 어노테이션
        
        @Inheritance(strategy = InheritanceType.XXX)
        
        JOINED : 조인
        
        SINGLE_TABLE : 단일테이블
        
        TABLE_PER_CLASS : 구현 클래스마다 테이블
        
        @DiscriminatorColumn(name = "DTYPE") : 부모
        
        @DiscriminatorValue("XXX") : 자식(구분가능)
        
        조인
        
        단일테이블
        
        구현 클래스마다 테이블 : 사용X
        
        추상클래스 권장
        
        검색, 조회 불가
        
        프록시 em.find() vs em.getReferene()
        
        실제 클래스를 상속받아 만들어짐. 겉모양이 같음. → 사용자 입장에서는 구분하지 않고 사용.
        
        값이 사용될 때 ← 초기화됨. 1번만
        
        원본 엔티티를 상속받음. 타입체크시 비교 실패(==). instanceof 사용
        
        이미, 영속성 컨테스트에 있으면 → 해당 인스턴스 그대로 가져옴m2 = em.getReference // member 클래스 2. m1 = em.getReference // member.hibernateproxy 클래스 m2 = em.find // member.hibernateproxy 클래스
        
        ex) 1. m1 = em.find // member 클래스
        
        즉시로딩 vs 지연로딩 ★ → 실무에서 모두 지연로딩 설정
        
        지연로딩 (fetch = FetchType.LAZY) // 가급적 지연로딩만 사용
        
        m.getTeam() 할때 초기화됨.
        
        ManyToOne, OneToOne → LAZY설정
        
        즉시로딩 (fetch = FetchType.EAGER) // N+1 문제
        
        예상치 못한 SQL 에러
        
        CASCADE : 영속성 전이
        
        ALL, PERSIST, REMOVE
        
        1개의 부모와 자식들을 관리할때 사용
        
        CASCADE는 연관관계를 매핑하는 것과 아무 관련이 없음
        
        엔티티를 영속화할 때 연관된 엔티티도 함께 영속화하는 편리함을 제공할 뿐
        
        임베디드 타입
        
        String 시티, 거리, 위치 → Address 클래스
        
        장점
        
        재사용
        
        높은 응집도
        
        값타입(int, String...)
        
        사용법
        
        정의 : @Embeddable
        
        사용 : @Embedded
        
        값 타입 비교
        
        동일성(==) : 참조값 비교
        
        동등성(equals()) : 인스턴스 값 비교
        
        값 타입 컬렌션
        
        사용법
        
        @ElementCollection
        
        @CollectionTable(name = "테이블명", joinColumns = @JoinColumn(name = "MEMBER_ID"))
        
        @Column(name = "FOOD_NAME")
        
        실무에서는 일대다 엔티티를 만들고 값타입 적용
        
        객체지향쿼리(JPQL) - 기본문법
        
        특징
        
        엔티티와 속성은 대소문자 구분 (Member, age...)
        
        JPQL 키워드는 대소문자 구분X
        
        엔티티 이름 사용(테이블 이름X)
        
        별칭은 필수(m)
        
        TypeQuery, Query
        
        TypeQuery : 반환타입이 명확할 때
        
        Query : 반환 타입이 명확하지 않을 때
        
        페이징쿼리
        
        //페이징 쿼리 String jpql = "select m from Member m order by m.name desc"; List<Member> resultList = em.createQuery(jpql, Member.class) .setFirstResult(10) .setMaxResults(20) .getResultList();
        
        서브쿼리
        
        종류
        
        EXISTS (서브쿼리) : 결과가 존재하면 참
        
        ALL, ANY, SOME (서브쿼리)
        
        ALL : 모두 만족
        
        ANY=SOME : 1개라도 만족하면 참
        
        IN (서브쿼리)
        
        한계
        
        현재 JPQL의 from 절에서는 서브쿼리 불가
        
        // m, m2 <- 다르게 구분해야함 select m from Member m where m.age > (select avg(m2.age) from Member m2
        
        조건식
        
        // CASE식 select case when m.age <= 10 then '학생요금' when m.age >= 60 then '경로요금' else '일반요금' end from Member m조인
        
        명시적 조인 : 사용하기
        
        묵시적 조인 : 사용X
        
        fetch join ★
        
        (left) join fetch
        
        select m from Member m join fetch m.team
        
        컬렉션(list)을 fetch join할 경우 @batchSize로 한번에 넘겨줌
        
        실무 → QueryDSL 사용
        
        : Entity의 List, Set → 새로운 Table (하나의 테이블에 여러 값 넣을 수 없기에)
        
        → Member를 조회할 때 Team도 조회를 해야할까?
        
        → 공통매핑정보가 사용될 때
        
        공통수퍼클래스 ( @MappedSuperclass )
        
        용어 이해
        
        실무 → QueryDSL 사용
        
        : Entity의 List, Set → 새로운 Table (하나의 테이블에 여러 값 넣을 수 없기에)
        
        → Member를 조회할 때 Team도 조회를 해야할까?
        
        → 공통매핑정보가 사용될 때
        
        공통수퍼클래스 ( @MappedSuperclass )
        
        용어 이해
        
        실무 → QueryDSL 사용
        
        : Entity의 List, Set → 새로운 Table (하나의 테이블에 여러 값 넣을 수 없기에)
        
        → Member를 조회할 때 Team도 조회를 해야할까?
        
        → 공통매핑정보가 사용될 때
        
        공통수퍼클래스 ( @MappedSuperclass )
        
        용어 이해
    - 실무 → QueryDSL 사용
    - : Entity의 List, Set → 새로운 Table (하나의 테이블에 여러 값 넣을 수 없기에)
    - → Member를 조회할 때 Team도 조회를 해야할까?
    - → 공통매핑정보가 사용될 때
    - 공통수퍼클래스 ( @MappedSuperclass )
    - 용어 이해
- 실무 → QueryDSL 사용
- : Entity의 List, Set → 새로운 Table (하나의 테이블에 여러 값 넣을 수 없기에)
- → Member를 조회할 때 Team도 조회를 해야할까?
- → 공통매핑정보가 사용될 때
- 공통수퍼클래스 ( @MappedSuperclass )
- 용어 이해

저작자표시

'공부 > Spring' 카테고리의 다른 글

[Spring] 스프링의 탄생과 개념 (0)	2022.04.19
Querydsl (0)	2021.10.04
스프링 데이터 JPA (0)	2021.10.02
스프링 공부 0 (0)	2021.09.05
스프링 공부 1 (0)	2021.09.05

댓글

티스토리툴바