[실전! Querydsl] 실무 활용 - 순수 JPA와 Querydsl

순수 JPA 리포지토리와 Querydsl

• 스프링이 주입하는 em은 실제 동작 시점에 트랜잭션 단위로 진짜 엔티티 매니저를 찾아주는 프록시 엔티티 매니저임
• JPAQueryFactory를 메인 어플리케이션 클래스에 Bean으로 등록하고, 리포지토리에서 주입받아도 됨
  • 장점: @RequiredArgsConstructor 활용해 리포지토리 코드 짤 때 깔끔함
  • 단점: 두 개를 주입받아야 하므로 테스트코드 짤 때 불편함

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

• 리포지토리

@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> findAll_Querydsl() {
        return queryFactory
                .selectFrom(member)
                .fetch();
    }

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

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

• 테스트

* make test: ctrl + shift + T

@SpringBootTest
@Transactional
class MemberJpaRepositoryTest {

    @Autowired
    EntityManager em;

    @Autowired
    MemberJpaRepository memberJpaRepository;

    @Test
    public 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> result1_querydsl = memberJpaRepository.findAll_Querydsl();
        assertThat(result1_querydsl).containsExactly(member);

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

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

    }
}

 

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

• 조회 최적화용 DTO 생성, @QueryProjection 사용

@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;
    }
}

• 회원 검색 조건 객체 생성

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

• 리포지토리

public List<MemberTeamDto> searchByBuilder(MemberSearchCondition condition) {
        BooleanBuilder builder = new BooleanBuilder();
        if (StringUtils.hasText(condition.getUsername())) { // 이름으로 null과 빈 문자열이 넘어오는 경우 필터링
            builder.and(member.username.eq(condition.getUsername()));
        }
        if (StringUtils.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,
                        member.username,
                        member.age,
                        team.id,
                        team.name
                ))
                .from(member)
                .leftJoin(member.team, team)
                .where(builder)
                .fetch();
    }

• 테스트

@Test
public void searchTest() {
    Team a = new Team("A");
    Team b = new Team("B");
    em.persist(a);
    em.persist(b);

    Member member1 = new Member("1", 10, a);
    Member member2 = new Member("2", 20, a);

    Member member3 = new Member("3", 30, b);
    Member member4 = new Member("4", 40, b);
    em.persist(member1);
    em.persist(member2);
    em.persist(member3);
    em.persist(member4);

    MemberSearchCondition condition = new MemberSearchCondition();
    condition.setAgeGoe(33);
    condition.setAgeLoe(40);
    condition.setTeamName("B");

    List<MemberTeamDto> result = memberJpaRepository.searchByBuilder(condition);
    assertThat(result).extracting("username").containsExactly("4");
}

• 조건이 없으면 모든 데이터를 다 가져오므로 주의
  • 기본조건을 두거나 limit 설정, 페이징 쿼리

 

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

• 가독성과 재사용성이 좋기 때문에 일반적으로 추천
  • 메서드 반환 타입을 BooleanExpression으로 해야 메서드끼리 조립 가능

public List<MemberTeamDto> search(MemberSearchCondition condition) {
    return queryFactory
            .select(new QMemberTeamDto(
                    member.id,
                    member.username,
                    member.age,
                    team.id,
                    team.name
            ))
            .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;
}

• 엔티티 자체를 반환하는 코드로 바꾸어도 조건 그대로 사용

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

 

조회 API 컨트롤러 개발

• 프로파일 설정
  • 로컬 환경에 샘플 데이터를 넣고 확인하는 경우, 테스트 환경에는 그 데이터가 영향을 주면 안되기 때문에 분리

// src/main/resources/application.yml
// 아래 사항 추가
spring:
    profiles:
    	active: local
        
// src/test/resources/application.yml
// 로컬 yml 파일 복사 후 아래 사항으로 수정
spring:
    profiles:
    	active: test

• 샘플 데이터 추가

@Profile("local") // local profile인 applicaion.yml의 설정을 따른다
@Component
@RequiredArgsConstructor
public class InitMember {

    private final InitMemberService initMemberService;

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

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

        @Transactional // @PostConstruct와 동시에 붙을 수 없으므로 따로 분리
        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));
            }
        }
    }

}

• 조회 컨트롤러
  • localhost:8080/v1/members에 쿼리 파라미터 형식으로 조건을 넣어 조회 가능

@RestController
@RequiredArgsConstructor
public class MemberController {

    private final MemberJpaRepository memberJpaRepository;

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