[QueryDSL] QueryDSL-JPA : DTO Projection과 Transform

QueryDSL을 사용하면서 조회 Query 성능을 높이는 방법 중에 하나는, 엔티티가 아닌 DTO로 값을 받으면 속도 향상을 얻을 수 있습니다.

그 이유는 아래와 같은데요.

1. 필요한 필드만 조회하므로 당연하게도 조회 속도가 증가한다.

SQL의 SELECT문을 보면, 필요한 컬럼만 얻어오는 것이 테이블 전체를 얻어오는 것보다 당연하게도 빠릅니다. DTO를 사용하면 필요한 데이터만 조회하려는 의도가 내포되어 있습니다.

불필요한 데이터를 가져오지 않음으로써 쿼리 성능을 최적화 할 수 있습니다.

2. JPA의 영속성 컨텍스트의 관리대상이 아니다.

엔티티는 JPA의 관리 대상이므로 영속성 컨텍스트에 의해 관리됩니다. 따라서 엔티티를 조회할 때는 메모리 사용량이 상대적으로 더 많을 수 있습니다.

반면 DTO는 순수한 데이터 객체이므로 영속성 컨텍스트에 의해 관리되지 않습니다. 따라서 DTO를 사용하면 메모리 사용량을 줄일 수 있습니다.

또한 Lazy Loading 등의 추가 쿼리 발생 여지도 없습니다.

추가적으로 성능과 별개로, 엔티티는 DDD에서는 애그리거트 루트이므로 비즈니스 로직을 포함하지만, DTO는 별개의 데이터 전송 객체이므로 분리된 형태로 사용됩니다. 시스템의 유지보수성과 확장성을 얻을 수 있습니다.

데이터베이스로부터 조회를 하기 원한다면 DTO를 사용하는 것이 좋은데, QueryDSL의 쿼리 결과로 DTO를 얻으려면 어떻게 해야 할까요?

바로 DTO Projection을 통해 문제를 해결할 수 있습니다.

💜 DTO Projection

DTO Projection을 위해 QueryDSL의 com.querydsl.core.types 패키지에서 Projections 클래스를 제공하게 됩니다.

쿼리를 통해 얻어낸 엔티티의 결과물을 DTO로 매핑시키기 위한 Projection 방법은 크게 4가지가 있습니다.

1-1. Projections.bean

public class UserDTO {
    private Long id;
    private String username;

    public UserDTO(){}
    
    public Long getId(){
    	return this.id;
    }
    
    public void setId(Long id){
    	this.id = id;
    }
    
    public String getUserName(){
    	return this.username;
    }
    
    public void setUserName(String username){
    	this.username = username;
    }
}

List<UserDTO> userDTOs = queryFactory
    .select(Projections.bean(UserDTO.class, user.id, user.username))
    .from(user)
    .fetch();

첫 번째는 기본 생성자와 setter, getter를 사용하는 Projections.bean 방식입니다.

DTO에 기본 생성자와 setter, getter가 있는 경우 사용할 수 있습니다.

Projections.bean(DTO의 클래스, 매핑될 필드1, 매핑될 필드2, ...)

위와 같은 형식을 통해 사용할 수 있습니다.

기본 생성자를 사용하기 때문에, 접근제어자가 public인 기본 생성자를 반드시 생성해야 합니다.

public class UserDTO {
    private Long id;
    private String name;

    public UserDTO(){}
    
    public Long getId(){
    	return this.id;
    }
    
    public void setId(Long id){
    	this.id = id;
    }
    
    public String getName(){
    	return this.name;
    }
    
    public void setName(String name){
    	this.name = name;
    }
}

List<UserDTO> userDTOs = queryFactory
    .select(Projections.bean(UserDTO.class, user.id, user.username.as("name")))
    .from(user)
    .fetch();

쿼리에 대한 결과와 DTO의 필드 명이 다르다면, 위와 같이 .as()를 통해 별칭을 정의해줘야 Projection이 올바르게 작동합니다.

1-2. Projections.fields

public class UserDTO {
    public Long id;
    public String username;
}

List<UserDTO> userDTOs = queryFactory
    .select(Projections.fields(UserDTO.class, user.id, user.username))
    .from(user)
    .fetch();

위의 Projections.bean 방식과 굉장히 유사하지만, 필드의 이름을 통해 프로젝션을 진행합니다.

1-3. Projections.constructor

public class UserDTO {
    private Long id;
    private String username;

    public UserDTO(Long id, String username) {
        this.id = id;
        this.username = username;
    }

    // getter 생략
}

List<UserDTO> userDTOs = queryFactory
    .select(Projections.constructor(UserDTO.class, user.id, user.username))
    .from(user)
    .fetch();

정의된 생성자를 통해 DTO에 프로젝션을 진행하는 방식입니다.

사용법으로는 Projections.constructor를 사용하게 되며, 첫 번째 파라미터인 DTO 클래스 이후에는 생성자의 파라미터 순서대로 값을 넣어줘야 합니다.

1-4. @QueryProjection

public class UserDTO {
    private final Long id;
    private final String username;

    @QueryProjection
    public UserDTO(Long id, String username) {
        this.id = id;
        this.username = username;
    }

    // getter 생략
}

List<UserDTO> userDTOs = queryFactory
    .select(new QUserDTO(user.id, user.username))
    .from(user)
    .fetch();

마지막으로 @QueryProjection을 이용하는 방식입니다.

DTO의 생성자 위에 @QueryProjection 어노테이션을 붙여주면, 해당 DTO 역시 Q타입 클래스가 자동으로 생성됩니다.

QueryDSL 코드에서 new QUserDTO와 같이 QDTO객체를 생성해 사용할 수 있습니다.

다른 방법에 비해 컴파일 타임에 필드 타입 체킹이 가능해 타입 세이프하고, DTO 객체를 new 키워드를 통해 생성하기 때문에 좀 더 친숙한 코드가 되는 것이 장점입니다.

좋은 방법이지만, DTO가 QueryDSL에 종속적이므로, 각 계층별로 DTO 변환이 이뤄지는 구조에는 사용해도 큰 문제가 없지만 그렇지 않은 경우에는 DTO가 QueryDSL에 의해 의존관계가 복잡해질 염려가 있어 이 점을 충분히 고려한 후 사용해야 합니다.

💜 DTO Transform / Groupby

Querydsl Reference Guide

The Java 6 APT annotation processing functionality is used in Querydsl for code generation in the JPA, JDO and Mongodb modules. This section describes various configuration options for the code generation and an alternative to APT usage. 3.3.1. Path initi

querydsl.com

querydsl/querydsl-collections/src/test/java/com/querydsl/collections/GroupByTest.java at master · querydsl/querydsl

Unified Queries for Java. Contribute to querydsl/querydsl development by creating an account on GitHub.

github.com

위의 테스트 코드 자료를 살펴보면, 쉽게 transform, groupBy 메서드에 대해 이해할 수 있습니다.

QueryDSL에서는 데이터를 불러와 메모리에서 데이터를 원하는 자료형으로 가공할 수 있는 메서드를 제공하는 데, 그것이 바로 transfrom()과 groupBy()입니다.

transform 내에서 사용되는 groupBy 메서드는 SQL에서의 GroupBy 와는 다르며, transform에서 groupBy를 쓴다고 해서 쿼리에서 groupBy 쿼리가 나가지 않습니다.

예시 코드를 하나 살펴봅시다.

    private static final List<Post> posts = Arrays.asList(
            new Post(1, "Post 1", users.get(0)),
            new Post(2, "Post 2", users.get(0)),
            new Post(3, "Post 3", users.get(1)));

    private static final List<Comment> comments = Arrays.asList(
            new Comment(1, "Comment 1", users.get(0), posts.get(0)),
            new Comment(2, "Comment 2", users.get(1), posts.get(1)),
            new Comment(3, "Comment 3", users.get(2), posts.get(1)),
            new Comment(4, "Comment 4", users.get(0), posts.get(2)),
            new Comment(5, "Comment 5", users.get(1), posts.get(2)),
            new Comment(6, "Comment 6", users.get(2), posts.get(2)));
            
    private static final QComment comment = QComment.comment;

    private static final QPost post = QPost.post;


    @Test
    public void group_min() {
        Map<Integer, String> results = CollQueryFactory.from(post, posts).from(comment, comments)
            .where(comment.post.id.eq(post.id))
            .transform(groupBy(post.id).as(min(comment.text)));

        assertEquals("Comment 1", results.get(1));
        assertEquals("Comment 2", results.get(2));
        assertEquals("Comment 4", results.get(3));
    }

포스트와 해당 포스트의 댓글을 가져와 결과를 집계할 때, fetch()가 아닌 transform()을 통해 다르게 집계할 수 있습니다.

.transform(groupBy(기준 Key 값).as(Key 값에 매핑될 값))을 사용하면 Map 타입으로 매핑됩니다.

.groupBy 메서드(.transform 이전에 거는 .groupBy 메서드)와는 다른 점은, .groupBy 메서드를 통해 SQL 쿼리를 날리면 SELECT 문에 groupBy 쿼리가 나가지만 Map<Integer, String>과 같이 자료형이 매핑되지 않고 QueryDSL의 자료형인 Tuple으로 리턴됩니다.

물론 .groupBy 메서드와 .transform(groupBy())를 같이 사용해 SELECT에도 필요한 데이터만 셀렉트 하고 집계 역시 Java에서 사용하고 싶은 자료형으로 변경하는 것도 가능합니다.

아래의 예시부터는 제가 transform 메서드를 개발에서 활용한 예시입니다.

🤔 사용된 도메인 코드

💜 StarPagePost Aggregate Root

@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 Aggregate Root

@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 Aggregate Root

@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<>();
    
}

💜 VotePost Aggregate Root

@Entity
@Table(name = "star_page_vote_post")
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class VotePost extends StarPagePost {

    @Column(name = "question")
    private String question;

    @Column(name = "vote_status")
    @Enumerated(value = EnumType.STRING)
    private VoteStatus voteStatus;

    @Column(name = "time_to_live")
    private int timeToLive;

    @OneToMany(cascade = CascadeType.ALL, orphanRemoval = true)
    @JoinColumn(name = "post_id")
    @OrderColumn(name = "vote_item_order")
    private List<VoteItem> voteItems = new ArrayList<>();

}

💜 VotePostHeadLine DTO

@Getter
@ToString
@RequiredArgsConstructor
public class StarPageHeadLine {
    private final Long postId;
    private final int likeCount;
    private final String categoryType;
}


@Getter
@ToString(callSuper = true)
public class VotePostHeadLine extends StarPageHeadLine {
    private final String question;
    private final Map<String, Integer> optionCount;

    public VotePostHeadLine(Long postId, int likeCount, String question, Map<String, Integer> optionCount){
        super(postId, likeCount, ContentType.VOTE.name());
        this.question = question;
        this.optionCount = optionCount;
    }
}

💜 QueryDSL 코드

    @Override
    public List<VotePostHeadLine> searchVotePostHeadLineByCategoryId(StarPageId starPageId, CategoryId categoryId, long limit) {
        return queryFactory
                // 1. 우선 Entity가 아닌 Tuple 형태의 결과물이 나오도록 Select
                .select(
                        starPagePost.id,
                        starPagePost.likeCount,
                        votePost.question,
                        voteItem.optionText,
                        voteItem.voterSet.size()
                )
                .from(starPagePost)
                .innerJoin(category).on(starPagePost.categoryId.eq(category.categoryId))
                .innerJoin(votePost).on(eqPostId(votePost.id))
                .innerJoin(votePost.voteItems, voteItem)
                .where(
                        eqStarPageId(starPageId),
                        eqCategoryId(categoryId),
                        eqPostStatus(PostStatus.OPEN).or(eqPostStatus(PostStatus.MAIN_EXPOSED))
                )
                .orderBy(starPagePost.createdAt.desc())
                .limit(limit)
                // 2. transform과 groupby를 통해 메모리에서 DTO로 변환
                .transform(GroupBy.groupBy(starPagePost.id)
                        .list(Projections.constructor(
                                VotePostHeadLine.class,
                                starPagePost.id,
                                starPagePost.likeCount,
                                votePost.question,
                                map(voteItem.optionText, voteItem.voterSet.size())
                        )));
    }

QueryDSL에서 DTO 프로젝션과 transform을 같이 사용한 예시입니다.

코드를 보면, 포스트의 ID / 좋아요 수 / 투표 포스트의 질문 / 질문 항목 / 질문 항목 당 투표 수를 SELECT하고 있습니다.

Tuple(1, 0, "몇 시에 만날까요?", "3시", 0)
Tuple(1, 0, "몇 시에 만날까요?", "4시", 0)
Tuple(1, 0, "몇 시에 만날까요?", "5시", 0)

한 투표형 포스트당 여러 항목과 그 항목에 대한 투표수를 갖고 있기 때문에 1:N의 자료형태가 됩니다.

이때 .transform(groupBy())에서 starPagePost.id 키 값을 기준으로 집계를 시도합니다.

.as()를 사용하면 Map으로 매핑되지만, list로도 매핑할 수 있습니다.

GroupBy.groupBy().list()에서 list 메서드, 뒤에 나오는 list 속의 map 메서드는 사용하려면 아래와 같이 import를 해야 합니다.

import static com.querydsl.core.group.GroupBy.list;
import static com.querydsl.core.group.GroupBy.map;

VotePostHeadLine에서 필드로 Map<String, Integer> 자료형을 갖고 있는데, 해당 필드를 map() 메서드를 통해 매핑한 모습입니다.

아래는 해당 쿼리와 결과 값입니다.

Select 문을 보면, 요구사항에 맞는 값들을 SELECT하고, 최종 아래의 결과를 보면 VotePostHeadLine에 알맞게 Select 한 값이 transform 된 것을 확인할 수 있습니다. (option_text와 select count 서브쿼리를 Map으로 변경)

1:N 관계를 가졌던 optionCount에도 올바르게 3시, 4시, 5시에 대한 내용이 잘 매핑된 것을 확인할 수 있습니다.

저작자표시 비영리 변경금지

'🌱 백엔드 : Backend' 카테고리의 다른 글

[Redis] M1 MacOS에서 Docker Redis Cluster 설정하기 + SpringBoot 애플리케이션에 클러스터 연결하기 (1)	2024.05.11
[QueryDSL] QueryDSL-JPA : JOIN 하기 (0)	2024.04.25
[QueryDSL] QueryDSL-JPA : @ElementCollection VO에 대한 JOIN (1)	2024.04.23
[Spring] Spring Security + OAuth2.0 + JWT Token을 활용한 소셜로그인 총정리 - (1) 배경 지식 이해하기, 전체 그림 살펴보기 (0)	2023.09.22
[Spring] API 관리를 위한 Swagger 도입하기 (gradle 기준) (0)	2023.03.24