🔥 TIL - Day 59 QueryDSL 1

3차 프로젝트 때 복잡한 쿼리는 되도록 QueryDsl을 사용해고자 알아봤다.

Springboot의 다른 라이브러리에 비해 설정이 복잡하다.

전체코드 Github

📌 설정 ㅠ

plugins {
    id 'org.springframework.boot' version '2.4.12'
    id 'io.spring.dependency-management' version '1.0.11.RELEASE'
    id 'java'
}

group = 'com.dhk'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '1.8'

configurations {
    compileOnly {
        extendsFrom annotationProcessor
    }
}

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    implementation 'org.springframework.boot:spring-boot-starter-web'
    compileOnly 'org.projectlombok:lombok'
    runtimeOnly 'com.h2database:h2'
    annotationProcessor 'org.projectlombok:lombok'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'

    // ==== Query dsl ==== //
    implementation 'com.querydsl:querydsl-jpa'
    // Q클래스 생성을 위한 라이브러리
    annotationProcessor "com.querydsl:querydsl-apt:${dependencyManagement.importedProperties['querydsl.version']}:jpa"
    annotationProcessor "jakarta.persistence:jakarta.persistence-api"
    annotationProcessor "jakarta.annotation:jakarta.annotation-api"
}

test {
    useJUnitPlatform()
}

테스트를 위한 도메인을 작성한다.
처음 접하는 기술이기 때문에 도메인은 매우매우 간단하게 작성했다.

User 엔티티

@Entity
@NoArgsConstructor
@Getter
public class User {

    @Id @GeneratedValue
    private Long id;
    @Column(nullable = false)
    private String username;
    @Column(nullable = false)
    private String password;

    private int age;

    @JoinColumn(name = "team_id")
    @ManyToOne(fetch = FetchType.LAZY)
    private Team team;

    public void setTeam(Team team) {
        this.team = team;
    }

    public User(String username, String password, int age) {
        this.username = username;
        this.password = password;
        this.age = age;
    }
}

Team 엔티티

@Entity
@NoArgsConstructor
@Getter
public class Team {

    @Id @GeneratedValue
    private Long id;
    @Column(nullable = false)
    private String teamName;

    private int teamAge; // 팀이 생긴지 몇 년 됐는지... 테스트를 위해 억지로 ..ㅎ

    public Team(String teamName, int teamAge) {
        this.teamName = teamName;
        this.teamAge = teamAge;
    }
}

우리가 만든 Entity를 QueryDsl에서 사용하려면 엔티티에 대응되는 Q타입 클래스가 필요하다.
앞서 Gradle 설정으로 Q타입 클래스를 만들 수 있는 상태이다.

Gradle 테스크의 도움을 받아 Q타입 클래스를 생성하면 아래 경로로 생성된다.
생성되는 경로는 build.gradle에서 변경가능하다.

마지막으로 QueryDsl 쿼리를 사용하기 위해 빈을 하나 등록해줘야 한다.
이제 쿼리를 작성할 때 EntityManager가 아니고 JPAQueryFactory를 주입받아서 작성해야 한다. QueryDsl의 EntityManager는 JPAQueryFactory이다 라고 이해해도 될 듯하다.

@RequiredArgsConstructor
@Configuration
public class AppConfig {

    private final EntityManager em;

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

---

등록한 JPAQueryFactory를 주입받아 쿼리를 작성할 수 있다.

@Autowired 
private JPAQueryFactory query;

📌 QueryDSL 맛보기

selectFrom은 *와 같은 의미라고 생각하면 된다.
여기서 user는 Q타입의 QUser클래스 인스턴스이다. static으로 선언되어 있어서 static import해서 사용하는 것이 일반적이다.

    @Order(1)
    @DisplayName("1. 기본조회 조건없이 모두 조회")
    @Test
    void 기본조회() {
        // select * from user;
        List<User> users = query.selectFrom(user) // QUser.user ==> user
                .fetch(); 

        users.forEach(u -> System.out.println(u.getUsername()));
    }

조건없는 finAll은 쓸 일이 없다. 조건을 하나씩 추가해보자.

조회 + 조건

조건들이 굉장히 직관적이다.
equal, greater than, less than, greater or equals, less or equals ...
느낌적으로 IDE의 도움을 받으면 될 것 같다.

    @Order(2)
    @Test
    @DisplayName("2. 기본조회 where 절 포함")
    void 기본조회_where() {
        // select * from user where username = test1;
        List<User> users = query.selectFrom(user)
                .where(user.username.eq("test1"))
                .fetch();

        users.forEach(u -> System.out.println(u.getUsername()));
    }
    
    @Test
    @DisplayName("2-1 기본조회 where절 포힘")
    void 기본조회_where2() {
        // select * from user where age between 20 and 30;
        List<User> users = query.selectFrom(user)
                .where(user.age.between(20, 30))
                .fetch();
        users.forEach(u -> System.out.println(u.getUsername()));
    }

정렬

    @Test
    @DisplayName("3. 정렬")
    void 나이_정렬_오름차순() {
        // 팀1에 속한 user를 나이순으로 정렬
        /**
         * select * from user u
         * join team t
         * where u.team_id = t.id and t.name = team1
         * orderBy u.age asc;
          */
        List<User> users = query.selectFrom(QUser.user)
                .where(user.team.teamName.eq("team1"))
                .orderBy(QUser.user.age.asc())
                .fetch();
        users.forEach(u -> System.out.println(u.getAge()));
    }

페이징

반환타입이 QueryReult이다.
JPA의 Page객체와 비슷한 형태이다. 페이징에 대한 정보와 리스트형태 데이터를 갖고 있다.

    @Order(5)
    @Test
    @DisplayName("4. 페이징")
    void 페이징() {
        QueryResults<User> queryResults = query.selectFrom(user)
                .offset(1)
                .limit(3)
                .fetchResults();

        List<User> users = queryResults.getResults();
        for (User user1 : users) {
            System.out.println(user1.getUsername());
        }

        System.out.println("offset = " + queryResults.getOffset());
        System.out.println("limit = " + queryResults.getLimit());
        System.out.println("total = " + queryResults.getTotal());
    }

Join

(User와 Team은 ManyToOne 단방향 관계이다)

    @Order(6)
    @Test
    @DisplayName("5. Join")
    void join1() {
        // team, user inner join
        List<User> users = query.selectFrom(user)
                .join(user.team, team)
                .fetch();

        users.forEach(u -> System.out.println(u.getUsername()));

        assertEquals(4, users.size());
    }

left join도 키워드만 바꿔주면 간단하게 가능하다.

    @Test
    @DisplayName("6. left join")
    void leftJoin() {
        List<User> users = query.selectFrom(user)
                .leftJoin(user.team, team)
                .fetch();

        users.forEach(u -> System.out.println(u.getUsername()));

        assertEquals(6, users.size());
    }

Subquery
서브쿼리는 JPAExpression을 통해 가능하다.
where절에서 서브쿼리를 사용하는 테스트이다.

Q타입 클래스의 필드에서 집계쿼리 호출이 가능한 것도 볼 수 있다. (max())

    @Test
    @DisplayName("7. where절 서브쿼리")
    void whereSubquery() {


        List<User> users = query.selectFrom(user)
                .where(user.age.in(
                        JPAExpressions
                                .select(team.teamAge.max())
                                .from(team)
                ))
                .fetch();

        assertEquals(1, users.size());
    }

Case 쿼리
실제로 사용해본 적은 없는데 충분히 써야 할 경우가 있을 것 같다.
CaseBuilder를 이용해서 when-then 절로 Case문을 구성하고 있다.

    @Test
    @DisplayName("8. case 쿼리")
    void caseQuery() {

        List<String> results = query
                .select(new CaseBuilder()
                        .when(user.age.loe(30)).then("주니어")
                        .when(user.age.goe(31)).then("시니어")
                        .otherwise("어린이: " + user.age)
                ).from(user)
                .fetch();

        results.forEach(System.out::println);
    }

프로젝션
프로젝션은 한 릴레이션에서 필요한 Attribute(칼럼)만 뽑아오는 것을 말한다.
프로젝션을 하는 여러가지 방법이 있는 것 같은데 여러 글에서 DTO 생성자를 이용한 프로젝션을 가장 좋은 방법으로 꼽는 것 같다.

그리고 이 방법이 원래 JPA에서 사용하는 방법과 가장 비슷한 같다.

프로젝션의 대상이 될 DTO를 정의한다.
쪼금 불편한 부분이 이 DTO 클래스를 QueryDsl에서 프로젝션 대상 클래스로 쓰려면 이 클래스에 대한 Q타입 클래스를 생성해줘야 한다.

@QueryProjection을 생성자에 추가해주고 Gradle tasks - other의 compile을 다시 해줘야 한다.

@NoArgsConstructor
@Data
public class UserDto {
    private String username;
    private int age;
    private String teamName;

    @QueryProjection // Q타입 클래스로 만들기 위함
    public UserDto(String username, int age, String teamName) {
        this.username = username;
        this.age = age;
        this.teamName = teamName;
    }
}

JPA에서는 DTO로 조회할 때 new 키워드와 해당 DTO의 패키지를 모두 적어주는 방식이였다.
Query dsl에서도 동일하게 new를 사용하지만 패키지는 적어주지 않아도 된다.

    @Test
    @DisplayName("9. 프로젝션 - DTO의 생성자 사용")
    void 프로젝션_DTO() {

        List<UserDto> userDtos = query.select(new QUserDto(user.username, user.age, team.teamName))
                .from(user)
                .join(user.team, team)
                .fetch();

        userDtos.forEach(ut -> System.out.println(ut.getUsername() + ": "+ ut.getTeamName()));
    }

동적쿼리

클라이언트로부터 받은 데이터가 쿼리에 포함되는 동적쿼리는 매우 자주 쓰인다.
JPA에서 이런 동적쿼리를 이용할 때 네이밍 쿼리로 복잡성을 줄일 수 있지만 네이밍 쿼리의 경우 한계가 있다.

때문에 직접 JPQL을 짜는 경우가 많은데 이 때 쿼리가 모두 문자열로 작성되기 때문에 쿼리자체가 조금 복잡해진다면 JPQL 작성은 더더더더 어려워진다. 어려워지는 것 뿐만 아니라 에러의 가능성 또한 높아진다. 이런 에러는 컴파일 시점에 캐치되지 않기 때문에 더 고생할 수 있다.

마지막으로 Intellij가 부족한 나의 길잡이가 되어준다. 👍👍👍👍👍👍

이를 위해 Querydsl의 동적쿼리를 사용한다.

이제 막 Querydsl 쪼금 알게 된 것이지만 앞서 했던 것들은 솔직히 JPA가 더 편하지 않을까 싶다. 하지만 동적쿼리의 경우 해보 결과 장점이 매우 많다. 잘 기억하고 활용해보자.

    @Test
    @DisplayName("10. 동적쿼리1")
    void 동적쿼리1() {
        List<UserDto> userDtos = getUserByUsernameAndTeamName("user1", "team1");

        userDtos.forEach(ut -> System.out.println(ut.getUsername() + ": "+ ut.getTeamName()));
        assertEquals(1, userDtos.size());
    }

    private List<UserDto> getUserByUsernameAndTeamName(String username, String teamName) {

        BooleanBuilder builder = new BooleanBuilder();
        if (!Objects.isNull(username)) {
            builder.and(user.username.eq(username));
        }
        if (!Objects.isNull(teamName)) {
            builder.and(team.teamName.eq(teamName));
        }

        return query
                .select(new QUserDto(user.username, user.age, team.teamName))
                .from(user)
                .join(user.team, team)
                .where(builder)
                .fetch();
    }

BooleanBuilder를 이용해서 조건을 쌓는다.
BooleanBuilder를 통해 만들어지는 결과는 BooleanExpresson이고 이 객체가 where 절의 조건역할을 할 수 있다. 파라미터에 대한 검증을 수행하고 파라미터가 정상이라면 Q타입 인스턴스를 이용해서 조건을 구성하고 builder를 where절에 넣어준다.

컴파일 시점에 에러를 잡아낼 수 있다는 것은 알겠다. 근데 좀 지나치게 길어지는게 아닌가 싶다.
두번째 장점이 나와줘야 한다.

    @Test
    @DisplayName("11. 동적쿼리2 조건 메서드로 빼내기")
    void 동적쿼리2() {

        List<UserDto> userDtos = query
                .select(new QUserDto(user.username, user.age, team.teamName))
                .from(user)
                .join(user.team, team)
                .where(ageGreaterThanEquals(20), teamNameEquals("team3")) // and로 연결
                .fetch();

        assertEquals(1, userDtos.size());
    }

    private BooleanExpression ageGreaterThanEquals(int age) {
        return age <= 0 ? null : user.age.goe(age);
    }

    private BooleanExpression teamNameEquals(String teamName) {
        return Objects.isNull(teamName) ? null : team.teamName.eq(teamName);
    }

구조와 기능은 조금 바뀌었지만 각각 하나의 파라미터를 전달받는 두 개 조건을 포함하는 것은 동일하다.
여기서 중요한 것은 조건문 자체를 메서드화 했다는 것이다. 재사용의 여지가 생겼다!
wow