저작권 안내: 저작권자표시 Yes 상업적이용 No 컨텐츠변경 No

스프링5 입문

JSP 2.3

JPA 입문

DDD Start

인프런 객체 지향 입문 강의

최근 수행중인 프로젝트에서 JPA의 구현체로 하이버네이트를 사용하고 있다. 매핑 설정에 따라 다르겠지만, 이런 JPA 구현체들은 Lazy 로딩을 구현하기 위해 프록시 객체를 사용하고 있는데, 이와 관련해서 한 가지 주의해야 할 것이 있다. 그것은 바로 this를 리턴하는 메서드와 관련된 것이다.


현재 수행중인 프로젝트에는 상속을 매핑한 코드가 있다. 예를 들면 다음과 같은 구조이다.


public class Content { ... 최상위 }

public class VideoContent extends Content { .... }

public class MovieContent extends VideoContent { ... }

public class BookContent extends Content { ... }


그리고, 특정 클래스과 다음과 같이 Content를 *-to-One의 형식으로 레퍼런스하고 있다.


public class Order {

    private Content content;

    public Content getContent() {

        return content;

    }

}


Order 객체를 구한 뒤에 Content 객체에 접근해야 하는 경우가 있으며, 특히 Content 타입이 아닌 실제 타입에 접근해야 할 때가 있다. 이런 경우에 아주 단순하게 생각하면 다음과 같이 Content에 자기 자신을 리턴하는 코드를 넣는 방법을 생각해 볼 수 있을 것이다.


public Content {

    public Content self() {

        return this; // 자기 자신을 리턴

    }

}


Order o = getOrder(xxx);

Content proxy = o.getContent(); // Content는 프록시

Content real = proxy.self(); // self() 메서드는 자기 자신을 리턴하므로 프록시가 아닌 실제 대상 객체???

if (real instanceof MovieContent) { // 하지만, real은 프록시 객체이므로 항상 false

    ...

}


하지만, 위와 같은 방법은 통하지 않는다. 그 이유는 프록시 객체는 대상 객체가 대상 객체 자신을 리턴하는 경우 프록시 객체를 리턴하도록 만들어지기 때문이다. 

  • proxy.self() 메서드는 대상 객체의 self() 메서드를 호출한다.
  • 대상 객체의 self() 메서드는 자기 자신을 리턴한다.
  • proxy.self() 메서드는 대상 객체가 리턴한 객체가 대상 객체와 동일한지 확인한다.
  • 동일하다면 프록시 객체 자신을 리턴한다.
그렇다면, 왜 프록시 객체가 대상 객체를 리턴하지 않고 자기 자신을 리턴하는 것일까? 그 이유는 간단하다. 대상 객체에 직접 접근하게 될 경우 ORM이 제공하는 Dirty Checking이나 Lazy Loading 등이 적용되지 않기 때문이다.

이런 이유로 실제 대상 객체에 접근해서 뭔가를 하고 싶다면, 대상 객체가 자기 자신을 리턴하도록 하지 말고, Double dispatch를 사용해야 한다. Double dispatch란 다음과 같은 것이다.
  • A 객체의 a() 메서드는 B 인터페이스를 파라미터로 갖는다.
  • B 인터페이스의 b() 메서드는 A를 파라미터로 갖는다.
  • A 객체의 a() 메서드는 파라미터로 전달받은 B 인스턴스의 b() 메서드를 호출할 때 자기 자신을 전달한다.
위 내용을 코드로 다시 살펴보면 다음과 같다.
public interface B {
    public void b(A a);
}

public class A {
    public void a(B b) {
        b.b(this);
    }
}

A aobj = new A();
B bobj = new BImpl();
aobj.a(bobj); // 내부적으로 bobj.b(a)가 호출됨

위 코드를 보면 aobj.a() 메서드를 호출하면, a() 메서드는 내부적으로 다시 파라미터로 전달받은 bobj의 b() 메서드를 호출한다. 이렇게 두 객체간의 호출이 두 번 이루어지기 때문에 이를 Double Dispatch라고 표현한다.

그럼, 요놈을 앞서 Content에 적용해 보자. 다음과 같이 변경해 주면 된다.

public interface Accessor {
    public void access(Content c);
}

public class Content {
    public void access(Accessor access) {
        accessor.access(this);
    }
}

위 코드에서 Accessor의 구현체는 Content의 프록시 객체가 아닌 실제 객체에 접근할 수 있게 된다.

Order o = getOrder(xxx);

Content proxy = o.getContent(); // Content는 프록시

proxy.access(new Accessor() {
    public void access(Content c) {
        // c는 proxy의 대상 객체인 실제 객체
        if (c instanceof MovieContent) {
            ...
        }
    }
});

Content 및 Content의 자식 클래스들은 상속 관계에 있으므로 사용하므로 Visitor 패턴을 사용하면 instanceof 연산자를 사용하지 않고 실제 타입으로 바로 접근할 수도 있어 더 보기 좋은 코드를 만들어 낼 수 있을 것이다.



Posted by 최범균 madvirus

댓글을 달아 주세요

  1. 권남 2012.08.29 23:10 신고  댓글주소  수정/삭제  댓글쓰기

    저도 비슷한 상황에서 Visitor 패턴으로 해결한 적이 있습니다.
    하지만 이런일 자체가 안일어나게 만드는게 제일 좋을 것 같습니다.
    예전에 Visitor 패턴으로 베베꽈가면서 만든 기능을 이번 프로젝트에서는 각 엔티티가 특정 interface를 구현하게 해서 간단히 해결했던게 생각나네요.
    즉, 예제에서 보여주신 Accessor가 할 일을 각 엔티티가 인터페이스를 구현해서 알아서 하게 만든거죠.
    상속구조니까 Accessor가 할일을 인터페이스 메소드로 빼고 @Override를 계속해가면서 어쩌면 쉽게 해결 될수도 있어보입니다. 하지만 프로javascript:;젝트 실제 요구사항이 어떤지를 모르니 속단은 금물이겠죠.

    • 최범균 madvirus 2012.08.30 09:22 신고  댓글주소  수정/삭제

      상속 구조에서 하위 타입이 특정 인터페이스를 상속받는다 하더라도, 최상위 타입에 대한 프록시 객체를 사용하기 때문에, 해당 인터페이스를 사용할 수 없는 상황이었습니다.
      그렇다고 해당 인터페이스를 최상위 타입이 상속받도록 할 수도 없었습니다. 왜냐면, 최상위 타입에는 해당 인터페이스에 대한 역할을 필요가 없었기 때문이다.
      또한, 각 엔티티의 역할이 아니면서 엔티티의 타입에 따라서 다르게 동작해야 하는 것들이 있었습니다.
      그래서 위와 같이 double dispatch되는 방식의 코드를 사용하게 되었습니다.

JPA를 이용해서 구현하는 프로젝트에서 두 개의 프로퍼티를 묶어서 식별자로 사용해야 하는 경우가 생겼다. 그래서, @EmbeddedId를 이용해서 ID 필드를 지정하였다. 이 프로젝트는 Spring Data JPA를 이용해서 Repository를 자동생성하고 있는데, @EmbeddedId 부분에서 문제가 발생했다. 아래 코드는 문제를 발생시킨 리포지토리의 인터페이스이다.


public interface FollowRepository extends Repository<Follow, FollowId> {


    Page<Follow> findAll(Specification<Follow> spec, Pageable pageable);

...

}


Follow의 식별자의 타입은 FollowId 클래스이고, FollowId 클래스는 두 개의 프로퍼티를 갖고 있다. 그런데, 위 코드에서 findAll()을 실행하는 순간에 다음과 같은 쿼리가 실행되면서 문제가 발생했다.


select count((follow0_.FOLLOWING_ID, follow0_.USER_ID)) as col_0_0_ 

from FOLLOW follow0_ 

where ....


DBMS로 오라클을 사용하고 있는데, 위 count() 부분에서 쿼리 오류가 발생한 것이다. 처음엔 Spring Data JPA 문제일까 해서 커스텀 구현을 넣어 보았다.


public class FollowRepositoryImpl implements FollowRepositoryCustom {


    @PersistenceContext

    private EntityManager entityManager;


    @Override

    public Page<Follow> findAll(Specification<Follow> spec, Pageable pageable) {

        List<Follow> result = getResultList(spec, pageable);

        long total = count(spec);

        return new PageImpl<Follow>(result, pageable, total);

    }


    private List<Follow> getResultList(Specification<Follow> spec,

            Pageable pageable) {

        ...

        return query.getResultList();

    }


    private long count(Specification<Follow> spec) {

        CriteriaBuilder cb = entityManager.getCriteriaBuilder();

        CriteriaQuery<Long> c = cb.createQuery(Long.class);

        Root<Follow> root = c.from(Follow.class);

        c.select(cb.count(root));

        Predicate predicate = spec.toPredicate(root, c, cb);

        c.where(predicate);


        TypedQuery<Long> query = entityManager.createQuery(c);

        return query.getSingleResult();

    }


}


하지만, 결과는 동일했다. JPA API를 직접 사용해도 변화가 없는 걸 봐서는 Spring Data JPA의 문제는 아니였다. Spring Data JPA 1.1 버전을 사용하고 있었는데, 이 버전은 하이버네이트 3.6.9를 기준으로 하고 있어서 해당 버전의 하이버네이트를 사용했었다.


하이버네이트의 버전 문제가 아닐까해서 범위를 좀 더 좁혀서 구글링을 해 봤더니 하이버네이트에서 이런 문제가 발생하고 있는 듯 했다. (관련 문의가 포럼에 있었다.) 좀 더 파 볼까 하다가, 하이버네이트 버전을 올려보기로 결심했다. 하이버네이트 버전을 3.6.9에서 4.1.4로 올렸다.


결과는? 야호! 테스트케이스의 녹색바! 에러가 없어졌다. 처음부터 하이버네이트 버전 업부터 할 걸, 괜히 코드 작성했다. 오픈소스에서 뭔가 이상한 문제가 있으면 먼저 버전을 올려보라는 걸 다시 한 번 확인했다.


Posted by 최범균 madvirus

댓글을 달아 주세요

  1. 권남 2012.07.12 17:37 신고  댓글주소  수정/삭제  댓글쓰기

    @IdClass를 사용할때도 마찬가지 현상이 발생합니다.
    @IdClass/MySQL

  2. PKH갈휘 2012.07.16 22:22 신고  댓글주소  수정/삭제  댓글쓰기

    버전업후에 말끔해졌네요, 감사합니다.

데이터를 조회하는 두 가지 방법(HQL, Criteria)에 대해서 살펴본다.

HQL을 사용한 데이터 조회

Hibernate는 HQL 실행 방식, Criteria 실행 방식 그리고 SQL 직접 실행 방식의 세 가지 데이터 조회 방식을 제공한다. 이들 세 가지 데이터 조회 방식 중 HQL을 사용하는 방법에 대해서 살펴보도록 하자.

HQL은 SQL과 비슷한 형태의 구문을 갖는 Hibernate의 쿼리 언어로서 OR 매핑 파일에서 설정한 객체를 쿼리문구에서 사용할 수 있다는 특징이 있다. 또한, SQL 만큼 쉽기 때문에 다양한 형태로 데이터를 조회하고자 할 때 유용하게 사용될 수 있다.

HQL의 기본

HQL을 이용하는 가장 기본적인 코드는 다음과 같다.

    Query query = session.createQuery("from Item");
    List list = query.list();
    
    // 또는 간단히 한줄로
    List list = session.createQuery("from Item").list();
    
    for (int i = 0 ; i < list.size() ; i++) {
        Item item = (Item)list.get(i);
    }

Hibernate Session은 createQuery(String hql) 메소드는 전달받은 HQL을 실제 쿼리로 변환하여 수행하는 net.sf.hibernate.Query 객체를 리턴한다. Query는 쿼리 실행과 관련된 인터페이스로서 다양한 조건을 사용해서 데이터를 조회할 수 있는 메소드를 제공하며, list() 메소드를 통해서 쿼리 실행 결과를 java.util.List로 생성해준다.

createQuery() 메소드가 전달받는 HQL의 가장 기본적인 형태는 다음과 같다.

    from 클래스이름

위 쿼리는 '클래스이름'과 관련된 테이블로부터 모든 행 데이터를 읽어온다. 클래스이름은 매핑 설정 파일에 명시한 클래스의 이름으로서 패키지를 포함한 완전한 클래스 이름을 사용해도 되고 패키지 부분을 제외한 클래스 이름만 사용해도 된다. 예를 들면 아래의 두 경우 모두 올바르게 동작한다.

    from javacan.hibernate.test.Item
    
    from Item

where 절이나 기타 다른 절에서 관련 객체의 프로퍼티값을 참조하기 위해 다음과 같이 별칭을 부여할 수 있다.

    from Member as member
    
    from Member member

'as' 뒤에 별칭을 입력하는데 'as'는 생략할 수 있다.

where 절과 파라미터 값 매핑

where 절은 SQL과 동일한 방법으로 입력한다. 차이점이 있다면, 테이블 컬럼명 대신에 퍼시스턴트 객체의 프로퍼티명을 사용한다는 점이다. 예를 들어, 특정 Member 객체 중에서 name 프로퍼티의 값이 '최범'으로 시작하는 것의 목록을 추출하고 싶다면 다음과 같이 쿼리를 작성하면 된다.

    from Member as member where member.name like '최범%'

물론, and, or, not 등을 사용하여 검색 조건을 조합할 수 있다. 예를 들면 아래와 같이 사용할 수 있다.

    from Member as member where member.id like '%mad%' or member.name like '최%'

JDBC의 PreparedStatement와 마찬가지로 HQL도 파라미터를 지정하는 형태로 비교값을 명시할 수 있다. PreparedStatement가 '?'를 사용하여 값을 지정하는 방식만 제공하는 반면에 HQL은 이름을 사용하는 방식과 '?'를 사용하는 방식의 두가지를 제공하고 있다. 먼저 다음은 이름을 사용하는 방식은 다음과 같이 값을 삽입할 부분에 :이름 의 형태를 삽입한다.

    Apartment apt = (Apartment)session.get(Apartment.class, "01135001");
    
    Query query = session.
        createQuery("from Member as member "+
                    "where member.id = :id or member.apartment = :apt");
    query.setParameter("id", "era13");
    query.setParameter("apt"apt);

Query.setParameter() 메소드를 사용해서 이름 부분에 삽입될 값을 지정한다. 이름을 사용하기 때문에 값의 의미가 명확한 장점이 있다.

'?'를 사용하는 방식은 PreparedStatement를 사용하는 경우와 동일한 방식으로 쿼리를 작성하면 된다. 위 코드를 '?'를 사용하여 작성하면 아래와 같이 바뀐다.

    Apartment apt = (Apartment)session.get(Apartment.class, "01135001");
    
    Query query = session.
        createQuery("from Member as member where member.id = ? or member.apartment = ?");
    query.setParameter(0, "era13");
    query.setParameter(1, apt);

위 코드에서 주의할 점은 JDBC의 PreparedStatement는 '?'의 인덱스가 1부터 시작하는 반면에, HQL의 '?'는 0부터 시작한다는 것이다.

setParameter() 메소드를 사용할 때 할당될 값의 타입에 대해 명확하게 정의하고 싶다면 타입을 세번째 인자로 받는 setParameter() 메소드를 사용하면 된다. 또는 setString(), setDouble(), setEntity()와 같은 메소드를 사용해서 파라미터 값을 지정해주어도 된다.

    query.setParameter("id", id, Hibernate.STRING);
    query.setInteger("no", 10);
    query.setEntity("apt", apartment);

대부분의 경우는 하이버네이트가 자동으로 값에 대한 매핑을 처리해주기 때문에 setParameter() 메소드만으로도 충분한다.

비교 연산자와 수식

HQL은 SQL과 같은 기본 연산자를 제공하며, 이들은 다음과 같다.

    =   <>   <   >   >=   <=    between    in    like

between이나 in, like 등은 not 연산자와 함께 사용될 수 있다. 예를 들어, 특정 목록에 속해 있지 않은 값만 읽어오고 싶다면 다음과 같이 not in 연산자를 사용할 수 있을 것이다.

    from Member as mem where mem.apartment not in (?, ?, ?);

HQL은 또한 사칙 연산을 수행하는 +, -, *, / 연산자를 제공한다. 아래 코드는 비교 연산자와 수식 연산자를 함께 사용한 예이다.

    from Member mem where (mem.height - 110) * 0.1 < mem.weight - (mem.height - 110)

select 절을 이용한 개별 프로퍼티 읽기

HQL은 SQL과 달리 select 절이 필요없으며 from 절만 입력해도 쿼리가 실행된다. 이렇게 from 절만 필수인 이유는 HQL이 조회한 결과가 퍼시스턴트 객체로 추출되기 때문이다. 하지만, 경우에 따라 특정 프로퍼티만을 추출하고 싶은 경우가 있으며, 이럴 때에는 다음과 같이 select 절을 사용해야 한다.

    Query query = session.
        createQuery("select member.id, member.name from Member as member "+
                    "where member.id = ? or member.apartment = ?");
    query.setParameter(0, "era13");
    query.setParameter(1, apt);
    
    List list = query.list();
    
    for (int i = 0 ; i < list.size() ; i++) {
        Object[] row = (Object[])list.get(i);
        // row[0] - member.id
        // row[1] - member.name
    }

Query를 실해한 결과 List는 select 절에 표시된 값들을 저장한 객체 배열(Object[])을 갖고 있다. 이 객체 배열은 하나의 행과 관련된 데이터를 저장하고 있다. 배열에 저장되는 순서는 select 절에 나열한 순서와 동일하다. 즉, 위의 코드의 경우 배열의 0번 인덱스에는 member.id가, 1번 인덱스에는 member.name이 저장된다.

함수 사용

select 절이나 where 절에서는 SQL Dialect에 따라 관련 DBMS가 제공하는 함수를 사용할 수 있다. ('Hibernate를 이용한 ORM 2 - 세션(커넥션) 및 트랜잭션 프로퍼티 설정'에서 SQL Dialect를 설정하는 방법을 살펴봤었다.) 예를 들어, 오라클을 사용하는 경우 다음과 같이 오라클이 제공하는 to_date() 함수와 substr() 함수를 사용할 수 있다.

    select to_date(member.regdate, 'YYYY/MM/DD'), substr(member.name, 1, 2)
    from Member as member where member.id = ? or member.apartment = ?

DBMS에 특정한 함수 뿐만 아니라 집합 관련 표준 SQL 함수인 count, avg, sum, max, min 함수도 사용할 수 있다.

    select max(member.mark), min(member.mark), avg(mark) from Member member

Hibernate가 제공하는 HQL 함수/프로퍼티

Hibernate는 HQL에서 콜렉션 프로퍼티와 관련된 쿼리를 쉽게 할 수 있도록 하기 위한 특별한 함수와 프로퍼티를 제공하는데 이들 함수는 다음과 같다.

Hibernate가 제공하는 콜렉션 관련 함수/프로퍼티
함수 관련 프로퍼티 설명
size() size 콜렉션의 크기를 구한다.
minIndex() minIndex 인덱스의 최소값을 구한다.
maxIndex() maxIndex 인덱스의 최대값을 구한다.
minElement() minElement 콜렉션의 요소 중 최소값을 구한다.
maxElement() maxElement 콜렉션의 요수 중 최대값을 구한다.

위 함수들은 다음과 같이 where 절에서 사용될 수 있다.

    from Item item where maxElement(item.bids) > 1000
    
    from Item item where item.bids.maxIndex > 5

any, all, in 함수를 조건에서 사용할 수도 있다. 예를 들어, Item과 관련된 모든 Bid의 amount 값이 100보다 큰 Item을 구하고 싶다면 다음과 같은 쿼리를 사용하면 된다.

    from Item item where 100 < all (select b.amount from item.bids b)

group by 절과 having 절

group by 절을 사용해서 특정 컬럼 값으로 그룹핑 할 수 있으며, having 절을 사용해서 그룹핑에 대해 조건을 줄 수도 있다. group by 절이나 having 절의 사용법은 SQL에서의 사용방법과 비슷하다. 예를 들어, 관련 Bid의 개수가 4개 이상인 Item의 개수를 구하고 싶은 경우 다음과 같은 쿼리를 사용하면 된다.

    from Item item group by item.id having size(item.bids) > 4

결과 순서 처리 및 페이징

HQL에서 조회한 결과를 정렬하고 싶은 경우에는 order by 절을 사용하면 된다. order by 절의 사용법은 SQL과 비슷하다. 예를 들어, Member 객체의 name 프로퍼티 값의 내림차순으로 정렬하고 싶다면 다음과 같은 HQL을 사용하면 된다.

    from Member member order by member.name desc

SQL과 마찬가지로 여러 프로퍼티에 대해서 정렬 방식을 명시할 수 있다.

    from Member member order by member.name desc, member.apartment.name asc

Query 인터페이스는 페이징 처리를 위한 메소드를 제공하고 있는데, 이 두 메소드는 아래와 같이 사용한다.

    Query query = session.createQuery("from Member member order by member.name asc");
    query.setFirstResult(30);
    query.setMaxResults(15);

Query.setFirstResult() 메소드는 Query의 결과 목록 중에서 읽어올 첫번째 항목의 인덱스값을 입력한다. 이때 인덱스 값은 0부터 시작한다. 따라서, 위 코드는 31번째 항목부터 읽어오게 된다. setMaxResults() 메소드는 읽어올 최대 개수를 나타낸다. 따라서, 위 코드는 Query 결과의 31번째 항목부터 최대 15개를 읽어오게 된다. 이 두 메소드를 사용하면 페이징 처리를 쉽게 할 수 있을 것이다.

연관의 조인(join) 처리

Hibernate의 연관은 결국 SQL 조인을 통해서 처리된다. HQL에서 연관을 위한 조인은 다음과 같이 네 가지 방식으로 지원된다.

  • from 절에서 join과 fetch 사용하기
  • 자동으로 조인 처리하기
  • where 절과 함께 카타시안 조인 사용하기
from 절에서 join 사용하기

HQL은 SQL이 제공하는 내부 조인과 외부 조인을 모두 사용할 수 있다. 예를 들어, 일반적인 내부 조인은 다음과 같이 사용할 수 있다.

    Query query = session.
        createQuery("from Item item inner join item.bids");
    
    List list = query.list();
    for (int i = 0 ; i < list.size() ; i++) {
        Object[] object = (Object[])list.get(i);
        Item item = (Item)object[0];
        Bid bid = (Bid)object[1];
        System.out.print(item.getId());
        System.out.print("-");
        System.out.println(bid.getId());
    }

위 코드에서 눈여겨 볼 부분은 Query.list()가 리턴한 List가 담고 있는 값이 객체 배열(Object[])이라는 것이다. 내부 조인을 했기 때문에 객체 배열의 첫번째 요소에는 Item 객체가 저장되고, 배열의 두번째 요소에는 내부 조인으로 읽어온 Bid 객체가 저장된다.

다음과 같이 외부 조인을 사용할 수도 있다.

    from Item item left outer join item.bids

외부 조인을 할 때에도 내부 조인을 할 때와 마찬가지로 from 절에 있는 조인된 객체들을 객체 배열에 담아 리턴한다.

내부 조인이든 외부 조인이든, 실행한 결과는 (왼쪽이나 오른쪽의) 조인된 객체에 대해서 중복된 값을 갖게 된다. 예를 들어, 다음의 쿼리를 생각해보자.

    from Item item inner join item.bids where item.id = 1

id가 1인 Item과 연관된 Bid 객체의 id 값이 1, 2, 3 이라고 해 보자. 이때 Query.list() 메소드는 다음과 같은 객체 배열을 담은 List를 리턴하게 된다.

Item Bid
Item (id = 1) Bid (id = 1)
Item (id = 1) Bid (id = 2)
Item (id = 1) Bid (id = 3)

즉, (내부 또는 외부) 조인을 하면 하나의 Item 객체만 리턴하는 것이 아니라 같은 값을 갖는 Item 객체를 중복해서 리턴하게 되는 것이다. 조인을 사용할 때에는 이 점에 유의해야 한다.

조인되는 객체에 alias를 부여할 수도 있다. 예를 들어, Item과 조인되는 Bid 중에서 amount 프로퍼티의 값이 100 이상인 것만 조인하고 싶다면 다음과 같은 쿼리를 사용할 수 있다.

    from Item item join item.bids bid where bid.amount >= 100

위와 같이 조인되는 객체에 alias를 부여해서 where 절의 쿼리를 좀더 쉽게 작성할 수 있게 된다.

from 절에서 fetch를 사용한 쿼리 조회

앞서 살펴봤던 'from Item item inner join item.bids where item.id = 1' HQL 쿼리는 다음과 같이 두개의 쿼리를 사용한다.

    select item.ITEM_ID, ..., bid.BID_ID 
    from ITEM item inner join BID bid on item.ITEM_ID = bid.ITEM_ID
    where item.ITEM_ID = 1
    
    select bid.BID_ID, ... from BID bid where bid.ITEM_ID = 1

위 SQL에서 첫번째 쿼리는 Item 객체를 읽어오기 위한 쿼리이며, 두번째 쿼리는 Item 객체를 읽어온 뒤 관련 Bid 객체를 읽어오기 위한 쿼리이다.

fetch 키워드를 사용하면 위와 같이 두 번의 쿼리를 수행하지 않고 한번의 쿼리만으로 조인되는 객체를 읽어올 수 있다. 예를 들어, fetch 키워드를 사용해서 다음과 같은 HQL 쿼리를 실행할 수가 있다.

    Query query = session.
        createQuery("from Item item left join fetch item.bids "+
                    "where item.id = 1");
    List list = query.list();
    for (int i = 0 ; i < list.size() ; i++) {
        Item item = (Item)list.get(i);
        System.out.println(item.getId());
    }

fetch 키워드를 join 뒤에 붙이면 다음과 같이 한번의 SQL 쿼리로 Item과 연관된 Bid 객체를 읽어오게 된다.

    select item.ITEM_ID, ..., bid.BID_ID ... 
    from ITEM item left outer join BID bid on item.ITEM_ID = bid.ITEM_ID
    where item.ITEM_ID = 1

따라서 한번의 SQL 쿼리로 읽어오고 싶다면 fetch 키워드를 사용해서 쿼리 성능을 높일 수 있다.

fetch 모드를 사용할 때 주의할 점은 Query.list()가 리턴한 List가 배열 객체가 아닌 from 절의 퍼시스턴트 객체를 포함한다는 점이다. 앞서 코드를 보면 List에서 객체를 읽어올 때 객체 배열(Object[])이 아닌 Item 으로 형변환하는 것을 알 수 있다.

자동으로 조인 처리하기

Hibernate는 HQL의 where 절이나 order by, group by 등에 연관된 객체의 프로퍼티가 사용되면 자동으로 조인을 수행한다. 예를 들어 다음의 HQL을 보자.

    from Bid bid where bid.item.minPrice >= 1000

위 HQL 쿼리는 다음과 같은 카타시안 조인을 사용해서 처리된다.

    select bid.BID_ID, .., bid.ITEM_ID 
    from BID bid, ITEM item 
    where item.MINPRICE>=1000 and bid.ITEM_ID = item.ITEM_ID

Hibernate는 where 절에서 사용된 값을 추출하기 위해 조인이 필요하다고 판단될 경우 위와 같이 조인을 수행하게 된다.

하지만, 자동으로 조인을 처리할 때 주의할 점은 HQL의 from 절에 명시된 객체만 결과 목록에 포함된다는 것이다. 실제로 사용되는 SQL에는 Item 객체와 매핑되는 ITEM 클래스가 from 절에 포함되지만, HQL에는 from 절에 Bid 객체만 포함되어 있기 때문에 Query.list() 메소드가 리턴하는 List에는 Bid만 포함된다.

where 절과 함께 카타시안 조인 사용하기

카타시안 조인을 직접 수행할 수도 있다. 예를 들어, 다음의 HQL 쿼리를 보자.

    from Member member, Item item
    where member.id = 'someman' and item.member = member

위 쿼리를 실행하면 [Member, Item] 배열을 저장한 List가 리턴된다.

조회환 결과를 임의의 클래스 객체에 저장하기

매핑 파일에서 작성한 클래스가 아닌 임의의 클래스에 조회 결과를 저장하고 싶다면 다음과 같이 HQL을 작성하면 된다.

    select new MemberRow(member.id, member.name, member.securityNo)
    from Member member
    where ...

위 코드에서 MemberRow 클래스는 인자를 세개 받는 생성자가 존재해야 한다.

위와 같이 임의의 클래스를 명시했다면 데이터를 조회할 때에도 지정한 클래스를 사용해야 한다.

    Query query = session.createQuery(
        "select new MemberRow(member.id, member.name, member.securityNo) "+
        "from Member member where ... ");
    list = query.list();
    for (int i = 0 ; i < list.size() ; i++) {
        MemberRow memberRow = (MemberRow)list.get(i);
    }

Criteria API 사용한 데이터 조회

HQL 뿐만 아니라 Criteria API를 사용해서 데이터를 조회할 수 있다. HQL이 SQL에 가까운 쿼리언어를 사용해서 데이터 조회와 관련된 조건을 입력했면, Criteria API는 Criteria가 제공하는 메소드를 사용해서 데이터 조회와 관련된 조건을 입력한다. 즉, Criteria API는 좀더 객체 지향적인 형태로 검색 조건을 명시할 수 있도록 해 준다.

Criteria 기본 사용 형태

Criteria API는 net.sf.hibernate.Criteria 인터페이스를 사용해서 검색 조건을 생성하는데, 다음과 같이 Session.createcriteria() 메소드를 사용해서 기본 검색 조건을 갖는 Criteria 인스턴스를 생성할 수 있다.

    Criteria crit = session.createCriteria(Member.class);
    List list = crit.list();

위 코드에서 눈여겨 볼 부분은 createCriteria() 메소드의 인자로 매핑 설정 파일에서 명시한 자바 클래스가 온다는 것이다. 위 코드는 다음과 같은 HQL을 이용한 코드와 동일한 결과를 리턴하게 된다.

    Query query = session.createQuery("from Member");
    List list = query.list();

조건 넣기

HQL과 마찬가지로 검색 조건을 지정하지 않으면 전체 행을 읽어오는데, 대부분의 경우는 검색 조건을 넣기를 원할 것이다. 검색 조건을 추가할 때에는 net.sf.hibernate.expression.Expression 클래스와 net.sf.hibernate.Criterion 인터페이스를 사용한다.

Criteria.add(Criterion crit) 메소드는 Criterion이 저장하고 있는 내용을 검색 조건에 추가하는데, Expression 클래스가 제공하는 메소드를 사용해서 손쉽게 Criterion 인스턴스를 생성할 수 있다. 예를 들어, id가 10 인 Item을 검색하고 싶다면 다음과 같이 Expression.eq() 메소드를 사용해서 Criterion을 추가할 수 있다.

    Criteria crit = session.createCriteria(Item.class);
    crit.add( Expression.eq("id", new Integer(10) );
    List list = crit.list();

Expression 클래스는 다양한 조건을 처리할 수 있는 메소드를 제공하고 있으며, 이들 메소드 중에서 가장 기본적인 메소드는 다음과 같다.

Expression의 기본 조건 관련 Criterion 생성 메소드
메소드 설명
SimpleExpression eq(String propertyName, Object value) 프로퍼티의 값이 value와 같은지 검사하는 조건을 생성한다.
Criterion eqProperty(String propertyName, String otherPropertyName) 두 프로퍼티의 값이 같은지 검사하는 조건을 생성한다.
Criterion between(String propertyName, Object lo, Object hi) 프로퍼티가 두 값 사이에 존재하는 지 검사하는 조건을 생성한다.
SimpleExpression ge(String propertyName, Object value) 프로퍼티의 값이 value보다 크거나 같은 지 검사하는 조건을 생성한다. ( >= 연산)
SimpleExpression gt(String propertyName, Object value) 프로퍼티의 값이 value보다 큰지 검사하는 조건을 생성한다.
SimpleExpression lt(String propertyName, Object value) 프로퍼티의 값이 value보다 작은지 검사하는 조건을 생성한다.
Criterion ltProperty(String propertyName, String otherPropertyName) 프로퍼티 값이 다른 프로퍼티 값보다 작은 지 검사하는 조건을 생성한다.
SimpleExpression le(String propertyName, Object value) 프로퍼티 값이 value보다 작거나 같은 지 검사하는 조건을 생성한다.
Criterion leProperty(String propertyName, String otherPropertyName) 프로퍼티 값이 다른 프로퍼티 값보다 작거나 같은 지 검사하는 조건을 생성한다.
Criterion in(String propertyName, Collection values) 프로퍼티 값이 values 목록에 포함되는 지 검사하는 조건을 생성한다.
Criterion in(String propertyName, Object[] values) 프로퍼티 값이 values 목록에 포함되는 지 검사하는 조건을 생성한다.
SimpleExpression like(String propertyName, Object value) like 검색 조건을 생성한다.
SimpleExpression like(String propertyName, String value, MatchMode matchMode) like 검색 조건을 생성한다.
Criterion ilike(String propertyName, Object value) 대소문자를 구분하지 않는 (Postgres의 ilike와 같은) 검색 조건을 생성한다.
Criterion ilike(String propertyName, String value, MatchMode matchMode) 대소문자를 구분하지 않는 (Postgres의 ilike와 같은) 검색 조건을 생성한다.
Criterion isNotNull(String propertyName) 프로퍼티 값이 null이 아닌지 검사하는 조건을 생성한다.
Criterion isNull(String propertyName) 프로퍼티 값이 null인지 검사하는 조건을 생성한다.
Criterion allEq(Map propertyNameValues) map의 키를 프로퍼티 이름으로 값을 비교할 값으로 사용해서, map에 저장된 모든 프로퍼티의 값이 관련 키의 값과 같은 지 검사하는 조건을 생성한다.

여러 개의 검색 조건을 추가할 때에는 다음과 같이 두 가지 방법중의 한가지를 사용하면 된다.

    Criteria crit = session.createCriteria(Item.class);
    crit.add( Expression.gt("minValue", new Integer(5000) );
    crit.add( Expression.eq("user", someUser) );
    
    // 또는 다음과 같이 연속된 방법을 조건 생성 가능
    Criteria crit = session.createCriteria(Item.class)
                           .add( Expression.gt("minValue", new Integer(5000) )
                           .add( Expression.eq("user", someUser) );

StringBuffer.append() 메소드와 마찬가지로 Criteria.add() 메소드는 Criteria 자기 자신을 리턴하기 때문에 위 코드의 두번째 방법과 같이 코드를 생성할 수 있다. (SimpleExpressoin 타입은 Criteria 인터페이스를 구현하고 있으므로, SimpleExpressoin 타입 역시 연속해서 add() 메소드를 사용할 수 있다.)

like() 메소드와 ilike() 메소드를 보면 net.sf.hibernate.expression.MatchMode 클래스를 사용하는 것을 알 수 있는데, MatchMode 클래스는 like 검색을 어떻게 할지를 결정한다. MatchMode는 다음과 같이 네 개의 상수값을 제공하고 있으며, 이들 네 가지 상수값을 통해서 like 검색의 비교 방법을 결정하게 된다.

  • MatchMode.ANYWHERE - like '%값%'의 형태로 검색한다.
  • MatchMode.START - like '값%'의 형태로 검색한다.
  • MatchMode.END - like '%값'의 형태로 검색한다.
  • MatchMode.MATCH - like '값'의 형태로 검색한다.
기본적으로 Criteria.add() 메소드는 추가된 조건들을 AND 로 연결한다. 하지만, OR 연산이 필요한 경우도 있고, AND와 OR를 함께 사용해야 하는 경우도 있다. 이런 경우에는 아래의 메소드를 사용하면 된다.

Expression의 기본 조건 관련 Criterion 생성 메소드
메소드 설명
Criterion or(Criterion lhs, Criterion rhs) 두 조건을 OR로 처리한다.
Criterion and(Criterion lhs, Criterion rhs) 두 조건을 AND로 처리한다.
Conjunction conjunction() conjunction() 메소드가 생성한 Conjunction의 add() 메소드로 추가한 조건을 AND로 연결한다.
Disjunction disjunction() disjunction() 메소드가 생성한 Disjunction의 add() 메소드로 추가한 조건을 OR로 연결한다.
Criterion not(Criterion expression) 관련 검색 조건(expression)의 not에 해당하는 조건을 생성한다.

위 메소드들의 사용예를 들기 위해 다음과 같은 검색 조건이 있다고 해 보자.

    where (age > 10 and sex = 'F') or (sex = 'M' or age <= 10 or bisexual = 'T')

위와 같은 조건은 아래의 코드를 사용해서 생성할 수 있다.

    Criteria crit = session.createCriteria(Member.class);
    crit.add(
        Expression.or(    /* 중간의 or */
            Expression.and(    /* 좌측의 (age > 10 and sex = 'F') */
                Expression.gt("age", new Integer(10)), Expression.eq("sex", "F")    
            )
            ,
            Expression.disjunction()  /* 우측의 (sex = 'M' or age <= 10 or bisexual = 'T') */
                .add(Expression.eq("sex", "M") )
                .add(Expression.le("age", new Integer(10)) )
                .add(Expression.eq("bisexual", "T"))
        )
    )

결과 순서 처리 및 페이징

Criteria의 addOrder() 메소드를 사용하면 결과의 조회순서를 명시할 수 있다. 예를 들어, name 프로퍼티의 오름차순으로, age의 내림차순으로 정렬하고 싶다면 다음과 같은 코드를 사용하면 된다.

    Criteria crit = session.createCriteria(Member.class);
    crit.addOrder(Order.asc("name"));
    crit.addOrder(Order.desc("age"));

net.sf.hibernate.expression.Order 클래스의 asc() 메소드는 오름차순을, desc() 메소드는 내림차순을 의미한다.

페이징 처리를 위해 사용되는 메소드는 Query 인터페이스와 마찬가지로 setFirstResult() 메소드와 setMaxResults() 메소드를 사용하면 된다.

    Criteria crit = session.createCriteria(Member.class);
    crit.addOrder( Order.asc("name") );
    crit.setFirstResult(30);
    crit.setMaxResults(15);

Criteria의 연관 처리

Criteria.setFetchMode() 메소드를 이용한 연관 객체 조회 모드 지정

연관된 객체를 한번의 쿼리로 읽어오고 싶은 경우에는 setFetchMode() 메소드를 사용할 수 있다. Criteria.setFetchMode() 메소드는 다음과 같이 연관된 프로퍼티를 어떻게 읽어올지를 지정할 수 있도록 해 준다.

    Criteria crit = session.createCriteria(Item.class);
    crit.setFetchMode("bids", FetchMode.EAGER)
        .add( Expression.gt("minValue", new Integer(100) );

net.sf.hibernate.FetchMode 클래스는 setFetcMode() 메소드에 지정할 int 상수값을 정의하고 있으며, 각 상수값은 아래와 같다.

  • FetchMode.DEFAULT - 매핑 설정 파일에 있는 값을 그대로 사용한다.
  • FetchMode.EAGER - 외부 조인을 사용해서 한번의 쿼리로 연관된 객체를 읽어온다. (매핑에서 outer-join="true"로 지정한 것과 같다.)
  • FetchMode.LAZY - lazy 모드로 읽어온다. (매핑에서 outer-join="false"로 지정한 것과 같다.)
중첩된 Criteria.createCriteria() 도는 alias를 이용한 연관 조인 처리

Criteria.createCriteria() 메소드를 사용해서 연관된 객체에 대한 조인 처리를 수행할 수 있다. 다음의 코드를 살펴보자.

    Criteria itemCrit = session.createCriteria(Item.class);
    itemCrit.add( Expression.ge("minValue", new Integer(100)) );
    
    Criteria bidCrit = itemCrit.createCriteria("bids"); // 연관된 객체에 대한 검색 조건 생성
    bidCrit.add( Expression.gt("amount", new Integer(100)) );
    
    List list = itemCrit.list();

alias를 사용해서 조인을 처리할 수도 있는데, alias는 Criteria.createAlias() 메소드를 사용하여 지정한다. 다음은 위 코드를 alias를 사용해서 다시 작성해본 것이다.

    Criteria itemCrit = session.createCriteria(Item.class);
    itemCrit.createAlias("bids", "bid");
    itemCrit.add( Expression.ge("minValue", new Integer(100)) );
    itemCrit.add( Expression.gt("bid.amount", new Integer(100));

Criteria의 데이터 조회 방식

앞서 HQL에서는 조인해서 객체를 가져오는 경우 배열에 저장해서 리턴한 것을 기억할 것이다. 아래 코드는 앞서 살펴봤었던 HQL을 이용한 조인 처리 코드이다.

    Query query = session.
        createQuery("from Item item inner join item.bids");
    
    List list = query.list();
    for (int i = 0 ; i < list.size() ; i++) {
        Object[] object = (Object[])list.get(i);
        Item item = (Item)object[0];
        Bid bid = (Bid)object[1];
        ...
    }

하지만, Criteria는 조인 처리를 하더라도 리턴되는 값을 최초에 Session.createCriteria() 메소드를 사용해서 명시한 객체이다. 예를 들어, 위와 같은 조인을 처리하는 Criteria 코드는 아래와 같다.

    Criteria itemCrit = session.createCriteria(Item.class);
    Criteria bidCrit = itemCrit.createCriteria("bids");
    
    List list = itemCrit.list();
    for (int i = 0 ; i < list.size() ; i++) {
        Item item = (Item)list.get(i);
        ...
    }

만약 연관된 객체를 동시에 읽고 싶다면, 다음과 같이 Criteria.returnMaps() 메소드를 호출해서 한 행과 관련된 Item과 Bid 객체를 Map에 저장할 수 있다.

    Criteria itemCrit = session.createCriteria(Item.class);
    itemCrit.createAlias("bids", "bid");
    itemCrit.add( Expression.gt("bid.amount", new Integer(100)) );
    
    List list = itemCrit.returnMap().list();
    for (int i = 0 ; i < list.size() ; i++) {
        Map map = (Map)list.get(i);
        Item item = (Item)map.get("this");
        Bid bid = (Bid)map.get("bid");
        ...
    }

관련링크:
Posted by 최범균 madvirus

댓글을 달아 주세요

Hibernate에서 퍼스시턴트 객체를 이용한 CRUD 처리 및 퍼시스턴트 생명주기, 객체로딩전략, 영속성 전이에 대해서 살펴본다.

퍼시스턴트 객체의 영속성 생명주기

Hibernate의 퍼시스턴트 객체는 영속성과 관련해서 아래 그림과 같은 세 가지 상태를 갖는다.


위 그림에서 모서리가 둥근 건 퍼시스턴트 객체의 상태를 나타내며, 메소드는 Hibernate Session이 제공하는 메소드를 의미한다. 각 상태는 퍼시스턴트가 객체가 데이터베이스 테이블과 연결되었느냐에 따라 달라진다.

  • 비영속 상태 - 퍼시스턴트 객체를 처음 만들었을 때의 상태. 데이터베이스 테이블에 관련 데이터가 없으며, 연관된 Session이 없다.
  • 영속 상태 - 현재 활성화된 Session과 연결된 퍼시스턴트 객체. 이 상태의 퍼시스턴트 객체는 고유성을 가지며, 프로퍼티 값의 변경이 Session을 통해 자동으로 데이터베이스에 반영된다.
  • 준영속 상태 - 영속 상태의 퍼시스턴트 객체가 Session과 연결이 끊기면 준영속 상태가 된다. Hibernate의 관리를 받지는 않지만, 영속 데이터를 갖고 있다.
위 상태를 코드에서 표시하면 아래와 같다.


퍼시스턴트 객체가 고유성이 없는 경우(즉, 데이터베이스에 1대 1로 매핑되는 데이터가 존재하지 않는 경우) 비영속 상태에 해당한다. 예를 들어, 위 코드처럼 퍼시스턴트 객체를 새로 생성한 경우에 비영속 상태가 된다.

비영속 상태의 객체를 Session을 통해 저장하면(save() 또는 saveOrUpdate() 등을 사용) 퍼시스턴트 객체는 영속 상태가 된다. 영속 상태의 퍼시스턴트 객체는 활성화된 Session과 관련을 맺는다. 보통 영속 상태가 된다 하더라도 Session의 트랜잭션이 커밋되지 않으면 데이터베이스에 실제로 저장되지는 않는다.

일단, 퍼시스턴트 객체가 영속 상태가 되면 퍼시스턴트 객체의 값 변화는 자동으로 데이터베이스에서 반영된다. (이를 automatic dirty checking)이라 한다. Hibernate Session은 트랜잭션이 끝날 때 Session과 관련 있는 영속 상태 퍼시스턴트 객체의 프로퍼티가 변경되었는 지 확인한 후, 변경된 내용을 데이터베이스와 동기화한다.

Session이 종료되면 Session과 관련된 모든 영속 상태의 퍼스시턴트 객체는 준영속 상태가 된다. 준영속 상태의 퍼시스턴트 객체는 데이터베이스와 연결되어 있지 않기 때문에 프로퍼티 값을 변경하더라도 그 내역이 데이터베이스에 반영되지는 않는다. 준영속 상태의 퍼시스턴트 객체는 나중에 다시 다른 Session과 연결될 수 있으며, Session과 연결되면 다시 영속 상태로 바뀌게 된다. 다음의 코드는 준영속 상태로 된 객체가 다시 영속 상태로 변경되는 예를 보여주고 있다.

    Session session1 = sessions.openSession();
    ...
    Book book = (Book)session1.get(Book.class, new Integer(1)); // 영속 상태
    ...
    session1.close(); // 이 시점에서 book은 준영속 상태로 변경
    
    ...
    
    Session session2 = sessions.openSession();
    ...
    session2.update(book); // 이 시점에서 다시 영속 상태로 변경
    ...
    session2.close();

준영속 객체의 활용

준영속 객체는 Session과 연결되어 있지는 않지만 테이블의 값을 저장하고 있기 때문에, 데이터를 보여줄 때 유용하게 사용할 수 있다. 보통 MVC 패턴에 기반한 프로젝트인 경우 다음과 같은 방식으로 준영속 객체를 사용한다.

  • 컨트롤러는 Hibernate를 사용하여 데이터베이스로부터 데이터를 읽어온다.
  • 컨트롤러는 읽어온 퍼시스턴트 객체를 준영속 객체로 변환한다. (보통, Session을 종료)
  • 컨트롤러는 준영속 객체를 뷰에 전달한다.
  • 뷰는 준영속 객체를 사용해서 데이터를 출력한다.
뷰에서는 일반 자바빈 객체를 사용해서 데이터를 출력하듯이 준영속 객체를 사용해서 데이터를 출력하면 된다.

또한 준영속 객체는 다시 영속 객체로 전환될 수 있기 때문에, 여러 단계에 걸쳐서 데이터를 수정한 후 DB에 반영하는 방식에서도 잘 적용될 수 있다. 예를 들어, 웹 어플리케이션인 경우 세션에 준영속 객체를 저장한 뒤 여러번에 걸쳐서 객체의 데이터를 수정한다. 그리고 마지막 과정에서 세션에 저장했던 준영속 객체를 읽어와 영속 객체로 전환한 뒤 변경 결과를 반영하면 된다.

Session이 제공하는 CRUD 처리 메소드

Hibernate를 사용하는 가장 큰 이유는 SQL 쿼리를 작성하지 않고도 Hibernate가 제공하는 Session의 메소드를 사용해서 간단한 코드로 CRUD 작업을 처리할 수 있기 때문이다. Session은 CRUD 작업을 처리할 수 있는 메소드를 제공하는데, 이들 메소드는 다음과 같다.

  • save(Object obj) - 새로운 객체를 (테이블에) 저장한다.
  • save(Object obj, Serializable id) - 새로운 객체를 (테이블에) 저장한다. 이때 식별값으로 두번째 인자로 전달받은 객체를 사용한다.
  • Object get(Class type, Serializable id) - 지정한 타입의 객체를 읽어온다. 두번째 인자는 객체를 읽어올 때 사용할 식별자이다.
  • Object load(Class type, Serializable id) - 지정한 타입의 객체를 읽어온다. 두번째 인자는 객체를 읽어올 때 사용할 식별자이다.
  • load(Object obj, Serializable id) - obj의 타입과 관련된 데이터를 읽어와 obj에 저장한다. 두번째 인자는 객체를 읽어올 때 사용할 식별자이다.
  • update(Object obj) - 객체의 값을 변경한다.
  • update(Object obj, Serializable id) - 지정한 식별자에 해당하는 테이블 행을 객체가 저장한 값으로 변경한다.
  • saveOrUpdate(Object obj) - 새로운 객체인 경우 (테이블에) 저장하고, 이미 존재하는 객체인 경우 (테이블의) 값을 새로운 값으로 변경한다.
  • delete(Object obj) - 객체를 (테이블에서) 삭제한다.
객체를 읽어오는 메소드가 get과 load 두가지가 있는데, 이 두 메소드는 다음과 같은 차이가 있다.

  • get : 읽어올 객체가 없는 경우 null을 리턴하며, 프록시 객체를 리턴하지 않는다.
  • load : 읽어올 객체가 없는 경우 예외를 발생하며, 프록시 객체를 리턴할 수 있다.
load() 메소드는 읽어올 객체가 존재하지 않는 경우 예외를 발생하기 때문에, 존재해야 하는 데이터가 없는 경우를 예외상황으로 처리하고 싶을 때 load() 메소드를 사용하면 된다. 그렇지 않고 단지 객체가 존재하는지의 여부를 판단할 필요만 있는 거라면 get() 메소드를 사용해서 리턴된 값이 null인지의 여부를 검사하는 편이 낫다.

객체를 변경하는 방법은 크게 두가지가 있는데 하나는 Session의 트랜잭션 범위에서 영속 상태의 객체의 프로퍼티를 변경하는 것이며, 두번째 방법은 준영속 상태의 개체를 변경한 뒤 Session과 연관시키는 것이다. 다음은 두 방식의 차이점을 코드로 보여준다.

    Session session1 = sessions.openSession();
    Transaction tx1 = session1.beginTransaction();
    
    Item item = (Item)session1.get(Item.class, new Integer(6));
    item.setTitle(newTitle); // 영속 상태의 객체 프로퍼티 값 변경    
    tx1.commit(); // update() 메소드를 호출하지 않아도 영속 상태 객체의 변경 내용이 적용
    session1.close();
    
    item.setLowPrice(1000); // 준영속 상태의 객체 프로퍼티 값을 변경
    
    Session session2 = sessions.openSession();
    Transaction tx2 = session1.beginTransaction();
    
    session2.update(item); // 준영속 상태를 영속 상태로 변경
    
    tx2.commit();
    session2.close();

객체를 삭제할 때에는 다음과 같이 get()이나 load()로 읽어온 뒤 delete() 메소드를 호출하면 된다.

    Session session = sessions.openSession();
    Transaction tx = session1.beginTransaction();
    
    Item item = (Item)session.get(Item.class, new Integer(6));
    session.delete(item);
    
    tx.commit();
    session.close();

이외에 CRUD를 처리하는 방법으로는 iterate(), update(), delete() 메소드에 쿼리를 전달하는 방식도 있고, Criteria를 사용해서 조건에 따라 조회하는 방법도 있는데 이에 대한 내용은 본 글에서는 다루지 않으며, 시리즈가 진행되는 동안에 살펴볼 것이다.

객체 로딩 전략, 프록시와 외부조인

도메인 영역의 객체는 서로 연관되어 있으며, Hibernate는 이런 연관 관계를 알맞게 처리해준다. 예를 들어, 지난 번 글에서 예제로 사용했었던 Item과 Bid의 관계를 다시 살펴보자.

      <class name="Item" table="ITEM">
            ...
            <set name="bids" inverse="true" cascade="all">
                  <key column="ITEM_ID" />
                  <one-to-many class="Bid" />
            </set>
      </class>

      <class name="Bid" table="BID">
            ...
            
            <many-to-one
                         name="item"
                         column="ITEM_ID"
                         class="Item"
                         not-null="true" />
            ...
      </class>

위 매핑 설정에서 알 수 있듯이 하나의 Item은 여러개의 Bid를 갖고 있으며 별도의 설정을 하지 않는 이상 Item을 읽어오면 Item과 관련된 모든 Bid 객체를 읽어오게 된다. 하지만, 경우에 따라서는 Item 객체만 필요하고 Item과 관련된 Bid 객체는 필요하지 않은 경우가 있으며, 이 경우 아래와 같은 코드를 실행할 때 Bid는 읽어오지 않길 원할 것이다.

    Session session = ...;
    ..
    Item item = (Item)session.get(Item.class, id); // 관련 Bid는 읽어오지 않길 원할 때가 있다
    ..
    session.close();

반대로 Bid 객체만 필요하고 Bid와 관련된 Item 객체는 필요하지 않은 경우가 있을 수 있다. 이렇게 연관된 객체를 읽어오지 않고 싶은 경우가 있을 수 있고, 반대로 늘 관련 객체를 함께 읽어오길 원하는 경우도 있을 수 있다. 이렇게 상황에 따라 데이터를 조회하는 네 가지 방식을 사용할 수 있는데, 이 네 가지 방식은 다음과 같다.

  • 즉시 읽어오기 방식 - 연관된 객체를 모두 읽어온다. 만약 one-to-one으로 연관되었을 경우, 연관된 객체를 읽어오기 위해 데이터베이스 조회가 발생한다.
  • 실제 사용할 때 읽어오기(lazy) 방식 - 실제로 연관된 객체가 사용될 때, 데이터베이스 조회가 발생한다. 예를 들어, Bid 객체를 읽어왔을 때, Bid.getItem() 메소드가 호출될 때 Item 객체를 읽어오기 위해 데이터베이스 조회가 발생한다.
  • 조인 읽어오기(outer-join) 방식 - 외부 조인을 수행하는 SQL 쿼리를 사용하여 연관된 객체를 모두 읽어온다. 즉시 읽어오기 방식이 연관 객체를 읽어오기 위해 여러번의 데이터베이스 조회가 발생하는 것과 달리 한번의 조회만 발생한다.
Hibernate는 위의 접근 방식을 매핑 파일에 속성을 사용해서 설정할 수 있도록 하고 있는데, 본 글에서는 실제 사용할 때 읽어오는 lazy 방식과 조인해서 읽어오는 outer-join 방식을 살펴보겠다. (참고로, lazy 방식과 outer-join 방식 중 아무것도 사용하지 않으면 즉시 읽어오는 방식을 사용한다.)

lazy 방식(프록시)

실제로 사용할 때 연관 객체를 읽어오는 걸, lazy 방식이라고 한다. Hibernate는 lazy 방식으로 연관 객체를 읽어올 때 다음과 같이 프록시 객체를 사용한다.


lazy 방식으로 지정된 경우, Hibernate는 위 그림에서 볼 수 있듯이 연관된 객체를 곧바로 읽어오지 않는다. 대신 연관된 객체와 연결될 수 있는 프록시 객체를 생성한다. 연관된 객체가 필요할 때 실제 연관될 객체가 생성되서 프록시와 연결된다.

many-to-one 관계에서 lazy 방식을 적용하기 위해서는 다음과 같이 연관될 클래스에 대한 정보를 담고 있는 class 태그의 lazy 속성값을 true로 지정해주어야 한다. (Bid-Item의 관계가 many-to-one)

      <class name="Item" table="ITEM" lazy="true">
            ...
      </class>

      <class name="Bid" table="BID">
            ...
            
            <many-to-one
                         name="item"
                         column="ITEM_ID"
                         class="Item"
                         not-null="true" />
            ...
      </class>

위와 같이 lazy 속성을 true로 지정하게 되면 Hibernate는 Item 클래스를 위한 프록시 클래스를 자동으로 생성해서 프록시로 사용한다.

one-to-one 관계에서도 마찬가지로 lazy 속성을 사용해서 lazy 방식을 적용할 수 있다. 예를 들어, 아래와 같이 one-to-one 관계를 맺을 때, 양쪽 모두 lazy 방식으로 읽어오도록 설정할 수 있다.

      <class name="Item" table="ITEM" lazy="true">
            ...
            <one-to-one name="detail"
                        class="ItemDetail" 
                        cascade="save-update" />            
            ...
            
      </class>

      <class name="ItemDetail" table="ITEM_DETAIL" lazy="true">
            ...
            <one-to-one name="item"
                        class="Item"
                        constrained="true" />
      </class>

콜렉션을 읽어올 때에도 lazy 방식을 사용할 수 있다. 예를 들어, set 태그에 다음과 같이 lazy 속성을 추가함으로써 lazy 방식으로 콜렉션을 읽어오도록 명시할 수 있다.

    <class name="javacan.hibernate.test.Item" table="ITEM" .. >
        ...

        <set name="bids" inverse="true" cascade="all-delete-orphan" lazy="true">
            <key column="ITEM_ID" />
            <one-to-many class="javacan.hibernate.test.Bid" />
        </set>
    </class>

lazy 방식을 사용할 때 주의할 점은 객체가 영속 상태일 때에만, 즉 Session과 연결되어 있는 경우에만 lazy 방식으로 데이터를 읽어올 수 있다는 것이다. 예를 들어, 아래의 코드처럼 lazy 방식으로 읽어온 프로퍼티를 준영속 상태에서 읽어올 수 없으며, 이런 경우 예외가 발생하게 된다.

      Session session = sessions.openSession();
      Transaction tx = session.beginTransaction();
      
      // Item의 bids 프로퍼티와 관련 객체를 lazy 방식으로 로딩
      Item item = (Item)session.get(Item.class, someId); 
      
      tx.commit();
      session.close();
      
      // 준영속 상태에서 lazy 방식의 프로퍼티에 접근 -> 예외 발생
      Iterator iter = item.getBids().iterator();

따라서, lazy 방식으로 읽어온 프로퍼티를 준영속 상태에서 사용해야 하는 경우에는 사전에 미리 lazy 방식으로 읽어온 프로퍼티를 초기화해야 한다. 이럴 때 사용할 수 있는 메소드가 Hibernate.initialize()이다. 위와 같은 경우 다음과 같이 Session을 종료하기 전에 Hibernate.initialize() 메소드를 호출해주면 된다.

      Session session = sessions.openSession();
      Transaction tx = session.beginTransaction();
      
      // Item의 bids 프로퍼티와 관련 객체를 lazy 방식으로 로딩
      Item item = (Item)session.get(Item.class, someId); 
      Hibernate.initialize(item.getBids());      
      tx.commit();
      session.close();
      
      // 사전에 초기화 되었으므로 예외 발생안함
      Iterator iter = item.getBids().iter();

outer-join 속성을 사용한 연관 객체 로딩

lazy 방식은 연관된 객체가 실제로 사용되기 전까지 최대한 늦게 객체를 로딩하는 반면에 outer-join 방식은 최대한 빨리 연관된 객체를 로딩한다. outer-join 방식은 외부 조인을 사용해서 한번의 SQL 쿼리로 연관 객체와 관련된 모든 데이터를 읽어오므로 데이터베이스 조회 회수를 줄이면서 동시에 연관 객체를 읽어오게 된다.

outer-join 속성값을 사용해서 outer-join 방식을 설정할 수 있는데, outer-join 속성에 사용할 수 있는 값을 다음과 같이 세가지가 존재한다.

  • auto - 기본값으로서 프록시가 가능한 경우 lazy 방식으로 읽어오고, 그렇지 않은 경우 outer-join 방식으로 읽어온다.
  • true - 프록시가 가능한 경우에도, 항상 outer-join 방식으로 읽어온다.
  • false - 프로시를 사용하지 않더라도, 항상 outer-join 방식을 사용하지 않는다.
예를 들어, Bid 객체를 읽어올 때 many-to-one의 관계에 있는 Item을 항상 outer-join 방식으로 읽어오고 싶다면 다음과 같이 하면 된다.

      <many-to-one name="item" class="Item" outer-join="true">

영속성 전이

이제 영속성 전이에 대해서 살펴보자. 영속성 전이는 영속 상태의 객체와 연관된 비영속 및 준영속 상태의 객체에 자동으로 영속성이 전파되는 특징을 말한다. 예를 들어, 다음의 코드를 보자.

      Bid bid = new Bid();
      ... // bid 프로퍼티들의 값 설정
      
      Session session = sessions.openSession();
      Transaction tx = session.beginTransaction();
      
      Item item = (Item)session.get(Item.class, id);
      item.addBid(bid); // 영속 객체(item)에 비영속 객체(bid)를 연관
      
      tx.commit();
      session.close();

위 코드는 영속 객체인 item에 비영속 객체인 bid를 연관시키고 있다. 이때 Hibernate는 자동으로 비영속 상태인 bid 객체를 영속 상태로 전환하게 된다. (영속 상태로 전환된다는 것은 데이터베이스에 저장된다는 것을 의미한다.) 이렇게 영속 상태의 객체와 연관된 비영속/준영속 객체들이 자동으로 영속 상태가 되는 것을 영속성 전이라고 표현한다.

영속성 전이는 저장 뿐만 아니라 삭제인 경우에도 발생할 수 있다. 예를 들어, 하나의 경매 항목이 삭제되면 그와 관련된 입찰 정보도 삭제될 것이다. 이렇게 영속 상태의 객체가 비영속 상태로 변경될 때 연관된 영속 객체들도 함께 비영속 상태로 변경되는 것 역시 영속성 전이에 해당한다.

Hibernate는 영속성 전이를 연관 객체에 대해 어느 정도까지 적용할 지를 설정하기 위해 cascade 속성을 사용하며, cascade 속성은 다음과 같은 값들을 가질 수 있다.

  • none - 연관을 무시한다.
  • save-update - 트랜잭션이 커밋될 때, save()나 update() 메소드가 호출될 때, 새롭게 생성한 비영속 객체를 영속 객체에 연관할 때, 준영속 객체를 영속 상태로 변경할 때, 영속성 전이를 수행한다.
  • delete - 객체가 delete()에 전달될 때 영속성 전이를 수행해서 연관되어 있는 객체를 삭제한다.
  • all - save-update와 delete 옵션을 함께 수행한다. 또한, evict() 메소드나 lock() 메소드가 실행될 때에도 영속성 전이를 수행한다.
  • all-delete-orphan - all과 같은 기능을 수행한다. 더불어, 연관에서 제거된 퍼시스턴트 객체를 삭제한다. 콜렉션과 관련된 영속성 전이에 사용된다.
예를 들기 위해 먼저 다음의 설정을 보자.

      <class name="javacan.hibernate.test.Item" table="ITEM" lazy="true">
            ...
            <set name="bids" inverse="true" cascade="save-update" >
                  <key column="ITEM_ID" />
                  <one-to-many class="javacan.hibernate.test.Bid" />
            </set>
      </class>
      
      <class name="javacan.hibernate.test.Bid" table="BID">
            
            <many-to-one name="item"
                         column="ITEM_ID"
                         class="javacan.hibernate.test.Item"
                         not-null="false"  />
      </class>
      

위 설정 코드는 Item-Bid를 one-to-many 관계로 하고 있고, Item->Bid로의 영속성 전이를 save-update로 설정하였다. save-update는 영속 객체와 연관된 객체에 영속성이 전이되므로 아래 코드와 같이 새로운 Bid 객체를 생성해서 연관한 경우 새롭게 생성한 Bid 객체가 DB에 저장된다.

      Session session = ...;
      Transaction tx = session.beginTransaction();
      
      Bid bid = new Bid();
      Item item = (Item)session.get(Item.class, id);
      item.addBid(bid);
      
      tx.commit();
      session.close();

하지만, 설정 파일의 set 태그에서 cascade 속성을 none으로 하게 되면 영속성 전이가 수행되지 않으므로, 위 코드에서 새롭게 생성한 Bid 객체는 데이터베이스에 저장되지 않는다.

cascade 속성값이 delete인 경우는 연관된 객체만 삭제한다. 예를 들어, 아래의 코드를 살펴보자.

      Session session1 = session.openSession();
      ...
      Item item1 = (Item)session1.get(Item.class, id);
      session1.delete(item1); // item1과 연관된 ItemDetail도 삭제
      ...
      session1.close();
      
      Session session2 = session.openSession();
      ...
      Item item2 = (Item)session2.get(Item.class, id);
      item2.setDetail(null); // item1과 연관됐었던 ItemDetail을 연관시키지 않음
      session2.delete(item2); // item1만 삭제되고, 연관됐던 ItemDetail은 삭제되지 않음
      ...
      session2.close();

cascade 속성값이 delete인 경우에는 첫번째와 같이 연관되어 있는 객체는 함께 삭제되나, 두번째와 같이 연관됐었다가 연관되지 않게된 객체의 경우는 삭제되지 않는다.

delete와 달리 all-delete-orphan은 연관됐었던 객체를 연관에서 해제하더라도 삭제된다. 예를 들어, Item과 Bid의 관계를 아래와 같이 설정했다고 해 보자. 아래 코드는 Item-Bid의 one-to-many 관계에서 cascade 속성을 all-delete-orphan으로 설정하고 있다.

      <class name="javacan.hibernate.test.Item" table="ITEM" lazy="true">
            ...
            <set name="bids" inverse="true" cascade="all-delete-orphan" >
                  <key column="ITEM_ID" />
                  <one-to-many class="javacan.hibernate.test.Bid" />
            </set>
      </class>
      
      <class name="javacan.hibernate.test.Bid" table="BID">
            
            <many-to-one name="item"
                         column="ITEM_ID"
                         class="javacan.hibernate.test.Item"
                         not-null="false"  />
      </class>
      

이 상태에서 다음과 같은 코드를 실행했다고 해 보자.

      Session session = HibernateUtil.currentSession();
      tx = session.beginTransaction();
      
      Item item = (Item)session.get(Item.class, new Integer(2));
      item.getBids().clear(); // Set에 있는 모든 객체를 비움
      
      tx.commit();

위 코드는 Item의 bids 프로퍼티인 Set 객체에 저장되어 있던 객체 자체를 삭제하는 게 아니라 단지 Set 객체를 비운 것에 불과하다. 하지만, cascade 속성 값이 all-delete-orphan 이기 때문에, Set에 저장되어 있는 Bid 객체와 매핑된 테이블 데이터도 함께 제거된다.

다음 글에서는

본 글의 예제 코드에서 set 태그를 사용했었는데, Hibernate는 set 태그 이외에 list, map과 같은 다양한 타입의 콜렉션을 지원하고 있다.다음 글에서는 Hibernate가 제공하는 콜렉션에는 어떤 것들이 있으며 어떻게 사용하는 지에 대해서 살펴볼 것이다. 또한 살펴보지 않았던 many-to-many 관계를 Hibernate에서 어떻게 적용할 수 있는 지에 대해서도 살펴볼 것이다.

관련링크:
Posted by 최범균 madvirus

댓글을 달아 주세요

  1. darkhorizon 2009.04.14 13:40 신고  댓글주소  수정/삭제  댓글쓰기

    좋은 글이네요.
    좀 담아가도 될까요?

  2. darkhorizon 2009.04.15 15:16 신고  댓글주소  수정/삭제  댓글쓰기

    네. 감사합니다

Hibernate에서 객체와 테이블사이의 매핑 설정 파일의 기본 작성법, Hibernate 타입, 키값 생성기에 대해서 살펴본다.

ORM 설정 파일 기본 작성법

본 시리즈의 첫번째 퀵스타트에서 봤듯이, ORM 설정 파일은 XML 파일로 저장된다. ORM 설정 파일에 대해서 살펴보기 전에 먼저 본 글에서 예제로 사용할 자바빈 클래스를 살펴보자. 본 글에서 사용할 자바빈 클래스는 간단한 책 정보를 담고 있는 Book 클래스로서 아래와 같다.

package javacan.hibernate.test;

public class Book {
      private Integer id;
      private String title;
      private String author;
      private String publishingCompany;
      private int price;
      
      public String getAuthor() {
            return author;
      }
      public void setAuthor(String author) {
            this.author = author;
      }
      public Integer getId() {
            return id;
      }
      public void setId(Integer id) {
            this.id = id;
      }
      public int getPrice() {
            return price;
      }
      public void setPrice(int price) {
            this.price = price;
      }
      public String getPublishingCompany() {
            return publishingCompany;
      }
      public void setPublishingCompany(String publishingCompany) {
            this.publishingCompany = publishingCompany;
      }
      public String getTitle() {
            return title;
      }
      public void setTitle(String title) {
            this.title = title;
      }
}

위의 자바빈 객체와 대응되는 테이블은 아래와 같다.

BOOK 테이블
컬럼 타입 NULL 여부
BOOK_ID INTEGER false PK
TITLE VARCHAR(100) false  
AUTHOR VARCHAR(100) false  
PUBLISHING VARCHAR(100) false  
PRICE INTEGER false  

오라클을 사용한다면 테이블 생성 스크립트는 아래와 같을 것이다.

create table BOOK (
         BOOK_ID INTEGER NOT NULL,
         TITLE VARCHAR2(100) NOT NULL,
         AUTHOR VARCHAR2(100) NOT NULL,
         PUBLISHING VARCHAR2(100) NOT NULL,
         PRICE INTEGER NOT NULL,
CONSTRAINT PK_BOOK PRIMARY KEY (BOOK_ID)
)

또한, 본 글에서는 오라클을 기준으로 BOOK_ID 컬럼에 삽입될 값을 오라클 시퀀스로부터 가져오도록 예제를 설정할 것이며, 이때 사용할 시퀀스는 아래와 같은 스크립트를 이용해서 생성해주면 된다.

CREATE SEQUENCE BOOK_ID_SEQ
      START WITH 0
      INCREMENT BY 1
      MINVALUE 0
NOCACHE NOCYCLE NOORDER

앞서 생성한 Book 클래스와 BOOK 테이블 사이의 매핑을 처리해주는 매핑 설정 파일은 아래와 같이 작성할 수 있을 것이다.

<?xml version="1.0" encoding="euc-kr" ?>

<!DOCTYPE hibernate-mapping PUBLIC
      "-//Hibernate/Hibernate Mapping DTD//EN"
      "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">

<hibernate-mapping>
      <class name="javacan.hibernate.test.Book" table="BOOK">
            <id name="id" type="integer" unsaved-value="null">
                  <column name="BOOK_ID" sql-type="INTEGER" not-null="true" />
                  <generator class="sequence">
                        <param name="sequence">BOOK_ID_SEQ</param>
                  </generator>
            </id>
            
            <property name="title" type="string">
                  <column name="TITLE" length="100" not-null="true" />
            </property>
            
            <property name="author" />
            
            <property name="publishingCompany" column="PUBLISHING" />
            
            <property name="price" type="integer" />
      </class>
</hibernate-mapping>

위 매핑 설정 파일은 가장 간단한 1대1로 이뤄진 객체-테이블 매핑을 보여주는 가장 간단한 형태의 매핑 설정 파일의 예이다. OR 매핑을 설정하는 가장 기본적인 형태이므로 Hibernate를 사용할 때 반드시 숙지해야 하는 코드이기도 하다.

위 코드에서 사용된 각 태그는 다음과 같은 의미를 지닌다.

  • hibernate-mapping : OR 매핑 정보를 담고 있는 XML의 루트 태그
  • class : OR 매핑에서 사용되는 자바 클래스에 대한 정보를 표시
  • id : 테이블의 PK 컬럼을 저장할 자바빈 프로퍼티에 대한 정보를 표시
  • property : 테이블의 컬럼과 매핑될 자바빈 프로퍼티에 대한 정보를 표시
  • column : 자바빈 프로퍼티와 매핑되는 테이블의 컬럼에 대한 정보를 표시
  • generator : 테이블에 객체를 저장할 때 사용되는 키 값 생성기
위 태그 외에도 다양한 태그가 존재하는데, 이들 태그에 대해서는 이 글의 뒷 부분에서 살펴볼 것이며, 일단 위 예제 코드에서 사용된 태그들에 대해서 차례대로 살펴보도록 하자.

<hibernate-mapping> 태그

hibernate-mapping 태그는 Hibernate가 사용하는 OR 매핑 설정 XML 파일의 루트 태그로서 XML 문서가 Hibernate 매핑 문서임을 나타낸다. 앞서 예제 OR 매핑 파일에서 볼 수 있듯이, hibernate-mapping 태그는 필수 속성을 갖고 있지 않다. hibernate-mapping 태그에서 옵션으로 사용할 수 있는 속성은 아래와 같이 네 개가 존재한다.

속성 설명
schema 데이터베이스 스키마의 이름을 명시한다.
default-cascade 기본적으로 사용할 케스케이딩 전략을 명시한다. 테이블 사이의 연관 관계가 있을 때, 테이블에 자체의 케스케이딩 전략이 없으면 이 속성의 값에서 명시한 전략을 사용한다. 'none'과 'save-update'를 값으로 가질 수 있으며, 기본값은 'none'이다.
auto-import 이 매핑 파일에 있는 클래스 설정 중에서 (패키지 이름을 포함한) 완전한 이름을 명시하지 않은 클래스를QL(Query Language)에서 사용할 수 있는지의 여부를 명시한다. true와 false를 값으로 가지며, 기본값은 true이다.
package 패키지 이름을 포함하지 않은 클래스 이름의 완전한 이름을 유추할 때 사용할 기본 패키지 이름을 명시한다.

schema 속성은 Hibernate가 내부적으로 생성하는 쿼리와 연관되는 데, 예를 들어, schema 속성의 값을 'javacan'이라고 주었다면 아래와 같이 테이블 이름 앞에 데이터베이스 스키마 명이 붙은 쿼리를 내부적으로 사용하게 된다.

   select ... from javacan.tableName ...

<class> 태그

OR 매핑 파일은 다음과 같이 여러 개의 class 태그를 가질 수 있다.

<?xml version="1.0" encoding="euc-kr" ?>

<!DOCTYPE hibernate-mapping PUBLIC
      "-//Hibernate/Hibernate Mapping DTD//EN"
      "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">

<hibernate-mapping>
      <class name="javacan.hibernate.test.Book" table="BOOK">
            ...
      </class>

      <class name="javacan.hibernate.test.PublishingCompany" table="PUBLISHING">
            ...
      </class>
      
</hibernate-mapping>

하나의 class 태그는 기본적으로 하나의 클래스와 하나의 테이블에 대한 매핑 정보를 담는데, class 태그를 사용해서 어떤 클래스가 어떤 테이블과 매핑되는 지에 대한 정보 및 기타 CRUD 처리와 관련된 속성 정보를 명시하게 된다. 가장 기본저인 형태는 아래와 같다.

      <class name="javacan.hibernate.test.Book" table="BOOK">
            ... <!-- 프로퍼티와 컬럼에 대한 매핑 정보 설정 -->
      </class>
      

class 태그의 가장 중요한 속성은 name과 table이다. 이 두 속성은 아래와 같다.

  • name - 퍼스시턴트 클래스의 완전한 자바 클래스(또는 인터페이스) 이름
  • table - 데이터베이스 테이블의 이름
즉, 위 코드는 javacan.hibernate.test.Book 클래스와 BOOK 테이블에 매핑된다는 것을 설정하고 있는 것이다.

이 두 속성 외에 다음 표와 같은 속성을 사용할 수 있다.

속성 설명
schema 테이블을 소유한 스키마를 명시한다.
dynamic-update 런타임에, 값이 변경되는 컬럼에 대해서만 SQL UPDATE 쿼리를 동적으로 생성할지의 여부를 명시한다. true 또는 false를 값으로 갖는다. 기본값은 false이다.
dynamic-insert 런타임에, 값이 null이 아닌 컬럼에 대해서만 SQL INSERT 쿼리를 동적으로 생성할지의 여부를 명시한다. true 또는 false를 값으로 갖는다. 기본값은 false이다.
select-before-update 객체가 실제로 변경되는 것이 아닌 경우 SQL UPDATE 쿼리를 수행하지 않을 지의 여부를 명시한다. 기본값은 false이다. 이 값을 true로 지정할 경우 Hibernate는 Session.update() 메소드를 호출할 때, UPDATE 쿼리를 수행할 필요가 있는 지의 여부를 검사하기 위해 SELECT 쿼리를 수행하게 된다. (성능이 좋지 않으므로 트리거와 같이 DBMS가 지원하는 기능으로 대체하는 것이 좋다.)

이 외에 여러 속성들이 존재하는데, 이들 속성들은 본 시리즈 글을 진행하면서 필요할 때에 추가적으로 설명하겠다.

<id> 태그

DB 테이블로부터 읽어온 데이터를 저장하기 위해서 사용되는 객체는 대부분 PK 값을 저장하기 위해 자바빈 스타일의 프로퍼티를 제공한다. (앞서 작성했던 Book 클래스도 id 프로퍼티를 제공하고 있다.) id 태그는 테이블의 PK 컬럼에 매핑되는 프로퍼티를 명시할 때 사용되며, 구문은 다음과 같다.

      <id name = "프로퍼티이름"
            type = "Hibernate타입"
            column = "테이블컬럼이름"
            unsaved-value = "any|none|null|id_value"
            
            generator class="generatorClass" />
      </id>

각 속성은 다음과 같은 의미를 지닌다.

속성 설명
name 식별자로 사용될 프로퍼티의 이름 (옵션)
type Hibernate 타입 (옵션)
column PK 컬럼의 이름. 입력하지 않은 경우 프로퍼티의 이름을 사용한다. (옵션)
unsaved-value 새로 생성한 객체를 아직 저장하지 않았음을 나타낼 때 사용할 식별자 프로퍼티의 값. Hibernate는 식별자 프로퍼티의 값이 이 속성에 명시한 값과 가을 경우, 객체가 DB 테이블에 저장되어 있지 않은 새롭게 생성된 객체라고 가정한다. 기본값은 null이다. (옵션)

만약 name 속성을 입력하지 않으면 클래스가 식별자 프로퍼티를 갖고 있지 않다고 가정한다. 이 경우 Hibernate는 읽어온 객체를 변경하거나 삭제할 때 사용할 키값을 별도로 관리하게 된다.

<property> 태그와 <column> 태그

property 태그는 PK 컬럼 이외의 컬럼과 매핑되는 프로퍼티에 대한 정보를 명시할 때 사용된다. property 태그의 일반적인 형태는 아래와 같다.

      <class name=".." table="..">
            <id .... > .. </id>
            
            <property name="title" type="string">
                  <column name="TITLE" length="100" not-null="true" />
            </property>            
            <property name="author" column="AUTHOR" />            
            ...
      </class>

첫번째 property 태그는 매핑될 컬럼 정보를 자식 태그인 column 태그에 명시하는 방법을 보여주고 있고, 두번째 property 태그는 컬럼 정보를 속성을 사용해서 명시하는 방법을 보여주고 있다. property 태그의 필수 속성은 name 뿐이며 나머지 속성은 hibernate가 기본값을 적용하여 알맞게 처리해준다. property 태그에서 사용가능한 속성을 다음 표와 같다.

속성 설명
name 프로퍼티의 이름. 첫번째 글자는 소문자이다. (옵션)
column 프로퍼티와 매핑될 테이블의 컬럼 이름. 기본값은 프로퍼티 이름이다. (옵션)
type 타입명을 입력한다. (옵션)
unique UNIQUE 컬럼과 매핑될 경우 true를 입력한다. 기본값은 false. (옵션)
update 매핑될 컬럼이 SQL의 UPDATE 쿼리에 포함될지의 여부를 나타낸다. 기본값은 true. (옵션)
insert 매핑될 컬럼이 SQL의 INSERT 쿼리에 포함될지의 여부를 나타낸다. 기본값은 true. (옵션)
formula 프로퍼티가 계산에 의해서 구해지는 경우, 프로퍼티의 값을 구할 때 사용되는 SQL 수식을 입력. 계산된 값을 갖는 프로퍼티는 매핑되는 컬럼을 갖지 못한다. (옵션)

type 속성은 타입명을 입력하는데, 타입명에는 다음과 같은 값이 올 수 있다.

  1. Hibernate 기본 타입 (예, integer, string, date, binary 등)
  2. Hibernate 기본 타입과 관련된 자바 클래스 이름 (예, int, java.lang.String, java.util.Date, java.sql.Clob)
  3. PersistentEnum의 하위 클래스 이름
  4. 직렬화 가능한 자바 클래스 이름
  5. 커스텀 타입의 클래스 이름
보통은 첫번째와 두번째로 대부분의 경우의 수를 처리할 수 있으며, 필요에 따라 세번째 값이 사용된다. 만약 type 속성의 값을 명시하지 않으면, Hibernate는 리플레션을 사용해서 프로퍼티의 타입을 알아낸 뒤, 그 타입에 따라 알맞은 type 속성의 값을 지정하게 된다.

<component> 태그를 이용한 값 저장

회원 정보는 다음과 같이 자택 주소와 직장 주소를 포함하는 것이 일반적이다.



위 코드에서 주소 자택 주소에 해당하는 필드와 직장 주소에 해당하는 필드는 동일한 구조를 갖고 있다. 따라서 자바에서는 다음과 같이 Address 객체를 사용해서 주소 정보를 담을 수가 있다.

public class Address {
      private String zipCode;
      private String address1;
      private String address2;
      
      public void setZipCode(String zipCode) {
            this.zipCode = zipCode;
      }
      public String getZipCode() {
            return zipCode;
      }
      
      .... // 관련 get/set 메소드
      
}

주소를 Address 클래스를 사용하여 표현할 경우 MEMBER 테이블과 매핑될 Member 클래스는 다음과 같은 코드 형태를 취하게 될 것이다.

public class Member {
      private String id;
      private String name;
      private String homeAddress;
      private String jobAddress;
      
      ....
      
      public void setHomeAddress(Address address) {
            homeAddress = address;
      }
      public Address getHomeAddress() {
            return homeAddress;
      }
      public void setJobAddress(Address address) {
            jobAddress = address;
      }
      public Address getJobAddress() {
            return jobAddress;
      }
}

위 Member 클래스가 의미하는 것은 MEMBER 테이블의 집주소에 해당하는 세 개의 컬럼, 즉 HOME_ZIPCODE, HOME_ADDRESS1, HOME_ADDRESS2가 homeAddress 프로퍼티(즉, Address 객체에) 매핑된다는 것을 의미한다. 이렇게 테이블의 여러 컬럼이 하나의 프로퍼티에 매핑될 때 사용되는 태그가 component 태그이다. MEMBER 테이블과 Member 클래스 사이의 매핑에서 component 태그는 다음과 같이 사용된다.

      <class name="Member" table="MEMBER" >
            <id name="id" column="MEMBER_ID">
                  <generator class="assigned" />
            </id>
            
            <property name="name" />
            
            <component name="homeAddress" class="Address">
                  <property name="zipCode" column="HOME_ZIPCODE" />
                  <property name="address1" column="HOME_ADDRESS1" />
                  <property name="address2" column="HOME_ADDRESS2" />
            </component>
            <component name="jobAddress" class="Address">
                  <property name="zipCode" column="JOB_ZIPCODE" />
                  <property name="address1" column="JOB_ADDRESS1" />
                  <property name="address2" column="JOB_ADDRESS2" />
            </component>
            ...
      </class>

component 태그의 name 속성과 class 속성은 다음과 같다.

  • name - component가 속한 클래스의 프로퍼티 이름.
  • class - 프로퍼티의 자바 클래스 이름
위의 코드에서 첫번째 component 태그는 Member 클래스의 homeAddress 프로퍼티를 나타내므로, name 속성의 값을 "homeAddress"로 주었으며, homeAddress 프로퍼티의 타입이 Addressd 클래스이므로 class 속성의 값을 "Address"로 주었다.

component 태그가 나타내는 자바 클래스와 테이블 사이의 매핑 정보를 처리하기 위해서는 component 태그에 property 태그를 포함시키면 된다. component 태그에 중첩된 property 태그는 class 태그가 나타내는 클래스가 아닌 component 태그가 나타내는 클래스의 프로퍼티와 테이블 사이의 매핑을 표현하게 된다.

Hibernate의 타입

자바 객체의 프로퍼티 타입과 테이블의 컬럼 타입은 정확하게 일치하지 않는다. 예를 들어, 자바의 java.lang.String 타입의 프로퍼티가 SQL의 VARCHAR로 매핑될 수도 있고, CHAR로 매핑될 수도 있다. Hibernate는 이러한 타입의 불일치 문제를 해결하기 위해서 Hibernate 자체적으로 타입을 제공하고 있으며, 이 타입을 사용해서 자바의 타입과 SQL 타입 사이의 매핑 문제를 해결하고 있다.

Hibernate가 제공하는 매핑 타입은 자바의 기본 데이터 타입, 날짜 및 시간 관련 타입, 대량 데이터 관련 타입 등이 존재한다. 이들 타입은 property 태그나 id 태그 등 프로퍼티와 컬럼 사이의 매핑 정보를 표시하는 부분에서 사용되며, 이 타입 정보를 통해 Hibernate는 OR 매핑을 올바르게 처리할 수 있게 된다.

자바 기본 데이터 타입 매핑

자바의 기본 데이터 타입의 매핑을 처리해주는 Hibernate 타입은 다음과 같다.

매핑 타입 자바 타입 SQL 타입
integer int 또는 java.lang.Integer INTEGER
long long 또는 java.lang.Long BIGINT
short short 또는 java.lang.Short SMALLINT
float float 또는 java.lang.Float FLOAT
double double 또는 java.lang.Double DOUBLE
big_decimal java.math.BigDecimal NUMERIC
character java.lang.String CHAR(1)
string java.lang.String VARCHAR
byte byte 또는 java.lang.Byte TINYINT
boolean boolean 또는 java.lang.Boolean BIT
yes_no boolean 또는 java.lang.Boolean CHAR(1) ('Y' 또는 'N')
true_false boolean 또는 java.lang.Boolean CHAR(1) ('T' 또는 'F')

날짜 및 시간 타입 매핑

자바의 날짜 및 시간 타입의 매핑을 처리해주는 Hibernate 타입은 다음과 같다.

매핑 타입 자바 타입 SQL 타입
date java.util.Date 또는 java.sql.Date DATE
time java.util.Time 또는 java.sql.Time TIME
timestamp java.util.Timestamp 또는 java.sql.Timestamp TIMESTAMP
calendar java.util.Calendar TIMESTAMP
calendar_date java.util.Calendar DATE

대량 데이터 관련 매팅 타입

바이너리 데이터와 대량 데이터를 처리할 때 사용되는 Hibernate 타입은 다음과 같다.

매핑 타입 자바 타입 SQL 타입
binary byte[] VARBINARY (또는 BLOB)
text java.lang.String CLOB
serializable java.io.Serializable를 구현한 모든 자바 클래스 VARBINARY (또는 BLOB)
clob java.sql.Clob CLOB
blob java.sql.Blob BLOB

JDBC 드라이버중에 clob이나 blob의 경우는 지원하지 않은 경우도 있으므로, clob과 blob을 사용할 때에는 먼저 JDBC 드라이버가 해당 타입을 지원하는지의 여부부터 확인해야 한다.

키 값 생성기

앞서 예로 들었던 OR 매핑 설정 파일의 일부를 다시 한번 살펴보자.

<hibernate-mapping>
      <class name="javacan.hibernate.test.Book" table="BOOK">
            <id name="id" type="integer" unsaved-value="null">
                  <column name="BOOK_ID" sql-type="INTEGER" not-null="true" />
                  <generator class="sequence">
                        <param name="sequence">BOOK_ID_SEQ</param>
                  </generator>
            </id>
            
            <property name="title" type="string">
                  <column name="TITLE" length="100" not-null="true" />
            </property>
            ...
      </class>
</hibernate-mapping>

위 코드에서 id 태그는 테이블의 PK 컬럼과 매핑을 처리할 때 사용된다고 했으며, 새롭게 생성한 자바 객체를 테이블에 저장할 때 사용할 키값은 generator 태그에서 명시한 클래스를 통해서 생성된다. generator 태그는 키값을 생성할 클래스와 클래스가 사용할 파라미터 값을 전달하는데 사용되며, 보통 다음과 같은 형태를 갖는다.

      <generator class="클래스이름">
            <param name="파라미터이름">파라미터값</param>
            <param name="파라미터이름">파라미터값</param>
      </generator>

클래스 이름에는 net.sf.hibernate.id.IdentifierGenerator 인터페이스를 구현한 클래스의 완전한 이름을 적어주면 된다. Hibernate는 몇가지 형태의 키값 생성기를 기본적으로 제공하고 있으며, 이들 생성기를 짧은 이름을 통해서 사용할 수 있도록 하고 있다. 다음은 Hibernate가 제공하는 기본 키값 생성기의 이름이다.

  • increment : 정수 타입의 키 값을 사용할 경우, 키 값을 1씩 증가시켜 생성한다.
  • identity : 테이블의 식별 컬럼을 지원한다. (예, MySQL의 auto_increment 컬럼)
  • sequence : 시퀀로부터 키 값을 가져온다. (예, 오라클의 시퀀스)
  • hilo / seqhilo : hi/lo 알고리즘을 사용하여 정수값 키값을 생성한다.
  • uuid.string / uuid.hex : UUID 알고리즘을 사용하여 키값을 생성한다.
  • native : DBMS 및 테이블에 알맞은 키값 생성기를 자동 선택한다.
  • assigned : 어플리케이션에 직접 키값을 생성한다.
  • foreign : 연관 객체의 식별자를 키값으로 사용한다. <one-to-one> PK 연관에서 주로 사용된다.
increment 생성기

increment는 DBMS에 상관없이 사용할 수 있는 키값 생성기로서 long, short, int 타입의 식별값을 생성한다. increment 생성기는 파라미터 값을 필요로 하지 않으며, 다음과 같이 사용할 수 있다.

      <id name="id" type="integer" column="BOOK_ID" unsaved-value="null">
            <generator class="increment" />
      </id>

클러스터(cluster)에서는 사용하면 안 된다.

identity 생성기

DB2, MySQL, MS SQL 서버, Sybase 그리고 HypersonicSQL의 식별 컬럼을 지원한다. (예를 들어, MySQL의 auto_increment 컬럼) 리턴된 식별값의 타입은 long, short, int 중 하나이다. increment 생성기와 마찬가지로 파라미터를 필요로 하지 않으며, 다음과 같이 생성기의 이름만 지정해주면 된다.

      <id name="id" type="integer" column="BOOK_ID" unsaved-value="null">
            <generator class="identity" />
      </id>

sequence 생성기

DB2, 오라클, PostgreSQL, SAP DB, McKoi의 시퀀스나 Interbase의 generator를 사용해서 키값을 생성한다. 리턴된 식별자의 타입은 long, short, int 중 하나이다. sequence 생성기는 아래와 같이 sequence 파라미터로부터 사용할 시퀀스의 이름을 전달받는다.

      <id name="id" type="integer" column="BOOK_ID" unsaved-value="null">
            <generator class="sequence">
                  <param name="sequence">BOOK_ID_SEQ</param>
            </generator>
      </id>

hilo / seqhilo 생성기

hilo 생성기는 hi/lo 알고리즘을 사용한다. 알고리즘에서 hi 값을 읽어올 때 사용할 테이블과 컬럼의 이름을 table 파라미터와 column 파라미터로부터 읽어온다. (테이블과 컬럼의 이름을 명시하지 않을 경우 기본값은 테이블 이름은 'hi_value'이고 컬럼 이름은 'next_value'이다.) 또한 hi/lo 알고리즘에서 사용될 값을 max_lo 파라미터로부터 읽어온다. hilo 생성기는 long, short, int 타입의 식별값을 생성한다. 다음은 hilo 생성기의 사용예이다.

      <id name="id" type="integer" column="BOOK_ID" unsaved-value="null">
            <generator class="hilo">
                  <param name="table">HILO_VALUE</param>
                  <param name="column">NEXT_VAL</param>
                  <param name="max_lo">5</param>
            </generator>
      </id>

hilo 생성기를 사용할 때 주의할 점은 테이블이 미리 생성되어 있어야 하며, 테이블이 한개의 레코드가 존재해야 한다는 점이다. 또 다른 주의점은, 데이터베이스 Connection을 세션에 직접 제공하거나 또는 JTA를 사용하기 위해서 어플리케이션 서버가 제공하는 DataSource를 사용하는 경우에는 hilo 생성기를 사용할 수 없다는 점이다.

seqhilo 생성기는 hilo 생성기와 비슷하나 알고리즘에서 사용할 값을 테이블이 아닌 시퀀스로부터 읽어온다는 차이점이 있다. 시퀀스의 이름은 sequence 파라미터로부터 전달받는다. 다음은 seqhilo 생성기의 사용예이다.

      <id name="id" type="integer" column="BOOK_ID" unsaved-value="null">
            <generator class="seqhilo">
                  <param name="sequence">BOOK_ID_SEQ</param>
                  <param name="max_lo">5</param>
            </generator>
      </id>

uuid.string / uuid.hex 생성기

uuid.string 생성기와 uuid.hex 생성기는 128비트 UUID 알고리즘을 사용하여 string 타입의 값을 생성한다. 차이점은 다음과 같다.

  • uuid.string - 16 개의 ASCII 글자로 구성된 식별값을 생성한다. PostgreSQL에서는 사용해서는 안 된다
  • uuid.hex - 32 개의 16진수 숫자로 구성된 식별값을 생성한다.
별도의 파라미터는 없으며 다음과 같이 사용된다.

      <id name="id" type="string" column="CAT_ID" unsaved-value="null">
            <generator class="uuid.string" />
      </id>

native 생성기

native 생성기는 DBMS가 제공하는 기능에 따라 identity, sequence, hilo 생성기를 선택적으로 사용한다.

assigned 생성기

assigned 생성기는 어플리케이션에서 직접 식별값을 입력한다는 것을 의미한다. assigned 생성기를 사용하면 객체를 저장하기 전에(즉, Session.save() 메소드를 호출하기 전에) 식별자에 키값을 입력해주어야 한다.

다음 글에서는

이번 글에서는 테이블과 객체의 매핑에 대해서만 살펴봤는데, 실제로는 객체 사이의 상속 관계와 테이블, 객체 사이의 연관과 테이블 사이의 연관 등 처리해줘야 할 것이 많다. 또한, 여러 컬럼이 PK가 되는 복합키에 대한 처리도 필요하다. 다음 글에서는 이처럼 좀더 복잡한 OR 매핑을 처리하는 방법에 대해서 살펴보도록 하자.

관련링크:
Posted by 최범균 madvirus

댓글을 달아 주세요

Hibernate의 OR 매핑에서 사용될 자바 객체에 대해서 살펴본다.

퍼시스턴트 클래스(Persistent Class) 작성 규칙

도메인 영역의 개체(entity)를 표현하는 데 가장 많이 사용되는 자바 클래스는 자바빈의 형태를 취한다. 대부분의 도메인 영역의 개체는 테이터베이스의 테이블에 지속적으로 저장되며 이렇게 지속적으로 저장되는 데이터를 표현하기 위해 사용되는 클래스를 퍼시스턴트 클래스(Persistent Class)라고 부른다. (영속적 클래스, 지속성 클래스 등의 해석한 용어가 어색해서 그냥 퍼시스턴트 클래스라고 부르겠다.)

퍼시스턴트 클래스를 Hibernate에서 사용가능하게 하려면 다음과 같은 규칙을 따라야 한다.

  • 퍼시스턴트 필드에 대한 접근/수정 메소드를 제공해야 한다.
  • 기본 생성자를 제공해야 한다.
  • ID 프로퍼티를 제공해야 한다. (선택사항)
  • non-final 클래스로 작성하는 것이 좋다. (선택사항)
퍼시스턴트 필드에 대한 접근/수정 메소드

퍼시스턴트 클래스는 DB 테이블에서 읽어온 값을 저장하기 위한 멤버 필드가 정의되어 있다. Hibernate는 퍼시스턴트 클래스의 멤버 필드에 직접 접근하기 보다는, 자바빈 스타일의 메소드를 통해서 멤버 필드에 간접적으로 접근한다. 즉, 자바빈 프로퍼티를 사용해서 DB 테이블의 값을 퍼시스턴트 클래스에 저장해준다.

자바빈 프로퍼티의 명명규칙을 따르기 때문에 set/get/is를 메소드 이름에 붙여서 사용하면 된다. 예를 들어, getId, setId, getName, setName 등의 이름을 사용한다.

기본 생성자를 제공해야 한다.

Hibernate는 Constructor.newInstance()를 사용해서 퍼시스턴트 클래스의 인스턴스를 생성하기 때문에, 인자가 없는 기본 생성자를 제공해야 한다. 예를 들어, 다음과 같이 기본 생성자를 제공하지 않는 클래스는 Hibernate에서 사용할 수 없다.

public class InvalidPersistentClass {

    private String name;
    ...
    
    /* 기본 생성자가 없음!! 아래와 같은 기본 생성자를 추가해주어야 Hibernate에서 사용가능 public InvalidPersistentClass() { } /*    
    public InvalidPersistentClass(String name) {
        ...
    }
    
    public String getName() {
        return name;
    }
    ...
}

자바에서는 어떤 생성자도 제공하지 않으면 기본 생성자를 자동으로 추가해준다. 따라서, 위 코드와 같이 생성자를 포함한 클래스는 기본 생성자를 추가해주어야 Hibernate에 적용할 수 있지만, 아래와 같이 어떤 생성자도 포함하지 않으면 기본 생성자가 자동으로 추가되므로 Hibernate에서 사용할 수 있다.

public class Product {
    private String id;
    private String name;
    
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    ...
}

식별자 프로퍼티를 제공해야 한다. (선택사항)

퍼시스턴트 클래스는 DB 테이블의 Primary Key 필드와 매핑되는 프로퍼티를 제공하는 것이 좋다. 이 프로퍼티의 타입은 기본 데이터 타입일 수도 있고, Integer나 Long과 같은 래퍼 타입일 수도 있고, String이나 Date 같은 일반 자바 객체일 수도 있다. (필드가 여러개로 구성된 복합 키이거나 사용자 정의 타입을 사용할 수도 있는데 이에 대한 대한 내용은 본 시리즈의 4회 글인 OR 매핑 부분에서 살펴볼 것이다.)

식별자 프로퍼티는 선택사항이다. 식별자 프로퍼티를 정의하지 않고, Hibernate가 내부적으로 객체의 ID를 추적하도록 할 수 있다. 하지만, 가급적이면 식별자 프로퍼티를 제공하는 것이 퍼시스턴트 클래스의 좋은 설계 방식이다.

식별자 프로퍼티의 경우 기본 데이터 타입보다는 클래스 타입을 사용하는 것이 좋다. 예를 들어, PK가 정수타입인 경우 다음과 같이 두 가지 형태로 식별자 프로퍼티를 정의할 수 있을 것이다.

public class Some {
    private int id;
    
    public int getId() {
        return id;
    }
    ...
}

public class Any {
    private Integer id;
    
    public Integer getId() {
        return id;
    }
    ...
}

여기서 Some은 값을 DB 테이블에 삽입하기 위해 새로운 객체를 생성하면 자동으로 id 프로퍼티에 0이라는 값이 할당된다. (int 타입의 기본값은 0이다.) 따라서, id 프로퍼티의 값을 올바르게 할당하지 않으면 0 값이 DB 테이블에 삽입될 수도 있다. 하지만, Any의 경우는 새로운 객체를 생성하더라도 id 프로퍼티의 값은 null이다. PK 필드에는 null값이 들어갈 수 없으므로, 실수로 id 프로퍼티의 값을 할당하지 않을 경우 잘못된 값이 DB 테이블에 삽입되는 것이 아니라 에러가 발생하게 된다. 따라서, 식별자 프로퍼티의 경우는 오류 방지를 위해 null 값을 가질 수 있는 타입으로 지정하는 것이 좋다.

non-final 클래스로 작성하는 것이 좋다. (선택사항)

Hibernate는 프록시 기능을 제공하는데, 이 기능을 사용하려면 퍼시스턴트 클래스가 final 클래스가 아니거나, public 메소드를 선언한 인터페이스를 구현해야 한다. final 클래스를 Hibernate에 적용할 수는 있지만, public 메소드를 선언한 인터페이스를 구현하지 않은 final 클래스의 경우 프록시 기능을 사용할 수 없게 된다.

equals()/hashCode() 메소드 오버라이딩 & 라이프사이클 콜백

equals() 메소드와 hashCode() 메소드의 구현

만약 퍼시스턴트 클래스들을 객체들이 섞인다면 equals() 메소드와 hashCode() 메소드를 알맞게 오버라이딩 해 주는 것이 좋다. (예를 들어, 퍼시스턴트 클래스 객체를 Set이나 Map 같은 곳에 저장할 경우)

테이블의 같은 레코드에 매핑된 두 객체가 서로 다른 Session에서 로딩된 경우를 생각해보자. 비록 두 객체가 갖는 값은 같더라도, 기본 equals() 메소드는 == 연산자를 사용해서 두 객체를 비교하기 때문에 두 객체는 서로 다른 객체로 판단된다. 따라서, 값이 같을 때 equals() 메소드가 true를 리턴하도록 하려면 equals() 메소드를 알맞게 구현해주어야 한다.

equals() 메소드를 구현하는 가장 확실한 방법은 객체의 각각의 프로퍼티가 동일한지 비교하는 것이다. 하지만, DB 테이블이 Primary Key 필드(또는 Unique 필드)로 각각의 레코드를 구분하므로, Primary Key 필드(또는 Unique 필드)에 해당하는 프로퍼티만 비교하면 효율적으로 비교를 할 수 있다.

라이프사이클 콜백: Lifecycle 인터페이스

새로운 객체를 DB 테이블에 저장할 때, DB 테이블로부터 데이터를 읽어와 객체에 저장할 때, 값을 변경할 때, DB 테이블에서 데이터를 삭제할 때 별도의 처리가 필요할 때가 있을 것이다. (예를 들어, 객체를 삭제하기 전에 객체에 의존하고 있는 또 다른 객체가 존재할 경우 객체 삭제가 안 되도록 하고 싶은 경우가 있다.)

이렇게 CRUD 작업이 처리될 때 값을 검증한다거나 별도의 처리를 하고 싶을 경우, 퍼시스턴트 클래스는 net.sf.hibernate.Lifecycle 인터페이스를 구현해주어야 한다. Lifecycle 인터페이스는 아래와 같이 네 개의 메소드를 선언하고 있다.

public interface Lifycycle {
    public boolean onSave(Session s) throws CallbackException;
    public boolean onUpdate(Session s) throws CallbackException;
    public boolean onDelete(Session s) throws CallbackException;
    public void onLoad(Session s, Serializable id) throws CallbackException;
}

각 메소드는 아래와 같은 기능을 제공한다.

  • onSave - 객체가 저장되기(삽입되기) 전에 호출된다.
  • onUpdate - 객체의 수정 결과가 테이블에 반영되기 전에(즉, Session.update() 메소드에 객체가 전달될 때) 호출된다.
  • onDelete - 객체가 삭제되기 전에 호출된다.
  • onLoad - 객체를 로딩한 이후에 호출된다.
onSave, onUpdate, onDelete 메소드는 boolean 타입을 리턴하는데, 리턴값에 따라서 다음과 같이 처리된다.

  • true - 작업을 거부한다. 예를 들어, onSave() 메소드가 true를 리턴하면 값이 저장되지 않는다.
  • false - 작업을 수행한다. 예를 들어, onSave() 메소드가 true를 리턴하면 값이 저장된다.
예를 들어, 아래와 같이 퍼시스턴트 클래스를 작성할 수 있을 것이다.

public class Product implements Lifecycle {
    ...
    private int stock; // 재고 개수
    
    ...
    
    public boolean onSave(Session s) throws CallbackException {
        if (stock < 0) return true;
        return false;
    }
    public boolean onUpdate(Session s) throws CallbackException {
        return false;
    }
    public boolean onDelete(Session s) throws CallbackException {
        // 재고가 남아 있는 경우 삭제 불가.
        if (stock > 0) throw CallbackException("stock > 0:" + stock);
    }
    public void onLoad(Session s, Serializable id) throws CallbackException {
    }
}

onSave, onUpdate, onDelete 메소드가 true를 리턴할 경우, 작업을 거부하기 때문에 DB 테이블에 객체값이 반영되지 않는다. 하지만, Hibernate를 사용하는 어플리케이션 코드에서는 DB 테이블에 반영되지 않은 사실을 알지 못한다.

    // Cat이 Lifecycle 인터페이스를 구현했다고 가정
    Product product = ...;
    
    tx = hbSession.beginTransaction();
    hbSession.save(product); // Product.onSave() 메소드가 true를 리턴하더라도 예외는 발생하지 않음
    tx.commit();

만약 Lifecycle 메소드 처리시에 CRUD 작업이 처리되지 않았다는 사실을 어플리케이션 코드가 알아야 한다면 true를 리턴하지 말고 CallbackException을 발생시켜야 한다. 앞서 예로 보여준 Product 클래스의 onDelete() 메소드는 stock 필드 값이 0보다 큰 경우 CallbackException 예외를 발생시키며, 이 경우 아래와 같이 어플리케이션에서 try-catch 블럭을 사용해서 CRUD 작업이 수행되지 않았음을 확인할 수 있게 된다.

    Product product = ...;
    tx = hbSession.beginTransaction();
    try {
        hbSession.delete(product); 
    } catch(CallbackException ex) {
        // onDelete()에서 예외 발생
    }
    tx.commit();

다음 글에서는

본 장에서는 퍼시스턴트 클래스를 작성하는 방법을 살펴봤는데, 퍼시스턴트 클래스의 목적은 DB 테이블과 매핑되어 테이블의 각 레코드를 메모리상에서 표현하는 것이다. 따라서, 퍼시스턴트 클래스와 DB 테이블이 어떻게 서로 연결되는 지에 대한 정보를 표시할 방법이 필요하며 이 방법에 대해서는 다음 글에서 살펴보도록 하겠다.

Posted by 최범균 madvirus

댓글을 달아 주세요

Hibernate API에서 사용될 세션 및 트랜잭션 프로퍼티를 설정하는 방법에 대해서 살펴본다.

Hibernate의 세션 설정 방법 및 프로퍼티 설정 방법

Hibernate API를 사용하는 기본 코드는 아래와 같은 형태를 띄고 있다.

    // 1. 초기화 메소드에서 SessionFactory를 초기화한다.
    Configuration cfg = new Configuration();
    cfg.configure();
    SessionFactory sessionFactory = cfg.buildSessionFactory();
    
    // 2. 실제 메소드에서는 sessionFactory에서 Session을 생성해서 사용한다.
    Session s = sessionFactory.openSession();
    ... // Session을 사용해서 CRUD 실행
    s.close();

코드는 크게

  1. OR 매핑 정보 및 커넥션 프로퍼티 정보를 담고 있는 Configuration을 생성하고, Configuration으로부터 SessionFactory를 생성하는 부분과
  2. SessionFactory로부터 Session을 구해 CRUD 작업을 처리하는 부분
이렇게 두 부분을 구성된다. 첫번째 부분은 Hibernate Session에 대한 어플리케이션의 초기화 과정에서 실행될 것이고, 두번째 부분은 어플리케이션의 로직을 구현하는 과정에서 사용될 것이다. 본 글에서는 첫번째 부분, 즉 OR 매핑 정보 및 커넥션 프로퍼티 정보를 담고 있는 Configuration을 생성하는 방법에 대해서 살펴볼 것이다.

Hibernate Session 생성 방법

Session은 데이터베이스 세션을 의미하는 것으로서, Session이 사용할 데이터베이스 커넥션을 구하는 방법은 다음과 같이 3가지가 존재한다.

  • JNDI로부터 커넥션 DataSource를 받아서 Session에 전달하기
  • Hibernate가 제공하는 커넥션 풀을 사용하기
  • 직접 생성한 커넥션을 Session에 전달하기
JNDI로부터 DataSource를 받거나 Hibernate가 제공하는 커넥션 풀을 사용하는 것이 일반적인 방법이다. 경우에 따라서 직접 커넥션을 생성해서 Hibernate Session에 제공해주어야 하는 경우가 있지만 비추천, 어쩔 수 없는 경우가 아니라면 직접 커넥션을 생성해서 제공하지 않기 바란다.

프로퍼티 정보 명시하기

커넥션 정보는 프로퍼티를 통해서 명시할 수 있는데, 프로퍼티는 4가지 방법으로 지정할 수 있다. Hibernate는 다음의 순서대로 프로퍼티 정보를 읽어온다.

  1. Configuration.setProperties() 메소드에 전달된 java.util.Properties에 저장된 프로퍼티 정보
  2. 클래스패스 루트에 위치한 hibernate.properties 파일에 저장된 프로퍼티 정보
  3. java -Dproperty=value를 사용해서 전달된 시스템 프로퍼티
  4. hibernate.cfg.xml 파일에 <property> 태그로 명시한 프로퍼티 정보
본 시리즈의 첫번째 글인 'Hibernate를 이용한 ORM 1 - 퀵 스타트'에서 사용한 방법은 hibernate.cfg.xml 파일을 사용한 네번째 방법이었다. 필자의 경우는 두번째와 네번째 방법을 선호하는데, 자신만의 설정 시스템에 Hibernate 설정 정보를 담고 싶다면 첫번째 방법을 사용하면 된다.

위의 네 가지 방법 중에서 두번째와 네번째는 파일을 클래스패스 루트에 위치시키면 다음의 코드를 통해서 Hibernate가 설정 파일로부터 프로퍼티를 읽어온다.

    Configuration cfg = new Configuration().configure();
    // 또는 아래와 같이 두줄로 실행
    // Configuration cfg = new Configuration();
    // cfg.configure();

하지만, 첫번째 방법을 사용하고 싶다면 아래와 같이 직접 코드에서 Properties 객체를 생성한 뒤 Configuration 객체에 전달해주어야 한다.

    Properties prop = new Properties();
    prop.setProperty(...);
    ...
    Configuration cfg = new Configuration();
    cfg.setProperties(prop);

네 가지 방법 중 어떤 방법으로 사용하더라도 Hibernate가 사용하는 프로퍼티의 이름과 값의 의미는 동일하므로, 본 글에서는 XML 파일 포맷인 hibernate.cfg.xml 파일에 프로퍼티 정보를 명시하는 방법을 사용해서 커넥션 정보를 명시하는 형태로 예제를 보여줄 것이다.

Sessin 설정 방법: JNDI 설정/커넥션 풀/직접 커넥션 제공

앞서 말했듯이 Hibernate Session이 사용할 데이터베이스 커넥션을 JNDI나 Hibernate의 커넥션 풀로부터 얻어오거나 또는 사용자가 직접 제공한 커넥션을 사용할 수도 있다.

JNDI 설정

Hibernate가 JNDI에 바인딩된 DataSource로부터 데이터베이스 커네션을 구하도록 설정하려면 다음과 같은 프로퍼티를 사용하면 된다.

프로퍼티 이름
hibernate.connection.datasource DataSource의 JNDI 이름
hibernate.jndi.url JNDI 제공자의 URL (옵션)
hibernate.jndi.class JNDI의 InitialContextFactory의 클래스 (옵션)
hibernate.connection.username 데이터베이스 사용자 (옵션)
hibernate.connection.password 데이터베이스 사용자 암호 (옵션)

예를 들어, JNDI에 등록된 DataSource의 이름이 "hibernate" 라면 다음과 같이 connection.datasource 프로퍼티 값을 설정해주면 된다. (위 표에 있는 나머지 프로퍼티들은 대부분의 WAS에서 설정하지 않아도 문제가 되지 않는다.)

    <?xml version="1.0" encoding="euc-kr" ?>
    
    <!DOCTYPE hibernate-configuration
        PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN"
               "http://hibernate.sourceforge.net/hibernate-configuration-2.0.dtd">
    
    <hibernate-configuration>
        <session-factory>
            <property name="connection.datasource">hibernate</property>
            <property name="hibernate.transaction.factory_class">
                net.sf.hibernate.transaction.JTATransactionFactory
            </property>
            <property name="hibernate.trasaction.manager_lookup_class">
                net.sf.hibernate.transaction.WeblogicTransactionManagerLookup
            </property>
            <property name="dialect">net.sf.hibernate.dialect.Oracle9Dialect</property>
            
            <mapping resource="Cat.hbm.xml" />
        </session-factory>
    </hibernate-configuration>

위 프로퍼티에서 DataSource외에 나머지 프로퍼티에 대해서 'SQL Dialect와 트랜잭션 전략 설정' 부분에서 설명할 것이므로 아직까진 신경쓰지 말기 바란다.

간단하게 톰캣의 예를 들어, 데이터 소스 설정 예제를 살펴보도록 하겠다. 참고로, 여기서 보여주는 예제는 지난 1회 글 'Hibernate를 이용한 ORM 1 - 퀵 스타트'에서 사용한 예제에서 설정 파일부분만 변경한 것이다.

먼저 톰캣에 웹 어플리케이션에서 사용할 DataSource에 대한 JNDI 설정을 추가해야 한다. 이 설정은 [톰캣]/conf/server.xml 파일에 추가하면 되며, 아래와 같은 형태의 코드를 사용하면 된다. (톰캣에서 DataSource를 추가하는 방법에 대한 자세한 내용은 톰캣 사이트인 http://jakarta.apache.org/tomcat/을 참고하기 바란다.)

파일 [톰캣]/config/server.xml에 추가할 내용
    <Host ...>
        ...
        <Context path="/hibernate" docBase="hibernate">
            <Resource name="jdbc/hibernate" auth="Container" 
                         scope="Shareable" type="javax.sql.DataSource" />
            <ResourceParams name="jdbc/hibernate">
                <parameter>
                    <name>factory</name>
                    <value>org.apache.commons.dbcp.BasicDataSourceFactory</value>
                </parameter>
                <parameter>
                    <name>url</name>
                    <value>jdbc:oracle:thin:@localhost:1521:ORA</value>
                </parameter>
                <parameter>
                    <name>driverClassName</name>
                    <value>oracle.jdbc.driver.OracleDriver</value>
                </parameter>
                <parameter>
                    <name>username</name>
                    <value>scott</value>
                </parameter>
                <parameter>
                    <name>password</name>
                    <value>tiger</value>
                </parameter>
                <parameter>
                    <name>maxWait</name>
                    <value>3000</value>
                </parameter>
                <parameter>
                    <name>maxIdle</name>
                    <value>100</value>
                </parameter>
                <parameter>
                    <name>maxActive</name>
                    <value>10</value>
                </parameter>
            </ResourceParams>
        </Context>
        
        ...
    </Host>

위 코드에서는 JNDI에 등록될 DataSource의 이름을 "jdbc/hibernate"로 지정하였는데, 이는 실제로 "java:comp/env/" 콘텍스트에 추가되므로 설정한 DataSource의 완전한 JNDI 이름은 "java:comp/env/jdbc/hibernate"가 된다. 따라서, Hibernate의 설정 파일에 아래와 같이 hibernate.connection.datasource 프로퍼티의 값을 주면 된다.

파일경로: [톰캣]/webapps/hibernate/WEB-INF/classes/hibernate.cfg.xml
<?xml version="1.0" encoding="euc-kr" ?>

<!DOCTYPE hibernate-configuration
    PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN"
           "http://hibernate.sourceforge.net/hibernate-configuration-2.0.dtd">

<hibernate-configuration>
    <session-factory>
        <property name="connection.datasource">java:comp/env/jdbc/hibernate</property>
        <property name="dialect">net.sf.hibernate.dialect.Oracle9Dialect</property>
        
        <mapping resource="Cat.hbm.xml" />
    </session-factory>
</hibernate-configuration>

어플리케이션 서버(톰캣)에 DataSource를 JNDI에 등록하고, JNDI를 사용하도록 Hibernate의 프로퍼티를 설정하면 모든 게 완료된다. 소스 코드는 전혀 변경할 필요가 없이 이 두가지만 변경해주면 1회에 작성했던 예제를 실행할 수 있을 것이다.

커넥션 풀 설정

Hibernate는 자체적으로 커넥션 풀 기능을 제공하고 있는데, Hibernate Session이 커넥션 풀로부터 필요한 데이터베이스 커넥션을 구하도록 설정할 수 있다. 기본적인 설정 방법은 다음과 같다.

<?xml version="1.0" encoding="euc-kr" ?>

<!DOCTYPE hibernate-configuration
    PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN"
           "http://hibernate.sourceforge.net/hibernate-configuration-2.0.dtd">

<hibernate-configuration>
    <session-factory>
        <property name="hibernate.connection.driver_class">JDBC 드라이버 클래스</property>
        <property name="hibernate.connection.url">JDBC URL</property>
        <property name="hibernate.connection.username">DB User</property>
        <property name="hibernate.connection.password">DB User Password;/property>
        <property name="hibernate.connection.pool_size">DB User Password;/property>
        
        ...
        
    </session-factory>
</hibernate-configuration>

위의 설정 내용을 보면 알겠지만, Hibernate Session이 Hibernate가 제공하는 커넥션 풀을 사용하도록 설정하려면 다음의 네 가지 기본 프로퍼티를 요구한다.

  • hibernate.connection.driver_class - DB 연결시 사용할 JDBC 드라이버 클래스
  • hibernate.connection.url - JDBC URL
  • hibernate.connection.username - DB 사용자 이름
  • hibernate.connection.password - DB 사용자 암호
  • hibernate.connection.pool_size - 커넥션 풀의 최대 크기 명시. (선택)
위의 프로퍼티를 설정하면 Hibernate는 자체적으로 제공하는 커넥션 풀을 사용하게 된다. 하지만, Hibernate에서 제공하는 커넥션 풀은 그다지 좋지 못하며, Hibernate 레퍼런스 문서를 보면 Hibernate의 배포판과 함께 제공하는 C3P0, DBCP 또는 Proxool 라이브러리를 사용하도록 권고하고 있다. 위의 다섯가지 속성 중에서 hibernate.connection.pool_size 대신에 DBCP, C3P0 또는 Proxool 관련 프로퍼티를 설정하면 Hibernate는 자동으로 이들 라이브러리를 커넥션 풀로 사용한다. 본 글에서는 DBCP에 대한 내용만 살펴보며, 나머지 C3P0와 Proxool에 대해서는 살펴보지 않겠다. C3P0와 Proxool를 설정하기 위한 프로퍼티는 Hibernate 홈페이지 및 각 라이브러리의 홈페이지를 참고하기 바란다.

DBCP 관련 프로퍼티

  • DBCP를 실행하는 데 필요한 jar 파일을 복사한다. 이 파일들은 hibernate 배포판의 lib/ 폴더에 포함되어 있다. 웹 어플리케이션이라면 DBCP 관련 jar 파일들을 WEB-INF/lib 폴더에 복사해주면된다.
    commons-dbcp-1.2.1.jar, commons-collections-2.1.1.jar, commons-pool-1.2.jar
  • DBCP 관련 프로퍼티를 설정한다.
DBCP 관련 프로퍼티에는 다음과 같은 것들이 있다.

프로퍼티 이름
hibernate.dbcp.maxActive 한번에 풀에서 갖다 쓸 수 있는 최대 커넥션 개수
hibernate.dbcp.whenExhaustedAction 풀에서 더이상 가져올 수 있는 커넥션이 없을 때 어떻게 처리할지를 명시한다. 값이 1이면, 풀에서 가져올 커넥션이 생길 때 까지 블럭킹된다. 값이 2이면, 풀은 새로운 커넥션을 생성해서 리턴한다. 값이 0이면, 에러를 발생시킨다. 기본값은 1이다.
hibernate.dbcp.maxWait hibernate.dbcp.whenExhaustedAction 프로퍼티의 값이 1인 경우, 블럭킹될 시간을 1/1000초 단위로 지정한다. 0보다 작으면 무한히 대기한다.
hibernate.dbcp.maxIdle 사용되지 않고 풀에 저장될 수 있는 최대 커넥션 개수
hibernate.dbcp.validationQuery 커넥션을 가져올 때 커넥션의 유효성 여부를 검사할 쿼리를 입력한다. 예를 들어, 오라클인 경우 select count(*) from dual과 같은 쿼리를 사용할 수 있다.
hibernate.dbcp.testOnBorrow true이면 풀에서 커넥션을 가져올 때 커넥션이 유효한지 검사한다.
hibernate.dbcp.testOnReturn true이면 커넥션을 풀에 반환할 때 커넥션이 유효한지 검사한다.

위의 모든 프로퍼티를 지정할 필요는 없으며, hibernate.dbcp. 로 시작하는 프로퍼티가 존재하면 Hibernate는 DBCP를 커넥션 풀 모듈로 사용하게 된다.

커넥션 Session에 직접 전달

앞서 두 가지 방법, 즉 JNDI를 사용하는 방법과 커넥션 풀을 사용하는 방법은 Hibernate의 프로퍼티로 설정할 수 있었다. 그런데 부득이한 이유로 JNDI나 커넥션 풀을 사용할 수 없는 경우도 있을 것이다. 예를 들어, 기존 커넥션 관련 모듈이 있어서 Hibernate도 이 모듈에서 제공하는 커넥션을 사용해야 하는 경우가 발생할 수 있다.

이런 경우에는 커넥션 관련된 Hibernate 프로퍼티에서 설정할 값이 없으며, 다음과 같이 SessionFactory.openSession(Connection conn) 메소드를 호출해서 Session 객체를 생성하면 된다.

    SessionFactory sessionFactory = ....;
    
    Connectoin conn = ...;
    
    Session session = sessionFactory.openSession(conn);
    ...
    session.close();
    conn.close();

직접 커넥션을 Session에 전달할 때 주의할 점은, 하나의 JDBC 커넥션에 대해서 동시에 두 개의 열린 Session을 생성해서는 안 된다는 점이다. 즉, 다음과 같은 코드를 작성하지 않도록 주의해야 한다.

    Connectoin conn = ...;
    
    Session session1 = sessionFactory.openSession(conn);
    Session session2 = sessionFactory.openSession(conn); // 같은 커넥션으로 Session 생성
    ...
    session1.close();
    session2.close();
    ...
    
    conn.close();

SQL Dialect와 트랜잭션 속성/처리 클래스 설정

Hibernate는 DBMS에 따라서 최적화된 기능을 제공할 수 있으며, 또한 사용할 어플리케이션 서버에 알맞은 트랜잭션 기능을 제공할 수 있다. DBMS에 최적화된 기능을 제공하기 위해 사용되는 것이 SQL Dialect이며, hibernate.trasaction.manager_lookup_class 프로퍼티를 통해서 트랜잭션 처리 클래스를 설정할 수 있다.

SQL Dialect

Hibernate는 특정 DBMS가 제공하는 기능을 사용할 수 있는 기능을 제공하며, Dialect 프로퍼티를 사용해서 이 기능을 사용할 수 있다. 예를 들어, Hibernate는 오라클를 사용할 때는 오라클에 최적화되도록 기능을 수행하며 MySQL을 사용하는 경우에는 MySQL에 최적화되도록 기능을 수행할 수 있다. 예를 들어, 오라클에 알맞은 Dialect를 설정하면, Hibernate는 시퀀스와 같이 DBMS에 특징적인 기능을 개발자가 직접 코딩하지 않고도 사용할 수 있게 된다.

hibernate.dialect 프로퍼티 값을 명시하면 SQL Dialect를 설정할 수 있는데, 각 DBMS에 따라 다음 표와 같이 프로퍼티값을 명시하면 된다.

DBMS 프로퍼티값
DB2 net.sf.hibernate.dialect.DB2Dialect
DB2 AS/400 net.sf.hibernate.dialect.DB2400Dialect
DB2 OS390 net.sf.hibernate.dialect.DB239Dialect
PostgreSQL net.sf.hibernate.dialect.PostgreSQLDialect
MySQL net.sf.hibernate.dialect.MySQLDialect
Oracle (모든 버전) net.sf.hibernate.dialect.OracleDialect
Oracle 9/10g net.sf.hibernate.dialect.Oracle9Dialect
Sybase net.sf.hibernate.dialect.SybaseDialect
Sybase Anywhere net.sf.hibernate.dialect.SybaseAnywhereDialect
Microsoft SQL Server net.sf.hibernate.dialect.SQLServerDialect
SAP DB net.sf.hibernate.dialect.SAPDBDialect
Informix net.sf.hibernate.dialect.InformixDialect
HypersonicSQL net.sf.hibernate.dialect.HSQLDialect
Ingres net.sf.hibernate.dialect.IngresDialect
Progress net.sf.hibernate.dialect.ProgressDialect
Mckoi SQL net.sf.hibernate.dialect.MckoiDialect
Interbase net.sf.hibernate.dialect.InterbaseDialect
Pointbase net.sf.hibernate.dialect.PointbaseDialect
FrontBase net.sf.hibernate.dialect.FrontbaseDialect
Firebird net.sf.hibernate.dialect.FirebirdDialect

트랜잭션 속성 및 처리 클래스 설정

Hibernate의 Transaction 객체를 사용하기 위해서는 hibernate.transaction.factory_class 프로퍼티 속성을 설정해야 한다. 이 속성을 통해서 사용할 Transaction 구현체를 명시하게 된다. Hibernate는 기본적으로 두 가지 Transaction 구현체를 제공하고 있으며, 이 두 구현체는 다음과 같다.

  • net.sf.hibernate.transaction.JDBCTransactionFactory
    JDBC 트랜잭션에 트랜잭션 처리를 위임한다.
  • net.sf.hibernate.transaction.JTATransactionFactory
    JTA에 처리를 위임한다. (기존의 트랜잭션이 존재하면 그 트랜잭션을 따르고, 존재하지 않을 경우 Session은 새로운 트랜잭션을 수행한다.
JTATransactionFactory 구현체를 사용할 때, JTATransactionFactory가 어플리케이션 서버로부터 JTA UserTransaction을 구하기 위해 사용할 JNDI 이름은 jta.UserTransaction 프로퍼티를 사용해서 명시할 수 있다.

JTA 환경에서 변경가능한 데이터를 JVM 레벨에서 캐싱하기 위해서는, JTA TransactionManager를 구하기 위한 전력을 명시해야 한다. JTA TransactionManager를 구할 클래스를 명시할 때에는 hibernate.transaction.manager_lookup_class 프로퍼티의 값을 WAS에 따라 알맞게 명시하면 된다. 아래표는 WAS에 따라 사용할 프로퍼티 값 목록이다.

WAS 프로퍼티값
JBoss net.sf.hibernate.transaction.JBossTransactionManagerLookup
Weblogic net.sf.hibernate.transaction.WeblogicTransactionManagerLookup
WebSphere net.sf.hibernate.transaction.WebSphereTransactionManagerLookup
Orion net.sf.hibernate.transaction.OrionTransactionManagerLookup
Resin net.sf.hibernate.transaction.ResinTransactionManagerLookup
JOTM net.sf.hibernate.transaction.JOTMTransactionManagerLookup
JOnAS net.sf.hibernate.transaction.JOnASTransactionManagerLookup
JRun4 net.sf.hibernate.transaction.JRun4TransactionManagerLookup
Borland ES net.sf.hibernate.transaction.BESTransactionManagerLookup

SessionFactory JNDI 등록

hibernate.session_factory_name 프로퍼티를 사용해서 JNDI 이름공간에 SessionFactory를 등록할 수 있다. hibernate.session_factory_name 프로퍼티의 값은 SessionFactory를 JNDI에 등록할 때 사용될 이름이 된다. 예를 들어, java:comp/env/hibernate/SessionFactory와 같은 이름을 사용하게 된다.

hibernate.session_factory_name 프로퍼티를 생략하면 SessionFactory를 JNDI에 등록하지 않는다. Tomcat과 같이 읽기전용 JNDI 구현체를 사용하는 서버에서는 hibernate.session_factory_name 프로퍼티 값을 설정하지 않는 것이 좋다.

hibernate.jndi.url 프로퍼티와 hibernate.jndi.class 프로터리를 사용해서 SessionFactory를 JNDI에 등록할 때 사용할 InitialContext를 명시할 수 있다. 이 속성값을 명시하지 않으면 기본 InitialContext가 사용된다.

다음 글에서는

이번 2회에서는 Hibernate가 사용할 데이터베이스 세션을 설정하는 세 가지 방법, 즉 JNDI를 이용하는 방법, 커넥션 풀을 사용하는 방법, 그리고 직접 코드에서 커넥션을 제공하는 방법에 대해서 살펴보았다. 그리고 DBMS의 기능을 활용할 수 있는 SQL Dialect 설정 방법과 WAS 서버에 따라 달라지는 JNDI 트랜잭션 속성 및 처리 클래스의 설정 방법에 대해서도 알아보았다.

다음 3회 글에서는 OR 매핑의 한 부분인 Object, 즉, Hibernate가 데이터를 메모리 상에서 표현할 자바 퍼시스턴트 클래스의 작성 방법에 대해서 살펴볼 것이다.

관련링크:
Posted by 최범균 madvirus

댓글을 달아 주세요

  1. 전재형 2015.09.09 10:39 신고  댓글주소  수정/삭제  댓글쓰기

    하이버네이트 세션처리을 찾는 중. 들렀습니다.

    너무 잘 정리된 내용이라. 블러그에 두고 보고 싶어요^^

Hibernate API를 사용하여 OR 매핑을 처리하는 예제를 작성해봄으로써 일단 Hibernate에 발을 담군다.

OR 매핑과 Hibernate API 사용 준비

OR 매핑은 객체와 관계형 DB 테이블 사이의 매핑을 뜻하는 것으로서, 객체의 데이터를 DB 테이블의 레코드로 또는 DB 테이블의 레코드를 객체의 데이터로 이동시켜주는 기법을 의미한다. 웹 어플리케이션 개발시 작성하는 코드의 핵심 부분은 거의 95% 이상이 DB 테이블과의 CRUD 작업과 연관되어 있기 때문에, OR 매핑 도구를 알맞게 사용하면 개발 효율성을 높일 수 있게 된다.(예를 들어, select 쿼리를 작성하고 테스트 하는 소비되는 시간이 없어지고, 대신 도메인 로직을 처리하는 코드를 작성하는 데 더 많은 시간을 투자할 수 있다.)

현재 Sun의 JDO, 자카르타의 OJB, Hibernate 등 다양한 OR 매핑 API가 존재한다.이 중에서, Hibernate API는 기존에 작성한 도메인 영역의 엔티티 객체를 그대로 사용할 수 있기 때문에 기존 코드를 작성하기가 쉬우며, OR 매핑 정보를 설정 파일로 관리하기 때문에 OR 매핑 설정이 쉽다. 또한, SELECT 쿼리 수행시 다양한 검색 조건을 제공하며, DBMS에 특징적인 기능도 지원하고 있다. 또한, 현재 많은 개발자들이 애용하고 있는 API이기도 한다. 이런 이유로 필자는 Hibernate API의 사용하는 방법에 대해서 7~8회에 걸쳐서 살펴보도록 하겠다.

Hibernate API를 사용하기 위한 준비

본 글에서는 Hibernate API를 사용하는 웹 어플리케이션을 작성해볼 것이다. 톰캣 5.0.xx 버전과 JDK 1.4.2 버전을 사용해서 웹 어플리케이션을 실행하였다. 웹 어플리케이션을 위한 폴더를 아래와 같이 생성하였다. (WEB-INF 폴더에 들어갈 web.xml 파일은 알맞게 작성하기 바란다.) 하단에 있는 관련 자료에서 예제 코드를 직접 다운로드 받아서 사용할 수 있다.

  - C:jakarta-tomcat-5.0.28
      - webapps
          - hibernate
              - WEB-INF
                  - lib
                  - classes

위와 같이 웹 어플리케이션 폴더를 작성했다면, 아래의 순서에 따라 Hibernate API를 사용하면 된다.

  1. Hibernate API를 다운로드 한다.
  2. 필요한 jar 파일을 복사한다.
  3. 매핑될 자바 클래스 파일을 작성한다.
  4. 객체의 데이터를 저장할 테이블을 생성한다.
  5. 자바 객체와 테이블 사이의 매핑 정보 파일을 작성한다.
  6. 자바 코드에서 Hibernate Session을 이용하여 OR 매핑을 처리한다.
먼저, Hibernate는 Hibernate 홈페이지인 http://www.hibernate.org 에서 다운로드 받을 수 있다. 현재 production 버전은 2.1.7c이며, development 상태의 버전은 3.0beta1이다. 본 글에서는 2.1.7c 버전을 사용할 것이다.

다운로드 받은 hibernate-2.1.7c.zip 파일의 압축을 풀면 여러 가지 jar 파일이 존재하는데, 이들 jar 파일 중에서 다음의 파일들을 WEB-INFlib 폴더에 복사한다.

  • hibernate2.jar
  • lib/cglib-full-2.0.2.jar
  • lib/commons-collections-2.1.1.jar
  • lib/commons-logging-1.0.4.jar
  • lib/dom4j-1.4.jar
  • lib/ehcache-0.9.jar
  • lib/jta.jar
  • lib/odmg-3.0.jar
  • JDBC 드라이버
JDBC 드라이버는 독자가 테스트를 위해 사용할 DBMS에 알맞은 걸 사용하면 된다. (본 글에서는 오라클9i에 해당하는 classes12.jar 파일을 사용해서 테스트할 것이다.)

필요한 jar 파일을 복사했다면 Hibernate API를 사용하기 위한 준비가 끝난 것이다.

매핑될 자바 클래스 작성과 테이블 생성

OR 매핑의 핵심 개체는 메모리 상에 존재할 자바 객체와 물리적으로 존재할 DB 테이블이다. Hibernate에 발을 담구는 단계이므로 간단한 객체와 테이블을 사용해볼 것이다. (참고로 여기서 사용하는 자바 클래스와 테이블은 Hibernate 레퍼런스의 퀵스타트에서 사용한 것들이다.)

매핑될 자바 클래스

테이블과 매핑될 자바 클래스는 다음과 같다.

package javacan.hibernate.test;

/**
 * Cat 클래스
 * 
 * @author 최범균
 */
public class Cat {
    private String id;
    private String name;
    private char sex;
    private float weight;
    
    public Cat() {
    }
    
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public char getSex() {
        return sex;
    }
    public void setSex(char sex) {
        this.sex = sex;
    }
    public float getWeight() {
        return weight;
    }
    public void setWeight(float weight) {
        this.weight = weight;
    }
}

위 코드를 보면 알겠지만 OR 매핑에서 테이블과 매핑될 객체를 위한 클래스는 Hibernate API에 대해서 전혀 연관되어 있지 않다.

테이블 생성

앞서 작성한 Cat 객체의 데이터를 저장할 테이블의 스키마는 아래와 같다.

컬럼명 컬럼타입 NOT NULL 인덱스
CAT_ID CHAR(32) NOT NULL PK
NAME VARCHAR(16) NOT NULL  
SEX CHAR(1)    
WEIGHT REAL    

빠른 이해를 위해 Cat 클래스의 프로퍼티와 CAT 테이블의 필드가 1대 1로 매핑되도록 하였다.

매핑 파일 및 Hibernate 세션 설정 파일 작성

매핑될 자바 객체와 DB 테이블이 준비되었다면, 그 다음으로 해야 할 작업은 매핑 설정 파일을 작성하는 것이다. 앞서 작성한 Cat 클래스와 CAT 테이블에 대한 매핑 정보를 담고 있는 매핑 설정 파일은 아래와 같다.

파일경로:/WEB-INF/classes/Cat.hbm.xml<?xml version="1.0" encoding="euc-kr" ?>

<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">

<hibernate-mapping>
    <class name="javacan.hibernate.test.Cat" table="CAT">
        <id name="id" type="string" unsaved-value="null">
            <column name="CAT_ID" sql-type="char(32)" not-null="true" />
            <generator class="uuid.hex" />
        </id>
        
        <property name="name">
            <column name="NAME" length="16" not-null="true" />
        </property>
        
        <property name="sex" />
        
        <property name="weight" />
    </class>
</hibernate-mapping>

OR 매핑 파일을 작성하는 방법에 대해서는 본 시리즈의 4회 글에서 살펴볼 것이며, 본 글에서는 위 설정 파일의 각 태그에 대해서 자세히 설명하지는 않겠다. 간단하게 각 태그 및 속성들은 간단히 설명하면 아래와 같다.

  1. <class> 태그 - OR 매핑에서 사용될 클래스와 테이블을 명시한다. name 속성에는 매핑될 클래스의 완전한 이름을, table 속성에는 매핑딜 DB 테이블의 이름을 명시한다.
  2. <id> 태그 - DB 테이블의 주요키와 매핑되는 객체의 프로퍼티를 설정한다. name 속성은 프로퍼티 이름을, type은 프로퍼티의 타입을 나타낸다.
  3. <property> 태그 - 객체에서 DB 테이블과 매핑될 프로퍼티의 이름을 명시한다.
  4. <column> 태그 - <id> 태그나 <property> 태그로 지정한 객체의 프로퍼티와 매핑되는 DB 테이블의 필드에 대한 정보를 지정한다. name 속성은 필드명을, sql-type은 SQL 타입을 not-null은 필드가 null 값을 허용하는지의 여부를 명시한다.
  5. <generator> 태그 - 키값 생성기를 나타낸다. 객체를 생성하면 <id> 태그에 해당하는 DB 테이블의 필드인 PK 필드에 키값을 삽입해야 하는데, 이때 <generator> 태그가 생성한 값을 키값으로 사용한다. 위 예제코드에서는 32자리의 HEX 코드를 만들어내는 생성기를 사용한다.
<property> 태그가 <column> 태그를 자식으로 갖지 않을 경우에는 프로퍼티 이름과 동일한 이름의 테이블 필드를 참조하게 된다. 예를 들어, weight 프로퍼티의 값을 저장하는 DB 테이블의 필드는 weight가 되는 것이다.

매핑 설정 파일을 작성했다면 그 다음으로 해야 할 일은 Hibernate의 세션 설정 파일을 작성하는 것이다. 세션 설정 파일에서는 다음과 같은 것들을 명시하게 된다.

  • DB 커넥션과 관련된 프로퍼티 지정
  • 세션이 사용할 OR 매핑 설정 파일 정보
설정 파일의 형태는 간단한데, 본 글에서 예젤 사용한 세션 설정 파일은 다음과 같다.

파일경로: /WEB-INF/classes/hibernate.cfg.xml
<?xml version="1.0" encoding="euc-kr" ?>

<!DOCTYPE hibernate-configuration
    PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN"
           "http://hibernate.sourceforge.net/hibernate-configuration-2.0.dtd">

<hibernate-configuration>
    <session-factory>
        <property name="hibernate.connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
        <property name="hibernate.connection.url">jdbc:oracle:thin:@localhost:1521:ORA</property>
        <property name="hibernate.connection.username">scott</property>
        <property name="hibernate.connection.password">tiger</property>
        
        <property name="dialect">net.sf.hibernate.dialect.Oracle9Dialect</property>
        
        <mapping resource="Cat.hbm.xml" />
    </session-factory>
</hibernate-configuration>

위 파일에서 <property> 태그는 DB 세션에 대한 설정을, <mapping> 태그는 이 세션과 관련된 매핑 설정 파일을 명시한다.

위 예제 파일은 Hibernate가 제공하는 커넥션 풀을 사용하도록 설정하고 있는데, 이 외에도 CP30이나 DBCP와 같은 다른 커넥션풀을 사용할 수 있으며, 또한 어플리케이션 서버(WAS)가 제공하는 JNDI로부터 커넥션을 구할 수도 있다. 심지어 프로그램에서 직접 세션에 커넥션을 전달할 수도 있는데 이에 대해서는 다음 글에서 살펴보도록 하겠다.

Hibernate Session을 사용한 OR 매핑 처리 코드 작성

Hibernate 세션 설정 파일 및 OR 매핑 설정 파일을 작성했다면 이제 남은 일은 Hibernate가 제공하는 OR 매핑 기능을 사용해서 어플리케이션을 개발하는 것이다.

세션을 구하기 위한 유틸리티 클래스 작성

Hibernate가 제공하는 세션을 구하는 코드는 아래와 같은 형태를 지닌다.

SessionFactory sessionFactory = null;
sessionFactory = new Configuration().configure().buildSessionFactory();

Session s = sessionFactory.openSession(); // Session을 통해서 CRUD 작업을 수행하게 된다.

...

s.close();

위 코드에서 Configuration.configure() 메소드를 호출하는 부분이 있는데, 이 코드가 실행되면서 설정 파일로부터 세션 정보를 읽어오게 된다.

SessionFactory는 초기화를 위해서 한번만 생성하면 되므로 보통은 아래와 같은 형태의 유틸리티 클래스를 작성해서 Hibernate 세션을 사용한다.

package javacan.hibernate.test;

import net.sf.hibernate.HibernateException;
import net.sf.hibernate.Session;
import net.sf.hibernate.SessionFactory;
import net.sf.hibernate.cfg.Configuration;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
 * Hibernate의 Session을 open/close 해주는 유틸리티 클래스.
 * 
 * @author 최범균
 */
public class HibernateUtil {
    private static Log log = LogFactory.getLog(HibernateUtil.class);
    
    private static final SessionFactory sessionFactory;
    
    static {
        try {
            sessionFactory = new Configuration().configure().buildSessionFactory();
        } catch(Throwable ex) {
            log.error("Initial SessionFactory creation failed.", ex);
            throw new ExceptionInInitializerError(ex);
        }
    }
    
    public static final ThreadLocal local = new ThreadLocal();
    
    public static Session currentSession() throws HibernateException {
        Session s = (Session) local.get();
        if (s == null) {
            s = sessionFactory.openSession();
            local.set(s);
        }
        return s;
    }
    public static void closeSession() throws HibernateException {
        Session s = (Session) local.get();
        local.set(null);
        if (s != null) {
            s.close();
        }
    }
}

위와 같이 유틸리티 클래스를 만들면 Hibernate 세션을 구하는 코드는 아래와 같이 간단해진다.

Session s = HibernateUtil.currentSession();

...

HibernateUtil.closeSession();

Hibernate를 이용한 CRUD 처리

Hibernate 세션을 구해주는 유틸리티 클래스도 작성했으므로, Hibernate를 이용해서 CRUD 처리를 어떻게 처리하는 지 대략적으로 살펴보도록 하자. 먼저 Hibernate를 사용하는 전형적인 코드는 아래와 같다.

    Session hbSession = null;
    Transaction tx = null;
    
    try {
        hbSession = HibernateUtil.currentSession();
        tx = hbSession.beginTransaction();
        
        // Hibernate 세션을 이용한 CRUD 처리 코드
        
        tx.commit();
    } catch(Exception ex) {
        if (tx != null) tx.rollback();
    } finally {
        HibernateUtil.closeSession();
    }

Transaction은 트랜잭션을 처리해주며, tx.commit()을 호출하면 트랜잭션이 완료되고, tx.rollback()을 호출하면 트랜잭션이 롤백된다. 트랜잭션은 Session.beginTransaction() 메소드를 호출하면 시작된다.

hbSession은 트랜잭션 처리를 위한 save(), update(), delete() 등의 메소드를 제공한다. 예를 들어, 앞서 작성했던 Cat 클래스의 객체를 생성한 뒤 프로퍼티 값을 알맞게 지정하고 DB 테이블에 저장하는 코드는 아래와 같이 save() 메소드를 사용해서 작성할 수 있다.

관련코드: /makeCat.jsp    
Session hbSession = null;
Transaction tx = null;

try {
    hbSession = HibernateUtil.currentSession();
    tx = hbSession.beginTransaction();
    
    Cat cat = new Cat();
    cat.setName("나비");
    cat.setSex('F');
    cat.setWeight(2.0f);
    
    hbSession.save(cat);    
    tx.commit();
} catch(Exception ex) {
    if (tx != null) tx.rollback();
} finally {
    HibernateUtil.closeSession();
}

만약 위의 코드를 JDBC API 만으로 작성한다면 아래와 같은 형태를 취할 것이다.

    Cat cat = new Cat();
    cat.setId(생성한ID값);
    ...

    Connection conn = null;
    PreparedStatement pstmt = null;
    
    try {
        conn = DButil.getConnection();
        pstmt = conn.prepareStatement("insert into cat values (?, ?, ?, ?)");
        pstmt.setString(1, cat.setId());
        ...
        pstmt.setFloat(4, cat.getWeight());
        pstmt.executeUpdate();
        
    } finally {
        if (pstmt != null) try { pstmt.close(); } catch(SQLException ex) {}
        if (conn != null) try { conn.close(); } catch(SQLException ex) {}
    }

앞서 Hibernate를 사용한 코드와 위의 JDBC를 사용한 코드를 비교해보면 Hibernate를 사용한 코드가 훨씬 이해가 빠르며, 코드도 짧은 것을 알수가 있다. 처리해야 할 필드의 개수가 많으면 많아질 수록 코딩량의 차이는 더욱 늘어날 것이다.

테이블에서 데이터를 읽어오는 부분은 가장 기본적인 형태는 아래와 같다.

관련코드: /listCat.jsp
    Session hbSession = null;
    Transaction tx = null;
    
    try {
        hbSession = HibernateUtil.currentSession();
        tx = hbSession.beginTransaction();
        
        Query query = hbSession.createQuery("select c from Cat as c where c.sex = :sex");        query.setCharacter("sex", request.getParameter("sex").charAt(0));
        for (Iterator iter = query.iterate() ; iter.hasNext() ; ) {
            Cat c = (Cat) iter.next();
        }
        tx.commit();
    } catch(Exception ex) {
        if (tx != null) tx.rollback();
    } finally {
        HibernateUtil.closeSession();
    }

Query 객체는 SQL 쿼리와 비슷한 HQL 정보를 담고 있는 객체로서, 위 코드에서는 select 쿼리를 위한 정보를 담고 있다. 위 코드에서 사용된 select 쿼리는 일반적인 SQL 쿼리와 비슷하지만 다른 형태를 취하고 있는 것을 알 수 있는데, 이 쿼리는 Hibernate가 자체적으로 제공하는 HQL이다. HQL은 SQL과 비슷하기 때문에 쉽게 배울 수 있는데, 이에 대해서는 본 시리즈의 6번째 글에서 살펴볼 것이다.

예제 실행 방법

글 하단에 위치한 관련 링크에서 본 글에서 사용한 예제 코드를 다운로드 받을 수 있다. 예제 파일은 hibernate.war인데, 이 파일을 톰캣이나 레신과 같은 웹 콘테이너에 알맞게 복사한다. 톰캣의 경우 [톰캣]/webapps 폴더에 복사한다. 알맞게 복사한 뒤 실행을 하면 hibernate.war 파일이 자동으로 배치될 것이다.

압축이 풀리면 /WEB-INF/classes/hibernate.cfg.xml 파일을 열어서 아래의 부분을 테스트하려는 DBMS에 알맞게 수정한다.

    <property name="hibernate.connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
    <property name="hibernate.connection.url">jdbc:oracle:thin:@localhost:1521:ORA</property>
    <property name="hibernate.connection.username">scott</property>
    <property name="hibernate.connection.password">tiger</property>

윗 부분을 알맞게 수정하고, DBMS에 앞서 보여줬던 CAT 테이블을 생성하고, DBMS에 알맞은 JDBC 드라이버를 /WEB-INF/lib 폴더에 복사한 뒤, WAS를 다시 시작하면 예제를 실행할 수 있다.

예제는 다음과 같은 3개의 JSP 파일이 있다.

  • makeForm.jsp - 고양이 정보를 입력하는 폼.
  • makeCat.jsp - makeForm.jsp로부터 전달받은 고양이 정보를 Cat 객체에 저장한 뒤, Hibernate를 사용해서 CAT 테이블에 저장
  • listCat.jsp - Hibernate를 사용해서 CAT 테이블에 저장된 정보를 읽어와 Cat 객체에 저장한 뒤 출력
makeForm.jsp를 실행해서 고양이 정보를 입력한 뒤, listCat.jsp를 통해서 DB 테이블에 저장되는 지의 여부를 확인할 수 있을 것이다.

다음 글에서는

이번 1회에서는 Hibernate가 무엇인지 감을 잡을 수 있도록 전체적인 사용 순서를 정리해보았다. 이번 글을 통해서 Hibernate가 무엇이며 어떤식으로 이용되는 지를 대략적으로 이해했을 것이라 생각한다. 다음 글에서는 Hibernate가 DB와 통신할 때 사용되는 Session에 대한 설정 방법에 대해서 살펴볼 것이다.

관련링크:

 

Posted by 최범균 madvirus

댓글을 달아 주세요

객체와 데이터베이스 사이의 그리고 매퍼 자체의 독립성을 유지하는 매퍼 레이어에 대해서 살펴본다.

메타 데이터 매퍼

본 글에서 소개하는 패턴은 '엔터프라이즈 어플리케이션 아키텍처 패턴' (마틴 파울러 저)에 소개된 패턴으로서, 필자가 파울러가 소개한 패턴을 보다 쉽게 이해할 수 있도록 재구성한 것이다.

'데이터 매퍼(Data Mapper)'는 이 글의 시리즈 글인 '데이터 소스 아키텍처 패턴 1'에서 살펴봤던 테이블 데이터 게이트웨이와 상당히 유사하다. 데이터 매퍼는 테이블 데이터 게이트웨이와 마찬가지로 도메인 모델 객체와 데이터베이스 테이블 사이에 존재하는 레이어로서 도메인 모델 객체와 데이터베이스 테이블 사이의 데이터 이동을 처리해준다.

테이블 데이터 게이트웨이는 테이블과 관련된 CRUD 작업을 처리하는 데 초점을 맞추고 있다면, 데이터 매퍼는 도메인 모델 객체와 테이블 사이의 매핑을 처리하는 데에 초점을 맞추고 있다. 이런 관점에서 테이블 데이터 게이트웨이는 테이블과 관련된 값을 RecordSet과 같은 범용타입을 통해서 처리해도 무방하지만, 데이터 매퍼의 경우는 정확한 타입의 객체와 테이블 사이의 매핑을 처리해주어야 한다.

마틴 파울러의 책에서 보여주는 데이터 매퍼의 구현 방법은 사실상 테이블 데이터 게이트웨이의 구현 코드에 '이미 로딩한 객체의 캐싱' 및 '추상 클래스를 통한 공통 코드 처리'를 추가 구현한 정도에 지나지 않으며, 같은 책의 뒤에서 소개하고 있는 메타 데이터 매퍼가 실제로 쓰임새 있는 패턴이라고 볼 수 있다. 메타 데이터 매퍼 패턴은 데이터 매퍼 개념을 범용적으로 확장한 것이므로 본 글에서는 메타 데이터 매퍼에 대해서 살펴볼 것이다.

메타 데이터 매퍼 패턴은 아래 그림과 같이 구성된다.


위 그림에서 DataMapper는 모델 객체가 테이블가 어떻게 연결되는지를 정의한 매핑 정보를 저장하고 있다. 예를 들어, DataMapper는 Team 객체의 id 프로퍼티와 데이터베이스의 TEAM 테이블의 TEAM_ID 필드가 매핑된다는 정보를 갖고 있다. 이 매핑 정보를 이용해서 DataMapper는 TEAM 테이블로부터 데이터를 읽어와 Team 객체를 생성하게 되며, Team 객체에 저장되어 있는 정보를 TEAM 테이블에 반영하게 된다.

DataMapper는 <객체, 테이블> 매핑 정보만 갖고 있으면 모든 CRUD 작업을 처리할 수 있게 된다. 설명에서 느꼈겠지만, 마틴 파울러가 설명한 데이터 매퍼 및 메타 데이터 매퍼 패턴은 객체(Object)-관계 데이터베이스(Relation Database) 매핑, 즉, OR 매핑에 대한 패턴이다.

구현 방법

메타 데이터 매퍼 패턴, 즉, OR 매핑을 구현하기 위해서는 다음의 정보가 필요하다.

  • 객체와 매핑할 테이블은 무엇인가?
  • 객체의 프로퍼티를 테이블의 어떤 필드에 매핑할 것인가?
보통은 위의 매핑 정보를 설정 파일로 처리한다. 예를 들어, 아래와 같은 설정 파일을 사용할 수 있다.

   <?xml version="1.0" ?>
   
   <mapping>
       <object class="madvirus.javacan.Employ" table="EMPLOY">
           <property name="id" field="EMPLOY_ID" />
           <property name="name" field="NAME" />
           <property name="address" field="ADDRESS" />
           
           <primary-key>
               <property>id</property>
           <primary-key>
       </object>
   </mapping>

위의 설정 파일을 보면 Employ 객체와 매핑되는 테이블이 EMPLOY 테이블이며, 객체의 id 프로퍼티, name 프로퍼티, address 프로퍼티는 각각 EMPLOY 테이블의 EMPLOY_ID 필드, NAME 필드, ADDRESS 필드와 매핑된다는 것을 나타내고 있음을 쉽게 알 수 있다.

DataMapper는 위와 같은 형태의 설정 파일로부터 매핑 정보를 읽어와 객체와 테이블 사이의 매핑을 알맞게 처리하게 된다. 위의 매핑 정보는 다음과 같은 형태의 클래스를 사용해서 저장될 것이다.

    public class MetaData {
        private Class object;
        private String tableName;
        private List<FieldMapping> fieldMappingList = new ArrayList<FieldMapping>();
        private List<FieldMapping> pkFieldList = new ArrayList<FieldMapping>();
        
        public List<FieldMapping> getFieldMappingList() {
            return fieldMappingList
        }
        public List<FieldMapping> getPKFieldList() {
            return pkFieldList;
        }
        ...
    }
    
    public class FieldMapping {
        private String property; // <property> 태그의 name 속성값
        private String field; // <property> 태그의 field 속성값
        
        ...
    }

DataMapper는 위의 메타 정보를 사용해서 알맞은 쿼리를 생성한다. 예를 들어, 특정 테이블로부터 데이터를 읽어오는 select() 메소드는 다음과 같은 형태가 될 것이다.

    public class DataMapper {
        Map<MetaData> map = new java.util.HashMap<MetaData>(); // <Object타입, MetaData> 매핑 저장
        
        public Object select(Class objectType, Map keyValue) {
            MetaData metaData = map.get(objectType);
            List<FieldMapping> fieldList = metaData.getFieldMappingList();
            List<FieldMapping> pkList = metaData.getFieldMappingList();
            
            StringBuffer query = new StringBuffer();
            query.append("select ");
            for (int i = 0 ; i < fieldList.size() ; i++) {
                query.append(fieldList.get(i).getField());
                if (i < fieldList.size() - 1) query.append(", ");
            }
            query.append(" from ").append(metaData.getTableName()).append(" where ");
            
            for (int i = 0 ; i < pkList.size() ; i++) {
                query.append(pkList.get(i).getField());
                query.append(" = ? ");
                if (i < pkList.size() - 1) query.append(" and ");
            }
            
            String sql = query.toString();
            
            PreparedStatement pstmt = null;
            ResultSet rs = null;
            
            try {
                pstmt = DB.prepareStatement(sql);
                for (int i = 0 ; i < pkList.size() ; i++) {
                    Object val = keyValue.get(pkList.get(i).getProperty());
                    
                    // setParameter 메소드는 PreparedStatement의 IN 파라미터값을
                    // val 객체의 타입에 알맞게 처리해준다고 가정하자.
                    setParameter(pstmt, i+1, val); 
                }
                rs = pstmt.executeQuery();
                if (rs.next()) {
                    Object obj = objectType.newInstance();
                    ... // rs의 값을 obj에 복사.
                    return object;
                }
            } finally {
                ...
            }
        }
    }

위 코드에서 볼 수 있듯이 객체와 테이블 사이의 관계를 DataMapper가 모두 처리해주기 때문에, 객체는 테이블에 대해서 전혀 알 필요가 없으며, 심지어 DataMapper의 존재에 대해서도 전혀 알 필요가 없다. 도데인 영역의 객체가 테이블과 DataMapper에 의존적이지 않기 때문에 데이터베이스를 변경하거나 테이블이 변경될 경우 모델에 끼치는 영향을 최소화할 수 있다.

데이터 매퍼의 장점

웹 어플리케이션 프로그래밍의 90% 이상이 데이터베이스와 연동하는 코드를 포함하고 있다. CRUD 코드를 일일이 작성하는 것은 굉장히 지루하고 실수를 유발하기 쉬울 뿐만 아니라 코딩 시간의 많은 부분을 차지하는 작업인데, 데이터 매퍼를 사용함으로써 개발 시간을 상당량 줄일 수 있게 되며 잘못된 코딩에 따른 버그도 줄일 수 있게 된다.

CRUD 코드를 작성하는 데 소모되는 시간을 줄일 수 있다는 것은 비즈니스 로직 부분의 코드를 작성하는데 더 많은 시간을 투자할 수 있다는 것을 의미한다. 로직 부분에 집중할 수 있는 시간이 늘어남으로써 빠른 시간에 원하는 어플리케이션을 구현할 수 있게 된다.

또한, 데이터 매퍼를 사용하게 되면, 테이블이 변경될 때 객체의 변경을 최소화시킬 수 있다. 예를 들어, 테이블 스키마에서 필드 하나를 제거했다고 해 보자. 이 경우 객체는 전혀 변경할 필요가 없이 매핑 정보만 변경하면 된다. 필드가 삭제되었다고 해서 변경해야 할 쿼리는 하나도 없는 것이다.

반대로, 테이블에 저장해야 하는 객체의 프로퍼티가 새롭게 추가되었다고 해 보자. 이때 해야 할 작업은 테이블에 관련 필드를 추가하고 매핑 정보를 변경하는 것이다. 앞의 경우와 마찬가지로 변경해야 할 쿼리는 전혀 없다.

마지막으로 객체가 데이터 매퍼에 의존적이지 않기 때문에, 데이터 매퍼를 독립적으로 유지할 수 있다. 즉, 객체에 상관없이 데이터 매퍼를 수정할 수 있으며, 심지어 데이터 매퍼 구현 클래스를 변경할 수도 있다.

데이터 매퍼를 직접 구현할 필요는 없다!

의욕이 높거나 한번 해보고 싶은 마음에 데이터 매퍼를 직접 구현해보는 것은 좋으나, 도메인 모델에 맞는 데이터 매퍼를 직접 구현하는 것은 쉬운 일이 아니다. 또한, 데이터 매퍼를 구현하는 시간이 짧지도 않다. 따라서, 미리 구현해둔 데이터 매퍼가 없거나 또는 기존에 구현한 데이터 매퍼가 프로젝트에서 사용하는 도메인 모델에 잘 맞지 않을 경우에는, 데이터 매퍼를 직접 구현하는 것 보다는 이미 존재하는 데이터 매퍼 라이브러리를 사용하는 것이 가장 좋다. 예를 들어, Hibernate와 같이 널리 사용되는 OR 매핑 도구를 사용하는 것이 직접 구현하는 것보다 프로젝트 개발 시간을 단축시키는 데 도움이 될 것이다.

관련링크:

 

Posted by 최범균 madvirus

댓글을 달아 주세요