Web/JPA 2019. 2. 9. 18:59

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


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



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




Criteria 기초


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//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();
cs

   



    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쿼리를 넣어주면 된다.



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//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);
 
cs

  


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


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

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





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


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
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==================");
}
cs



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



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


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/*
 * 반환타입을 알수 없을때, 여러개의 반환타입을 가질 경우 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==================");
}
cs



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



Java Map과 비슷한 TupleQuery - Criteria


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


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
/*
 * 튜플 - 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==================");
}
cs



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

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





조인(Join & Fetch Join) - Criteria


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
/*
 * 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==================");
}
cs



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


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
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==================");
 
}
cs


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>


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<!-- 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>
cs



이렇게 두개를 설정해준다. 첫번째 의존 라이브러리를 내려받아주고, 두번째는 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 적용후 쿼리



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
/*
 * 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==================");
 
}
cs




m.get(MemberJPQL_.username)

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





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



저작자표시

'Web > JPA' 카테고리의 다른 글

JPA - NativeQuery ( SQL ) 네이티브 SQL 사용하기!  (0) 2019.02.11
JPA - QueryDSL, JPQL Query Builder Class  (0) 2019.02.11
JPA - @NamedQuery , 정적 쿼리  (0) 2019.02.09
JPA - JPQL 서브쿼리 (객체지향 쿼리 언어)  (0) 2019.02.09
JPA - JPQL 조인(객체지향쿼리),Java Persistence Query Language  (0) 2019.02.09
posted by 여성게
:
Web/JPA 2019. 2. 9. 13:44

JPA - JPQL(객체지향쿼리),Java Persistence Query Language

JPA - JPQL(객체지향쿼리)

jpa-study.zip

(예제소스파일/ jpql package참조)

JPQL은 가장 중요한 객체지향 쿼리 언어이다. Criteria나 QueryDSL은 결국 JPQL을 편리하게 사용하도록 도와주는 기술이므로 JPA로 데이터베이스 엑세스를 다룬다면 JPQL은 꼭 필수라고 생각이 든다. SQL과 꼭 닮은 쿼리 언어이며 SQL은 데이터 중심의 쿼리라고 하면 JPQL은 엔티티를 대상으로 하는 쿼리 언어라고 할 수 있다. 결국 JPA에서 해당 JPQL을 분석한 다음 적절한 SQL로 변환해주어서 데이터베이스에서 데이터를 가져오는 것이다.

JPQL 특징

1. 엔티티 객체를 조회하는 객체지향 쿼리이다.(테이블 대상이 아니다.)
2. JPQL은 SQL을 추상화해서 특정 데이터베이스에 의존하지 않는다.(데이터베이스 방언(Dialect)만 변경하면 소스 수정없이 데이터베이스 변경가능)
3. SQL보다 간결하다.





SELECT문

 


간단한 Select문이다. 일단 from절은 절대 테이블명이 아닌 엔티티명을 넣어주어야한다.(@Entity에서 name을 정의하지 않았다면 테이블명) 그리고 where절 혹은 프로젝션(select 다음 조회할 목록을 지칭) 쪽에서 엔티티의 필드를 참조하기 위해서는 반드시 클래스 내부에 정의된 필드 네임을 그대로 가야한다. 또한 from절 다음 엔티티의 별칭을 꼭 필수로 줘야한다. jqpl을 작성한 이후 쿼리를 생성할때는 2개의 객체를 반환 받을 수 있다. TypeQuery와 Query 클래스이다. 두개의 차이점은 주석에 명시되어있다. 


TypeQuery, Query

위에서 설명한 것과 같이 반환타입이 명확한가? 명확하지 않은가? 에 따라 두개중 하나의 쿼리 객체를 이용한다.



파라미터 바인딩(parameter bind)

1. 이름 기준 파라미터 - 이름 기준으로 파라미터를 구분하는 방법 ":"를 사용한다.

2. 위치 기준 파라미터 - 위치 기준으로 파라미터를 구분하는 방법 "?"를 사용한다.



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
/*
 * SELECT문
 * 1. 엔티티와 속성은 대소문자를 구분한다. but JPQL keyword는 대소구분을 않는다.
 * 2. Member는 테이블명이 아닌, 클래스명도 아닌 엔티티 명이다.
 * 3. 엔티티명에 별칭은 필수값으로 사용해야한다.
 */
public void select(){
        String jpql="select m from MemberJPQL m where m.username = '여성게'";
        /*
         * TypeQuery - 반환타입이 명확할때
         * Query - 반환타입이 명확하지 않을때
         */
        TypedQuery<MemberJPQL> query=em.createQuery(jpql,MemberJPQL.class);
 
        /*
         * getResultList() - 결과를 리스트로 받는다.(결과가 없으면 빈 컬렉션을 반환.)
         * 
         * getSingleResult() - 결과가 정확히 하나임을 기대할때 사용한다.
         *                      - 결과가 없으면 javax.persistence.NoResultException
         *                      - 결과가 하나 이상이면
                javax.persistence.NonUniqueResultException
         */
        List<MemberJPQL> resultList=query.getResultList();
 
        System.out.println("================select=================");
 
        for(MemberJPQL m:resultList){
            System.out.println(m.toString());
        }
 
        String jpql2="select m.username,m.age from MemberJPQL m where m.username = '여성게'";
        Query query2=em.createQuery(jpql2);
        List resultList2=query2.getResultList();
 
        for(Object o:resultList2){
            Object[]result=(Object[])o;
            for(Object o2:result){
                System.out.println("result element => "+o2);
            }
        }
        System.out.println("================select=================");
}
cs



위치기준 파라미터 바인딩보다 이름기준으로 바인딩하는 것이 더 명확함으로 이름기준 파라미터 바인딩 사용을 하는 것이 나을 듯 싶다.

프로젝션(projection)

SELECT 절에 조회할 대상을 지정하는 것을 프로젝션이라 한다. [SELECT {프로젝션 대상} FROM~] 프로젝션 대상은 엔티티, 임베디드 타입, 스칼라 타입이 있다. 스칼라 타입은 숫자,문자 등 기본 데이터 타입을 뜻한다(엔티티 클래스에서 int,Long,String 등의 필드)

여기서 하나 얘기할 것이 있다면 임베디드 타입 프로젝션은 절대 조회의 시작점이 될 수 없다. 즉, From절에서 엔티티를 정의하고 select에서 엔티티.임베디드필드로 참조해야한다.(SELECT m.embeddedTypeField FROM MemberEntity m ~)



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
/*
 * projection - SELECT 절에 조회할 대상을 지정하는 것.
 *
 * ex) SELECT {projection} FROM ~
 *
 * 1.엔티티
 * 2.임베디드
 * 3.스칼라(숫자,문자 등 기본 데이터타입)
 */
public void projection() {
        /*
         * 엔티티타입 프로젝션 - 조회한 엔티티는 영속성컨텍스트에서 관리된다.
         */
        String jpql = "select m.team from MemberJPQL m where m.username = '여성게1'";
        TypedQuery<TeamJPQL> query = em.createQuery(jpql,TeamJPQL.class);
        List<TeamJPQL> resultList = query.getResultList();
 
        System.out.println("================projection=================");
 
        for(TeamJPQL t : resultList) {
            System.out.println(t.toString());
        }
 
        /*
         * 임베디드타입 프로젝션 - 임베디드 타입은 조회의 시작점이 될 수 없기에 Order엔티티로 조회를 시작해
         *                      그다음 임베디드 타입을 참조한다.
         */
        String jpql2 = "select o.address from OrderJPQL o where o.product.name ='맥북1'";
        TypedQuery<AddressJPQL> query2 = em.createQuery(jpql2,AddressJPQL.class);
        List<AddressJPQL> resultList2 = query2.getResultList();
 
        for(AddressJPQL o : resultList2) {
            System.out.println(o.toString());
        }
 
        /*
         * 스칼라타입 - 여러종류의 스칼라타입을 받기 위해서는 TypeQuery를 사용할 수 없다.
         * 해결책 - new 명령어를 사용한 DTO 타입변환
         * 반드시 밑 문자열에 들어간 파라미터의 순서대로 해당 dto에 생성자가 존재해야한다.
         */
        String jpql3 = "select new com.spring.jpa.jpql.MemberDTO(m.username,m.age)"
        + " from MemberJPQL m where m.username = '여성게1'";
        TypedQuery<MemberDTO> query3 = em.createQuery(jpql3,MemberDTO.class);
        List<MemberDTO> members = query3.getResultList();
 
        for(MemberDTO dto : members) {
            System.out.println(dto.toString());
        }
 
        System.out.println("================projection=================");
}
cs



위에서 조금 특이한 것이 있다면 jpql3이다. 조회할 대상이 여러개이면 TypeQuery로는 조회할 수 없기 때문에 하나의 DTO를 만들어서 위와 같이 "new" 명령어를 사용해서 결과를 DTO로 받아 TypeQuery 객체를 이용할 수 있다.


페이징 API

페이징을 하기 위해서는 다소 지루하고 반복적인 일이다. 게다가 데이터베이스 구현체에 따라 문법도 다르다. 하지만 JPA는 모든 데이터베이스에서 동일하게 사용할 수 있는 페이징 메소드를 제공해준다.



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public void paging() {
        String jpql = "select m from MemberJPQL m ";
        TypedQuery<MemberJPQL> query = em.createQuery(jpql,MemberJPQL.class);
        //11부터 조회
        query.setFirstResult(10);
        //20개 11~30까지 조회
        query.setMaxResults(20);
        List<MemberJPQL> members = query.getResultList();
 
        System.out.println("================paging=================");
 
        for(MemberJPQL m : members) {
            System.out.println(m.toString());
        }
 
        System.out.println("================paging=================");
}
 
cs



현 예제는 값을 직접 입력해주었지만, 추후에는 컨트롤러 단에서 페이징에 대한 데이터를 직접 주입받아서 사용하지 않을까 싶다.(Pagable 클래스)





집합과 정렬


함수 

설명 

COUNT 

결과 수를 구한다. 반환타입:Long 

MAX,MIN 

최대,최소 값을 구한다. 

 AVG

평균값을 구한다. 반환타입: Double 

 SUM

합을 구한다.

정수합 반환타입 : Long

소수합 반환타입 : Double

BigInteger,BigDecimal합 반환타입 : BigInteger,BigDecimal  



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public void groupFunction() {
        String jpql = "select count(m) from MemberJPQL m ";
        Query query = em.createQuery(jpql);
        Long count = (Long) query.getSingleResult();
 
        System.out.println("================groupFunction=================");
        System.out.println("count = "+count);
        System.out.println("================groupFunction=================");
}
 
public void groupByHaving() {
        String jpql = "select t.name, count(m.age) "
                    + "from MemberJPQL m left join m.team t "
                    + "group by t.name ";
 
        Query query = em.createQuery(jpql);
        List members = query.getResultList();
 
        System.out.println("================groupByHaving=================");
 
        for(Object o : members) {
            Object[] result = (Object[]) o;
            for(Object o2 : result) {
                System.out.print("result element => "+o2);
            }
            System.out.println();
        }
        System.out.println("================groupByHaving=================");
}
 
cs



집합함수 사용시 참고사항


1.Null 값은 무시하므로 통계에 잡히지 않는다.

2.만약 값이 없는데 집합함수를 사용한다면 Null값이 된다.(단 count는 0)

3.DISTINCT를 집합함수 안에 사용하여 중복된 값을 제거하고 집합을 구할 수 있다.

  (ex select count(distinct m.age) from MemberJPQL m)

4.DISTINCT를 count에서 사용할 때 임베디드타입 필드는 지원하지 않는다.



여기까지 JPQL포스팅을 한번 끊고 양이 많아 JPQL 조인부터는 다음 포스팅에 정리하겠습니다. :)







저작자표시

'Web > JPA' 카테고리의 다른 글

JPA - JPQL 서브쿼리 (객체지향 쿼리 언어)  (0) 2019.02.09
JPA - JPQL 조인(객체지향쿼리),Java Persistence Query Language  (0) 2019.02.09
JPA - @Embedded,@Embeddable 임베디드타입  (0) 2019.02.04
JPA - 영속성 전이(Cascade)와 고아 객체(Orphan)  (0) 2019.02.04
JPA - 즉시로딩과 지연로딩(FetchType.EAGER,FetchType.LAZY) 그리고 프록시  (0) 2019.02.04
posted by 여성게
:

티스토리툴바