출처

---

순수 JPA 리포지토리

@Repository
public class MemberJpaRepository {

    private final EntityManager em;
    private final JPAQueryFactory queryFactory;

    public MemberJpaRepository(EntityManager em) {
        this.em = em;
        this.queryFactory = new JPAQueryFactory(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 리포지토리는 위와 같다

QueryDSL로 전환

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

querydsl을 사용하면 매개변수를 훨씬 간단히 사용할 수 있다.
또한 컴파일 시 에러를 잡을 수 있다.

---

동적 쿼리와 성능 최적화 조회

Builder 사용

@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 을 활용해서 DTO를 만들 수 있다.
@QueryProjection을 DTO에 생성자에 달아주면 dto 또한 compilequerydsl을 눌러서 QType으로 만들 수 있다.
관련 내용

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

위와 같이 조건을 입력받을 dto를 만든다

---

    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.getAgeGoe()));
        }
        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();
    }

member의 id는 필드명이 id인데 dto에서는 memberId로 받기 때문에
member.id.as("memberId")로 코드를 작성한다.

username 같은 경우 null이나 "" 로 들어올 수 있어서 StringUtils를 사용한다.
hasText로 null이 아니고 empty가 아닌 경우를 전부 검사할 수 있다
조건에 따라 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");
    }

테스트 코드는 위와 같이 짤 수 있다
MemberSearchCondition을 직접 만들어서 조건을 전달해준다

이런 동적 쿼리를 짤 때는 개발할 때는 상관 없지만 실제 운영할 때 데이터가 많아졌을 때 조건이 없으면 모든 데이터를 끌고오게 된다. 따라서 페이징이나 limit를 걸어주는 것이 좋다

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 ageLoe(Integer ageLoe) {
        return ageLoe !=null? member.age.loe(ageLoe) : null;
    }

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

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

    private BooleanExpression usernameEq(String username) {
        return hasText(username) ? member.username.eq(username) : null;
    }

반환형을 BooleanExpression 형으로 한 이유는 얘내들끼리 또 조합이 가능해지기 때문이다.

where 절 다중 파라미터 방식을 사용하면 쿼리가 깔끔해지고 또 파라미터 부분이 재사용이 가능하다

프로젝션이 달라져도 조건들은 재사용 할 수 있다.