📗 QueryDsl 적용

참고 QueryDSL 프로젝트 적용 후기 및 트러블슈팅

📄 설정

⌨️ gradle 의존성 추가

plugins {
	...
    
	// QueryDsl
	id "com.ewerk.gradle.plugins.querydsl" version "1.0.10"
}

dependencies {

	...
    
	// QueryDsl
	implementation "com.querydsl:querydsl-jpa:5.0.0"
	annotationProcessor "com.querydsl:querydsl-apt:5.0.0"
}

// script for querydsl
def querydslDir = "$buildDir/generated/querydsl"
querydsl {
	jpa = true
	querydslSourcesDir = querydslDir
}
sourceSets {
	main.java.srcDir querydslDir
}
configurations {
	querydsl.extendsFrom compileClasspath
}
compileQuerydsl {
	options.annotationProcessorPath = configurations.querydsl
}

⌨️ QueryDslConfig 추가

@Configuration
public class QueryDslConfig {
    @PersistenceContext
    private EntityManager em;

    @Bean
    public JPAQueryFactory query(){
        return new JPAQueryFactory(em);
    }
}

⌨️ Entity -> Qclass 생성

@Entity
@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@EntityListeners(AuditingEntityListener.class)
public class Board {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, length = 30)
    private String title;
    @Column(nullable = false, length = 3000)
    private String content;
    @Column(nullable = false)
    private String writer;

    @Column(nullable = true, columnDefinition = "bigint default 0")
    private long heart;

    @LastModifiedDate
    private LocalDateTime modifiedAt;

    @CreatedDate
    private LocalDateTime createdAt;

    public static Board createBoard(PostBoard request){
        return new Board(null, request.getTitle(), request.getContent(), Naming.getName(), 0L, null, null);
    }

    public void addHeart(){
        this.heart++;
    }
}

@Entity
@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@EntityListeners(AuditingEntityListener.class)
public class Comment {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private Long memberId;

    @ManyToOne
    @JoinColumn(name = "board_id")
    private Board board;

    @Column(nullable = false, length = 100)
    private String comment;
    @LastModifiedDate
    private LocalDateTime modifiedAt;
    @CreatedDate
    private LocalDateTime createdAt;
}

Board와 Comment를 QueryDsl을 통해 뿌려보려고 한다.

gradlew compileQuerydsl

를 입력해주면

자동으로 gradle을 통해 Qclass를 생성해준다.

위의 설정을 그대로 따라했다면 다음 위치에서 Qclass들을 확인해볼 수 있다.

📄 QueryDsl 사용하기

⌨️ QueryDsl Repository

public interface BoardRepositoryCustom {
    Page<BoardDto> findBoardPage(Pageable pageable);
}

@Repository
@RequiredArgsConstructor
public class BoardRepositoryImpl implements BoardRepositoryCustom{
    private final QueryDslConfig qd;

    @Override
    public Page<BoardDto> findBoardPage(Pageable pageable) {

        List<BoardDto> content = qd.query()
                .select(Projections.constructor(BoardDto.class,
                        board.boardId,
                        board.title,
                        board.content,
                        board.writer,
                        ExpressionUtils.as(
                                JPAExpressions.select(comment1.board.count())
                                .from(comment1)
                                .where(comment1.board.boardId.eq(board.boardId)),"commentCount"
                        ),
                        board.heart,
                        board.modifiedAt,
                        board.createdAt
                ))
                .from(board)
                .orderBy(board.boardId.desc())
                .offset(pageable.getOffset())
                .limit(pageable.getPageSize())
                .fetch();

        for(BoardDto dto : content){
            List<Comment> comments = qd.query()
                    .selectFrom(comment1)
                    .orderBy(comment1.commentId.desc())
                    .limit(5L)
                    .where(comment1.board.boardId.eq(dto.getBoardId()))
                    .fetch();
            dto.setComments(comments);
        }

        Long total = qd.query()
                .from(board)
                .stream().count();
        return new PageImpl<>(content, pageable, total);
    }
}

QueryDsl을 적용하여 사용할 BoardRepositoryCustom 인터페이스를 만들고 구현체를 정의해주었다.

JPA보다 QueryDsl을 사용해보니 정말로 쿼리를 짠다기 보다는 java 문법으로 객체를 만들어내는 느낌이 나서 더 재밌었다.

그리고 반환할때 Entity를 그대로 반환하지 않는 것이 좋다. 대체로는 Tuple과 Dto 생성이 있는데. Tuple은 마치 Map을 사용하여 객체를 전달하는 기분이라 Dto를 따로 정의해서 반환하도록 했다.

또 여기서 QueryDsl에서 정의하는 @QueryProjection 어노테이션을 Entity나 Dto 생성자에 붙여주면 되는데. 이것 또한 너무 QueryDsl 의존도가 높아지는거 같아서 그냥 내가 따로 정의한 Dto 객체에 값을 넣어주는 것으로 정의했다.

그리고 Projections.constructor('생성할 객체 class', 생성자 매개변수...) 을 사용하여 반환할 타입을 정의했고 ExpressionUtils.as('쿼리', 'alias')를 사용하여 별칭을 정의해주었다.

쿼리 부분에는 JPAExpressions.select()를 사용하여 서브쿼리를 추가해주어 다른 테이블의 데이터를 조회해올 수 있다.

for(BoardDto dto : content){...} 그리고 해당 부분을 통해 list 형태의 댓글 테이블의 데이터를 조회해와 넣어주었다. 이부분은 나중에 5번 조회가 아닌 1번 조회로 줄일 수 있을거 같다. 리팩토링 대상으로 정해두고 수정하는 글을 다음에 올려야겠다.

⌨️ 기본 JPA 사용

public interface BoardRepository extends JpaRepository<Board, Long>, BoardRepositoryCustom {
}

기본적인 JPA의 메서드들을 사용하기 위해 정의해준다. 그리고 BoardRepositoryCustom 우리가 정의한 Repository를 추가로 적용해주어 Service에서 하나의 Repository를 주입하여 사용할 수 있게 하자.

⌨️ Service 구현

@Service
@RequiredArgsConstructor
@Transactional(readOnly = true)
@Slf4j
public class BoardServiceImpl implements BoardService{
    private final BoardRepository boardRepository;

    @Override
    public GetBoardResponse getBoard(Pageable page) {
        Page<BoardDto> findAll = boardRepository.findBoardPage(page);
        return GetBoardResponse.builder()
                .last(findAll.isLast())
                .empty(findAll.isEmpty())
                .totalPage(findAll.getTotalPages())
                .totalElements(findAll.getTotalElements())
                .boardList(findAll.getContent())
                .numberOfElements(findAll.getNumberOfElements())
                .build();
    }
}

그리고 테스트를 작성해서 확인해보면

@SpringBootTest
@Execution(ExecutionMode.SAME_THREAD)
class BoardServiceImplTest {

    @Autowired
    private BoardService boardService;

    @Test
    @DisplayName("게시글 페이징 성공한다.")
    void getBoardSuccess() throws Exception {
        //given
        for(int i=1; i<=20; i++){
            PostBoard postBoard = new PostBoard("제목" + i, "내용" + i);
            boardRepository.save(Board.createBoard(postBoard));
        }

        Pageable pageable = Pageable.ofSize(5);
        pageable = pageable.next();
        pageable = pageable.next();

        //when
        GetBoardResponse board = boardService.getBoard(pageable);

        //then
        Stream<String> title = board.getBoardList().stream().filter(b -> b.getContent().equals("내용10")).map(b -> b.getTitle());
        assertTrue(title.count() == 1);
    }
}

정상적으로 페이징한 내용을 가져오는 것을 확인할 수 있다!

👏 페이징 쿼리 리팩토링

위 쿼리로 실행하면

다음과 같이 하나의 페이징 요청당 5개의 댓글 찾는 쿼리가 발생했다. 해당 쿼리가 만약 댓글을 10개 찾는 쿼리라면 10개의 쿼리가 추가로 나가는 것이다. 이것이 N+1 문제인데 QueryDsl로 변경한 의미가 없다. 그래서 최대한 줄여보려고 한다.

@Repository
@RequiredArgsConstructor
public class BoardRepositoryImpl implements BoardRepositoryCustom{
    private final QueryDslConfig qd;

    @Override
    public Page<BoardDto> findBoardPage(Pageable pageable) {

        List<BoardDto> content = qd.query()
                .select(Projections.constructor(BoardDto.class,
                        board.boardId,
                        board.title,
                        board.content,
                        board.writer,
                        ExpressionUtils.as(
                                JPAExpressions.select(comment1.board.count())
                                .from(comment1)
                                .where(comment1.board.boardId.eq(board.boardId)),"commentCount"
                        ),
                        board.heart,
                        board.modifiedAt,
                        board.createdAt
                ))
                .from(board)
                .orderBy(board.boardId.desc())
                .offset(pageable.getOffset())
                .limit(pageable.getPageSize())
                .fetch();

        ArrayList<Long> boardIdList = new ArrayList<>();

        for(BoardDto dto : content){
            boardIdList.add(dto.getBoardId());
        }

        List<CommentDto> findComment = qd.query().select(Projections.constructor(CommentDto.class,
                    comment1.commentId,
                    comment1.memberId,
                    comment1.board.boardId,
                    comment1.comment,
                    comment1.modifiedAt,
                    comment1.createdAt
                ))
                .from(comment1)
                .where(comment1.board.boardId.in(boardIdList))
                .fetch();

        for(BoardDto dto : content){
            Stream<CommentDto> commentStream = findComment.stream().filter(c -> c.getBoardId() == dto.getBoardId());
            List<CommentDto> comments = commentStream.collect(Collectors.toList());
            dto.setComments(comments);
        }

        Long total = qd.query()
                .from(board)
                .stream().count();
        return new PageImpl<>(content, pageable, total);
    }
}

쿼리가 board를 최초로 select 하는 쿼리와 boardId를 기준으로 Comment를 select하는 쿼리 2개로 줄였다. 이 쿼리는 댓글을 몇개를 찾아도 변경되지 않으므로 좀더 개선했다고 할 수 있다!

    @Test
    @DisplayName("게시글 페이징 후 댓글을 불러오는데 성공한다.")
    void getBoardSuccess2() throws Exception {
        //given
        for(int i=1; i<=20; i++){
            PostBoard postBoard = new PostBoard("제목" + i, "내용" + i);
            Board saveBoard = boardRepository.save(Board.of(postBoard));
            for(int j=1; j<=3; j++){
                commentRepository.save(Comment.of(0L, "댓글"+j, saveBoard));
            }
        }

        Pageable pageable = Pageable.ofSize(5);
        pageable = pageable.next();
        pageable = pageable.next();

        //when
        GetBoardResponse board = boardService.getBoard(pageable);
    }

테스트 코드는 다음과 같이 작성해서 테스트를 돌려보면

데이터도 내가 생각한대로 잘 나오는 것을 확인할 수 있다.