QueryDSL을 활용한 동적 쿼리 최적화

1. 기술 도입 배경

기존 프로젝트에서는 JPA의 @Query 또는 Criteria API를 사용하여 복잡한 쿼리를 작성했으나,

  • 가독성이 떨어지고 유지보수가 어려웠음.
  • 동적 쿼리 작성 시 코드가 길어지고 복잡해짐.
  • 여러 필터 조건을 유연하게 적용하기 어려웠음.

이러한 문제를 해결하기 위해 QueryDSL을 도입하여 가독성과 유지보수성을 향상하고, 동적 쿼리를 효율적으로 작성하는 방식을 적용함.


2. QueryDSL 적용 과정

  1. QueryDSL 환경 설정
    • build.gradle에 QueryDSL 관련 의존성을 추가하고, JPAQueryFactory 빈을 설정하여 사용함.
  2. 동적 쿼리 구현
    • 검색 필터(예: 사용자 이름, 카테고리, 작성일 등)를 조합하여 동적으로 데이터를 조회하는 기능을 구현.
    • where() 절을 활용하여 조건이 있을 때만 쿼리에 추가하는 방식 적용.
  3. 페이징 및 성능 최적화
    • 페이징을 위한 count 조회는 fetchOne()을 사용하여 불필요한 데이터 조회를 최소화함.

3. 해결한 문제 및 성과

가독성 및 유지보수성 향상

  • 기존 @Query 기반의 복잡한 SQL을 QueryDSL로 변환하여 가독성을 개선.
    동적 필터링 구현
  • 검색 조건(이름, 날짜, 카테고리 등)을 조합하여 유연하게 검색할 수 있도록 개선.
    쿼리 성능 최적화
  • QueryDSL의 fetchJoin()을 활용하여 N+1 문제를 해결하고, 필요한 컬럼만 Projections.constructor()로 가져와 성능 개선.

 페이징 처리

  • offset()과 limit()을 활용하여 데이터 페이징 처리.
@Override
public Page<ReviewDetailResponseDto> findAllReviews(ReviewSearchCondition condition, Pageable pageable) {
    int pageSize = pageable.getPageSize() > 0 ? pageable.getPageSize() : 10;

    // 리뷰 목록 조회 쿼리 (fetchJoin을 통한 N+1문제 해결)
    List<ReviewDetailResponseDto> content = queryFactory
            .select(Projections.constructor(ReviewDetailResponseDto.class,
                    review.id,
                    order.id,
                    menu.id,
                    restaurant.id,
                    review.title,
                    review.content,
                    review.rating,
                    menu.name,
                    restaurant.name,
                    review.createdBy,
                    review.createdAt
            ))
            .from(review)
            .join(review.order, order).fetchJoin()
            .join(order.menu, menu).fetchJoin()
            .join(menu.restaurant, restaurant).fetchJoin()
            .where(
                    review.isDeleted.isFalse(),
                    keywordContains(condition.keyword()),
                    createdAtBetween(condition.startDate(), condition.endDate())
            )
            .orderBy(
                    condition.isAsc() ? review.createdAt.asc() : review.createdAt.desc(),
                    condition.isAsc() ? review.updatedAt.asc() : review.updatedAt.desc()
            )
            .offset(pageable.getOffset())
            .limit(pageSize)
            .fetch();

    // 총 레코드 수 조회 (fetchJoin 없이 실행하여 성능 최적화)
    Long total = queryFactory
            .select(review.count())
            .from(review)
            .join(review.order, order)
            .join(order.menu, menu)
            .join(menu.restaurant, restaurant)
            .where(
                    review.isDeleted.isFalse(),
                    keywordContains(condition.keyword()),
                    createdAtBetween(condition.startDate(), condition.endDate())
            )
            .fetchOne();

    return new PageImpl<>(content, pageable, total != null ? total : 0);
}

 

각각의 코드들(JPAQueryFactory, fetchjoin, projections.constructor , offset, fetchone 등 )의 사용이유들은 좀더 조사해서 추가 작성 필요.

'TIL' 카테고리의 다른 글

RabbitMQ 기반 비동기 아키텍처 도입 성능 개선 사례  (0) 2025.04.02
캐싱을 통한 성능 개선  (0) 2025.04.01
RabbitMQ 와 Kafka  (0) 2025.03.07
DB인덱싱  (0) 2025.03.06
Cache  (0) 2025.03.05

[문제 링크]

https://school.programmers.co.kr/learn/courses/30/lessons/87377

 

프로그래머스

SW개발자를 위한 평가, 교육, 채용까지 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

[난이도]

- Level 2

 

[알고리즘]

- 구현

- 배열

 

[코드]

import java.util.*;

class Solution {
    public String[] solution(int[][] line) {
        long maxX = Long.MIN_VALUE;
        long maxY = Long.MIN_VALUE;
        long minX = Long.MAX_VALUE;
        long minY = Long.MAX_VALUE;

        List<long[]> list = new ArrayList<>();

        for (int i = 0; i < line.length - 1; i++) {
            for (int j = i + 1; j < line.length; j++) {
                long A = line[i][0];
                long B = line[i][1];
                long E = line[i][2];
                long C = line[j][0];
                long D = line[j][1];
                long F = line[j][2];

                long denominator = A * D - B * C;

                if (denominator == 0) continue;  // 평행 또는 동일 직선

                long numeratorX = B * F - E * D;
                long numeratorY = E * C - A * F;

                // 정수 교차점인지 확인
                if (numeratorX % denominator != 0 || numeratorY % denominator != 0) continue;

                long x = numeratorX / denominator;
                long y = numeratorY / denominator;

                maxX = Math.max(maxX, x);
                maxY = Math.max(maxY, y);
                minX = Math.min(minX, x);
                minY = Math.min(minY, y);

                list.add(new long[]{x, y});
            }
        }

        int width = (int)(maxX - minX + 1);
        int height = (int)(maxY - minY + 1);

        char[][] graph = new char[height][width];
        for (char[] row : graph) {
            Arrays.fill(row, '.');
        }

        for (long[] point : list) {
            int x = (int)(point[0] - minX);
            int y = (int)(maxY - point[1]);  // y축 뒤집기

            graph[y][x] = '*';
        }

        String[] answer = new String[height];
        for (int i = 0; i < height; i++) {
            StringBuilder sb = new StringBuilder();
            for (int j = 0; j < width; j++) {
                sb.append(graph[i][j]);
            }
            answer[i] = sb.toString();
        }

        return answer;
    }
}

 

[풀이]

단순 구현 문제이다. 중요한점은 int가 아닌 long타입으로 변환해서 풀어야한다는것이다. 그 이유는 int*int가 int의 범위를 벗어나는 경우가 있어 테스트케이스29번을 통과하지 못하기 때문이다.

[문제 링크]

https://school.programmers.co.kr/learn/courses/30/lessons/388351

[난이도]

- Level 1

 

[알고리즘]

- 구현

 

[코드]

class Solution {
    public int solution(int[] schedules, int[][] timelogs, int startday) {
        int answer = 0;
        boolean flag = false;
        for(int i=0;i<schedules.length;i++){
            int time = function(schedules[i]);
            flag = false;
            for(int j=0;j<7;j++){
               if(j == 7-startday || j == 6-startday){
                   continue;
               }
                if(6-startday == -1){
                    if(j==6){
                        continue;
                    }
                }

                
                if(timelogs[i][j]>time){
                    flag = true;
                    break;
                }
            }
            if(!flag){
                answer++;
            }
        }
        return answer;
    }
    static int function(int time){
        int min = time%100;
        int hour = time/100;
        int newMin = min+10;
        if(newMin>=60){
            newMin -=60;
            hour++;
        }
        int newTime = hour*100 + newMin;
        return newTime;
    }
}

 

[풀이]

단순 구현 문제이다. 토요일과 일요일이 위치할 배열을 고르는 법은 6 - startday, 7-startday이다. 중요한점은 startday가 7일때를 고려해야한다. 이때 토요일은 배열의 마지막에 위치하기 때문에 한 번 더 if문으로 해결했다.

 

10분이 지난시간이 60분을 넘길때를 고려해주어야 한다. 

[문제 링크]

https://school.programmers.co.kr/learn/courses/30/lessons/42884

[난이도]

- Level 3

 

[알고리즘]

- 그리디

 

[코드]

import java.util.*;

class Solution {
    public int solution(int[][] routes) {
        // 차량의 진출 지점을 기준으로 오름차순 정렬
        Arrays.sort(routes, Comparator.comparingInt(o -> o[1]));
        
        int count = 1; // 첫 번째 카메라 설치
        int camera = routes[0][1]; // 첫 번째 차량의 진출 지점에 카메라 설치
        
        for (int i = 1; i < routes.length; i++) {
            // 현재 차량의 진입 지점이 마지막 설치된 카메라보다 크면 새로운 카메라 필요
            if (routes[i][0] > camera) {
                count++; // 새로운 카메라 설치
                camera = routes[i][1]; // 카메라 위치 갱신
            }
        }
        
        return count;
    }
}

 

[풀이]

이 문제를 해결하기 위해 그리디 알고리즘을 사용합니다. 핵심 아이디어는 차량의 진출 지점을 기준으로 정렬한 후, 가장 많은 차량이 겹치는 곳에 카메라를 설치하는 것입니다.

  1. 차량의 진출 지점을 기준으로 정렬합니다.
  2. 첫 번째 차량의 진출 지점에 첫 번째 카메라를 설치합니다.
  3. 이후 차량을 순차적으로 확인하면서:
    • 현재 차량의 진입 지점이 마지막 카메라 위치보다 크면, 새로운 카메라가 필요합니다.
    • 새로운 카메라는 해당 차량의 진출 지점에 설치합니다.

설치한 카메라의 개수를 반환합니다.

RabbitMQ와 Kafka 모두 메시지 브로커이다. 하지만 목적과 동작 방식이 꽤 다르다.

쉽게 말하자면

  • Kafka : 대규모 데이터를 실시간 스트리밍
    • 실시간 로그 수집, 모니터링, 이벤트 스트리밍
    • 대규모 트래픽 처리
    • 인스타그램 피드, 넷플릭스 추천 시스템 등에 적합
    • 장기 저장을 목표
  • RabbitMQ : 큐에 담아 하나씩 처리
    • 이메일 인증, 결제 처리, 알림 전송 같은 소규모 작업에 적합
    • 트랜잭션 보장(한 번만 전달)
    • MSA간 데이터 전달
    • 단기 저장을 목표

 

'TIL' 카테고리의 다른 글

캐싱을 통한 성능 개선  (0) 2025.04.01
QueryDSL을 활용한 동적 쿼리 최적화  (0) 2025.03.31
DB인덱싱  (0) 2025.03.06
Cache  (0) 2025.03.05
Redis  (0) 2025.03.04

+ Recent posts