[JPA] QueryDSL 사용하기

[210626]

[JPA] QueryDSL 사용하기

• JPA 사용 시, @Query와 JPQL 대신 메서드로 SQL문을 처리 가능

• 문법 오류를 컴파일 단계에서 확인 가능

build.gradle 의존성 추가

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

...

dependencies {
    implementation 'com.querydsl:querydsl-jpa'
    implementation 'com.querydsl:querydsl-apt' 
    // 아래는 없다면 추가 (lombok은 선택)
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    compileOnly 'org.projectlombok:lombok'
    annotationProcessor 'org.projectlombok:lombok'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

..

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

QueryDSL 프로젝트 셋팅 (Q클래스 생성)

https://jojoldu.tistory.com/372 <- 이 링크에서 초기 셋팅을 따라하기

Q클래스 생성 안 될 때 ...

-> 혹시 Project Structure - Project Settings - Modules 에서 Excluded Folders 에서 build가 빨간색으로 설정되어 있는지 확인한다.

사용 예 - IssueRepositorySupport

기존 IssueRepository 인터페이스 메소드에 @Query 커스텀쿼리로 구현하던 부분을 메소드로 대체하는 느낌. 편하다!

findByAssignee(), findByCommentUserId() : join문

• QueryDSL Join문 사용하기 참고 링크..

  • https://stackoverflow.com/questions/60833916/querydsl-projection-elementcollection
  • https://lelecoder.com/145

• Predicate : (뜻 : 서술부). where() 내의 조건 들을 뜻함. predicate 여러 개를 and나 or로 묶은 것도 predicate임. (boolean && boolean = boolean 인 것처럼)

@Repository
public class IssueRepositorySupport extends QuerydslRepositorySupport {

    private final JPAQueryFactory queryFactory;

    public IssueRepositorySupport(JPAQueryFactory queryFactory) {
        super(Issue.class);
        this.queryFactory = queryFactory;
    }


    public List<Issue> findByTitle(String title) {
        return queryFactory
                .selectFrom(issue)
                .where(issue.title.contains(title))
                .fetch();
    }

    public List<Issue> findByStatusTrue() {
        return queryFactory
                .selectFrom(issue)
                .where(issue.status.isTrue())
                .fetch();
    }

    public List<Issue> findByStatusFalse() {
        return queryFactory
                .selectFrom(issue)
                .where(issue.status.isFalse())
                .fetch();
    }

    public List<Issue> findByAuthor(Long userId) {
        return queryFactory
                .selectFrom(issue)
                .where(issue.user.id.eq(userId))
                .fetch();
    }

    public List<Issue> findByAssignee(Long userId) {
        return queryFactory
                .selectFrom(issue)
                .innerJoin(assignee)
                .on(assignee.issueId.eq(issue.id))
                .where(assignee.userId.eq(userId))
                .fetch();
    }

    public List<Issue> findByCommentUserId(Long userId) {
        return queryFactory
                .selectFrom(issue)
                .innerJoin(comment)
                .on(comment.issueId.eq(issue.id))
                .where(comment.user.id.eq(userId))
                .fetch();
    }

    public List<Issue> getFilteredIssues(IssueFilter issueFilter) {
        JPAQuery query = queryFactory
                .selectFrom(issue)
                .where(getPredicate(issueFilter));

        Long userId = issueFilter.getAssignee();
        if (userId != null) {
            query.innerJoin(assignee)
                    .on(assignee.issueId.eq(issue.id))
                    .where(assignee.userId.eq(userId));
        }

        userId = issueFilter.getCommenter();
        if (userId != null) {
            query.innerJoin(comment)
                    .on(comment.issueId.eq(issue.id))
                    .where(comment.user.id.eq(userId));
        }

        return query.fetch();

    }

    public Predicate getPredicate(IssueFilter filter) {
        return new PredicateBuilder(issue.isNotNull())
                .containsAnd(issue.title, filter.getTitle())
                .isBooleanAnd(issue.status, filter.getStatus())
                .isLongEqualAnd(issue.user.id, filter.getAuthor())
                .build();
    }
}

위의 getPredicate()에 필요한 클래스인 PredicateBuilder

package com.codesquad.issuetracker.domain.issue;

import com.querydsl.core.types.dsl.BooleanExpression;
import com.querydsl.core.types.dsl.BooleanPath;
import com.querydsl.core.types.dsl.NumberPath;
import com.querydsl.core.types.dsl.StringPath;

public class PredicateBuilder {

    private final BooleanExpression predicate;

    public PredicateBuilder(BooleanExpression predicate) {
        this.predicate = predicate;
    }

    public PredicateBuilder containsAnd(StringPath qValue, String rValue) {
        if (rValue != null) {
            return new PredicateBuilder(predicate.and(qValue.containsIgnoreCase(rValue)));
        }
        return this;
    }

    public PredicateBuilder isBooleanAnd(BooleanPath qValue, Boolean rValue) {
        if (rValue != null) {
            return (rValue) ? new PredicateBuilder(predicate.and(qValue.isTrue()))
                    : new PredicateBuilder(predicate.and(qValue.isFalse()));
        }
        return this;
    }

    public PredicateBuilder isLongEqualAnd(NumberPath qValue, Long rValue) {
        if (rValue != null) {
            return  new PredicateBuilder(predicate.and(qValue.eq(rValue)));
        }
        return this;
    }

    public BooleanExpression build() {
        return predicate;
    }

}