QueryDSL — 동적 쿼리를 타입 안전하게 작성하는 방법

// JPQL (문자열)
em.createQuery("SELECT m FROM Member m WHERE m.name = :name AND m.age > :age");

// QueryDSL (자바 코드)
queryFactory
    .selectFrom(member)
    .where(member.name.eq(name), member.age.gt(age))
    .fetch();

// 원본 엔티티
@Entity
public class Member {
    @Id @GeneratedValue
    private Long id;
    private String name;
    private int age;

    @ManyToOne(fetch = FetchType.LAZY)
    private Team team;
}

// 자동 생성되는 Q클래스 (build/generated 하위에 위치)
@Generated("com.querydsl.codegen.DefaultEntitySerializer")
public class QMember extends EntityPathBase<Member> {
    public static final QMember member = new QMember("member1");

    public final NumberPath<Long> id = createNumber("id", Long.class);
    public final StringPath name = createString("name");
    public final NumberPath<Integer> age = createNumber("age", Integer.class);
    public final QTeam team;
}

dependencies {
    implementation 'com.querydsl:querydsl-jpa:5.1.0:jakarta'
    annotationProcessor 'com.querydsl:querydsl-apt:5.1.0:jakarta'
    annotationProcessor 'jakarta.annotation:jakarta.annotation-api'
    annotationProcessor 'jakarta.persistence:jakarta.persistence-api'
}

@Configuration
public class QueryDslConfig {

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

@Repository
@RequiredArgsConstructor
public class MemberQueryRepository {

    private final JPAQueryFactory queryFactory;

    public List<Member> findByNameAndAge(String name, int age) {
        return queryFactory
            .selectFrom(member)
            .where(
                member.name.eq(name),
                member.age.gt(age)
            )
            .orderBy(member.age.desc())
            .fetch();
    }
}

public List<Member> searchByBuilder(String name, Integer age, String teamName) {
    BooleanBuilder builder = new BooleanBuilder();

    if (name != null) {
        builder.and(member.name.contains(name));
    }
    if (age != null) {
        builder.and(member.age.goe(age));
    }
    if (teamName != null) {
        builder.and(member.team.name.eq(teamName));
    }

    return queryFactory
        .selectFrom(member)
        .where(builder)
        .fetch();
}

public List<Member> searchByExpression(MemberSearchCondition cond) {
    return queryFactory
        .selectFrom(member)
        .leftJoin(member.team, team)
        .where(
            nameContains(cond.getName()),
            ageGoe(cond.getAgeGoe()),
            ageLoe(cond.getAgeLoe()),
            teamNameEq(cond.getTeamName())
        )
        .fetch();
}

private BooleanExpression nameContains(String name) {
    return name != null ? member.name.contains(name) : null;
}

private BooleanExpression ageGoe(Integer age) {
    return age != null ? member.age.goe(age) : null;
}

private BooleanExpression ageLoe(Integer age) {
    return age != null ? member.age.loe(age) : null;
}

private BooleanExpression teamNameEq(String teamName) {
    return teamName != null ? member.team.name.eq(teamName) : null;
}

List<Member> members = queryFactory
    .selectFrom(member)
    .fetch();

List<MemberDto> result = queryFactory
    .select(Projections.constructor(MemberDto.class,
        member.name,
        member.age
    ))
    .from(member)
    .fetch();

// DTO 생성자에 어노테이션 추가
public class MemberDto {
    private String name;
    private int age;

    @QueryProjection
    public MemberDto(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

// 컴파일 시 QMemberDto 생성 → 타입 안전한 Projection
List<MemberDto> result = queryFactory
    .select(new QMemberDto(member.name, member.age))
    .from(member)
    .fetch();

QMember memberSub = new QMember("memberSub");

// WHERE 서브쿼리: 평균 나이 이상인 회원
List<Member> result = queryFactory
    .selectFrom(member)
    .where(member.age.goe(
        JPAExpressions
            .select(memberSub.age.avg())
            .from(memberSub)
    ))
    .fetch();

// SELECT 서브쿼리
List<Tuple> result = queryFactory
    .select(member.name,
        JPAExpressions
            .select(memberSub.age.avg())
            .from(memberSub)
    )
    .from(member)
    .fetch();

public Page<MemberDto> searchPageComplex(MemberSearchCondition condition, Pageable pageable) {

    List<MemberDto> content = queryFactory
        .select(new QMemberDto(member.name, member.age))
        .from(member)
        .leftJoin(member.team, team)
        .where(nameContains(condition.getName()), teamNameEq(condition.getTeamName()))
        .offset(pageable.getOffset())
        .limit(pageable.getPageSize())
        .orderBy(member.age.desc())
        .fetch();

    JPAQuery<Long> countQuery = queryFactory
        .select(member.count())
        .from(member)
        .leftJoin(member.team, team)
        .where(nameContains(condition.getName()), teamNameEq(condition.getTeamName()));

    return PageableExecutionUtils.getPage(content, pageable, countQuery::fetchOne);
}