JPA - Criteria Query(객체지향 쿼리 빌더), JPQL Query Builder Class

JPA - Criteria Query(객체지향 쿼리 빌더), JPQL Query Builder Class

---

Criteria 쿼리는 JPQL을 자바 코드로 작성하도록 도와주는 빌더 클래스 API이다. Criteria를 사용하면 문자가 아닌 코드로 JPQL를 작성하므로 문법 오류를 컴파일 단계에서 잡을 수 있고 문자 기반의 JPQL보다 동적 쿼리를 안전하게 생성할 수 있다. 하지만 이번에 Criteria를 간단하게만 다루려고 한다. 이유는 실제 Criteria를 사용해서 개발하다보면 코드가 복잡하고 장황하며 직관적으로 이해하기 힘들다는 단점이 있기때문이다. 다음 포스팅에서는 코드로 쿼리를 작성할 수 있고 간단한 QueryDSL을 다음에 자세히 다뤄볼 예정이기에 이번 포스팅은 몇가지 간단하게만 다뤄본다.

---

Criteria 기초

---

//EntityManager 혹은 EntityManagerFactory에서 CriteriaBuilder를 가져온다.
CriteriaBuilder builder = em.getCriteriaBuilder(); --> 1
//CriteriaBuilder로부터 CriteriaQuery객체를 얻어온다. 
//반환타입을 알수 없다면 제네릭타입을 Object로 준다.
CriteriaQuery<MemberJPQL> query = builder.createQuery(MemberJPQL.class); --> 2
        
//조회의 시작점을 뜻하는 Root객체 생성 여기서 변수명 m은 JPQL에서 별칭이라고 생각하면 된다.
//반환타입을 알수 없다면 제네릭타입을 Object로 준다.
Root<MemberJPQL> m = query.from(MemberJPQL.class); --> 3
//distinct 중복제거.
query.select(m).distinct(true); --> 4
    
//위에서 반환타입이 명확하지 않다면 Query 객체로 쿼리를 만들고 결과를 받는다.
TypedQuery<MemberJPQL> typeQuery = em.createQuery(query);
    
List<MemberJPQL> members = typeQuery.getResultList();

   

1	Criteria 쿼리를 생성하려면 먼저 Criteria 빌더(CriteriaBuilder)를 얻어야 한다. Criteria 빌더는 EntityManager나 EntityManagerFactory에서 얻을 수 있다.
2	Criteria 쿼리 빌더에서  Criteria 쿼리( CriteriaQuery)를 생성한다. 이때 반환 타입을 지정할 수 있다.
3	FROM 절을 생성한다. 반환된 값 m은  Criteria에서 사용하는 특별한 별칭이다. m을 조회의 시작점이라는 의미로 쿼리 루트(Root)라고 한다.
4	SELECT 절을 생성한다.

이렇게  Criteria쿼리를 완성하고 나면 다음 순서는 기존의 JPQL과 같다. em.createQuery(query)에 완성된  Criteria쿼리를 넣어주면 된다.

//EntityManager 혹은 EntityManagerFactory에서 CriteriaBuilder를 가져온다.
CriteriaBuilder builder = em.getCriteriaBuilder();
    
//CriteriaBuilder로부터 CriteriaQuery객체를 얻어온다. 
//반환타입을 알수 없다면 제네릭타입을 Object로 준다.
CriteriaQuery<MemberJPQL> query = builder.createQuery(MemberJPQL.class);
 
//조회의 시작점을 뜻하는 Root객체 생성 여기서 변수명 m은 JPQL에서 별칭이라고 생각하면 된다.
//반환타입을 알수 없다면 제네릭타입을 Object로 준다.
Root<MemberJPQL> m = query.from(MemberJPQL.class);
 
//검색조건 정의
Predicate usernameEqual = builder.equal(m.get("username"), "여성게1");
//정렬조건 정의
Order ageDesc = builder.desc(m.get("age"));
 
//distinct 중복제거.
query.select(m)
     .distinct(true)
     .where(usernameEqual)
     .orderBy(ageDesc);
 

  

다음으로는 검색조건,정렬조건을 정의하는 부분이다. 위와 같이 where절에 들어가는 부분은 Predicate 클래스로, orderBy에 들어가는 부분은 Order 클래스로 정의해준다. 위와 같이 객체로 정의하여도 되지만

~.where(builder.equal(m.get("username"),"여성게1"); 

-->이런식으로 where절에 바로 넣어주어도 된다.

---

조회(한건,여러건) - Criteria

---

public void select() {
 
    //EntityManager 혹은 EntityManagerFactory에서 CriteriaBuilder를 가져온다.
    CriteriaBuilder builder = em.getCriteriaBuilder();
 
    //CriteriaBuilder로부터 CriteriaQuery객체를 얻어온다. 
    //반환타입을 알수 없다면 제네릭타입을 Object로 준다.
    CriteriaQuery<MemberJPQL> query = builder.createQuery(MemberJPQL.class);
    
    //조회의 시작점을 뜻하는 Root객체 생성 여기서 변수명 m은 JPQL에서 별칭이라고 생각하면 된다.
    //반환타입을 알수 없다면 제네릭타입을 Object로 준다.
    Root<MemberJPQL> m = query.from(MemberJPQL.class);
 
    //검색조건 정의
    Predicate usernameEqual = builder.equal(m.get("username"), "여성게1");
    //정렬조건 정의
    Order ageDesc = builder.desc(m.get("age"));
 
    //distinct 중복제거.
    query.select(m)
         .distinct(true)
         .where(usernameEqual)
         .orderBy(ageDesc);
 
    //위에서 반환타입이 명확하지 않다면 Query 객체로 쿼리를 만들고 결과를 받는다.
    TypedQuery<MemberJPQL> typeQuery = em.createQuery(query);
 
    List<MemberJPQL> members = typeQuery.getResultList();
    
    System.out.println("=================select==================");
 
    for(MemberJPQL member : members) {
        System.out.println(member.toString());
    }
 
    System.out.println("=================select==================");
}
 
    
/*
 * 조회대상을 여러건 지정할때
 * ex) select m.name,m.age from MemberJPQL m
 */
 
public void select2() {
 
    //EntityManager 혹은 EntityManagerFactory에서 CriteriaBuilder를 가져온다.
    CriteriaBuilder builder = em.getCriteriaBuilder();
 
    //CriteriaBuilder로부터 CriteriaQuery객체를 얻어온다. 
    //반환타입을 알수 없다면 제네릭타입을 Object로 준다.
    CriteriaQuery<Object[]> query = builder.createQuery(Object[].class);
 
    //조회의 시작점을 뜻하는 Root객체 생성 여기서 변수명 m은 JPQL에서 별칭이라고 생각하면 된다.
    //반환타입을 알수 없다면 제네릭타입을 Object로 준다.
    Root<MemberJPQL> m = query.from(MemberJPQL.class);
 
    query.multiselect(m.get("username"),m.get("age")).distinct(true);
 
    //query.select(builder.array(m.get("username"),m.get("age"))).distinct(true); ->위와 같다.
 
    TypedQuery<Object[]> query2 = em.createQuery(query);
    List<Object[]> resultList = query2.getResultList();
 
    System.out.println("=================select2==================");
 
    for(Object o : resultList) {
        Object[] o2 = (Object[])o;
        System.out.print(o2[0]+" ");
        System.out.println(o2[1]);
    }
 
    System.out.println("=================select2==================");
}

크게 어려울 부분은 없을 것같다. select()는 단일조회, select2()는 다중값 조회이다. 하지만 여기서 JPQL을 생각해보면 여러 값의 조회를 하나의 DTO클래스로 반환받았던 것이 기억날 것이다. Criteria 역시 NEW 명령어 쿼리를 지원한다.

---

NEW 명령어를 이용하여 다중값 특정 객체 매핑이후 반환 - Criteria

---

/*
 * 반환타입을 알수 없을때, 여러개의 반환타입을 가질 경우 DTO클래스로 반환값을 갖는다.
 */
public void constructSelect() {
    //EntityManager 혹은 EntityManagerFactory에서 CriteriaBuilder를 가져온다.
    CriteriaBuilder builder = em.getCriteriaBuilder();
 
    //CriteriaBuilder로부터 CriteriaQuery객체를 얻어온다. 
    //반환타입을 알수 없다면 제네릭타입을 Object로 준다.
    CriteriaQuery<MemberDTO> query = builder.createQuery(MemberDTO.class);
 
    //조회의 시작점을 뜻하는 Root객체 생성 여기서 변수명 m은 JPQL에서 별칭이라고 생각하면 된다.
    //반환타입을 알수 없다면 제네릭타입을 Object로 준다.
    Root<MemberJPQL> m = query.from(MemberJPQL.class);
 
    query.select(builder.construct(MemberDTO.class, m.get("username"),m.get("age")) );
 
    TypedQuery<MemberDTO> typeQuery = em.createQuery(query);
        
    List<MemberDTO> members = typeQuery.getResultList();
 
    System.out.println("=================constructSelect==================");
 
    for(MemberDTO member : members) {
        System.out.println(member.toString());
    }
    
    System.out.println("=================constructSelect==================");
}

JPQL과 비교하여 달라진 점이 좀있다. 문자기반이 아니라 코드기반으로 쿼리를 다루다보니 DTO클래스를 풀 패키지명으로 안써도 되는 것이다. 이런것들을 생각하면 문자열을 잘못넣어서 오류날 일은 거의 없을듯 싶다. 하지만 아직까지도 문자열을 쓰는 부분은 조금 남아있다.

---

Java Map과 비슷한 TupleQuery - Criteria

---

만약 반환값이 여러개라면 위처럼 DTO로 받을 수도 있지만 마치 Map과 같은 객체처럼 느껴지는 Tuple이라는 객체를 이용해서도 다중 값 쿼리가 가능하다.

/*
 * 튜플 - Java의 Map과 흡사한 형태로 결과를 반환받는다.
 */
public void tupleQuery() {
    //EntityManager 혹은 EntityManagerFactory에서 CriteriaBuilder를 가져온다.
    CriteriaBuilder builder = em.getCriteriaBuilder();
 
    CriteriaQuery<Tuple> query = builder.createTupleQuery();
 
    //CriteriaQuery<Tuple> query = builder.createQuery(Tuple.class); -> 위와 같다.
    Root<MemberJPQL> m = query.from(MemberJPQL.class);
    query.multiselect(m.get("username").alias("username"),m.get("age").alias("age"));
    //query.select(builder.tuple(m.get("username").alias("username"),m.get("age").alias("age")))
 
    ->위와같다.
 
    /*
     * 멤버전체를 하나의 튜플로 받을때.
     * 
     * query.select(builder.tuple(m.alias("m"))); 
     * 이러면 m이라는 별칭으로 tuple에서 회원엔티티를 얻어올 수 있다.
     */
    TypedQuery<Tuple> query2 = em.createQuery(query);
    List<Tuple> resultList = query2.getResultList();
 
    System.out.println("=================tupleQuery==================");
 
    for(Tuple t : resultList) {
        System.out.println(t.get("username",String.class)+" "+t.get("age",Integer.class));
    }
    System.out.println("=================tupleQuery==================");
}

코드만 봐도 조금은 직관적으로 보인다. Tuple의 key가 될 값을 반환value.alias(key값)로 지정해준다. 그런다음 결과를 꺼낼때 Tuple객체에서 키값과 반환타입을 넘겨 꺼낸다. 위의 주석에도 있듯이 스칼라타입의 필드말고 엔티티를 전체로 튜플의 값으로도 설정해줄수 있다.

결론적으로 튜플은 이름 기반이므로 순서 기반의 Object[]로 반환받는 것보다 훨씬 안전하다. 그리고 tuple.getElements() 같은 메소드를 사용해서 현재 튜플의 별칭과 자바 타입도 조회가능하다.

---

조인(Join & Fetch Join) - Criteria

---

/*
 * Join
 * 
 * public enum JoinType{
 *     INNER,LEFT,RIGHT
 * }
 */
public void join() {
    //EntityManager 혹은 EntityManagerFactory에서 CriteriaBuilder를 가져온다.
    CriteriaBuilder builder = em.getCriteriaBuilder();
 
    CriteriaQuery<Tuple> query = builder.createTupleQuery();
 
    Root<MemberJPQL> m = query.from(MemberJPQL.class);
 
    //JPQL에서 조인구문과 연관 엔티티의 별칭이라 보면된다.
    Join<MemberJPQL, TeamJPQL> t =m.join("team",JoinType.INNER);
 
    query.multiselect(m.alias("m"),t.alias("t"))
         .where(builder.equal(t.get("name"), "티스토리1"));
 
    TypedQuery<Tuple> query2 = em.createQuery(query);
    List<Tuple> resultList = query2.getResultList();
 
    System.out.println("=================join==================");
 
    for(Tuple tuple : resultList) {
        MemberJPQL member = tuple.get("m",MemberJPQL.class);
        TeamJPQL team = tuple.get("t",TeamJPQL.class);
        System.out.println(member.toString());
        System.out.println(team.toString());
    }
 
    System.out.println("=================join==================");
}
 
public void fetchJoin() {
    //EntityManager 혹은 EntityManagerFactory에서 CriteriaBuilder를 가져온다.
    CriteriaBuilder builder = em.getCriteriaBuilder();
 
    CriteriaQuery<MemberJPQL> query = builder.createQuery(MemberJPQL.class);
 
    Root<MemberJPQL> m = query.from(MemberJPQL.class);
 
    //fetchJoin이다. 만약 외부조인이라면 밑에 주석과 같이 left,right를 넣어준다.
    m.fetch("team"/*,JoinType.LEFT*/);
 
    query.select(m)
         .where(builder.equal(m.get("username"), "여성게1"));
    
    TypedQuery<MemberJPQL> query2 = em.createQuery(query);
    List<MemberJPQL> resultList = query2.getResultList();
 
    System.out.println("=================fetchJoin==================");
 
    for(MemberJPQL member : resultList) {
        System.out.println(member.toString());
    }
 
    System.out.println("=================fetchJoin==================");
}

JPQL에서 다루었던 조인과 패치조인이다. 크게 어려울 부분은 없을 것같아 몇가지만 설명하려고 한다. 

Join<MemberJPQL, TeamJPQL> t =m.join("team",JoinType.INNER);

->JPQL과 비교하면 ~ [inner] join m.team t 와 비슷한 구문이라고 보면된다.

그리고 튜플로 반환받기위해 두개의 엔티티 모두에게 별칭을 주었고 마지막 결과를 출력하는 부분에 별칭을 이용하여 객체를 얻어왔다.

그 다음은 패치조인이다.

m.fetch("team"/*,JoinType.LEFT*/);

-> 

일반 조인과는 다르게 반환값을 받아서 사용하지 않는다. 즉, 조회의 결과로 나오는 회원엔티티의 team필드에 값이 세팅되서 나오는 것이다. 그래서 결과값을 받을 경우 회원엔티티로만 받고 그 회원엔티티의 팀엔티티 필드에서 값을 꺼내 사용한다.(사실 Criteria에서 패치조인을 이용하여 두개의 결과값을 받을 수 있는지는 확실히 모르겠다. 혹시 아시는 분은 댓글부탁드립니다.)

---

Parameter Binding

---

public void paramBind(String param) {
 
    //EntityManager 혹은 EntityManagerFactory에서 CriteriaBuilder를 가져온다.
 
    CriteriaBuilder builder = em.getCriteriaBuilder();
 
        
 
    CriteriaQuery<MemberJPQL> query = builder.createQuery(MemberJPQL.class);
 
        
 
    Root<MemberJPQL> m = query.from(MemberJPQL.class);
 
        
 
    //fetchJoin이다. 만약 외부조인이라면 밑에 주석과 같이 left,right를 넣어준다.
 
    m.fetch("team"/*,JoinType.LEFT*/);
 
        
 
    query.select(m).where(builder.equal(m.get("username")
 
                 ,builder.parameter(String.class,"username")));
 
    TypedQuery<MemberJPQL> query2 = em.createQuery(query)
 
                    .setParameter("username", param);
 
        
 
    List<MemberJPQL> resultList = query2.getResultList();
 
        
 
    System.out.println("=================paramBind==================");
 
        
 
    for(MemberJPQL member : resultList) {
 
        System.out.println(member.toString());
 
    }
 
        
 
    System.out.println("=================paramBind==================");
 
}

query.select(m).where(builder.equal(m.get("username")

 ,builder.parameter(String.class,"username")));

-> 이름기반 파라미터 정의를 해준다. (Predicate 객체로 선언해도되지만 이렇게 where절에 바로 넣어도된다.)

TypedQuery<MemberJPQL> query2 = em.createQuery(query)

.setParameter("username", param);

->JPQL과 동일하게 setParameter메소드를 호출해서 세팅해준다.

---

Criteria Meta Code Generate

---

지금까지 간단하게 Criteria 쿼리를 설명했다. 확실히 그냥 JPQL을 사용할때 보다 문자열을 사용하여 쿼리를 작성하는 부분이 확 줄었다. 그렇지만 그렇다고 100% 문자열을 사용하지 않는 것은 아니다. 그 말은 100% 실수하지 않으리라는 보장이 없는 것이다. 이때 사용할 수 있는 것이 Meta Code를 생성하여서 위에서 조금 사용한 문자열마저 사용하지 않는 것이다. Meta Code를 생성하면 각 엔티티 클래스마다 메타정보를 가진 자바파일들이 생성되게 된다.

<pom.xml>

<!-- Criteria Meta Code -->
<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-jpamodelgen</artifactId>
    <version>1.3.0.Final</version>
</dependency>
 
<!-- Criteria Meta Code Plugin -->
 
<plugin>
       <groupId>org.apache.maven.plugins</groupId>
       <artifactId>maven-compiler-plugin</artifactId>
       <configuration>                    
        <source>1.8</source>
        <target>1.8</target>
        <outputDirectory>target/generated-sources/annotations</outputDirectory>
        <compilerArguments>
            <processor>org.hibernate.jpamodelgen.JPAMetaModelEntityProcessor</processor>
         </compilerArguments>
    </configuration>
</plugin>

이렇게 두개를 설정해준다. 첫번째 의존 라이브러리를 내려받아주고, 두번째는 Meta Code를 생성하기 위한 플러그인 설정을 해주는 것이다.

->Run As..->Run Configuration 에 들어가서 해당 프로젝트의 메이븐 빌드 Goals를 입력하고 Run을 해준다.

->빌드가 완료되었다면 target->generated-sources에 Meta Code들이 생성되어 있을 것이다. 이 다음은 과정은 각자의 IDE환경에 따라 다르다. 만약 target>generated-sources가 자동으로 클래스패스로 잡힌다면 문제가 없지만 만약 클래스패스로 잡히지 않는다면 직접 등록해주어야한다. 클래스패스가 디폴트로 잡히지 않는다는 가정하에 진행한다.

-> 첫 이미지처럼 반드시 패키지명직전까지를 패스로 잡아야한다. 그래서 Meta Code생성시 package관련 에러가 뜨지 않는다. 마지막으로 Apply를 누르면 방금생성된 메타코드가 클래스패스에 들어가있을 것이다(기존의 target부분에는 코드가 없어짐). 혹시나 에러표시가 프로젝트에 계속 난다면 maven update를 하길바란다.

---

Criteria Meta Code 적용후 쿼리

---

/*
 * Criteria Meta Code 생성
 */
public void afterMetaCodeGen(String username,String teamname) {
    //EntityManager 혹은 EntityManagerFactory에서 CriteriaBuilder를 가져온다.
    CriteriaBuilder builder = em.getCriteriaBuilder();
 
    CriteriaQuery<MemberJPQL> query = builder.createQuery(MemberJPQL.class);
    Root<MemberJPQL> m = query.from(MemberJPQL.class);
 
    //fetchJoin이다. 만약 외부조인이라면 밑에 주석과 같이 left,right를 넣어준다.
    m.fetch("team"/*,JoinType.LEFT*/);
 
    List<Predicate> searchConditions = new ArrayList<Predicate>();
 
    if(!StringUtils.isEmpty(username)){
        searchConditions.add(builder.equal(m.get(MemberJPQL_.username)
                            ,builder.parameter(String.class,"username")));
    }
 
    if(!StringUtils.isEmpty(teamname)) {
        searchConditions.add(builder.equal(m.get(MemberJPQL_.team).get(TeamJPQL_.name)
                ,builder.parameter(String.class,"teamname")));
    }
 
    query.select(m)
         .where(builder.and(searchConditions.toArray(new Predicate[0])));
 
    TypedQuery<MemberJPQL> query2 = em.createQuery(query);
 
    if(!StringUtils.isEmpty(username)){
        query2.setParameter("username", username);
    }
 
    if(!StringUtils.isEmpty(teamname)) {
        query2.setParameter("teamname", teamname);
    }
 
    List<MemberJPQL> resultList = query2.getResultList();
 
    System.out.println("=================afterMetaCodeGen==================");
 
    for(MemberJPQL member : resultList) {
        System.out.println(member.toString());
    }
 
    System.out.println("=================afterMetaCodeGen==================");
 
}

m.get(MemberJPQL_.username)

->여기에서 사용하던 문자열이 없어졌다. 이제 조금은 에러가 줄것 같다.

---

지금까지 간단하게 Criteria를 다뤄봤습니다. 사실 개인적인 생각으로는 이것이 편해진것인가...? 하는 생각이 조금 들었습니다. 문자기반으로 작성하지 않을 뿐이고 오히려 코드는 그냥 JPQL을 쓸때보다 복잡해진것같기도 하는 생각이 듭니다.(개인적인 생각입니다. 물론 런타임시점에 에러를 발견해야하는 큰 문제를 해결해준 것만으로도 엄청난 가치가 있다고 생각듭니다.) 그래서 다음 포스팅에서는 쉽고, 간단하고, 코드로 쿼리를 다룰 수 있는 QueryDSL을 이용하여 JPA쿼리를 다뤄보겠습니다.