Mapping File의 전체적인 구성은 아래와 같다. Movie.hbm.xml 파일의 일부이다.

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="org.anyframe.sample.model.bidirection.Country" table="COUNTRY"
            lazy="true" schema="PUBLIC">
        <id name="countryCode" type="string">
            <column name="COUNTRY_CODE" length="12" />
            <generator class="assigned" />
        </id>
        <property name="countryId" type="string">
            <column name="COUNTRY_ID" length="2" not-null="true" />
        </property>
        <property name="countryName" type="string">
            <column name="COUNTRY_NAME" length="50" not-null="true" />
        </property>
        ...중략
    </class>
</hibernate-mapping>

Hibernate 매핑 파일은 크게 다섯 부분으로 나눠져 있다.

Mapping File에 대한 기본 설정 방법은 위에서 언급한 것처럼 다음과 같다.

<property name="countryId" type="string">
    <column name="COUNTRY_ID" length="2" not-null="true" />
</property>

위의 설정에서 보면 type은 countryId라는 자바 attribute와 COUNTRY_ID라는 DB 컬럼의 매핑을 위해 설정한다. type에 설정된 매핑 타입을 이용해 자바 attribute와 DB 컬럼 사이의 값을 알맞게 변환한다. type에 설정되는 매핑 타입은 Hibernate에서 기본적으로 제공하는 것 외에 개발자가 커스터마이즈할 수 있다.

Hibernate에서 제공하는 기본 Id Generator

Hibernate에서 제공하는 기본 gernerator를 이용할 수도 있겠지만 직접 키 값을 생성해서 저장하는 경우도 있다. 'MV-00001', 'MV-00002'과 같이 identifier를 저장하고 싶을 때는 위에서 언급한 Hibernate 기본 generator를 사용 할 수 없다.

A:B = 1:1 관계에 놓여 있는 두 클래스 사이의 관계를 매핑하는 방법은 여러가지가 있는데 그 중의 하나가 동일한 Primary Key 를 기반으로 클래스 사이의 참조 관계를 매핑하는 것이다.

왼쪽 그림은 클래스 다이어그램으로 Foo : Bar = 1:1 이며, 단방향 참조 관계를 표현하고 있다. 이것은 오른쪽 그림 상단의 ERD와 같이 각각 TBL_FOO와 TBL_BAR로 매핑될 수 있으며, 별도 추가 컬럼을 필요로 하지는 않으면서 동일한 Primary Key를 사용하고 있음을 알 수 있다. 이와 같은 매핑 관계를 Hibernate Mapping XML 파일에 정의하는 방법은 오른쪽 그림 하단의 내용과 같다. 그림 내용에 대해 설명하자면, Foo, Bar 각각의 클래스 및 속성 정보를 class 태그를 이용하여 정의하고, 두 클래스간 참조 관계에 대해서는 참조하는 측에서 one-to-one 태그를 이용하여 참조 관계에 놓인 클래스와 테이블을 명시 하고 있다.

A:B = 1:m 관계에 놓여 있는 두 클래스 사이의 관계를 매핑할 때 객체 B는 기본적으로 Collection의 형태이다. One to Many Mapping에서는 샘플을 기반으로 Hibernate Mapping XML 파일 정의 방법에 대해 살펴본 후, Hibernate에서 지원하는 다양한 Collection 유형 과 Collection의 중요한 속성 중의 하나인 inverse와 cascade 에 대해 알아보도록 한다.

왼쪽 그림은 클래스 다이어그램으로 Foo : Bar = 1:m이며, 단방향 참조 관계를 표현하고 있다. 이것은 오른쪽 그림 상단의 ERD와 같이 각각 TBL_FOO, TBL_BAR로 매핑될 수 있으며, TBL_BAR 테이블은 TBL_FOO 테이블에 대한 Foreign Key가 필요 하다. 이와 같은 매핑 관계를 Hibernate Mapping XML 파일에 정의하는 방법은 오른쪽 그림 하단의 내용과 같다. 그림 내용 에 대해 설명하자면, Foo, Bar 각각의 클래스 및 속성 정보를 class 태그를 이용하여 정의하고, A 측에서 B 클래스에 대해 set 태그를 이용하여 Collection 형태를 표현한다. 또한 set 태그 내에서는 one-to-many 태그를 이용하여 두 객체 사이의 관계를 명시하면서, key 태그를 통해 Foreign Key 컬럼을 명시하고 있다. 1:m 단방향 관계에 대한 Hibernate Mapping XML 정의 방법은 Country : Movie = 1:m 단방향 관계를 표현한 Country.hbm.xml 과 Movie.hbm.xml 를 참고하도록 한다. Hibernate Mapping XML 파일 내의 B 측에 다음과 같이 매핑 정보를 추가할 경우 양방향 참조도 가능해진다.

<class name="Bar" table="TBL_BAR">
    …
    <many-to-one name="TBL_FOO" class="Foo" column="FOO_ID"/>
</class>

1:m 양방향 관계에 대한 Hibernate Mapping XML 정의 방법은 Country : Movie = 1:m 양방향 관계를 표현한 Country. hbm.xml 과 Movie.hbm.xml 를 참고하도록 한다.

두 클래스 사이의 관계가 m:n 일 경우 각각의 Foreign Key를 가진 Association 테이블을 정의함으로써 매핑한다.

왼쪽 그림은 클래스 다이어그램으로 User : Role = m:n이며, 단방향 참조 관계를 표현하고 있다. 이것은 오른쪽 그림 상단의 ERD와 같이 각각 TBL_USER, TBL_ROLE로 매핑될 수 있으며, 각 테이블의 Primary Key를 Foreign Key로 가지는 Association 테이블인 TBL_USER_ROLE이 필요하다. 이와 같은 매핑 관계를 Hibernate Mapping XML 파일에 정의하는 방법은 오른쪽 그림 하단의 내용과 같다. 그림 내용에 대해 설명하자면, User, Role 각각의 클래스 및 속성 정보를 class 태그를 이용하여 정의하고, User 측에서 Role 클래스에 대해 set 태그를 이용하여 Collection 형태를 표현하고 연관된 테이블로는 Association 테이블인 TBL_USER_ROLE로 정의한다. 또한 set 태그 내에서는 many-to-many 태그를 이용하여 두 객체 사이의 관계를 명시하면서, key 태그를 통해 Foreign Key 컬럼을 명시하고 있다. 양방향 m:n 관계에 대한 Hibernate Mapping XML 정의 방법은 Category : Movie = m:n 양방향 관계를 표현한 Category.hbm.xml 과 Movie.hbm.xml 를 참고하도록 한다. 양방향의 m-n 관계 설정을 위해서는 양쪽 모두 <class> 에 <many-to-many>를 사용하되, 반드시 Relation의 책임을 지는 한 쪽에는 "inverse=true"를 지정하여 매핑 관리 를 한쪽에서 처리할 수 있도록 하는 것이 좋다. 양방향 m:n 관계에 대한 Hibernate Mapping XML 정의 방법은 Category : Movie = m:n 양방향 관계를 표현한 Category.hbm.xml 과 Movie.hbm.xml 를 참고하도록 한다.

상속 관계에 참여하는 모든 Parent, Child 클래스들을 모두 한 개의 테이블로 매핑하고, Child 클래스의 유형을 구분하기 위해 별도 Discriminator 칼럼을 추가로 정의하는 매핑 방법이다.

왼쪽 상단 그림은 클래스다이어그램으로 User 클래스를 상속받은 Guest, Member, Staff 클래스들이 존재한다. 그리고 왼쪽 하단 그림은 ERD로 User, Guest, Member, Staff 클래스를 TBL_USER라는 하나의 테이블로 매핑하고 있다. 이와 같은 매핑 관계를 Hibernate Mapping XML 파일에 정의하는 방법은 오른쪽 그림의 내용과 같다. 그림 내용에 대해 설명하자면, User 클래스 정보를 class 태그를 이용하여 정의하고, 하위에 discriminator 태그를 이용하여 Child 클래스의 유형을 구분하기 위해 별도로 필요한 Discriminator 칼럼이 추가 정의되어야 한다. 또한 하위에 subclass 태그를 이용하여 User 클래스를 상속하는 하위 클래스와 속성들에 대해 정의하는데 이 때 각 subclass에 대한 Discriminator 값 정의가 필요하다. Table per Class Hierarchy 매핑의 장,단점에 대해 살펴보면 다음과 같다.

[장점]

[단점]

별도 Discriminator 칼럼을 만들지 않고자 하는 경우에는 다음과 같이 formula라는 속성을 이용할 수 있다. 특정 칼럼의 값에 대한 연산을 통해 Discriminator 값을 정의하는 경우로 아래의 예에서는 DEPT_ID의 값이 NOT NULL인 경우 Discriminator 값은 'STAFF'이므로 해당되는 객체는 Staff가 될 것이다.

<discriminator formula="CASE WHEN DEPT_ID IS NOT NULL THEN 'STAFF' 
        …"
        type="string"/>

상속 관계에 참여하는 모든 Parent, Child 클래스들을 각각의 테이블로 매핑시키되, 모든 하위 테이블들이 상위 클래스와 동일한 Primary Key를 공유하는 형태이다.

왼쪽 상단 그림은 클래스다이어그램으로 User 클래스를 상속받은 Guest, Member, Staff 클래스들이 존재한다. 그리고 왼쪽 하단 그림은 ERD로 상속 관계에 참여하는 모든 클래스를 TBL_USER, TBL_GUEST, TBL_MEMBER, TBL_STAFF라는 테이블로 매핑하고 있다. 이와 같은 매핑 관계를 Hibernate Mapping XML 파일에 정의하는 방법은 오른쪽 그림의 내용과 같다. 그림 내용에 대해 설명하자면, User 클래스 정보를 class 태그를 이용하여 정의하고, 하위에 joined-subclass 태그를 이용하여 User 클래스를 상속하는 하위 클래스와 속성들에 대해 정의하고 있다. Table per Subclass 매핑의 장,단점에 대해 살펴보면 다음과 같다.

[장점]

[단점]

※ 조회하고자 하는 특정 Child 클래스를 명시하지 않고 Parent 클래스를 통해 조회를 요청할 경우 (즉, Parent 클래스를 이용하여 Query를 수행시키는 경우), Hibernate은 실제 조회 대상 클래스를 알 수 없어 해당 클래스의 유형을 찾기 위해 상속 관계에 참여하는 모든 테이블들에 대해 Outer JOIN이 수행되므로 성능 저하를 유발할 수 있음에 유의해야 한다.

(* 특정 Child 클래스를 조회 대상으로 명시하였을 경우에는 Inner JOIN이 수행된다.)

상속 관계에 참여하는 모든 Concrete 클래스들을 각각 한 개의 테이블로 매핑하는 방법으로, 매핑되는 모든 테이블에 상위 클래스의 속성 정보가 반복 정의되어야 한다. Parent 클래스가 추상 클래스일 경우 별도 테이블 정의는 필요하지 않으며, abstract를 true로 정의해야 한다.

왼쪽 상단 그림은 클래스다이어그램으로 User 클래스를 상속받은 Guest, Member, Staff 클래스들이 존재한다. 그리고 왼쪽 하단 그림은 ERD로 TBL_GUEST, TBL_MEMBER, TBL_STAFF라는 테이블로 매핑하고 있다. 이와 같은 매핑 관계를 Hibernate Mapping XML 파일에 정의하는 방법은 오른쪽 그림의 내용과 같다. 그림 내용에 대해 설명하자면, User 클래스 정보를 class 태그를 이용하여 정의하고 User 클래스의 abstract 속성을 true로 정의하고 있다. 또한 하위에 union-subclass 태그를 이용하여 각 하위 클래스들과 속성들에 대해 정의하고 있다. Table per Concrete Class 매핑의 장,단점에 대해 살펴보면 다음과 같다.

[장점]

[단점]

A 객체에서 Collection B에 대한 cascade 속성을 true로 정의하고, Collection B를 포함한 해당 객체 A에 대해 save() 메소드를 호출하는 경우를 가정해 보자. 상위 객체인 A에 대해서는 예상하는 바와 동일하게 동작하나, Collection B에 대해서는 saveOrUpdate()와 동일하게 동작함을 알 수 있다.

이를 확인하기 위해서 Country:Movie = 1:m 관계에 대한 HibernateSaveOrUpdateParentChild 의 각 테스트 메소드 실행 결과를 중심으로 확인해보도록 하자.

1. DB에 추가되어 있지 않은 Country 정보에 대해 save() 메소드 호출하는 경우

Transaction Commit시 신규 생성한 Country 객체에 대해 INSERT문이 실행된다.

public void addCountryCallingSave() throws Exception {
    // 1. try to insert a country information without movies
    newSession();
    Country country1 = makeNewCountry();
    session.save(country1);

    closeSession();

    ...중략
}

* 콘솔 - 실행된 SQL문
insert
    into PUBLIC.COUNTRY (COUNTRY_ID, COUNTRY_NAME, COUNTRY_CODE) 
        values ('KR', 'Korea', 'COUNTRY-0001'

2. DB에 추가되어 있지 않은 Country 정보에 대해 saveOrUpdate() 메소드를 호출하는 경우

신규 생성한 Country 객체가 DB에 존재하지 않으므로 Transaction Commit시 해당 객체에 대해 INSERT문이 실행된다.

public void addCountryCallingSaveOrUpdate() throws Exception {
    // 1. try to insert a country information without movies
    newSession();
    Country country1 = makeNewCountry();
    session.saveOrUpdate(country1);

    closeSession();

    ...중략
}

* 콘솔 - 실행된 SQL문
insert
    into PUBLIC.COUNTRY (COUNTRY_ID, COUNTRY_NAME, COUNTRY_CODE) 
        values ('KR', 'Korea', 'COUNTRY-0001')

3. DB에 추가되어 있지 않은 Movie 정보를 포함한 Country에 대해 update() 메소드를 호출하였을 경우

첫번째 Transaction에서 신규 Country 정보를 추가하였고, 두번째 Transaction에서 앞서 등록한 Country 객체에 신규 Movie Collection 정보를 셋팅한 후 update() 메소드를 호출한 경우이다. 두번째 Transaction Commit시 Country 객체에 대해서는 변경 정보가 있다면 UPDATE문이 실행되고, 신규 Movie Collection 정보에 대해서는 INSERT문이 실행된다.

public void addMoviesCallingUpdate() throws Exception {
    // 1. try to insert a country information without movies
    newSession();
    Country country1 = makeNewCountry();
    session.save(country1);

    closeSession();

    // 2. try to insert a country information with movies.
    newSession();
    Country country2 = makeNewMovieSet(country1.getCountryCode());
    session.update(country2);

    closeSession();

    ...중략
}

* 콘솔 - 실행된 SQL문
// 첫번째  Transaction
insert
    into PUBLIC.COUNTRY (COUNTRY_ID, COUNTRY_NAME, COUNTRY_CODE) 
        values ('KR', 'Korea', 'COUNTRY-0001') 
    ...
// 두번째 Transaction
insert
    into PUBLIC.MOVIE (COUNTRY_CODE, TITLE, DIRECTOR, RELEASE_DATE, MOVIE_ID) 
        values ('COUNTRY-0001', 'My Sassy Girl', 'Jaeyong Gwak', 2001-07-27, 'MV-00001') 
insert
    into PUBLIC.MOVIE (COUNTRY_CODE, TITLE, DIRECTOR, RELEASE_DATE, MOVIE_ID) 
        values ('COUNTRY-0001', 'My Little Bride', 'Hojun Kim', 2004-04-02, 'MV-00002') 
    ...

4. DB에 추가되어 있지 않은 Country 정보를 추가한 후, Movie 정보에 대해 save() 메소드를 호출하였을 경우

첫번째 Transaction에서 신규 Country 정보를 추가하였고, 두번째 Transaction에서 앞서 등록한 Country 객체에 신규 Movie Collection 정보를 셋팅한 후 save() 메소드를 호출한 경우이다. 3번의 경우와 동일하게 동작한다.

public void addMoviesCallingSave() throws Exception {
    // 1. try to insert a country information without movies
    newSession();
    Country country1 = makeNewCountry();
    session.save(country1);

    closeSession();
    
    // 2. try to insert a country information with movies.
    newSession();
    Country country2 = makeNewMovieSet(country1.getCountryCode());
    session.save(country2);

    closeSession();

    ...중략
}

* 콘솔 - 실행된 SQL문
// 첫번째  Transaction
insert
    into PUBLIC.COUNTRY (COUNTRY_ID, COUNTRY_NAME, COUNTRY_CODE) 
         values ('KR', 'Korea', 'COUNTRY-0001') 
...
// 두번째  Transaction
insert
    into PUBLIC.MOVIE (COUNTRY_CODE, TITLE, DIRECTOR, RELEASE_DATE, MOVIE_ID) 
        values ('COUNTRY-0001', 'My Sassy Girl', 'Jaeyong Gwak', 2001-07-27, 'MV-00001')
insert
    into PUBLIC.MOVIE (COUNTRY_CODE, TITLE, DIRECTOR, RELEASE_DATE, MOVIE_ID) 
        values ('COUNTRY-0001', 'My Little Bride', 'Hojun Kim', 2004-04-02, 'MV-00002') 
...

전달받고자 하는 조회 결과값을 구체적으로 명시하고자 할 경우 정의한다.

SELECT [object 또는  property], …        

여러 건의 데이터를 조회할 경우 조회 결과값을 List, Map 또는 사용자 정의 Type으로 정의 가능하다. (Default = Object[])

SELECT new List(prop1, prop2, …)

Hibernate에서 제공하는 다양한 aggregate function(sum, avg, min, max, count, count(distinct), count(all), arithmetic operator(+, -, …), concatenation) 그리고 일반 SQL에서 사용 가능한 keyword(distinct, …)들도 정의 가능하다.

이외에도 Hibernate은 문자열, 숫자, 날짜 및 시간 처리를 위한 함수를 제공하며 자세한 사항은 아래와 같다.

조회 대상 객체를 정의하며, SELECT 절이 생략되었을 경우 FROM 절에 정의된 객체가 전달 대상이 된다.

FROM [object] ((as) alias), …        

조회 결과 영역을 보다 상세히 구분하고자 할 경우 정의한다.

WHERE [condition], …        

Mapping XML 파일에 정의한 특정 객체의 식별자 값을 추출하기 위해 "id"를 사용할 수 있다. (Hibernate 3.2.2 이상부터 해당 클래스의 식별자 필드가 아닌 다른 필드명이 id일 경우 id라는 이름을 가진 필드의 값을 전달한다)

WHERE user.id = 'test'        

또한 Discriminator 값에 접근하기 위해서는 아래와 같이 "class"를 사용할 수 있다. 이 외에도 Hibernate에서 제공하는 다양한 expression을 활용하여 WHERE 절 정의가 가능하다.

WHERE user.class = 'MEMBER'        

HQL WHERE 절에서 사용 가능한 Operation은 다음과 같은 것들이 있다.

SELECT 또는 WHERE 절에서 괄호 사이에 Sub Query 형태의 또다른 HQL을 정의할 수 있다.

조회 결과의 정렬 방법을 정의한다.

ORDER BY [condition] (ASC 또는 DESC), …        

조회 결과를 특정 기준으로 그룹핑하고자 할 경우 정의한다.

GROUP BY [condition], …        

※ Order By, Group By 절에 수식 정의는 불가하며, 일반 SQL처럼 Having 절을 추가하는 것은 가능하다.

HQL을 통해 하나의 테이블을 대상으로 조회 작업을 수행할 수 있다.

StringBuilder hqlBuf = new StringBuilder();
hqlBuf.append("FROM Country country ");
hqlBuf.append("WHERE country.countryName like :condition ");
hqlBuf.append("ORDER BY country.countryName");
Query hqlQuery = session.createQuery(hqlBuf.toString());
hqlQuery.setParameter("condition", "%%");
List countryList = hqlQuery.list();

위와 같이 정의된 HQL문을 통해 조회 조건에 맞는 Country 객체의 List가 리턴된다. WHERE절의 조회 조건은 객체명.Attribute명(country.countryName)으로 정의할 수 있으며 ':'을 사용하여 정의된 속성과 값을 전달하여 조회 조건을 완성할 수 있다. 조회 조건의 값은 org.hibernate.Query의 setParameter() 메소드를 통해 지정해 주고 있다.

HQL을 이용하여 테이블 간의 JOIN을 수행하고자 할 경우 Explicit Join, Implicit Join으로 처리 가능하다. Hibernate에서는 (inner) join, left (outer) join, right (outer) join, full join을 지원하며, Explicit Join은 FROM 절에 join 키워드를 명시적으로 정의하여 사용하는 방법이다. Implicit Join은 join 키워드를 별도로 사용하지 않고 "." 을 이용하여 HQL 어느 절에서나 정의할 수 있으며, Inner Join으로 처리된다.

다음은 Relation 관계에 놓여 있는 두개의 테이블을 대상으로 Inner Join을 수행한 조회 작업의 예이다.

StringBuilder hqlBuf = new StringBuilder();
hqlBuf.append("SELECT movie ");
hqlBuf.append("FROM Movie movie join movie.categories category ");
hqlBuf.append("WHERE category.categoryName = ?"); 
Query query = session.createQuery(hqlBuf.toString());
query.setParameter(0, "Romantic");...

위의 코드와 같이 'join'을 이용해 relation 관계에 놓여있는 MOVIE 테이블과 CATEGORY 테이블을 Inner Join할 수 있으며 기본적인 HQL 사용 때와 마찬가지로 검색 조건을 정의할 수 있다. 또한 Relation 관계에 놓여 있는 두개의 테이블을 대상으로 Right Outer Join을 수행할 수 있다.

StringBuilder hqlBuf = new StringBuilder();
hqlBuf.append("SELECT distinct category ");
hqlBuf.append("FROM Movie movie right join movie.categories category ");
hqlBuf.append("ORDER BY category.categoryName ASC ");
...   

Inner Join과 마찬가지로 'right join' 또는 'left join'을 사용할 수 있으며 위의 예는 right join을 사용하였다.

두 테이블 간의 Relation 관계가 정의되어 있지 않을시 ','를 통해 두 테이블을 Join 할 수 있으며 WHERE 절에 'movie.country.countryCode = country.countryCode'와 같이 join을 위한 조건문을 정의하여 사용한다.

StringBuilder hqlBuf = new StringBuilder();
hqlBuf.append("SELECT distinct movie ");
hqlBuf.append("FROM Movie movie, Country country ");
hqlBuf.append("WHERE movie.country.countryCode = country.countryCode ");
hqlBuf.append("AND country.countryId = :condition1 ");
hqlBuf.append("AND movie.title like :condition2 ");

Query query = session.createQuery(hqlBuf.toString());
query.setParameter("condition1", "KR");
query.setParameter("condition2", "%%");
... 

위에서 설명된 코드를 포함하는 HQL을 이용한 기본적인 조회 방법에 대한 예제는 HibernateBasicHQL.java 에서 확인할 수 있다.

Relation 관계에 놓여 있는 두개의 테이블을 대상으로 HQL(Inner Join)을 이용한 조회 결과를 특정 객체(예에선 Movie 객체)형태로 전달받는다.

StringBuilder hqlBuf = new StringBuilder();
hqlBuf.append("SELECT new Movie(movie.movieId as movieId, ");
hqlBuf.append("movie.title as title, movie.director as director, ");
hqlBuf.append("category.categoryName as categoryName, ");
hqlBuf.append("movie.country.countryName as countryName) ");
hqlBuf.append("FROM Movie movie join movie.categories category ");
...

위와 같이 정의할 경우 Movie라는 객체의 형태로 결과값이 리턴되는데 정의된 클래스에 해당 Constructor가 존재해야 함에 유의하도록 한다. 다음은 Movie.java 의 Constructor 정의 부분의 일부이다.

public Movie(String movieId, String title, String director,
        String categoryName, String countryName) {
    this.movieId = movieId;
    this.title = title;
    this.director = director;
    this.categoryName = categoryName;
    this.countryName = countryName;
}

또한 리턴된 결과값에서 각각의 attribute에 해당하는 값을 꺼낼 때에는 List에서 각 Movie 객체를 꺼낸 다음 getter 메소드를 사용하도록 한다.

List movieList = query.list();
Movie movie1 = (Movie) movieList.get(0);
movie1.getTitle();
Movie movie2 = (Movie) movieList.get(1);
movie2.getTitle();
...        

Relation 관계에 놓여 있는 두개의 테이블을 대상으로 HQL(Inner Join)을 이용한 조회 결과를 Map 형태로 전달받는다.

StringBuilder hqlBuf = new StringBuilder();
hqlBuf.append("SELECT new Map(movie.movieId as movieId, ");
hqlBuf.append("movie.title as title, movie.director as director, ");
hqlBuf.append("category.categoryName as categoryName, ");
hqlBuf.append("movie.country.countryName as countryName) ");
hqlBuf.append("FROM Movie movie join movie.categories category ");
... 

위와 같이 정의할 경우 조회 결과는 Map의 List 형태가 된다. 이때 alias로 정의한 movieId, title, director, categoryName, countryName이 Map의 Key 값이 된다. 따라서 다음과 같이 Map으로 정의된 Key 값을 통해 결과값을 조회할 수 있다.

List movieList = query.list();
Map movie1 = (Map) movieList.get(0);
movie1.get("title");
movie1.get("director");
Map movie2 = (Map) movieList.get(1);
movie2.get("title");
movie2.get("director");        

Relation 관계에 놓여 있는 두개의 테이블을 대상으로 HQL(Inner Join)을 이용한 조회 결과를 List 형태로 전달받을 수 있다.

hqlBuf.append("SELECT new List(movie.movieId as movieId, ");
hqlBuf.append("movie.title as title, movie.director as director, ");
hqlBuf.append("category.categoryName as categoryName, ");
hqlBuf.append("movie.country.countryName as countryName) ");
hqlBuf.append("FROM Movie movie join movie.categories category ");

위와 같이 정의할 경우 조회 결과는 List의 List 형태가 된다. List에서 결과값을 꺼낼 때에는 정의된 순서에 따르면 된다.

List movieList = query.list();
List movie1 = (List) movieList.get(0);
movie1.get(1); //title
movie1.get(2); //director
List movie2 = (List) movieList.get(1);
movie2.get(1); //title
movie2.get(2); //director  

위에서 설명된 HQL을 이용하여 결과값을 특정 객체로 전달받는 전체 테스트 코드는 HibernateHQLWithDefinedResult.java 에서 확인할 수 있다.

다음은 HQL을 사용한 Insert문의 예이다.

StringBuilder hql = new StringBuilder();
hql.append("INSERT INTO Country (countryCode,countryId,countryName) ");
hql.append("SELECT CONCAT(countryCode,'UPD'), CONCAT(countryId,'UPD'), countryName ");
hql.append("FROM Country country ");
hql.append("WHERE countryCode = :countryCode");
Query query = session.createQuery(hql.toString());
query.setParameter("countryCode", "COUNTRY-0001");

query.executeUpdate();
closeSession();

위와 같이 작성할 경우 HQL을 이용하여 신규 Country 정보를 등록할 수 있다. 단, Hibernate에서는 INSERT INTO ... VALUES 형태의 INSERT문은 지원되지 않으며, INSERT INTO ... SELECT 형태의 INSERT문만 지원됨에 유의하도록 한다.

다음은 HQL을 사용한 Update문의 예이다.

newSession();
StringBuilder hql = new StringBuilder();
hql.append("UPDATE Country country ");
hql.append("SET country.countryName = :countryName ");
hql.append("WHERE country.countryCode = :countryCode and country.countryId = :countryId ");

Query query = session.createQuery(hql.toString());
query.setParameter("countryName", "Republic of Korea");
query.setParameter("countryCode", "COUNTRY-0001");
query.setParameter("countryId", "KR");

query.executeUpdate();
closeSession(); 

위의 예는 HQL을 사용하여 Country 정보를 수정한 것이며 Query의 setParameter() 메소드를 통해 인자값을 셋팅하고 있다.

다음은 HQL을 사용한 Delete문의 예이다.

newSession();
StringBuilder hql = new StringBuilder();
hql.append("DELETE Country country ");
hql.append("WHERE country.countryCode = :countryCode ");

Query query = session.createQuery(hql.toString());
query.setParameter("countryCode", "COUNTRY-0001");

query.executeUpdate();
closeSession();  

또한 위에서 언급된 HQL을 이용한 CUD를 위한 코드는 HibernateCUDHQL.java 에서 확인할 수 있다.

다음은 하나의 테이블을 대상으로 Criteria를 이용하여 조회를 수행하는 예이다.

Criteria criteria = session.createCriteria(Country.class);
criteria.add(Restrictions.like("countryName", "", MatchMode.ANYWHERE));
criteria.addOrder(Order.asc("countryName"));
List countryList = criteria.list();

대상이 되는 테이블과 매핑되는 클래스로 Criteria를 생성하고 Restriction API를 호출해 WHERE조건에 해당하는 조건절을 정의할 수 있다. 위와 같이 정의 한 경우 WHERE Country.countryNamelike '%%'와 같은 조건절이 생성된다. 또한 addOrder ()를 통해 order by절을 정의할 수 있다. 이와 같이 Criteria API를 이용할 경우 메소드를 통해 검색 조건을 정의하기 때문에 오타로 인한 오류를 최소화할 수 있게 된다. 조회 조건을 정의하기 위한 org.hibernate.criterion.Restrictions 는 eq, gt, ge, isNull 등을 비롯하여 다양한 API를 제공하고 있다. 보다 자세한 내용을 알기 위해서는 여기 를 참고하도록 한다.

Relation 관계에 놓여 있는 두개의 테이블을 대상으로 Hibernate Criteria(Inner Join)를 이용한 조회 작업을 수행할 수 있다.

Criteria movieCriteria = session.createCriteria(Movie.class);
Criteria categoryCriteria = movieCriteria.createCriteria("categories");
categoryCriteria.add(Restrictions.eq("categoryName", "Romantic"));
List movieList = movieCriteria.list();

위 코드에서는 Movie 클래스와 Relation 관계에 놓인 Category를 Join하기 위해 각 Movie 객체에 해당하는 Criteria에 Category 객체에 해당하는 Criteria를 생성하고 있다. 여기서는 Restrictions API를 사용하여 categoryName = 'Romantic'인 결과값을 찾게될 것이다.

또한, Relation 관계에 놓여 있는 두개의 테이블을 대상으로 Hibernate Criteria(Left Outer Join)을 이용한 조회 작업을 수행할 수 있다.

Criteria categoryCriteria = session.createCriteria(Category.class);
Criteria movieCriteria = categoryCriteria.createCriteria("movies",
        CriteriaSpecification.LEFT_JOIN);
categoryCriteria.addOrder(Order.asc("categoryName"));
categoryCriteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);

List categoryList = categoryCriteria.list();

Relation 관계에 있는 테이블의 Criteria를 생성할 때 CriteriaSpecification을 통해 LEFT_JOIN, RIGHT_JOIN 등을 명시할수 있다. 또한 Criteria.DISTINCT_ROOT_ENTITY를 사용하면 List에 중복 포함된 루트 개체를 제거할 수 있다. 위에서 설명된 코드들은 HibernateBasicCriteria.java 에서 확인할 수 있다.

Relation 관계에 놓여 있는 두개의 테이블을 대상으로 Criteria를 이용한 조회 결과를 특정 객체인 Movie 객체 형태로 전달받을 수 있다.

Criteria movieCriteria = session.createCriteria(Movie.class);
ProjectionList projectionList = Projections.projectionList();
projectionList.add(Projections.id().as("movieId"));
projectionList.add(Projections.property("title").as("title"));
projectionList.add(Projections.property("director").as("director"));
movieCriteria.setProjection(projectionList);
movieCriteria.setResultTransformer(new AliasToBeanResultTransformer(Movie.class));

Criteria categoryCriteria = movieCriteria.createCriteria("categories", "category");
Criteria countryCriteria = movieCriteria.createCriteria("country", "country");
categoryCriteria.add(Restrictions.eq("categoryName", "Romantic"));
countryCriteria.add(Restrictions.like("countryName", "", MatchMode.ANYWHERE));

List movieList = movieCriteria.list();

ProjectionList에 SELECT 절을 구성할 조회 대상 attribute들을 추가시키고 as() 메소드를 이용하여 각각의 attribute에 대한 alias를 정의할 수 있다. AliasToBeanResultTransformer 클래스를 사용하여 조회 결과의 형태를 Movie 클래스로 지정해준다. 따라서 위에서 정의한 Criteria 수행 결과는 Movie 객체의 List 형태가 될 것이다.

Movie movie1 = (Movie) movieList.get(0);
movie1.getTitle();
movie1.getDirector();

Relation 관계에 놓여 있는 두개의 테이블을 대상으로 Criteria를 이용한 조회 결과를 Map 형태로 전달받을 수 있다.

Criteria movieCriteria = session.createCriteria(Movie.class);
ProjectionList projectionList = Projections.projectionList();
projectionList.add(Projections.id().as("movieId"));
projectionList.add(Projections.property("title").as("title"));
projectionList.add(Projections.property("director").as("director"));
movieCriteria.setProjection(projectionList);
movieCriteria.setResultTransformer(Criteria.ALIAS_TO_ENTITY_MAP);

Criteria categoryCriteria = movieCriteria.createCriteria("categories","category");
Criteria countryCriteria = movieCriteria.createCriteria("country","country");
categoryCriteria.add(Restrictions.eq("categoryName", "Romantic"));
countryCriteria.add(Restrictions.like("countryName", "",MatchMode.ANYWHERE));

List movieList = movieCriteria.list();

위에서 생성한 Criteria의 resultTransformer를 ALIAS_TO_ENTITY_MAP으로 지정하여 Map 형태의 결과값으로 전달 받을 수 있다. 이 때 조회 결과는 Map의 List 형태이며, alias로 정의한 movieId, title, director 등이 Map의 Key 값이 된다. 따라서 다음과 같이 Map의 Key 값을 통해 다음과 같이 결과값을 알아낼 수 있다.

Map movie1 = (Map) movieList.get(0);
movie1.get("title");
movie1.get("director");

위에서 언급된 코드는 HibernateCriteriaWithDefinedResult.java 에서 확인할 수 있다.

하나의 테이블을 대상으로 Native SQL을 이용한 조회 작업을 수행할 수 있다.

hqlBuf = new StringBuilder();
hqlBuf.append("SELECT * ");
hqlBuf.append("FROM COUNTRY ");
hqlBuf.append("WHERE COUNTRY_NAME like :condition ");
hqlBuf.append("ORDER BY COUNTRY_NAME");

SQLQuery query = session.createSQLQuery(hqlBuf.toString());
query.addEntity(Country.class);
query.setParameter("condition", "%%");
List countryList = query.list();

session.createSQLQuery()를 사용하여 정의된 SQL문을 실행한다. 또한, 조회 결과값을 특정 Persistence 객체로 전달 받고자 하는 경우 SQLQuery.addEntity()를 통해 특정 타입의 객체를 정의하여 사용한다.

Relation 관계에 놓여 있는 두개의 테이블을 대상으로 Native SQL(Inner Join)을 이용한 조회 작업을 수행할 수 있다.

hqlBuf.append("SELECT movie.* ");
hqlBuf.append("FROM MOVIE movie ");
hqlBuf.append("join MOVIE_CATEGORY moviecategory on movie.MOVIE_ID 
        = moviecategory.MOVIE_ID ");
hqlBuf.append("join CATEGORY category on moviecategory.CATEGORY_ID 
        = category.CATEGORY_ID ");
hqlBuf.append("WHERE category.CATEGORY_NAME = ?");
SQLQuery query = session.createSQLQuery(hqlBuf.toString());
query.addEntity(Movie.class);
query.setParameter(0, "Romantic");
List movieList = query.list(); 

위의 코드와 같이 join 키워드를 사용하여 Inner Join을 수행할 수 있다.

또한, Relation 관계에 놓여 있는 두개의 테이블을 대상으로 Native SQL(Right Outer Join)을 이용한 조회 작업을 수행할 수 있다. 작성 방법은 아래와 같다.

hqlBuf.append("SELECT distinct category.* ");
hqlBuf.append("FROM MOVIE movie ");
hqlBuf.append("right join MOVIE_CATEGORY moviecategory on 
        movie.MOVIE_ID=moviecategory.MOVIE_ID ");
hqlBuf.append("right join CATEGORY category on 
        moviecategory.CATEGORY_ID=category.CATEGORY_ID ");
hqlBuf.append("ORDER BY category.CATEGORY_NAME ASC ");
SQLQuery query = session.createSQLQuery(hqlBuf.toString());
query.addEntity(Category.class); 
List categoryList = query.list();        

또한 Join하여 조회한 결과를 각각의 Join된 객체의 값으로 select 하기 위해서는 addJoin 메소드를 사용한다.

hqlBuf.append("SELECT distinct movie.*, country.* ");
hqlBuf.append("FROM MOVIE movie, COUNTRY country ");
hqlBuf.append("WHERE movie.COUNTRY_CODE = country.COUNTRY_CODE ");
hqlBuf.append("AND country.COUNTRY_ID = :condition1 ");
hqlBuf.append("AND movie.TITLE like :condition2 ");

SQLQuery query = session.createSQLQuery(hqlBuf.toString());
query.addEntity("movie", Movie.class);
query.addJoin("country", "movie.country");
query.setParameter("condition1", "KR");
query.setParameter("condition2", "%%");
List movieList = query.list(); 

Movie와 Country 정보를 한꺼번에 조회하기 위해 위 Select문의 Movie 객체의 alias와 같은 'movie'를 이용하여 Movie 클래스를 addEntity()의 입력 인자로 정의한 다음 Join 대상이 되는 Country 또한 addJoin() 메소드에 정의해주어야 한다. 위의 코드에서는 Country 객체의 alias인 'country'와 이 객체의 값인 movie.country를 입력 인자로 지정해주었다. (movie.country의 movie는 addEntity() 메소드를 통해 정의된 Entity의 Key 값이다.) 이때 리턴되는 List는 Object Array 배열이 되며 Object Array에는 아래와 같이 movie와 country가 차례대로 저장되게 된다.

language="java">Object[] results1 = (Object[]) movieList.get(0);
Movie movie1 = (Movie)results1[0];
Country country1 = (Country)results1[1];

두 개의 테이블을 대상으로 검색 조건을 별도 명시한 Native SQL을 이용하여 조회 작업을 수행할 수 있다.

hqlBuf.append("SELECT distinct movie.* ");
hqlBuf.append("FROM MOVIE movie, COUNTRY country ");
hqlBuf.append("WHERE movie.COUNTRY_CODE = country.COUNTRY_CODE ");
hqlBuf.append("AND country.COUNTRY_ID = :condition1 ");
hqlBuf.append("AND movie.TITLE like :condition2 ");

SQLQuery query = session.createSQLQuery(hqlBuf.toString());
query.addEntity(Movie.class); 
query.setParameter("condition1", "KR");
query.setParameter("condition2", "%%");
List movieList = query.list();

":"(Named Parameter 형태)으로 조건을 명시할 수 있으며 해당 조건의 값은 setParameter()를 통해 셋팅해 줄 수 있다. 위에서 설명한 기본적인 Native SQL 사용 코드는 HibernateNativeSQL.java 에서 확인할 수 있다.

Mapping XML 파일에 정의한 Procedure를 호출하여 결과값을 확인할 수 있다.

Query query = session.getNamedQuery("callFindCategoryList");
query.setParameter("condition", "%%");
List categoryList = query.list();

위 코드에서는 session.getNameQuery()를 호출하여 Mapping XML에 정의된 'callFindCategoryList'라는 이름의 query를 찾는다. 다음은 'callFindCategoryList'가 정의되어 있는 Category.hbm.xml 파일의 일부이다.

<sql-query name="callFindCategoryList" callable="true">
    <return alias="category" class="org.anyframe.sample.model.bidirection.Category"/>	
        { call FIND_CATEGORY_LIST (?, :condition) }
</sql-query>

위의 코드에서는 해당 DB에 기 정의되어있는 FIND_CATEGORY_LIST 라는 Procedure를 호출하게 된다.

해당 DB에 생성한 Function을 이용하여 HQL을 실행하고 결과를 확인할 수 있다.

hqlBuf.append("FROM Movie movie ");
hqlBuf.append("WHERE movie.releaseDate > FIND_MOVIE(:condition)");
Query query = session.createQuery(hqlBuf.toString());
query.setParameter("condition", "MV-00002");
List movieList = query.list();

위 코드에서는 'FIND_MOVIE'라는 Function의 호출 결과를 이용하여 HQL을 수행하고 있다. 보다 자세한 코드는 HibernateProcedure.java 에서 확인한다.

Hibernate Session 내부에 정의된 Cache로, Session의 시작과 종료 사이에서 사용되며 한 Session 내에서 Hibernate을 통해 읽혀진 객체들을 보관하는 역할을 수행한다. Hibernate은 하나의 Session 내에서 동일한 객체를 한 번 이상 Loading할 경우 2번째부터는 1LC로부터 해당 객체를 추출하고 또한, 한 Session 범위 내에서 객체의 속성 변경시 변경 사항은 Session 종료시에 자동적으로 DB에 반영하도록 한다. 즉, 하나의 Hibernate Session 내에서 동일한 객체에 대한 재조회가 이루어지 는 경우 1LC를 이용함으로써 DB 접근 횟수를 줄여주기 때문에 어플리케이션 성능 향상에 도움이 되는 것이다. 1LC는 Hibernate에서 기본적으로 제공하는 Cache이므로 별도의 설정없이도 적용된다.

public void findMovie() throws Exception {
    newSession();
    // Add data to DB
    SetUpInitData.initializeData(session);	
    // 2. find a movie without accessing DB (using 1LC)
    /* #1 */ Movie movie = (Movie) session.get(Movie.class, "MV-00001");
	
    Set categories = movie.getCategories();
    categories.iterator();
	
    // 3. find a movie again without accessing DB (using 1LC)
    movie = (Movie) session.get(Movie.class, "MV-00001");
	
    categories = movie.getCategories();
    categories.iterator();
    closeSession();
}

위와 같이 작성할 경우 동일한 Session 내에서 SetUpInitData.initializeData(session)를 통해 save된 Persistence 객체는 1LC에 저장되므로 다음에 #1번 코드에서처럼 동일한 Persistence 객체 조회시 DB에 재접근하지 않고도, Cache를 통해 조회된다. findMovie() 메소드를 포함한 HibernateFirstLevelCache.java 테스트 소스를 DEBUG 모드로 실행시켜서 실행되는 쿼리를 콘솔창을 통해 확인해 보면 이를 확인할 수 있을 것이다. SetUpInitData.java에 대한 내용은 여기 에서 확인할 수 있다.

2LC는 어플리케이션 단위의 Cache로, 어플리케이션 관점에서의 Cache 기능을 지원한다. 이는 여러 트랜잭션들을 통해 Load된 Persistence 객체를 Session Factory 레벨에서 저장하는 방법으로 처리된다.

hibernate.cache.use_second_level_cache, hibernate.cache.provider_class 등을 정의 하고, 2LC에 저장되어야 할 Persistence Class 매핑 파일의 <cache> 속성을 정의하면 해당 어플리케이션을 구성하는 특정 Persistence 객체들에 대해 2LC를 적용할 수 있다.

다음은 2LC에 대한 속성이 정의되어 있는 hibernate.cfg.xml 파일의 일부이다.

<property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider
</property>
<property name="hibernate.cache.use_second_level_cache]">true
</property>

다음은 cache 속성이 read-write로 설정되어 있는 Persistence Class 매핑 파일 Country.hbm.xml 의 일부이다.

<class name="org.anyframe.sample.model.bidirection.Country" table="COUNTRY" lazy="true"
        schema="PUBLIC">
    <cache usage="read-write"/>
    <id name="countryCode" type="string">
        <column name="COUNTRY_CODE" length="12" />
        <generator class="assigned" />
    </id>
    <property name="countryId" type="string">
        <column name="COUNTRY_ID" length="2" not-null="true" />
    </property>
	...
 </class>

cache의 속성은 위에서 언급한 read-write외에도 다음과 같은 속성값으로 정의할 수 있다.

위와 같은 설정을 기반으로 HibernateSecondLevelCache.java findCountry() 메소드를 실행해보면 다음의 #1번 코드에 의해 새로운 Session이 시작되었음에도 #2번 코드에서 DB에 접근하지 않고 이전 Session에서 Cache에 저장한 값을 가지고 사용한다는 것을 확인할 수 있다.

public void findCountry() throws Exception {
    newSession();
    SetUpInitData.initializeData(session);
    closeSession();
	
    // 2. find a movie without accessing DB (using 2LC)
    /* #1 */ newSession();
    /* #2 */ Country country = (Country) session.get(Country.class, "COUNTRY-0001");
	
    Set movies = country.getMovies();
    movies.iterator();
    closeSession();
	
    // 3. find a movie again without accessing DB (using 2LC)
    newSession();
    country = (Country) session.get(Country.class, "COUNTRY-0001");
	
    movies = country.getMovies();
    movies.iterator();
    closeSession();
}

DEBUG 모드에서 테스트케이스를 실행시켜보면서 DB에 접근하지 않고도 2LC를 통해 객체가 조회되는 것을 살펴볼 것을 권장 한다. HibernateSecondLevelCache.java 의 findMovie()는 2LC 사용하지 않는 Persistence Class인 Movie에 대한 테스트로써 앞서 언급한 findCountry()와 달리 Session이 다를 경우 매번 DB에 접근하여 해당 Persistence 객체를 조회해 오는 것을 알 수 있다.

단, 2LC를 적용하고자 할 경우 해당 어플리케이션을 통하지 않고, 외부에서 직접적으로 DB 정보가 수정될 가능성이 있다면 데이터의 동기화를 위해 세밀한 Cache 속성 제어가 필요함에 유의하도록 한다.

하나의 어플리케이션을 대상으로 하는 경우 앞서 언급한 2LC를 사용하는데 문제가 없으나, 일반적인 Clustered 환경에서 실행된 여러 개의 어플리케이션에 속한 2LC 사이의 데이터 동기화는 중요한 사항이 될 것이다. 이를 위해 Hibernate는 분산 Cache를 지원하는 구현체를 통해 분산 어플리케이션에 대한 Cache 기능을 지원한다.

다음에서는 분산 Cache를 지원하는 구현체별로 설정 방법 및 실행 결과에 대해 살펴보기로 하자.

<session-factory>
    ...중략    	
    <property name="hibernate.format_sql">true</property>
    <property name="hbm2ddl.auto">create</property>
    <property name="hibernate.cache.use_second_level_cache">true</property>
    <property name="hibernate.cache.provider_class">
            com.opensymphony.oscache.hibernate.OSCacheProvider</property>
    <property name="hibernate.cache.region_prefix">
            hibernate.cache</property> 
    <property name="com.opensymphony.oscache.configurationResourceName">
            oscache-hibernate.properties</property>
    ...중략
</session-factory>

cache.event.listeners=org.anyframe.cache.listener.JMSBroadcastingListener
cache.cluster.jndi.config=jndi.properties

cache.cluster.jms.topic.factory=TopicConnectionFactory
cache.cluster.jms.topic.name=dynamicTopics/topic
cache.cluster.jms.node.name=node1

Hibernate Mapping XML 파일 내에 특정 객체에 대한 batch-size를 지정할 경우 지정한 개수만큼 해당 객체를 로딩하는 방식으로 쿼리 실행 회수가 n/batch size + 1로 감소한다. 다음은 batch-size 설정 예인 Country.hbm.xml 파일의 일부이다.

<hibernate-mapping>
    <class name="org.anyframe.sample.model.bidirection.Country" table="COUNTRY" 
            lazy="true" schema="PUBLIC">
        <id name="countryCode" type="string">
        ..
        </id>
        <property name="countryId" type="string">
            <column name="COUNTRY_ID" length="2" not-null="true" />
        </property>
        ..        
        <set name="movies" inverse="true" cascade="save-update" batch-size="2">
            <key>
                <column name="COUNTRY_CODE" length="12" />
            </key>
            <one-to-many class="org.anyframe.sample.model.bidirection.Movie" />
        </set>
    </class>
</hibernate-mapping>

위와 같이 정의할 경우 Country:Movie 관계에서 Movie Set에 대한 Fetch Strategy를 Batch Fetching한다.(여기서는 batch-size="2"로 정의함.) 특정 Country에 속한 Movie Set을 조회하고자 할 때 batch-size를 기반으로 SELECT문이 수행된다.

hqlBuf.append("FROM Country");
Query query = session.createQuery(hqlBuf.toString());
List countryList = query.list();

// 3. check result - country

for (int i = 0; i < countryList.size(); i++) {
    Country country = (Country) countryList.get(i);

    if (i == 0) {
        Set movies = country.getMovies();
		
        /* batch-size가 2이므로 2개씩 조회
        select movies0_.COUNTRY_CODE as COUNTRY2_1_, movies0_.MOVIE_ID as MOVIE1_1_,
        movies0_.MOVIE_ID	as MOVIE1_3_0_, movies0_.COUNTRY_CODE as COUNTRY2_3_0_,
        movies0_.TITLE as TITLE3_0_, movies0_.DIRECTOR as DIRECTOR3_0_, 
        movies0_.RELEASE_DATE as RELEASE5_3_0_ from PUBLIC.MOVIE movies0_ 
        where movies0_.COUNTRY_CODE in ('COUNTRY-0001', 'COUNTRY-0003')'*/        
    } else if (i == 1) {
        Set movies = country.getMovies();
        //쿼리 수행 안함.
}

위에 대한 테스트 코드는 HibernateFetchWithBatchSize.java 를 참고한다.

또다른 fetch 전략으로 subselect 속성을 주는 방법이 있다. subselect 속성 정의 방법은 Mapping XML 파일인 Movie.hbm.xml 에서 다음과 같이 확인할 수 있다.

<hibernate-mapping>
    <class name="org.anyframe.sample.model.bidirection.Movie" table="MOVIE" lazy="true"..>
        <id name="movieId" type="string">
            <column name="MOVIE_ID" />
            <generator class="assigned" />
        </id>
        <property name="title" type="string">
            <column name="TITLE" length="100" not-null="true" />
        </property>
		...
        <set name="categories" inverse="false" table="MOVIE_CATEGORY" fetch="subselect">
            <key>
                <column name="MOVIE_ID" length="8" not-null="true" />
            </key>
            ..
        </set>
    </class>           
</hibernate-mapping>

위와 같이 Movie 클래스 내의 categories set에 대해 fetch 속성의 값을 subselect로 정의할 경우 해당 데이터를 불러올때 Sub Query 형태의 SELECT 문이 수행되며 한번에 모두 로딩하게 된다.

for (int i = 0; i < movieList.size(); i++) {
    Movie movie = (Movie) movieList.get(i);

    if (i == 0) {
    ..
		
        Set categories = movie.getCategories();
		
        /* categories에 대한 Sub Query 형태의 SELECT문이 발생한다.
        select categories0_.MOVIE_ID as MOVIE2_1_, categories0_.CATEGORY_ID 
        as CATEGORY1_1_, category1_.CATEGORY_ID as CATEGORY1_0_0_, category1_.CATEGORY_NAME 
        as CATEGORY2_0_0_, category1_.CATEGORY_DESC as CATEGORY3_0_0_ 
        from MOVIE_CATEGORY categories0_ 
        left outer join PUBLIC.CATEGORY category1_ 
        on categories0_.CATEGORY_ID=category1_.CATEGORY_ID
        where categories0_.MOVIE_ID 
        in (select movie0_.MOVIE_ID from PUBLIC.MOVIE movie0_) */
				
     } else if (i == 1) {
        ..
        Set categories = movie.getCategories();
        //쿼리 수행 안함.
    ...

하지만 최초로 필요한 순간에 모든 데이터를 로딩하므로 동시에 많은 데이터 요청이 있을 경우 메모리 사용량이 급격히 증가할 수 있음에 유의한다. 위의 테스트 코드는 HibernateFetchWithSubselect.java 에서 확인할 수 있다.

특정 HQL문에 "join fetch"절을 사용하게 되면 해당 Join 객체에 대해서 Lazy Loading과 다른 방식으로 한 번에 필요한 데이터를 모두 로딩하게 된다. 다음은 join fetch가 적용된 HibernateFetchWithoutLazyLoading.java 파일의 일부이다.

StringBuilder hqlBuf = new StringBuilder();
hqlBuf.append("SELECT movie ");
hqlBuf.append("FROM Movie movie join fetch movie.categories category ");
hqlBuf.append("WHERE category.categoryName = ?");
Query query = session.createQuery(hqlBuf.toString());
query.setParameter(0, "Romantic");

/* fetch join된 categories의 데이터도 한꺼번에 모두 로드시킨다. (Lazy Loading이 아님)
select movie0_.MOVIE_ID as MOVIE1_3_0_, category2_.CATEGORY_ID as CATEGORY1_0_1_, 
movie0_.COUNTRY_CODE as COUNTRY2_3_0_, movie0_.TITLE as TITLE3_0_, 
movie0_.DIRECTOR as DIRECTOR3_0_, movie0_.RELEASE_DATE as RELEASE5_3_0_, 
category2_.CATEGORY_NAME as CATEGORY2_0_1_, category2_.CATEGORY_DESC as CATEGORY3_0_1_, 
categories1_.MOVIE_ID as MOVIE2_0__, categories1_.CATEGORY_ID as CATEGORY1_0__ 
from PUBLIC.MOVIE movie0_ inner join MOVIE_CATEGORY categories1_ 
on movie0_.MOVIE_ID=categories1_.MOVIE_ID inner join PUBLIC.CATEGORY category2_ 
on categories1_.CATEGORY_ID=category2_.CATEGORY_ID where category2_.CATEGORY_NAME='Romantic' */
List movieList = query.list();

// 3. check result - movie

for (int i = 0; i < movieList.size(); i++) {
    Movie movie = (Movie) movieList.get(i);

    if (i == 0) {
		..
        Set categories = movie.getCategories();
        //쿼리 수행 안함.
    } else if (i == 1) {
        ..
        Set categories = movie.getCategories();
        //쿼리 수행 안함.
    ...

이는 categories에 대한 fetch 속성을 "join"으로 준것과 같이 동작하게 된다. 하지만 Mapping XML에 정의할 경우 Movie를 조회할 때마다(Category 목록이 필요하지 않은 경우에도) 모든 Category 목록도 함께 초기화되어 메모리에 올라 오게 되므로 위와 같이 HQL문에 join fetch를 사용하여 필요한 경우에만 적용되도록 하는 것이 효율적이다.

Spring에서 제공하는 HibernateDaoSupport는 내부적으로 Hibernate 연계를 위해 HibernateTemplate을 생성하는데 이 클래스는 SessionFactory를 필요로 한다. 이를 위해 HibernateDaoSupport를 상속받은 클래스들은 SessionFactory를 필요로 하며, SessionFactory는 다음과 같은 속성 정보를 가질 수 있다. 다음은 SessionFactory의 속성을 정의한 context-hibernate.xml 파일의 일부이다.

<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
    <!-- SessionFactory에서 사용할 dataSource 정의 -->
    <property name="dataSource" ref="dataSource" />
    <!-- Mapping XML의 위치 지정 -->
    <property name="mappingLocations">
        <list>
            <value>classpath:anyframe/sample/model/bidirection/Category.hbm.xml</value>
            <value>classpath:anyframe/sample/model/bidirection/Country.hbm.xml</value>
            <value>classpath:anyframe/sample/model/bidirectionMovie.hbm.xml</value>
        </list>
    </property>
<!-- Hibernate Property에 대한 속성 정의 -->
    <property name="hibernateProperties">
        <props>
            <prop key="hibernate.hbm2ddl.auto">create</prop>
            <!-- DBMS에 따른 dialect 설정-->
            <prop key="hibernate.dialect">org.hibernate.dialect.HSQLDialect</prop>
            <!-- hibernate을 이용한 sql문을 보여줄지 여부-->
            <prop key="hibernate.show_sql">false</prop>
            <prop key="hibernate.format_sql">true</prop>
        </props>
    </property>
</bean>

조건에 따라 HQL문을 dynamic하게 생성해 주기 위해 Anyframe에서는 DynamicHibernateService를 제공한다. 이러한 기능을 사용하기 위해서는 다음과 같이 DynamicHibernateService 클래스에 대한 속성을 정의하고 특정 DAO 클래스 정의시 DynamicHibernateService를 참조하도록 할 수 있다. 다음은 dynamicHibernateService bean이 정의된 context-hibernate.xml 파일의 일부이다.

<bean id="dynamicHibernateService"
        class="org.anyframe.hibernate.impl.DynamicHibernateServiceImpl">
    <!-- SessionFactory 지정  -->
    <property name="sessionFactory" ref="sessionFactory" />
    <!-- Velocity 문법이 적용된 dynamic한 HQL을 정의한 XML파일의 경로 지정 -->
    <property name="fileNames">
        <list>
            <value>classpath*:hibernate/spring/dynamic-hibernate.xml</value>
        </list>
    </property>
</bean>

위와 같이 정의할 경우 dynamicHibernateService bean은 sessionFactory bean을 SessionFactory로 가지며 fileNames에 정의된 XML들에서 해당되는 HQL또는 Native SQL을 찾게 될것이다.

DAO 클래스에 대한 속성 정의 파일을 작성한다. SessionFactory와 DynamicHibernateService를 참조하는 MovieDAOHibernateImpl 클래스에 대한 속성은 다음과 같이 정의할 수 있다.

<bean id="movieService" class="org.anyframe.sample.service.movie.impl.MovieServiceImpl">
    <property name="movieDAO">
        <bean class="org.anyframe.sample.service.movie.impl.MovieDAOHibernateImpl">
            <!-- Hibernate Template을 이용하기 위한 SessionFactory 정의 -->
            <property name="sessionFactory" ref="sessionFactory"/>
            <!-- Dynamic HQL문 지원을 위한 dynamicHibernateService 정의 
            (dynamicHibernateService를 사용할 때만 정의) -->
            <property name="dynamicHibernateService" ref="dynamicHibernateService"/>
        </bean>
    </property>
</bean> 

위 코드는 context-sample.xml 에서 확인할 수 있다.

Spring에서 제공하는 HibnernateDaoSupport를 상속받아 DAO 클래스를 정의한다. 이 때, getHibernateTemplate() 메소드를 사용하여 HibernateTemplate을 이용한 데이터 입력/수정/삭제/조회가 가능하다.

public class MovieDAOHibernateImpl extends HibernateDaoSupportimplements MovieDAO{

    private DynamicHibernateService dynamicHibernateService;

    //dynamicHibernateService Setter Injection
    public void setDynamicHibernateService(
            DynamicHibernateService dynamicHibernateService) {
            this.dynamicHibernateService = dynamicHibernateService;
        }

    public void createMovie(Movie movie) throws Exception {
        this.getHibernateTemplate().save(movie);
    }
    public Movie findMovie(String movieId) throws Exception {
        return (Movie) this.getHibernateTemplate().get(Movie.class, movieId);
    }

    public List findMovieList(int conditionType, String condition)
                throws Exception {
        Object[] args = new Object[3];
        if (conditionType == 0) {
            args[0] = "director=%" + condition + "%";
            args[1] = "sortColumn=movie.director";
        } else {
            args[0] = "title=%" + condition + "%";
            args[1] = "sortColumn=movie.title";
        }
        args[2] = "sortDirection=ASC";

        return dynamicHibernateService.findList("findMovieListAll", args);
    }

    public List findMovieListAll() throws Exception {
    return this.getHibernateTemplate().find(
            "FROM Movie movie ORDER BY movie.title");
    }

    public void removeMovie(Movie movie) throws Exception {
        this.getHibernateTemplate().delete(movie);
    }

    public void updateMovie(Movie movie) throws Exception {
        this.getHibernateTemplate().update(movie);
    }

    public void updateMovieByBulk(Movie movie) throws Exception {
        StringBuilder hqlBuf = new StringBuilder();
        hqlBuf.append("UPDATE Movie movie ");
        hqlBuf.append("SET movie.director = ? ");
        hqlBuf.append("WHERE movie.movieId = ? ");

        //HQL문을 이용한 CUD를 할 경우에는 
        //getHibernateTemplate().bulkUpdate() 메소드를 사용한다.
        this.getHibernateTemplate().bulkUpdate(hqlBuf.toString(),
                new Object[] { movie.getDirector(), movie.getMovieId() });
    }

    public void createCategory(Category category) throws Exception {
        this.getHibernateTemplate().save(category);
    }

    public void createCountry(Country country) throws Exception {
        this.getHibernateTemplate().save(country);
    }
}

위의 코드는 MovieDAOHibernateImpl.java 에서 확인할 수 있다.

※ Dynamic Hibernate에 대한 자세한 사항은 본 매뉴얼 >> Hibernate Plugin >> Dynamic Hibernate를 참고한다.