Querydsl(1)

💡 Querydsl이란?

QueryDSL은 정적 타입을 이용해서 SQL과 같은 쿼리를 생성할 수 있도록 해 주는 오픈소스 프레임워크입니다.
쿼리를 문자열로 작성하거나 작성하는 것이 아닌, QueryDSL이 제공하는 Fluent API를 이용해 코드 작성의 형식으로 쿼리를 생성할 수 있게 도와줍니다.

Querydsl vs JPQL

테스트코드를 작성하여 두 개의 차이점을 알아보겠습니다.

- JPQL

@Test
 public void startJPQL() {
	//member1을 찾아라. 
	String qlString =
             "select m from Member m " +
             "where m.username = :username";
             
     Member findMember = em.createQuery(qlString, Member.class)
             .setParameter("username", "member1")
             .getSingleResult();
             
     assertThat(findMember.getUsername()).isEqualTo("member1");
}

- Qeurydsl

 @Test
 public void startQuerydsl() {
    //member1을 찾아라.
    JPAQueryFactory queryFactory = new JPAQueryFactory(em); 
    QMember m = new QMember("m");
    Member findMember = queryFactory
                 .select(m)
                 .from(m)
                 .where(m.username.eq("member1"))//파라미터 바인딩 처리 
                 .fetchOne();
    
    assertThat(findMember.getUsername()).isEqualTo("member1");
 }

JPQL으로 문자로 작성되고 Querydsl은 코드로 작성됩니다.
JPQL은 실행을 해야 오류를 발견할 수 있지만 Querydsl은 컴파일시점에 오류를 잡을 수 있습니다.
또한, JPQL은 파라미터를 직접 바인딩해야하지만, Querydsl은 파라미터 바인딩을 자동처리 해줍니다.

프로젝트 환경설정

querydsl을 사용하기 위해서 .gradle파일에 관련 의존성을 추가해줍니다.

	//Querydsl 추가
	implementation 'com.querydsl:querydsl-jpa:5.0.0:jakarta'
	annotationProcessor """com.querydsl:querydsl-apt:${dependencyManagement.importedProperties['querydsl.version']}:jakarta"""
	annotationProcessor "jakarta.annotation:jakarta.annotation-api"
	annotationProcessor "jakarta.persistence:jakarta.persistence-api"

엔티티를 하나 생성해보겠습니다.

@Entity
@Getter
@Setter
public class Hello {

     @Id
     @GeneratedValue
     private Long id;

}

빌드 후 프로젝트 파일을 확인해보면 Q 타입이 생성된것을 확인할 수 있습니다.

기본 문법

기본 구조

먼저, querydsl을 사용하기 위한 기본 구조에 대해 살펴보겠습니다.

@SpringBootTest
@Transactional
public class QuerydslBasicTest {

   @PersistenceContext
   EntityManager em;
   
   JPAQueryFactory queryFactory;
   
   @BeforeEach
   public void before() {
       queryFactory = new JPAQueryFactory(em);
	//...
	}
   
   @Test
   public void startQuerydsl2() {
   //member1을 찾아라.
   QMember m = new QMember("m"); //Q타입 클래스 객체 생성
   
   Member findMember = queryFactory
               .select(m) // select 메소드
               .from(m) // from 메소드
               .where(m.username.eq("member1")) // where 메소드
               .fetchOne(); //fetch메소드
               
   assertThat(findMember.getUsername()).isEqualTo("member1");
   }
}

• querydsl을 사용하기 위해서는 JPAQeuryFactory객체를 생성합니다.
• querydsl은 빌더 패턴 구조로 이루어져 있습니다.
  SELECT 절에 필요한 데이터는 select 메서드에, FROM 절에 필요한 데이터는 from 메서드에, WHERE절에 필요한 데이터는 where 메소드에 세팅하면 됩니다. 이런 메서드들은 파이프라인 구조로 되어있어 가독성이 올라갑니다.
• 엔티티 데이터는 Q타입 클래스 객체로 전달합니다.
  
  

💡 JPAQueryFactory를 필드로 제공하면 동시성 문제는 어떻게 될까?

동시성 문제는 JPAQueryFactory를 생성 할 때 제공하는 EntityManager(em)에 달려있습니다.
스프링 프레임워크는 여러 쓰레드에서 동시에 같은 EntityManager에 접근해도, 트랜잭션 마다 별도의 영속성 컨텍스트를 제공하기 때문에, 동시성 문제는 걱정하지 않아도 됩니다!!!

Q-Type

Q클래스 인스턴스를 사용하는 방법은 여러가지가 있습니다.

1. 별칭을 직접 지정하는 방법

QMember qMember = new QMember("m");

Q클래스를 생성할때 직접 별칭을 지정하여 생성할 수 있습니다.

2. 기본 인스턴스 사용
Q클래스를 살펴보면 내부에 기본 인스턴스가 선언되어 있는 것을 확인할 수 있습니다.
같은 테이블을 조인하는 경우가 아니라면 기본 인스턴스를 사용할 수 있습니다.

QMember qMember = QMember.member;

3. 기본 인스턴스를 static import와 함께 사용

 import static study.querydsl.entity.QMember.*;
 
 @Test
 public void startQuerydsl3() {
    //member1을 찾아라.
    Member findMember = queryFactory
                 .select(member)
                 .from(member)
                 .where(member.username.eq("member1"))
                 .fetchOne();
                 
    assertThat(findMember.getUsername()).isEqualTo("member1");
 }

위와 같이 static import를 사용하면 따로 선언을 하지 않아도 바로 인스턴스를 참조하여 사용할 수 있습니다.

검색 조건 쿼리

• 비교 연산

member.username.eq("member1") // username = 'member1'
member.username.ne("member1") //username != 'member1'
member.username.eq("member1").not() // username != 'member1'

• null 검사

member.username.isNotNull() //이름이 is not null

• 범위 비교

member.age.in(10, 20) // age in (10,20)
member.age.notIn(10, 20) // age not in (10, 20)
member.age.between(10,30) //between 10, 30

• 크기 비교

member.age.goe(30) // age >= 30
member.age.gt(30) // age > 30
member.age.loe(30) // age <= 30
member.age.lt(30) // age < 30

• like 연산

member.username.like("member%") //like 검색 
member.username.contains("member") // like ‘%member%’ 검색 
member.username.startsWith("member") //like ‘member%’ 검색

💡 검색 조건은 .and(), .or()를 메서드 체인으로 연결할 수 있습니다.

 @Test
 public void search() {
     Member findMember = queryFactory
            .selectFrom(member) // select, from을 selectFrom으로 합칠 수 있음
            .where(member.username.eq("member1")
                    .and(member.age.eq(10)))
            .fetchOne();
            
    assertThat(findMember.getUsername()).isEqualTo("member1");
}

.and() 메서드를 생략하고 where()에 파라미터로 검색조건을 추가 할 수도 있습니다.
이 경우 null 값은 무시되며 메서드 추출을 활용해서 동적 쿼리를 깔끔하게 만들 수 있습니다.

@Test
public void searchAndParam() {
     List<Member> result1 = queryFactory
             .selectFrom(member)
		     .where(member.username.eq("member1"),
					member.age.eq(10))
             .fetch();
     
     assertThat(result1.size()).isEqualTo(1);
 }

결과 조회

• fetch() : 리스트 조회, 데이터 없으면 빈 리스트 반환

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

• fetchOne() : 단 건 조회
  결과가 없으면 : null
  결과가 둘 이상이면 : com.querydsl.core.NonUniqueResultException

  Member findMember1 = queryFactory
        .selectFrom(member)

• fetchFirst() : 처음한건 조회 = limit(1).fetchOne()

  Member findMember2 = queryFactory
        .selectFrom(member)
        .fetchFirst();

• fetchResults() : 페이징 정보 포함, total count 쿼리 추가 실행

	QueryResults<Member> results = queryFactory
        .selectFrom(member)
        .fetchResults();

• fetchCount() : count 쿼리로 변경해서 count 수 조회

	long count = queryFactory
         .selectFrom(member)
         .fetchCount();

정렬

• .orderBy()
• desc() , asc() : 일반 정렬
• nullsLast() , nullsFirst() : null 데이터 순서 부여

/**
*회원 정렬 순서
* 1. 회원 나이 내림차순(desc)
* 2. 회원 이름 올림차순(asc)
* 단 2에서 회원 이름이 없으면 마지막에 출력(nulls last) */
 @Test
 public void sort() {
     em.persist(new Member(null, 100));
     em.persist(new Member("member5", 100));
     em.persist(new Member("member6", 100));
     
     List<Member> result = queryFactory
             .selectFrom(member)
             .where(member.age.eq(100))
             .orderBy(member.age.desc(), member.username.asc().nullsLast())
             .fetch();
             
     Member member5 = result.get(0);
     Member member6 = result.get(1);
     Member memberNull = result.get(2);
     
     assertThat(member5.getUsername()).isEqualTo("member5");
     assertThat(member6.getUsername()).isEqualTo("member6");
     assertThat(memberNull.getUsername()).isNull();
}

페이징

: 조회 건수 제한

 @Test
 public void paging1() {
     List<Member> result = queryFactory
            .selectFrom(member)
            .orderBy(member.username.desc()) .offset(1) //0부터 시작(zero index) 
            .limit(2) //최대 2건 조회
            .fetch();
     assertThat(result.size()).isEqualTo(2);
 }

💡 페이징 쿼리를 작성할 때, 데이터를 조회하는 쿼리는 여러 테이블을 조인해야 하지만, count 쿼리는 조인이 필요 없는 경우도 있습니다. 그런데 자동화된 count 쿼리(.fetchResults와 같은)는 원본 쿼리와 같이 모두 조인을 해버리기 때문에 성능이 안나올 수 있습니다. count 쿼리에 조인이 필요없는 성능 최적화가 필요하다면, count 전용 쿼리를 별도로 작성해야 합니다.

집합

• 집합함수
  JPQL이 제공하는 모든 집합 함수를 제공합니다.

 @Test
 public void aggregation() throws Exception {
 
     List<Tuple> result = queryFactory
             .select(member.count(),
                     member.age.sum(),
                     member.age.avg(),
                     member.age.max(),
                     member.age.min())
             .from(member)
             .fetch();
             
     Tuple tuple = result.get(0);
     
     assertThat(tuple.get(member.count())).isEqualTo(4);
     assertThat(tuple.get(member.age.sum())).isEqualTo(100);
     assertThat(tuple.get(member.age.avg())).isEqualTo(25);
     assertThat(tuple.get(member.age.max())).isEqualTo(40);
     assertThat(tuple.get(member.age.min())).isEqualTo(10);
}

프로젝션 대상이 둘 이상일 경우 튜플을 사용합니다.

• GroupBy

 @Test
 public void group() throws Exception {
 
     List<Tuple> result = queryFactory
             .select(team.name, member.age.avg())
             .from(member)
             .join(member.team, team)
             .groupBy(team.name)
             .fetch();
             
     Tuple teamA = result.get(0);
     Tuple teamB = result.get(1);
     
     assertThat(teamA.get(team.name)).isEqualTo("teamA");
     assertThat(teamA.get(member.age.avg())).isEqualTo(15);
     
     assertThat(teamB.get(team.name)).isEqualTo("teamB");
     assertThat(teamB.get(member.age.avg())).isEqualTo(35);
 }

💡 having을 이용하여 그룹화된 결과를 제한할 수도 있습니다.

    .groupBy(item.price)
    .having(item.price.gt(1000))