[JPA] 페치 조인(fetch join) - 기본

2022-03-23 5 분 소요

📌 Topic

💡 JPQL fetch join 기본

⚡ JPQL fetch join

fetch join은 실무에서 상당히 중요한 부분이다.

01. 페치 조인(fetch join)

우선 페치 조인은 SQL의 조인 종류가 아니다. JPQL에서 성능 최적화를 위해 제공하는 기능으로써 연관된 엔티티나 컬렉션을 SQL 한 번에 함께 조회하기 위해 사용이 되는 기능이다.

join fetch 명령어 사용
페치 조인 ::=[LEFT [OUTER] INNSERT] JOIN FETCH 조인 경로

02. 엔티티 페치 조인

회원을 조회하면서 연관된 팀도 함께 조회(SQL 한 번에)
아래 SQL을 보면 회원 뿐만 아니라 팀(T.*)도 함께 SELECT 한다.
즉시 로딩을 사용하여 데이터를 가져오는 상황과 동일한 상황이다.

-- JPQL
select m from Member m join fetch m.team

-- DB JOIN
SELECT
    M.*,
    T.*
FROM
    MEMBER M
INNER JOIN TEAM T
ON M.TEAM_ID=T.ID

2022_03_23_fetch_join_회원

회원1, 회원2는 팀A를 참고하는 상황(좌측 사진)
회원3은 팀B를 참고하는 상황(좌측 사진)
INNERT JOIN을 수행하기 때문에, 조건에 맞지 않는 데이터는 출력안됨(우측 사진)

2022_03_23_fetch_join_회원2

위와 같이 조인을 한 결과는 위와 같다.
1차 캐시에 보관된 사진.

02-1. 페치 조인 사용

// 아래 예시는 fetch join을 사용하지 않은 예제 입니다
try {
    JpqlTeam teamA = new JpqlTeam();
    teamA.setName("팀A");
    em.persist(teamA);

    JpqlTeam teamB = new JpqlTeam();
    teamB.setName("팀B");
    em.persist(teamB);

    JpqlMember member1 = new JpqlMember();
    member1.setUsername("회원1");
    member1.setTeam(teamA);
    em.persist(member1);

    JpqlMember member2 = new JpqlMember();
    member2.setUsername("회원2");
    member2.setTeam(teamA);
    em.persist(member2);

    JpqlMember member3 = new JpqlMember();
    member3.setUsername("회원3");
    member3.setTeam(teamB); //팀B에 속하는 회원
    em.persist(member3);

    em.flush();
    em.clear();

    // 회원 조회
    String query = "select m FROM JpqlMember m";
    List<JpqlMember> memberList = em.createQuery(query, JpqlMember.class)
                                    .getResultList();

    // 회원1, 팀A(DB에 SQL을 날려서 조회)
    // 회원2, 팀A(DB에 SQL을 날리지 않고 1차캐시에서 조회)
    // 회원3, 팀B(DB에 SQL을 날려서 조회)
    for (JpqlMember member : memberList) {
        System.out.println("member = " + member.getUsername()
                                       + ", " + member.getTeam().getName());
    }

위 코드는 회원 엔티티에서 데이터를 조회하는 구문이다. 현재 회원은 3명이 존재하며, 각각 다른 팀에 속해 있는 것을 확인할 수 있다. 쿼리를 날린 결과를 아래에서 살펴보자.

// JPQL 회원 조회 결과
Hibernate:
    /* select
        m
    FROM
        JpqlMember m */ select
            jpqlmember0_.id as id1_10_,
            jpqlmember0_.age as age2_10_,
            jpqlmember0_.TEAM_ID as team_id5_10_,
            jpqlmember0_.type as type3_10_,
            jpqlmember0_.username as username4_10_
        from
            JPQL_MEMBER jpqlmember0_
Hibernate:
    select
        jpqlteam0_.TEAM_ID as team_id1_13_0_,
        jpqlteam0_.name as name2_13_0_
    from
        JPQL_TEAM jpqlteam0_
    where
        jpqlteam0_.TEAM_ID=?
member = 회원1, 팀A // [DB에서 가져옴]
member = 회원2, 팀A // [1차 캐시에서 가져옴]
Hibernate:
    select
        jpqlteam0_.TEAM_ID as team_id1_13_0_,
        jpqlteam0_.name as name2_13_0_
    from
        JPQL_TEAM jpqlteam0_
    where
        jpqlteam0_.TEAM_ID=?
member = 회원3, 팀B // [DB에서 가져옴]

Loop문 안에서 발생되는 상황

회원1, 팀A(DB에 SQL을 날려서 조회)
- 첫 번째, 두 번째 SQL을 의미함
회원2, 팀A(DB에 SQL을 날리지 않고 1차 캐시에서 조회)
- 영속성 컨텍스트에 이미 올라가 있기에 DB 조회 안해도 된다
회원3, 팀B(DB에 SQL을 날려서 조회)
- 영속성 컨텍스트에 존재하지 않기에 쿼리를 날린다

위와 같이 조회를 하는 경우 쿼리가 3번이나 나간다. 다음은 fetch join이다.

// fetch join
String query = "select m FROM JpqlMember m join fetch m.team";
List<JpqlMember> memberList = em.createQuery(query, JpqlMember.class)
                                .getResultList();

for (JpqlMember member : memberList) {
    System.out.println("member = " + member.getUsername()
                                    + ", " + member.getTeam().getName());
}

지연 로딩을 설정하여도, fetch join이 항상 우선시 된다

이번에는 위에서 작성한 코드와는 다르게 join fetch라는 키워드가 들어 갔다. join fetch 키워드를 사용하면 일반 join과는 다르게 한 방에 데이터를 조회할 수 있다. 다음 결과를 한번 살펴보자.

// JPQL 회원 조회 결과
Hibernate:
    /* select
        m
    FROM
        JpqlMember m
    join
        fetch m.team */ select
            jpqlmember0_.id as id1_10_0_,
            jpqlteam1_.TEAM_ID as team_id1_13_1_,
            jpqlmember0_.age as age2_10_0_,
            jpqlmember0_.TEAM_ID as team_id5_10_0_,
            jpqlmember0_.type as type3_10_0_,
            jpqlmember0_.username as username4_10_0_,
            jpqlteam1_.name as name2_13_1_
        from
            JPQL_MEMBER jpqlmember0_
        inner join
            JPQL_TEAM jpqlteam1_
                on jpqlmember0_.TEAM_ID=jpqlteam1_.TEAM_ID
member = 회원1, 팀A
member = 회원2, 팀A
member = 회원3, 팀B
3월 23, 2022 7:22:53 오후 org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl$PoolState stop
INFO: HHH10001008: Cleaning up connection pool [jdbc:h2:tcp://localhost/~/jpashop]

Process finished with exit code 0

join fetch를 사용하게 되면 MEMBER와 TEAM을 조인해서 가져올 때 프록시가 아닌, 실제 데이터를 가져온다.

03. 컬렉션 페치 조인

@Entity
public class Member {

    //..중략

    // @OneToOne, @ManyToOne은 default가 즉시 로딩이기 때문에, 반드시 지연로딩으로 설정해야 한다
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "TEAM_ID")
    private Team team;

    //..중략
}

@Entity
public class Team {

    //..중략

    @OneToMany(mappedBy = "team")
    private List<Member> memberList = new ArrayList<>();

    //..중략
}

일대다 관계[1 : N], 컬렉션 페치 조인
@OneToMany 관계
- JPQL에서 데이터를 조회할 때 target을 Team으로 한다는 의미다.
DB 입장에서 1 : N 조인이 일어나는 경우 데이터가 뻥튀기 될 수 있다.
N : 1은 데이터 뻥튀기가 일어나지 않는다.

-- JPQL
select t
from Team t join fetch t.memberList -- memberList => List<Member> => Collection fetch join
where t.name = '팀A'

-- DB
SELECT T.*, M.*
FROM TEAM T
INNER JOIN MEMBER M
ON T.ID=M.TEAM_ID
WHERE T.NAME = '팀A'

2022_03_23_fetch_join_team

Team 입장에서는 하나의 데이터지만, Member 입장에서는 2개의 데이터가 된다.
즉, 위와 같은 이유로 조인을 수행하면 2개의 데이터가 하나로 묶여 나오게 된다.
JPA는 이렇게 묶인(2개의 row) 데이터를 알 수가 없다.
- 객체와 RDB의 차이점.
- 만약 회원이 200000명이라면, 해당 데이터를 다 묶어서 가져올 것이다.

그렇다면 이러한 중복 데이터를 제거하는 방법은 무엇일지 생각해야 한다.
해당 내용은 “04. 패치 조인과 DISTINCT” 장에서 알아볼 것이다.

03-1. 컬렉션 페치 조인 사용 코드

// memberList가 List 컬렉션
String jpql = "select t from Team t join fetch t.memberList where t.name = '팀A'";
List<JpqlTeam> teamList = em.createQuery(jpql, JpqlTeam.class).getResultList();

for (JpqlTeam team : teamList) {
     //페치 조인으로 팀과 회원을 함께 조회해서 지연 로딩 발생 안함
     System.out.println("team = " + team.getName() + ", " + team.getMemberList().size());
}

// JPQL 회원 조회 결과
Hibernate:
    /* select
        t
    FROM
        JpqlTeam t
    join
        fetch t.memberList */ select
            jpqlteam0_.TEAM_ID as team_id1_13_0_,
            memberlist1_.id as id1_10_1_,
            jpqlteam0_.name as name2_13_0_,
            memberlist1_.age as age2_10_1_,
            memberlist1_.TEAM_ID as team_id5_10_1_,
            memberlist1_.type as type3_10_1_,
            memberlist1_.username as username4_10_1_,
            memberlist1_.TEAM_ID as team_id5_10_0__,
            memberlist1_.id as id1_10_0__
        from
            JPQL_TEAM jpqlteam0_
        inner join
            JPQL_MEMBER memberlist1_
                on jpqlteam0_.TEAM_ID=memberlist1_.TEAM_ID
team = 팀A, 2
-> Member = JpqlMember{id=3, username='회원1', age=0}
-> Member = JpqlMember{id=4, username='회원2', age=0}
team = 팀A, 2
-> Member = JpqlMember{id=3, username='회원1', age=0}
-> Member = JpqlMember{id=4, username='회원2', age=0}
team = 팀B, 1
-> Member = JpqlMember{id=5, username='회원3', age=0}

팀A 는 중복되서 나온다.
JPA는 뻥튀기 된 데이터의 중복을 제거하지 않고, 그대로 반환 한다는 의미.

04. 페치 조인과 DISTINCT

SQL의 DISTINCT는 중복된 결과를 제거하는 명령이다.
JPQL의 DISTINCT 2가지 기능을 제공한다.
- SQL에 DISTINCT를 추가.
- 애플리케이션에서 엔티티 중복 제거.

-- JPQL
select distinct t
from JpqlTeam t join fetch t.memberList
where t.name = '팀A'

SQL에서 DISTINCT를 추가하지만 데이터가 다르므로 SQL 결과에서 중복제거 실패

2022_03_23_fetch_join_distinct

04-1. 페치 조인과 DISTINCT

DISTINCT 추가로 애플리케이션에서 중복 제거 시도.
같은 식별자를 가진 Team 엔티티 제거.

2022_03_23_fetch_join_disticnt2

// DISTINCT 추가시 결과
teamname = 팀A, team = Team@0x100
-> username = 회원1, member = Member@0x200
-> username = 회원2, member = Member@0x300

05. 페치 조인과 일반 조인의 차이

일반 조인 실행 시 연관된 엔티티를 함께 조회하지 않는다.

-- JPQL
select t
from Team t join t.memberList m
where t.name = '팀A'

-- DB
SELECT T.*
FROM TEAM T
INNER JOIN MEMBER M ON T.ID=M.TEAM_ID
WHERE T.NAME = '팀A'

JPQL은 결과를 반환할 때 연관관계를 고려하지 않는다.
단지 SELECT 절에 지정한 엔티티만 조회할 뿐이다.
- 여기서는 팀 엔티티만 조회하고, 회원 엔티티는 조회하지 않는다.
페치 조인을 사용할 때만 연관된 엔티티도 함께 조회 한다(즉시 로딩)
페치 조인은 객체 그래프를 SQL 한 번에 조회하는 개념이다.

참고 자료

페치 조인(fetch join) - 기본

Twitter Facebook LinkedIn

YOUNGMINKIM

[JPA] 페치 조인(fetch join) - 기본

📌 Topic

⚡ JPQL fetch join

01. 페치 조인(fetch join)

02. 엔티티 페치 조인

02-1. 페치 조인 사용

03. 컬렉션 페치 조인

03-1. 컬렉션 페치 조인 사용 코드

04. 페치 조인과 DISTINCT

04-1. 페치 조인과 DISTINCT

05. 페치 조인과 일반 조인의 차이

참고 자료

공유하기

댓글남기기

참고

[쿠버네티스(v1.20)] 쿠버네티스의 구성요소와 파드 배포 흐름 확인

[쿠버네티스(v1.20)] 파드, 서비스, 로드밸런서를 통한 서비스 배포

[쿠버네티스(v1.20)] 코드로 쉽게 구성하는 쿠버네티스 랩 환경

[쿠버네티스(v1.20)] 쿠버네티스란?