[QueryDSL] 4. 실무 활용 - 순수 JPA와 Querydsl

실무 활용 - 순수 JPA와 Querydsl

1. 순수 JPA 리포지토리와 Querydsl

2. 동적 쿼리와 성능 최적화 조회 - Builder 사용

3. 동적 쿼리와 성능 최적화 조회 - Where절  파라미터 사용

4. 조회 API 컨트롤러 개발

---

📌 순수 JPA 리포지토리와 Querydsl

순수 JPA 리포지토리 

@Repository
public class MemberJpaRepository {

    private final EntityManager em;

    public MemberJpaRepository(EntityManager em) {
        this.em = em;
    }

    public void save(Member member) {
        em.persist(member);
    }

    public Optional<Member> findById(Long id) {
        Member findMember = em.find(Member.class, id);
        return Optional.ofNullable(findMember);
    }

    public List<Member> findAll() {
        return em.createQuery("select m from Member m", Member.class)
                .getResultList();
    }

    public List<Member> findByUsername(String username) {
        return em.createQuery("select m from Member m where m.username = :username", Member.class)
                .setParameter("username", username)
                .getResultList();
    }
}

 

순수 JPA 리포지토리 테스트 코드

@Test
void basicTest() {
    Member member = new Member("member1", 10);
    memberJpaRepository.save(member);

    Member findMember = memberJpaRepository.findById(member.getId()).get();
    assertThat(findMember).isEqualTo(member);

    List<Member> result1 = memberJpaRepository.findAll();
    assertThat(result1).containsExactly(member);

    List<Member> result2 = memberJpaRepository.findByUsername(member.getUsername());
    assertThat(result2).containsExactly(member);
}

 

Querydsl 사용

순수 JPA 리포지토리 - Querydsl 추가

@Repository
public class MemberJpaRepository {

    private EntityManager em;
    private JPAQueryFactory queryFactory;

    public MemberJpaRepository(EntityManager em) {
        this.em = em;
        this.queryFactory = new JPAQueryFactory(em);
    }

    // ...
    
    public List<Member> findAll_Querydsl() {
        return queryFactory
                .selectFrom(member)
                .fetch();
    }

    public List<Member> findByUsername_Querydsl(String username) {
        return queryFactory
                .selectFrom(member)
                .where(member.username.eq(username))
                .fetch();
    }
}

 

Querydsl 테스트 추가

@Test
public void basicQuerydslTest() {
    Member member = new Member("member1", 10);
    memberJpaRepository.save(member);

    Member findMember = memberJpaRepository.findById(member.getId()).get();
    assertThat(findMember).isEqualTo(member);

    List<Member> result1 = memberJpaRepository.findAll_Querydsl();
    assertThat(result1).containsExactly(member);

    List<Member> result2 = memberJpaRepository.findByUsername_Querydsl(member.getUsername());
    assertThat(result2).containsExactly(member);
}

 

JPAQueryFactory를 스프링 빈으로 등록

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

• JPAQueryFactory를 스프링 빈으로 등록해서 외부에서 주입받아 사용해도 된다.
• JPAQueryFactory를 스프링 빈으로 등록해서 외부에서 주입받아 사용할 경우 다음과 같이 생성자 주입이 가능하다.

@Repository
public class MemberJpaRepository {

    private final EntityManager em;
    private final JPAQueryFactory queryFactory;

    public MemberJpaRepository(EntityManager em, JPAQueryFactory queryFactory) {
        this.em = em;
        this.queryFactory = queryFactory;
    }
    
    // ...
}

• lombok의 @RequiredArgsConstructor 어노테이션도 사용할 수 있어 코드를 간략하게 작성할 수 있다.
• 하지만 생성자에 주입을 두 가지나 해줘야하고 JPAQueryFactory를 외부에서 주입받아야 하기 때문에 테스트 코드를 작성할 때 번거롭다는 단점이 있다.

참고 : 동시성 문제는 걱정하지 않아도 된다.
여기서 스프링이 주입해주는 엔티티 매니저는 실제 동작 시점에 진짜 엔티티 매니저를 찾아주는 프록시용 가짜 엔티티 매니저이다.
이 가짜 엔티티 매니저는 실제 사용 시점에 트랜잭션 단위로 엔티티 매니저(영속성 컨텍스트)를 할당해준다.

 

---

📌 동적 쿼리와 성능 최적화 조회 - Builder 사용

MemberTeamDto - 조회 최적화용 DTO 추가

@Data
public class MemberTeamDto {
    private Long memberId;
    private String username;
    private int age;
    private Long teamId;
    private String teamName;

    @QueryProjection
    public MemberTeamDto(Long memberId, String username, int age, Long teamId, String teamName) {
        this.memberId = memberId;
        this.username = username;
        this.age = age;
        this.teamId = teamId;
        this.teamName = teamName;
    }
}

• @QueryProjection을 추가했다. QMemberTeamDto를 생성하기 위해 ./gradle → complieQuerydsl을 실행해주자.

참고 : @QueryProjection을 사용하면 해당 DTO가 Querydsl을 의존하게 된다. 이런 의존이 싫다면 Proehction.bean(), fileds(), constructor()을 사용하면 된다.

 

회원 검색 조건

@Data
public class MemberSearchCondition {
    // 회원명, 팀명, 나이(ageGoe, ageLoe)
    private String username;
    private String teamName;
    private Integer ageGoe;
    private Integer ageLoe;
}

• 이름이 너무 길면 MemberCond 등으로 줄여 사용해도 된다.

 

동적쿼리 - Builder를 사용한 예제

// ...
import static org.springframework.util.StringUtils.hasText;
import static study.querydsl.entity.QMember.member;
import static study.querydsl.entity.QTeam.team;

@Repository
public class MemberJpaRepository {

    private final EntityManager em;
    private final JPAQueryFactory queryFactory;

    public MemberJpaRepository(EntityManager em, JPAQueryFactory queryFactory) {
        this.em = em;
        this.queryFactory = queryFactory;
    }
	
    // ...

    public List<MemberTeamDto> searchByBuilder(MemberSearchCondition condition) {
        BooleanBuilder builder = new BooleanBuilder();
        if (hasText(condition.getUsername())) {
            builder.and(member.username.eq(condition.getUsername()));
        }
        if (hasText(condition.getTeamName())) {
            builder.and(team.name.eq(condition.getTeamName()));
        }
        if (condition.getAgeGoe() != null) {
            builder.and(member.age.goe(condition.getAgeGoe()));
        }
        if (condition.getAgeLoe() != null) {
            builder.and(member.age.loe(condition.getAgeLoe()));
        }

        return queryFactory
                .select(new QMemberTeamDto(
                        member.id.as("memberId"),
                        member.username,
                        member.age,
                        team.id.as("teamId"),
                        team.name.as("teamName")
                ))
                .from(member)
                .leftJoin(member.team, team)
                .where(builder)
                .fetch();
    }
}

 

동적쿼리 - Builder를 사용한 예제 테스트

@Test
public void searchTest() {
    Team teamA = new Team("teamA");
    Team teamB = new Team("teamB");
    em.persist(teamA);
    em.persist(teamB);

    Member member1 = new Member("member1", 10, teamA);
    Member member2 = new Member("member2", 20, teamA);
    Member member3 = new Member("member3", 30, teamB);
    Member member4 = new Member("member4", 40, teamB);

    em.persist(member1);
    em.persist(member2);
    em.persist(member3);
    em.persist(member4);

    MemberSearchCondition condition = new MemberSearchCondition();
    condition.setAgeGoe(35);
    condition.setAgeLoe(40);
    condition.setTeamName("teamB");

    List<MemberTeamDto> result = memberJpaRepository.searchByBuilder(condition);

    assertThat(result).extracting("username").containsExactly("member4");
}

 

---

📌 동적 쿼리와 성능 최적화 조회 - Where절 파라미터 사용

Where절에 파라미터를 사용한 예제

public List<MemberTeamDto> search(MemberSearchCondition condition) {
    return queryFactory
            .select(new QMemberTeamDto(
                    member.id.as("memberId"),
                    member.username,
                    member.age,
                    team.id.as("teamId"),
                    team.name.as("teamName")
            ))
            .from(member)
            .leftJoin(member.team, team)
            .where(usernameEq(condition.getUsername()),
                   teamNameEq(condition.getTeamName()),
                   ageGoe(condition.getAgeGoe()),
                   ageLoe(condition.getAgeLoe()))
            .fetch();
}
private BooleanExpression usernameEq(String username) {
    return hasText(username) ? member.username.eq(username) : null;
}

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

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

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

 

Where 절에 파라미터 방식을 사용하면 조건 재사용 가능

public List<Member> searchMember(MemberSearchCondition condition) {
    return queryFactory
            .selectFrom(member)
            .leftJoin(member.team, team)
            .where(usernameEq(condition.getUsername()),
                    teamNameEq(condition.getTeamName()),
                    ageGoe(condition.getAgeLoe()),
                    ageLoe(condition.getAgeLoe()))
            .fetch();
}

• 프로젝션 부분을 변경했는데도 조건을 재사용할 수 있다는 큰 장점이 있다.

 

---

📌 조회 API 컨트롤러 개발

이전 예제의 조회용 API를 만들고 확인한다.

 

편리한 데이터 확인을 위해 사전 샘플 데이터를 추가하고

샘플 데이터 추가가 테스트 케이스 실행에 영향을 주지 않도록 다음과 같이 프로파일을 설정한다.

• src/main/resources/application.yml 프로파일 local로 설정
• src/test/resources/application.yml 패키지 생성 후 프로파일 test로 설정
• 이렇게 분리하면 main 소스코드와 테스트 소스 코드 실행 시 프로파일을 분리할 수 있다.

 

샘플 데이터 추가

package study.querydsl.controller;

import lombok.RequiredArgsConstructor;
import org.springframework.context.annotation.Profile;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import study.querydsl.entity.Member;
import study.querydsl.entity.Team;

import javax.annotation.PostConstruct;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

@Profile("local")
@Component
@RequiredArgsConstructor
public class InitMember {

    private final InitMemberService initMemberService;
    @PostConstruct
    public void init() {
        initMemberService.init();
    }

    @Component
    static class InitMemberService {
        @PersistenceContext
        private EntityManager em;

        @Transactional
        public void init() {
            Team teamA = new Team("teamA");
            Team teamB = new Team("teamB");
            em.persist(teamA);
            em.persist(teamB);

            for (int i=0; i<100; i++) {
                Team selectedTeam = i%2 == 0? teamA : teamB;
                em.persist(new Member("member"+i, i, selectedTeam));
            }
        }
    }
}

• 100개의 테스트 데이터를 생성한다.

 

조회 컨트롤러

@RestController
@RequiredArgsConstructor
public class MemberController {
    private final MemberJpaRepository memberJpaRepository;

    @GetMapping("/v1/members")
    public List<MemberTeamDto> searchMemberV1(MemberSearchCondition condition) {
        return memberJpaRepository.search(condition);
    }
}

 

예제 실행(POST MAN)

• 동적 쿼리가 실행 확인 가능.

 

---

해당 글은 인프런의 [실전! Querydsl] 강의를 정리한 내용입니다.

실전! Querydsl - 인프런 | 강의