[QueryDSL] QueryDSL-JPA : JOIN 하기

🏝 환경

- QueryDSL 5.0.0
- Spring Data JPA 3.1.2

 

 

💜 JOIN 종류

1. INNER JOIN

JOIN 당하는 테이블을 A, JOIN을 거는 테이블을 B라고 할 때, A와 B 테이블 모두 JOIN을 하려는 대상 Key 컬럼에 대해 값이 존재하는 경우만 JOIN을 하는 것을 INNER JOIN이라고 합니다.

 

queryDSL에서 Inner join을 쓰는 방법은 간단합니다.

queryFactory에서 select와 from절 이후에 join 메서드를 포함하면 됩니다.

 

아래는 코드 예시입니다. 

@Entity
@Getter
@Table(name = "neo_starpage")
public class StarPage {

    @EmbeddedId
    @AttributeOverride(name = "value", column = @Column(name = "star_page_id"))
    private StarPageId starPageId;

    // 스타 페이지 정보
    @Embedded
    private StarPageInfo information;

    // 스타 페이지 수정 가능 어드민
    @ElementCollection
    @CollectionTable(name = "neo_starpage_admin", joinColumns = @JoinColumn(name = "star_page_id"))
    private Set<NEOMember> admins = new HashSet<>();

    // 스타페이지를 구성하는 레이아웃 구성요소
    @OneToMany(cascade = {CascadeType.PERSIST, CascadeType.REMOVE}, orphanRemoval = true)
    @JoinColumn(name = "star_page_id")
    @OrderColumn(name = "layout_order")
    private List<StarPageLayoutLine> layoutLines = new ArrayList<>();
    
}

@Getter
@Entity
@Table(name = "neo_starpage_layout")
@DiscriminatorColumn(name = "unique_or_categorical")
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
public abstract class StarPageLayoutLine {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long layoutId;

    @Embedded
    @AttributeOverride(name = "value", column = @Column(name = "layout_title"))
    private LayoutTitle layoutTitle;

    @Column(name = "layout_type")
    @Enumerated(EnumType.STRING)
    private StarPageLayoutType type;

    public StarPageLayoutLine(LayoutTitle layoutTitle, StarPageLayoutType type){
        this.layoutTitle = layoutTitle;
        this.type = type;
    }

    public abstract boolean isRemoveAble();

    public abstract List<? extends StarPageHeadLine> getHeadLineByLayout(StarPageId starPageId, StarPageRepository repo);

}

    @Override
    public Optional<StarPage> findStarPageWithLayout(StarPageId starPageId) {
        return Optional.ofNullable(queryFactory
                .selectFrom(starPage)
                .innerJoin(starPage.layoutLines, starPageLayoutLine).fetchJoin()
                .where(starPage.starPageId.eq(starPageId))
                .fetchOne());
    }

 

위 queryDSL 코드의 starPage와 starPageLayoutLine은 Q클래스 객체입니다.

inner join을 통해 스타페이지와 레이아웃 테이블을 INNER JOIN하는 것을 볼 수 있습니다.

INNER JOIN이기 떄문에 레이아웃 테이블에 특정 스타페이지 아이디가 없다면, 해당 스타페이지 아이디에 대한 스타페이지 테이블의 내용도 포함되지 않습니다.

 

 

2. LEFT JOIN, RIGHT JOIN

 

 

Left Join은 JOIN 당하는 테이블 (from 절)의 모든 테이블에 대해 JOIN 하려는 대상 테이블의 데이터를 합치는 JOIN입니다.

만약 Right Table에 Left Table의 키 값을 가지고 있지 않다면, JOIN된 테이블에서는 해당 부분은 NULL인 상태로 JOIN 됩니다.

 

 

 

Right Join은 JOIN 하려는 대상 테이블에 대해 JOIN 당하는 대상 테이블(from)의 데이터를 합치는 JOIN입니다.

만약 Left Table에 Right Table의 키 값을 가지고 있지 않다면, JOIN된 테이블에서는 해당 부분은 NULL인 상태로 JOIN 됩니다.

 

 

QueryDSL에서는 .leftJoin(), .rightJoin()을 통해 구현할 수 있습니다.

아래는 .leftJoin()을 사용한 예시입니다.

 

    @Override
    public List<RepresentativeArticleHeadLine> searchHeadLineByStarPageIdAndLimit(StarPageId id, long limit) {
        // 카테고리명, 제목, 작성자, 좋아요 수, 글 내용 확인 API Path, 대표 이미지 DTO에 담기.
        return queryFactory
                .select(
                        Projections.constructor(
                                RepresentativeArticleHeadLine.class,
                                starPagePost.id, starPagePost.likeCount, starPagePost.author.authorName,
                                category.categoryInformation.categoryTitle, starPagePost.postType.stringValue(), starPagePost.title,
                                albumPost.image.path.coalesce(commonPost.representativeImage).as("representativeImage"),
                                Expressions.asString("베스트 팬 게시물").as("tapName")
                        ))
                .from(starPagePost)
                .innerJoin(category).on(starPagePost.categoryId.eq(category.categoryId))
                .leftJoin(albumPost).on(eqPostId(albumPost.id))
                .leftJoin(commonPost).on(eqPostId(commonPost.id))
                .leftJoin(starPage).on(starPage.starPageId.eq(category.starPageId))
                .where(
                        eqStarPageId(id),
                        neHostEmail(starPage.information.host.email),
                        eqPostStatus(PostStatus.MAIN_EXPOSED)
                )
                .orderBy(starPagePost.exposureAt.desc())
                .limit(limit)
                .fetch();
    }

starPagePost는 common, album, vote, goldbalance 총 4개의 유형으로 나눠져있고, JOIN 테이블 전략으로 상속하는 부모 엔티티입니다.

스타페이지 포스트들 중에 album, common만 미리보기 이미지를 포함하고 있기 때문에 나머지 포스트 유형에 대해 albumPost, commonPost를 innerJoin을 한다면 vote, goldbalance인 포스트들은 테이블에서 빠지게 됩니다. 그렇기 때문에 leftJoin을 활용한 모습입니다.

 

 

3. Fetch JOIN

 

JPQL의 Fetch JOIN은 관계형 엔티티에서 연관된 엔티티들을 함께 로딩하는 방법을 지정하는 기능입니다. Fetch JOIN을 사용하면 연관된 엔티티를 지연 로딩(Lazy Loading)이 아니라 즉시 로딩(Eager Loading)할 수 있습니다. 이를 통해 N+1 쿼리 문제를 방지하고 성능을 향상시킬 수 있습니다.

 

JPA를 사용하면서 연관관계가 있는 Entity, ElementCollection에 대해 JOIN을 통해 한 번에 가져오길 원하는 경우가 많은데 Fetch JOIN을 통해 문제를 해결할 수 있습니다.

 

QueryDSL-JPA는 JPQL을 Typesafe하게 작성할 수 있도록 도와주는 라이브러리이므로, QueryDSL-JPA에서도 FetchJoin을 사용할 수 있습니다.

사용법은 단순하게 .innerJoin(), .leftJoin(), .rightJoin() 뒤에 .fetchJoin()을 붙여주기만 하면 됩니다.

.innerJoin(starPage.layoutLines, starPageLayoutLine).fetchJoin()

 

아래는 FetchJoin을 한 경우와 하지 않은 경우에 대한 결과입니다.

fetchJoin()을 한 경우

 

fetchJoin()을 하지 않은 경우

 

- FetchJoin을 한 경우에는 연관관계에 속한 엔티티의 값까지 한 번에 SELECT하는 것을 볼 수 있습니다. 즉시 로딩을 통해 layout을 사용하더라도 추가 쿼리 없이 바로 사용가능합니다.

- FetchJoin을 하지 않은 경우에는 JOIN은 잘 되었지만, SELECT에는 layout에 대한(연관관계 엔티티) 정보는 가져오지 않는 것을 확인할 수 있습니다. 이 경우에는 스타페이지에서 레이아웃을 사용한다면 추가 쿼리가 발생하게 됩니다.

 

참고로 조회를 위해 엔티티가 아닌 'DTO'를 SELECT 한다면, FetchJoin은 당연하게도 필요 없습니다.

FetchJoin은 JPQL의 Fetch JOIN은 관계형 엔티티에서 연관된 엔티티들을 함께 로딩하는 방법을 지정하는 기능입니다. 따라서 DTO는 엔티티가 아니기 때문에 사용하면 오류가 납니다.

query specified join fetching, but the owner of the fetched association was not present in the select list

 

DTO는 일반적인 JOIN만 진행하면 됩니다.

 

+ 엔티티를 사용할 때 JOIN을 하면 무조건 즉시로딩을 위한 JOIN인가? 무조건 FetchJoin인가?

즉시로딩을 위한 JOIN이라면 FetchJoin을 쓰면 되지만,
즉시로딩을 원하는 것이 아니라 연관된 엔티티에 대한 '조건'만 필요한 경우에는 일반 조인을 사용할 수 있습니다.

 

 

 

4. CROSS JOIN (명시적 JOIN을 통해 CROSS JOIN에 의한 성능 저하 제거)

Querydsl (JPA) 에서 Cross Join 발생할 경우

QueryDSL, JPA CrossJoin

 

명시적인 JOIN을 사용하면 CROSS JOIN이 발생하지 않습니다.

연관관계를 맺은 엔티티에서 별다른 JOIN 없이 WHERE 조건 절에서 연관관계 엔티티를 사용한다면 하이버네이트에서 CROSS JOIN을 암묵적으로 선택하는 경향이 있습니다.

 

따라서 QueryDSL을 작성할 때 명시적으로 JOIN문을 작성하는 것을 권장합니다.

 

 

💜 JOIN 대상에 따른 정리

1. 연관관계가 있는 Entity간 JOIN하기

 

🤔 StarPage Entity

@Entity
@Getter
@Table(name = "neo_starpage")
public class StarPage {

    @EmbeddedId
    @AttributeOverride(name = "value", column = @Column(name = "star_page_id"))
    private StarPageId starPageId;

    // 스타 페이지 정보
    @Embedded
    private StarPageInfo information;

    // 스타 페이지 수정 가능 어드민
    @ElementCollection
    @CollectionTable(name = "neo_starpage_admin", joinColumns = @JoinColumn(name = "star_page_id"))
    private Set<NEOMember> admins = new HashSet<>();

    // 스타페이지를 구성하는 레이아웃 구성요소
    @OneToMany(cascade = {CascadeType.PERSIST, CascadeType.REMOVE}, orphanRemoval = true)
    @JoinColumn(name = "star_page_id")
    @OrderColumn(name = "layout_order")
    private List<StarPageLayoutLine> layoutLines = new ArrayList<>();
    
}

 

위의 코드에서, StarPage와 StarPageLayoutLine은 1:N의 연관관계(@OneToMany)를 가집니다. 이 두 엔티티를 한 번에 InnerJoin해 가져오려면, 아래와 같이 코드를 작성합니다.

 

    @Override
    public Optional<StarPage> findStarPageWithLayout(StarPageId starPageId) {
        return Optional.ofNullable(queryFactory
                .selectFrom(starPage)
                .innerJoin(starPage.layoutLines, starPageLayoutLine).fetchJoin()
                .where(starPage.starPageId.eq(starPageId))
                .fetchOne());
    }

// .innerJoin(엔티티의 연관관계 필드, 연관관계 대상 Q클래스).fetchJoin()
.innerJoin(starPage.layoutLines, starPageLayoutLine).fetchJoin()

위와 같은 문법으로 Join을 한다면, JoinColumn을 기반으로 두 테이블을 Join해 스타페이지 엔티티를 가져옵니다. 언급한 FetchJoin을 사용해 레이아웃도 함께 가져오게 됩니다. 아래처럼요.

 

 

 

2. 연관관계가 없는 Entity간 JOIN하기 (다른 애그리거트의 ID를 소지한 경우 등.)

 

하지만 우리는 연관관계를 가진 엔티티에 대해서만 JOIN을 하지 않습니다.

DDD START!라는 책에서는 애그리거트의 연관관계 남용을 방지하기 위해 상대 애그리거트에 대한 ID를 포함하는 방식을 제시합니다. 이러한 경우에는 JPA 연관관계를 사용하지 않고, 상대 테이블에 대한 ID만을 가지고 있기 때문에 위와 같은 형식으로는 테이블 조인을 진행할 수 없습니다.

 

QueryDSL을 사용하면 .on 메서드와 함께 사용하면 문제를 해결할 수 있습니다.

아래는 예시 코드입니다.

 

🤔 StarPagePost Entity

@Entity
@Table(name = "star_page_post")
@Inheritance(strategy = InheritanceType.JOINED)
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public abstract class StarPagePost extends NEOTimeDefaultEntity {

    @Id
    @Column(name = "post_id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Embedded
    @Column(name = "category_id")
    private CategoryId categoryId;

    @Column(name = "post_title")
    private String title;

    @Embedded
    @Column(name = "author_name")
    private Author author;

    @Column(name = "status")
    @Convert(converter = PostStatusConverter.class)
    private PostStatus status;

    @Column(name = "like_count", nullable = false)
    private int likeCount;

    @Column(name = "host_heart", nullable = false)
    private boolean hostHeart;

    @Column(name = "exposure_at")
    private LocalDateTime exposureAt;

    @Column(name = "post_type", nullable = false)
    @Convert(converter = PostTypeConverter.class)
    private PostType postType;

    @ElementCollection
    @CollectionTable(name = "star_page_post_like", joinColumns = @JoinColumn(name = "post_id"))
    private Set<PostLike> likes = new HashSet<>();
 
 }

 

🤔 Category Entity

@Entity
@Table(name = "neo_starpage_category")
@AllArgsConstructor
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class Category {

    @Getter
    @EmbeddedId
    @Column(name = "category_id")
    private CategoryId categoryId;

    @Getter
    @Column(name = "starpage_id")
    private StarPageId starPageId;

    @Column(name = "category_status")
    @Convert(converter = CategoryStatusConverter.class)
    private CategoryStatus categoryStatus;

    @Getter
    @Column(name = "content_type")
    @Convert(converter = ContentTypeConverter.class)
    private ContentType contentType;

    @Getter
    @Embedded
    @AttributeOverride(name = "categoryTitle", column = @Column(name = "title"))
    private CategoryInformation categoryInformation;

    @Embedded
    private ContentRestriction restriction;
    
}

 

StarPagePost 엔티티는 Category의 ID를 소지하고 있습니다. JPA 연관관계를 사용했었다면, Category : StarPagePost는 1:N의 관계를 갖게 됩니다.

 

아래는 메인화면에 노출될 헤드라인을 조건에 따라 뽑아오는 QueryDSL 코드인데요,

나머지 코드는 보지 않고 연관관계가 없는 Entity간 JOIN하는 방법을 알기 위한 자료이니 innerJoin과 leftJoin만 보면 됩니다.

 

🤔 연관관계가 없는 Entity간 Join하는 QueryDSL 예시 코드

    @Override
    public List<RepresentativeArticleHeadLine> searchHeadLineByStarPageIdAndLimit(StarPageId id, long limit) {
        // 카테고리명, 제목, 작성자, 좋아요 수, 글 내용 확인 API Path, 대표 이미지 DTO에 담기.
        return queryFactory
                .select(
                        Projections.constructor(
                                RepresentativeArticleHeadLine.class,
                                starPagePost.id, starPagePost.likeCount, starPagePost.author.authorName,
                                category.categoryInformation.categoryTitle, starPagePost.postType.stringValue(), starPagePost.title,
                                albumPost.image.path.coalesce(commonPost.representativeImage).as("representativeImage"),
                                Expressions.asString("베스트 팬 게시물").as("tapName")
                        ))
                .from(starPagePost)
                .innerJoin(category).on(starPagePost.categoryId.eq(category.categoryId))
                .leftJoin(albumPost).on(eqPostId(albumPost.id))
                .leftJoin(commonPost).on(eqPostId(commonPost.id))
                .leftJoin(starPage).on(starPage.starPageId.eq(category.starPageId))
                .where(
                        eqStarPageId(id),
                        neHostEmail(starPage.information.host.email),
                        eqPostStatus(PostStatus.MAIN_EXPOSED)
                )
                .orderBy(starPagePost.exposureAt.desc())
                .limit(limit)
                .fetch();
    }

// .innerJoin(Join하고자 하는 엔티티 Q객체).on(조건(소지하고 있는 아이디와, Join하고자 하는 엔티티의 아이디가 동일하다는 조건))
.innerJoin(category).on(starPagePost.categoryId.eq(category.categoryId))

 

위와 같이 Join과 on 메서드를 사용하면 연관관계가 없는 두 엔티티간 Join도 가능합니다.

 

 

 

3. Entity와 컬렉션 VO(Element Collection)간 JOIN하기

[QueryDSL] QueryDSL-JPA : @ElementCollection VO에 대한 JOIN

 

이전 글에서 작성했듯이, 별다른 .on() 메서드를 사용하지 않고 해당 Q타입 객체에서 컬렉션 VO를 선택하면 JOIN을 할 수 있습니다.

    @Override
    public Optional<StarPage> findStarPageWithInformation(StarPageId starPageId) {
        return Optional.ofNullable(queryFactory.
                selectFrom(starPage)
                .innerJoin(starPage.information.host.starTypes).fetchJoin()
                .innerJoin(starPage.information.host.snsLines).fetchJoin()
                .where(starPage.starPageId.eq(starPageId))
                .fetchOne());
    }

 

위의 코드에서 starPage는 애그리거트 루트인 엔티티이며, starPage.information.host.starTypes는 컬렉션 값 객체입니다. 별다른 방법 없이 Q타입의 컬렉션 값 객체를 넣어주면 자동으로 연계된 엔티티의 ID를 기준으로 JOIN되어 SELECT하는 모습을 볼 수 있습니다.