더블에스 devlog

JPA - 엔티티 매핑

더블에스님 — Fri, 15 Mar 2019 22:41:53 +0900

ch04-entity-mapping.md

본 글은 자바 ORM 표준 JPA 프로그래밍를 읽고 개인적으로 학습한 내용 복습하기 위해 작성된 글로 내용상 오류가 있을 수 있습니다. 오류가 있다면 지적 부탁 드리겠습니다.

JPA - 엔티티 매핑

JPA를 사용할 때 엔티티와 테이블을 정확하게 매핑하는 것이 가장 중요하다. JPA는 매핑 어노테이션을 지원하는데 아래와 같이 크게 4가지로 분류할 수 있다.

객체와 테이블 매핑
기본키 매핑
필드와 컬럼 매핑
연관관계 매핑

위의 분류를 이제 차근차근 정리해보자.

1. @Entity

JPA를 사용해서 테이블과 매핑할 클래스에는 @Entity 어노테이션을 붙인다. @Entity가 붙은 클래스는 JPA가 관리하는 것으로 엔티티라 부른다.

1.1 속성

name : JPA와 사용할 엔티티 이름을 지정, 사용하지 않을 경우 클래스이름이 그대로 적용

1.2 주의사항

기본생성자 필수
final, enum, interface, inner 클래스는 사용할 수 없음
저장할 필드에 final 사용할 수 없음

그리고 기억해야할 것은 자바에서는 기본생성자가 없을 경우 자동으로 생성해주지만 만약 파라미터가 있는 생성자가 클래스에 존재할 경우 기본생성자를 자동으로 생성해주지 않기 때문에 직접 작성해주어야한다.

2. @Table

@Table 어노테이션은 엔티티와 매핑할 테이블을 지정하고, 생략시 매핑한 엔티티 이름을 테이블 이름으로 사용한다.

2.1 속성

name : 매핑할 테이블 이름
catalog : catalog 기능이 있는 데이터베이스에서 catalog를 매핑
schema : schema 기능이 있는 데이터베이스에서 schema를 매핑
uniqueConstraint : DDL 매핑 시에 유니크제약조건을 만듬, 스키마 자동생성 기능을 사용해서 DDL을 만들때만 사용

3. 데이터베이스 스키마 자동생성

JPA는 데이터베이스 스키마를 자동으로 생성하는 기능을 제공한다. 클래스의 매핑정보를 보면 어떤 테이블에 어떤 칼럼을 사용하는지 알 수 있다. 아래는 예제에 사용할 클래스를 작성한 것이다.

3.1 스키마 자동 생성을 위한 클래스 작성

@Entity // 클래스와 테이블 매핑
@Table(name = "MEMBER") // 매핑할 테이블 정보 명시
public class Member {

    @Id // 기본키 매핑
    @Column(name = "ID") // 필드를 컬럼에 매핑
    private String id;

    @Column(name = "NAME")
    private String username;

    private Integer age; // 매핑 정보가 없을 경우 필드명이 컬럼명으로 매핑

    // 회원 타입 구분
    @Enumerated(EnumType.STRING)
    private RoleType roleType;

    // 날짜 타입 매핑
    @Temporal(TemporalType.TIMESTAMP)
    private Date createdDate;

    // 날짜 타입 매핑
    @Temporal(TemporalType.TIMESTAMP)
    private Date lastModifiedDate;

    @Lob // 길이 제한 없음
    private String description;

    // getter, setter
}

3.2 스키마 자동 생성 옵션 설정

persistence.xml에서 아래와 같은 속성을 추가하면 데이터베이스 테이블을 자동으로 생성해주고, 콘솔에 DDL을 출력해준다.

<property name="hibernate.hbm2ddl.auto" value="create" />
<property name="hibernate.show_sql" value="true" />

예제 프로젝트 실행 후 콘솔화면을 확인해보면 아래와 같이 DDL이 출력되고, DB에 테이블이 생성되는 것을 확인 할 수 있다.

Hibernate:
    drop table MEMBER if exists
Hibernate:
    create table MEMBER (
        ID varchar(255) not null,
        age integer,
        createdDate timestamp,
        description clob,
        lastModifiedDate timestamp,
        roleType varchar(255),
        NAME varchar(255),
        primary key (ID)
    )

위와 같이 스키마 자동생성 기능을 사용하면 애플리케이션 실행 시점에 테이터베이스 테이블이 자동으로 생성된다. 하지만 스키마 자동 생성 기능이 만든 DDL은 운영환경에서 사용할 만큼 완벽하지 않기 때문에 개발환경에서 사용하거나 매핑을 어떻게 해야하는지 참고정도로만 사용하는 것이 좋다.

hibernate.hbm2ddl.auto의 속성은 아래와 같다.

create : 기존 테이블을 삭제하고 새로 생성, DROP + CREATE
create-drop : 애플리케이션을 종료할 때 생성한 DDL을 제거, DROP + CREATE + DROP
update : DB 테이블과 엔티티 매핑정보를 비교해서 변경사항만 수정
validate : DB 테이블과 엔티티 매핑정보를 비교해서 차이가 있으면 경고를 남기고 애플리케이션 실행X, DDL수정 X
none : 자동생성 기능을 사용하지않으려면 속성을 제거하거나, 유효하지않은 옵션값을 주면 됨

그리고 HBM2DDL에서 주의 해야할 것은 DDL을 수정하는 옵션(create, creat-drop, update)은 운영서버에서 사용을 절대 하면 안된다. 오직 개발서버나 개발단계에서만 사용해야만 한다.

개발 초기단계 : create, update
테스트 서버 : update, validate
스테이징, 운영서버 : validate, none

JPA는 2.1부터는 스키마 자동생성기능을 표준으로 지원하지만 HBM2DDL 속성이 지원하는 update, validate 옵션을 지원하지 않는다.

지원옵션 : none, create, drop-and-create, drop

3.3 이름 매핑 전략 변경

일반적으로 단어와 단어를 구분할 때 자바는 카멜표기법을 DB는 언더스코어를 주로 사용한다. 이러한 차이를 매핑하기 하기 위해서는 @Column.name 속성을 명시적으로 사용해서 이름을 지정해주어야 한다.

@Column(name = "role_type")
String roleType;

위와 같이 이름 매핑 전략을 직접 지정해주어도 되지만 persistence.xml에서 아래와 같이 속성을 지정해주면 자동으로 자바의 카멜표기법을 테이블의 언더스코어 표기법으로 매핑한다.

<property name="hibernate.ejb.naming_strategy" value="org.hibernate.cfg.ImprovedNamingStrategy" />

프로젝트를 다시 실행해보면 아래와 같이 카멜표기법에서 언더스코어 표기법으로 칼럼이 매핑 된 것을 확인할 수 있다.

Hibernate:
    drop table member if exists
Hibernate:
    create table member (
        id varchar(255) not null,
        age integer,
        created_date timestamp,
        description clob,
        last_modified_date timestamp,
        role_type varchar(255),
        name varchar(255),
        primary key (id)
    )

4. DDL 생성기능

회원 클래스에서 회원 이름이 필수로 입력되고, 10자를 초과하면 안된다는 제약조건을 추가해보자.

@Column(name = "NAME", nullable = false, length = 10) // 필수입력(null 허용X), 길이는 10자
private String username;

프로젝트를 다시 실행해보면 제약 조건이 아래와 같이 추가 되었다.

Hibernate:
    drop table member if exists
Hibernate:
    create table member (
        id varchar(255) not null,
        age integer,
        created_date timestamp,
        description clob,
        last_modified_date timestamp,
        role_type varchar(255),
        name varchar(10) not null,  // 제약조건에 의해 컬럼 생성
        primary key (id)
    )

유니크 제약조건을 만들어주는 @Table의 uniqueConstraints속성에 대해 알아보자.

회원 클래스에서 테이블 어노테이션에 아래와 같이 유니크 제약조건(유일한 값만 저장)을 추가해줄 수 있다.

@Entity
// 유니크 제약조건 추가
@Table(name = "MEMBER", uniqueConstraints = {@UniqueConstraint(
        name = "NAME_AGE_UNIQUE",
        columnNames = {"NAME", "AGE"} )})
public class Member {
   // ...
}

프로젝트 실행 후 콘솔화면을 확인 하면 아래와 같이 제약 조건이 추가된 것 을 확인 할 수 있다.

Hibernate:
    drop table member if exists
Hibernate:
    create table member (
        id varchar(255) not null,
        age integer,
        created_date timestamp,
        description clob,
        last_modified_date timestamp,
        role_type varchar(255),
        name varchar(10) not null,
        primary key (id)
    )
Hibernate:
    alter table member
        add constraint NAME_AGE_UNIQUE  unique (name, age)  // 유니크 제약조건 변경

5. 기본키 매핑

기본키 매핑의 경우 직접 할당할 수도 있고, 데이터베이스가 생성해주는 값을 사용할 수도 있다. 데이터베이스마다 기본키를 생성하는 방식이 다르기 때문에 JPA가 제공하는 데이터베이스 기본키 생성 전략이 아래와 같이 다양하다.

직접할당 : 기본키를 애플리케이션에서 직접할당
자동생성 : 대리키 사용방식
- IDENTITY : 기본키 생성을 데이터베이스에 위임, 데이터베이스에 의존
- SEQUENCE : 데이터베이스 시퀀스를 사용하여 기본키를 할당, 데이터베이스에 의존
- TABLE : 키 생성 테이블을 사용, 데이터베이스에 의존X
- AUTO : 자동으로 기본키 생성

5.1 기본키 생성 전략 설정

기본키 생성 전략을 사용하기 위해서는 pesistence.xml에 아래와 같이 속성을 추가해주어야한다.

<property name="hibernate.id.new_generator_mappings" value="true" />

5.2 직접할당

기본키를 직접 할당하는 방법은 아래와 같이 클래스 필드를 @Id로 매핑을 하고, 엔티티를 저장하기 전에 애플리케이션에서 기본키를 직접 할당해주면 된다.

// 기본키 직접 할당 전략
@Entity
@Table(name = "MEMBER_DIRECT")
public class MemberDirect {

    @Id // 기본키 매핑
    @Column(name = "ID")
    private String id;

    @Column(name = "NAME")
    private String username;

    // getter, setter ...
}

// 기본키 직접 할당 사용 코드
for (int i = 0; i < 5; i++) {
    MemberDirect member = new MemberDirect();
    member.setUsername("doubles" + i);
    member.setId("id00" + i); // 기본키 직접 할당
    entityManager.persist(member);
    System.out.println("DIRECT member id = " + member.getId());
}

// 테이블 생성
Hibernate:
    drop table member_direct if exists
Hibernate:
    create table member_direct (
        id varchar(255) not null,
        name varchar(255),
        primary key (id)
    )

// 식별자 출력
DIRECT member id = id000
DIRECT member id = id001
DIRECT member id = id002

// 엔티티 DB 테이블 저장
Hibernate:
    insert
    into
        member_direct
        (name, id)
    values
        (?, ?)
Hibernate:
    insert
    into
        member_direct
        (name, id)
    values
        (?, ?)
Hibernate:
    insert
    into
        member_direct
        (name, id)
    values
        (?, ?)

코드를 실행한 결과를 콘솔화면에서 확인하면 위와 같은 결과를 확인할 수 있다.

@Id에 적용가능 자바타입은 아래와 같다.

자바 기본형
래퍼형
String
java.util.Date
java.sql.Date
java.math.BigDecimal
java.math.BigInteger

5.2 IDENTITY 전략

IDENTITY 전략은 기본키 생성을 데이터베이스에 위임하는 방식으로 주로 MySql, PostgreSQL, SQL Server, DB2에서 사용한다.

회원 클래스를 아래와 같이 작성하고, id 칼럼값을 지정하지 않고 저장하면 콘솔에서 확인할 수 있듯이 자동으로 기본키가 생성되는 것을 확인할 수 있다.

// 기본키 IDENTITY 전략
@Entity
@Table(name = "MEMBER_IDENTITY")
public class MemberIdentity {

    @Id // 기본키 매핑
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "NAME")
    private String username;

    // getter, setter 생략...
}

// 기본키 IDENTITY 전략 사용 코드
for (int i = 0; i < 3; i++) {
    MemberIdentity member2 = new MemberIdentity();
    member2.setUsername("doubles" + i);
    // 기본키를 직접 할당는 코드 X
    entityManager.persist(member2);
    System.out.println("IDENTITY member id = " + member2.getId());
}

// 테이블 생성
Hibernate:
    drop table member_identity if exists
Hibernate:
    create table member_identity (
        id bigint generated by default as identity, // 기본키 생성 전략
        name varchar(255),
        primary key (id)
    )

// 엔티티 DB 저장
Hibernate:
    insert
    into
        member_identity
        (id, name)
    values
        (null, ?)
// 식별자 출력
IDENTITY member id = 1  

// 엔티티 DB 저장
Hibernate:
    insert
    into
        member_identity
        (id, name)
    values
        (null, ?)
// 식별자 출력
IDENTITY member id = 2

// 엔티티 DB 저장
Hibernate:
    insert
    into
        member_identity
        (id, name)
    values
        (null, ?)
// 식별자 출력
IDENTITY member id = 3

콘솔화면을 보면 기본키를 직접할당 했을 때와 차이점을 확인할 수 있다. 기본키를 직접할당 했을 때는 엔티티의 식별자가 바로 출력되었지만 IDENTITY 전략을 사용한 경우 엔티티를 DB에 저장한 뒤에 출력된 것을 볼 수 있다.

이렇게 두 개의 전략이 차이점을 보이는 이유는 아래와 같다.

엔티티가 영속상태가 되려면 식별자가 반드시 필요한데 IDENTITY전략의 경우 엔티티를 데이터베이스에 저장해야먼 식별자를 구할수 있음
entityManager.persist()를 호출하는 즉시 INSERT SQL이 DB에 바로 전달되기 때문에 트랜잭션을 지원하는 쓰기 지연이 동작하지 않음

5.3 SEQUENCE 전략

SEQUENCE 전략은 유일한 값을 순서대로 생성하는 특별한 데이터베이스 오브젝트이다. 시퀀스를 지원하는 Oracle, PostgreSQL, DB2, H2에서 사용이 가능하다.

// SEQUENCE 전략
@Entity
@SequenceGenerator(
        name = "MEMBER_SEQ_GENERATOR",  // 식별자 생성기 이름
        sequenceName = "MEMBER_SEQ", // 매핑할 데이터베이스 시퀀스 이름
        initialValue = 1,  // DDL 생성시에 사용, 시퀀스 DDL을 생성할 때 처음 시작하는 수
        allocationSize = 1) // 시퀀스 한번 호출에 증가하는 수
public class MemberSequence {

    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "MEMBER_SEQ_GENERATOR")
    private Long id;

    @Column(name = "NAME")
    private String username;

    // getter, setter 생략
}

우선 사용할 데이터베이스 시퀀스를 매핑해주어야 하는데 @SequenceGenerator를 사용해서 MEMBER_SEQ_GENERATOR라는 시퀀스 생성기를 등록했다. sequenceName속성의 이름으로 MEMBER_SEQ을 지정했는데 JPA는 이 시퀀스 생성기를 실제 데이터베이스의 MEMBER_SEQ와 매핑한다.

그리고 키 생성 전략을 GenerationType.SEQUENCE로 설정하고 generator = "MEMBER_SEQ_GENERATOR"로 방금 등록한 시퀀스 생성기를 선택한다. 이렇게 되면 id 식별자 값은 MEMBER_SEQ_GENERATOR 시퀀스 생성기가 할당을 한다.

// 시퀀스 사용 코드
for (int i = 0; i < 3; i++) {
    MemberSequence member3 = new MemberSequence();
    member3.setUsername("doubles" + i);
    entityManager.persist(member3);
    System.out.println("SEQUENCE member id = " + member3.getId());
}

위의 코드를 실행하고 나면 아래와 같이 콘솔화면을 확인 할 수 있다. 콘솔화면에 출력된 내용을 살펴보면 회원 테이블과 시퀀스를 생성하고 회원객체를 생성하고 저장할 때 마다 시퀀스를 호출해 1씩 증가시키는 것을 알 수 있다. 그리고 IDENTITY 전략과 다르게 쓰기지연이 가능한 것을 확인할 수 있다.

// 테이블 생성
Hibernate:
    drop table member_sequence if exists
Hibernate:
    drop sequence if exists MEMBER_SEQ
Hibernate:
    create table member_sequence (
        id bigint not null,
        name varchar(255),
        primary key (id)
    )

// 시퀀스 생성
Hibernate:
    create sequence MEMBER_SEQ start with 1 increment by 1

// 시퀀스 호출시 1씩 증가
Hibernate:
    call next value for MEMBER_SEQ

// 기본키 할당
SEQUENCE member id = 1

// 시퀀스 호출시 1씩 증가
Hibernate:
    call next value for MEMBER_SEQ

// 기본키 할당
SEQUENCE member id = 2

// 시퀀스 호출시 1씩 증가
Hibernate:
    call next value for MEMBER_SEQ

// 기본키 할당
SEQUENCE member id = 3

// 엔티티 DB 저장
Hibernate:
    insert
    into
        member_sequence
        (name, id)
    values
        (?, ?)
Hibernate:
    insert
    into
        member_sequence
        (name, id)
    values
        (?, ?)
Hibernate:
    insert
    into
        member_sequence
        (name, id)
    values
        (?, ?)

@SequenceGenerator의 속성을 정리해보면 아래와 같다.

name : 식별자 생성기 이름
sequenceName : 데이터베이스에 등록된 시퀀스 이름, 기본값은 hibernate_sequence
initialValue : DDL 생성시에만 사용되는 속성, 시퀀스 DDL을 생성할 때 처음 시작하는 수를 지정, 기본값은 1
allocationSize : 시퀀스 호출에 증가하는 수, 기본값은 50
catalog, schema : 데이터베이스 catalog, schema 이름

SEQUENCE 사용코드는 IDENTITY와 다를게 없지만 동작방식은 다르다. SEQUENCE 전략이 이루어지는 과정은 아래와 같다.

entityManager.persist()를 호출할 때 먼저 데이터베이스 시퀀스를 사용해 식별자를 조회
조회한 식별자를 엔티티에 할당한 뒤 영속성 컨텍스트에 저장
트랜젝션 커밋해서 플러시가 일어나면 엔티티를 저장

5.4 TABLE 전략

TABLE 전략은 키 생성 전용 테이블을 하나 만들고 여기에 이름과 값으로 사용할 칼럼을 만들어 데이터베이스 시퀀스를 흉내내는 전략으로 모든 DB에서 사용이 가능하다.

// TABLE 전략
@Entity
@TableGenerator(name = "MEMBER_SEQ_GENERATOR",  // 식별자 생성기 이름
        table = "MY_SEQUENCES", // 키 생성 테이블 명
        pkColumnValue = "MEMBER_SEQ", // 키로 사용할 값 이름
        allocationSize = 1) // 시퀀스 한번 호출에 증가하는 수
public class MemberTable {

    @Id
    @GeneratedValue(strategy = GenerationType.TABLE, generator = "MEMBER_SEQ_GENERATOR")
    private Long id;

    // 생략 ...
}

위의 코드를 살펴보면 먼저 @TableGenerator를 사용하여 MEMBER_SEQ_GENERATOR라는 이름을 가진 테이블 키 생성기를 등록한다. MY_SEQUENCES라는 테이블을 키 생성 테이블로 매핑하고, 키로 사용할 값의 이름을 MEMEBR_SEQ라고 지정했다.

그리고 기본키를 매핑한 곳에 테이블 전략을 사용한다고 명시하고, 키 생성기는 MEMBER_SEQ_GENERATOR으로 지정해주었다.

// 기본키 TABLE 전략 사용 코드
for (int i = 0; i < 3; i++) {
    MemberTable member4 = new MemberTable();
    member4.setUsername("doubles" + i);
    entityManager.persist(member4);
    System.out.println("TABLE member id = " + member4.getId());
}

위의 코드를 실행하면 아래와 같은 결과를 출력한다. 테이블 전략은 시퀀스 대신에 테이블을 사용한다는 것만 제외하면 시퀀스 전략과 내부 동작 방식이 같다. TABLE 전략은 값을 조회하면서 SELECT 쿼리를 사용하고, 다음 값을 증가 시키기 위해 UPDATE 쿼리를 사용한다.

// 회원 테이블, 시퀀스 테이블 생성
Hibernate:
    drop table member_table if exists
Hibernate:
    drop table MY_SEQUENCES if exists
Hibernate:
    create table member_table (
        id bigint not null,
        name varchar(255),
        primary key (id)
    )
Hibernate:
    create table MY_SEQUENCES (
         sequence_name varchar(255) not null ,
        next_val bigint,
        primary key ( sequence_name )
    )

// 값 조회
Hibernate:
    select
        tbl.next_val
    from
        MY_SEQUENCES tbl
    where
        tbl.sequence_name=? for update

// 테이블에 값 존재하지 않을 경우 삽입
Hibernate:
    insert
    into
        MY_SEQUENCES
        (sequence_name, next_val)  
    values
        (?,?)

// 다음값 증가를 위해 업데이트
Hibernate:
    update
        MY_SEQUENCES
    set
        next_val=?  
    where
        next_val=?
        and sequence_name=?
TABLE member id = 1

// 값 조회
Hibernate:
    select
        tbl.next_val
    from
        MY_SEQUENCES tbl
    where
        tbl.sequence_name=? for update

// 다음값 증가를 위해 업데이트
Hibernate:
    update
        MY_SEQUENCES
    set
        next_val=?  
    where
        next_val=?
        and sequence_name=?
TABLE member id = 2

// 값 조회
Hibernate:
    select
        tbl.next_val
    from
        MY_SEQUENCES tbl
    where
        tbl.sequence_name=? for update

// 다음값 증가를 위해 업데이트
Hibernate:
    update
        MY_SEQUENCES
    set
        next_val=?  
    where
        next_val=?
        and sequence_name=?
TABLE member id = 3

// 앤타타 DB에 저장
Hibernate:
    insert
    into
        member_table
        (name, id)
    values
        (?, ?)
Hibernate:
    insert
    into
        member_table
        (name, id)
    values
        (?, ?)
Hibernate:
    insert
    into
        member_table
        (name, id)
    values
        (?, ?)

5.5 AUTO 전략

AUTO 전략은 선택한 데이터베이스 방언에 따라 IDENTITY, SEQUENCE, TABLE 전략 중 하나를 자동으로 선택한다.

// 기본키 AUTO 전략
@Entity
@Table(name = "MEMBER_AUTO")
public class MemberAuto {

    @Id // 기본키 매핑
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    @Column(name = "NAME")
    private String username;

    // 생략 ...
}

// H2 DB : 기본키 Auto 전략
for (int i = 0; i < 3; i++) {
    MemberAuto member5 = new MemberAuto();
    member5.setUsername("doubles" + i);
    entityManager.persist(member5);
    System.out.println("AUTO member id = " + member5.getId());
}

// 테이블 생성
Hibernate:
    drop table member_auto if exists
Hibernate:
    drop sequence if exists hibernate_sequence
Hibernate:
    create table member_auto (
        id bigint not null,
        name varchar(255),
        primary key (id)
    )

// 시퀀스 생성
Hibernate:
    create sequence hibernate_sequence start with 1 increment by 1

// 시퀀스 호출
Hibernate:
    call next value for hibernate_sequence
AUTO member id = 1
Hibernate:
    call next value for hibernate_sequence
AUTO member id = 2
Hibernate:
    call next value for hibernate_sequence
AUTO member id = 3

// 엔티티 DB 저장
Hibernate:
    insert
    into
        member_auto
        (name, id)
    values
        (?, ?)
Hibernate:
    insert
    into
        member_auto
        (name, id)
    values
        (?, ?)
Hibernate:
    insert
    into
        member_auto
        (name, id)
    values
        (?, ?)

AUTO 전략의 장점은 데이터베이스를 변경해도 코드를 수정할 필요가 없다. 특히 키 생성 전략이 확정되지 않은 개발 초기단계나 프로토 타입 개발시 편리하게 사용할 수 있다.

5.6 기본키 매핑 요약

직접할당 : em.persist()를 호출하기전에 애플리케이션에서 직접 식별자 값을 할당해야한다. 값이 없으면 예외발생
SEQUENCE : 데이터베이스 시퀀스에서 식별자 값을 획득한 후 영속성 컨텍스트에 저장
TABLE : 데이터베이스 시퀀스 생성요 테이블에서 식별자 값을 획득한 후 영속성 컨텍스트에 저장
IDENTITY : 테이터베이스에 엔티티를 저장해서 식별자 값을 획득한 후 영속성 컨텍스트에 저장(테이블에 데이터를 저장해야 식별자 값 획득 가능)

6. 필드와 칼럼 매핑 : 레퍼런스

필드와 칼럼 매핑을 간단하게 분류하면 아래와 같다.

필드와 컬럼 매핑
- @Column : 컬럼 매핑
- @Enumerated : 자바 enum 타입 매핑
- @Temporal : 날짜 타입 매핑
- @Lob : BLOB, CLOB 타입을 매핑
- @Transient : 특정 필드를 DB에 매핑하지 않음
기타
- @Access : JPA가 엔티티에 접근하는 방식을 지정

이 분류에 따라 좀더 자세히 알아보자.

6.1 @Column

@Column은 객체 필드를 테이블 칼럼에 매핑한다.

6.1.1 속성

name 속성 - 필드와 매핑할 테이블의 컬럼 이름, 기본값은 객체의 필드 이름
nullable 속성 - null 값의 허용여부를 설정, 기본값 true
unique 속성 - 한 컬럼에 간단한 유니크 제약조건을 걸 때 사용, 만약 두 컬럼이상일 경우 클래스 레벨에서 사용해야함
length 속성 - 문자 길이 제약조건, String 타입일 경우만 사용, 기본값 255

6.1.2 주의사항

주의해야 할 것은 자바의 기본타입의 경우 @Column을 사용하면 nullable = false로 지정하는 것이 안전하다. 그 이유는 자바 기본타입의 경우 null값을 입력할 수 없기 때문이다.

6.2 @Enumerated

@Enumerated는 자바의 enum 타입을 매핑할 때 사용한다.

6.2.1 예

// enum 클래스
enum RoleType {
  ADMIN, USER
}

// enum 매핑
@Enumerated(EnumType.STRING)
private RoleType roleType1;

@Enumerated(EnumType.ORDINAL)
private RoleType roleType2;

// enum 사용
member1.setRoleType(roleType1.ADMIN); // DB에 문자 ADMIN으로 저장

member2.setRoleType(roleType2.ADMIN); // DB에 숫자 0으로 저장

6.2.2 속성

EnumType.ORDINAL
- enum 순서를 데이터베이스에 저장
- DB에 저장되는 크기가 작음
- 저장된 enum의 순서변경 불가
EnumType.STRING
- enum 이름을 데이터베이스에 저장
- DB에 저장되는 크기가 비교적 큼
- 저장된 enum의 순서가 바뀌거나 추가되도 안전

6.3 @Temporal

날짜 타입(java.util.Date, java.util.Calendar)을 매핑할 때 사용한다.

6.3.1 속성

TemporalType.DATE : 날짜, 데이터베이스 date 타입과 매핑, ex) 2017-01-01
TemporalType.TIME : 시간, 데이터베이스 time 타입과 매핑, ex) 01:00:00
TemporalType.TIMESTAMP : 날짜와 시간 데이터베이스 timestamp 타입과 매핑, ex) 2017-01-01 01:00:00

6.3.2 예

@Temporal(TemporalType.DATE)
private Date date; // 날짜

@Temporal(TemporalType.TIME)
private Date time; // 시간

@Temporal(TemporalType.TIMESTAMP)
private Date timestamp; // 날짜와 시간

6.4 @Lob

데이터베이스 BLOB, CLOB 타입과 매핑한다.

6.4.1 속성

지정할 수 있는 속성이 없음
매핑하는 필드 타입이 문자면 CLOB으로 매핑, 나머지는 BLOB으로 매핑
- CLOB - String, char[], java.sql.CLOB
- BLOB - byte[], java.sql.BLOB

6.4.2 예

@Lob
private String lobString;

@Lob
private byte[] lobByte;

6.5 @Transient

@Transient는 특정 필드를 DB에 매핑하지 않는다.

데이터베이스에 저장하지 않고, 조회도 하지않음
객체에 임시로 어떤 값을 보관하고 싶을 경우 사용

6.6 @Access

@Access는 JPA가 엔티티에 접근하는 방식을 지정한다.

6.6.1 접근 방식

필드 접근 : AccessType.FIELD로 지정, 필드에 직접 접근, 접근권한이 private이어도 가능
프로퍼티 접근 : AccessType.PROPERTY로 지정, 접근자(getter)를 사용

6.6.2 예

// 필드 접근
@Entity
@Access(AccessType.FIELD) // 생략 가능
public class Member {

  @Id
  private String id;

  // ....
}

// 프로퍼티 접근
@Entity
@Access(AccessType.PROPERTY) // 생략 가능
public class Member {

  private String id;

  // ....

  @Id
  public String getId() {
    return id;
  }

  // ....
}

// 필드와 프로퍼티 접근 혼용
@Entity
public class Member {

  @Id
  private String id;  // 필드 접근 방식

  @Transient
  private String firstName;

  @Transient
  private String lastName;

  // ....

  @Access(AccessType.PROPERTY)  // 프로퍼티 접근 방식
  public String getFullName() {
    return firstName + lastName;
  }

}

7. Summery / Conclusion

객체 매핑 : @Entity
테이블 매핑 : @Table
스키마 자동생성
기본키 매핑 전략
- 직접할당
- IDENTITY
- SEQUENCE
- TABLE
- AUTO
필드 / 칼럼 매핑
- @Column
- @Enumerated
- @Temporal
- @Lob
- @Transient
필드, 프로퍼티 접근
- @Access

JPA - 영속성 관리

더블에스님 — Thu, 14 Mar 2019 23:11:55 +0900

ch03-persistence-context.md

본 글은 자바 ORM 표준 JPA 프로그래밍를 읽고 개인적으로 학습한 내용 복습하기 위해 작성된 글로 내용상 오류가 있을 수 있습니다. 오류가 있다면 지적 부탁 드리겠습니다.

JPA - 영속성 관리

1. 영속성 컨텍스트 기본 개념

영속성 컨텍스트(Persistence Context)란 "엔티티를 영구 저장하는 환경"이라는 뜻이다. 엔티티 매니저로 엔티티를 저장하거나 조회하면 엔티티 매니저는 영속성 컨텍스트에서 엔티티를 보관하고 관리한다.

persist()메서드는 엔티티 매니저를 사용해서 회원 엔티티를 영속성 컨텍스트에 저장한다.

2. 엔티티 생명주기

엔티티에는 4가지 상태가 존재하며 생명주기는 아래의 그림과 같다.

비영속(new/transient) : 영속성 컨텍스트와 관계가 없는 상태
영속(managed) : 영속성 컨텍스트에 저장된 상태
준영속(detached) : 영속성 컨텍스트에 저장되었다가 분리된 상태
삭제(removed) : 삭제된 상태

2.1 비영속

엔티티 객체를 생성하여 순수한 객체의 상태이며 저장하지 않은 상태를 말한다. 따라서 영속성 컨텍스트나 데이터베이스와 관련이 없다.

// 객체 생성 : 비영속
Member member = new Member();
member.setId("id001");
member.setUsername("doubles");

2.2 영속

앤티티 매니저를 통해 앤티티를 영속성 컨텍스트에 저장한 상태를 말한다. 영속성 컨텍스트가 관리하는 엔티티를 영속상태라고 한다.

// 저장 : 영속
entityManager.persist(member);
// 한건 조회 : 영속
entityManager.find("id001");
// 목록 조회 : 영속
List<Member> members = entityManager.createQuery("SELECT m FROM Member m", Member.class).getResultList();

2.3 준영속

영속성 컨텍스트가 관리하던 영속상태의 엔티티를 영속성 컨텍스트가 관리하지 않으면 준영속 상태가 된다. 특정 엔티티를 준영속 상태로 만드려면 아래의 메서드들을 호출하면 된다.

entityManager.detach() : 분리
entityManager.close() : 영속성 컨텍스트 닫음
entityManager.clear() : 영속성 컨텍스트 초기화

2.4 삭제

엔티티를 영속성 컨텍스트와 데이터베이스에서 삭제한다.

entityManager.remove();

3. 영속성 컨텍스트 특징

영속성 컨텍스트의 특징은 아래와 같다.

영속성 컨텍스트는 엔티티를 식별자 값으로 구분한다, 즉 영속상태는 식별자 값이 존재해야만 한다.
영속성 컨텍스트에 저장된 엔티티는 트랜잭션을 커밋하는 순간 데이터베이스에 반영된다. 이것을 플러시라 한다.
영속성 컨텍스트의 장점
- 1차 캐시
- 동일성 보장
- 트랜잭션을 지원하는 쓰기 지연
- 변경감지
- 지연로딩

그럼 영속성 컨텍스트가 왜 필요하고 어떤 장점이 있는지 CRUD를 하면서 알아보자

3.1 조회 : 1차 캐시, 동일성 보장

영속성 컨텍스는 내부에 캐시를 가지고 있는데 이것을 1차 캐시라 한다. 영속상태의 엔티티는 이곳에 모두 저장된다. 쉽게 말하면 영속성 컨텍스트 내부에 Map이 있는데 키는 @Id로 매핑한 식별자고 값은 엔티티 컨텍스트이다.

// 비영속 상태 : 객체 생성
Member member = new Memebr();
member.setId("id001");
member.setUsername("doubles");

// 영속 상태
// 1차 캐시에 저장
entityManager.persist(member); // 엔티티 저장

// 1차 캐시에 존재하는 엔티티를 조회할 경우
// 1. 1차 캐시에서 조회
// 2. 반환
Member member1 = entityManager.find(Member.class, "id001"); // 한 건 조회

// 1차 캐시에 존재하지 않는 엔티티를 조회할 경우
// 1. 1차 캐시에서 id002를 식별자로 가진 엔티티 조회
// 2. 1차 캐시에 존재하지 않기 때문에 DB에서 조회해서 엔티티를 생성
// 3. 1차 캐시에 저장
// 4. 반환
Member member2 = entityManager.find(Member.class, "id002"); // 한 건 조회

// 영속 엔티티 동일성
// 식별자가 같은 엔티티 2번 조회
Member a = entityManager.find(Member.class, "id001");
Member b = entityManager.find(Member.class, "id001");

// 엔티티 a와 b는 1차 캐시에 있는 같은 엔티티를 반환 받았기 때문에 같은 인스턴스
System.out.println(a == b); // true

3.2 등록 : 트랜잭션을 지원하는 쓰기 지연

// memberA, memberB 객체 생성
// 엔티티 매니저 생성, 트랜잭션 획득 ...

transaction.begin(); // 트랜잭션 시작

entityManager.persist(memberA);
entityManager.persist(memberB);
// INSERT SQL을 DB에 보내지 않음

// 커밋을 수행하는 순간 INSERT SQL을 DB에 보냄
transaction.commit(); // 트랜잭션 커밋

엔티티 매니저는 트랜잭션을 커밋하기 전까지 DB에 엔티티를 저장하지 않고, 내부 쿼리 저장소에 INSERT SQL을 차곡차곡 모아둔다. 트랜잭션을 커밋할 때 모아둔 SQL을 DB에 보낸다. 이것을 쓰기 지연이라고 한다.

트랜잭션을 커밋하면 영속성 컨텍스트는 플러시를 하는데 여기서 플러시는 영속성 컨텍스트의 변경 내용을 DB에 동기화하는 작업을 말한다.

3.3 수정 : 변경 감지, 지연 로딩

// 엔티티 매니저 생성, 트랜잭션 획득 ...

transaction.begin(); // 트랜잭션 시작

Member findMember = entityManager.find(Member.class, "id001"); // 영속 엔티티 조회

// 영속 엔티티 데이터 수정
findMember.setUsername("더블에스");
findMember.setAge(29);

//entityManager.update(findMember); // 이런 코드는 없다!

transaction.commit(); // 트랜잭션 커밋

JPA에서 엔티티를 수정할 때는 위와 같이 엔티티를 조회하고 데이터만 변경해주기만 하면 된다. 수정과 관련된 메서드는 JPA에서 따로 존재하지 않는다. 이렇게 엔티티의 변경사항을 DB에 자동으로 반영하는 것을 변경감지라고 한다.

그렇다면 변경감지 기능은 어떻게 작동하는지 알아보자.

JPA는 엔티티를 영속성 컨텍스트에 보관할 때, 최초 상태를 복사해 저장해두는데 이것을 스냅샷이라 한다. 그리고 플러시 시점에 스냅샷과 엔티티를 비교하여 변경된 엔티티를 찾게된다.

트랜잭션 커밋 ---> 플러시 호출
엔티티와 스냅샷 비교, 변경된 엔티티를 찾음
변경된 엔티티가 존재하면 수정 쿼리를 생성 ---> 쓰기지연 SQL 저장소에 보관
쓰기지연 SQL을 DB에 전송
DB 트랜잭션 커밋

변경 감지는 영속성 컨텍스트가 관리하는 영속상태의 엔티티에만 적용되고 비영속, 준영속 상태의 엔티티는 적용되지 않는다.

변경감지로 인해 생성된 UDPATE SQL은 엔티티의 모든 필드를 업데이트 한다. 모든 필드를 DB에 보내면 데이터 전송량이 증가하는 단점이 존재하지만 아래와 같은 장점을 얻게 된다.

모든 필드를 사용하면 수정 쿼리가 항상 같다. 애플리케이션 로딩시점에 수정쿼리를 미리 생성하고 재사용이 가능하다.
DB에 동일한 쿼리를 보내면 DB는 이전에 한번 파싱된 쿼리를 재사용할 수 있다.

3.4 삭제

Member member1 = entityManager.find(Member.class, "id001"); // 삭제 대상 엔티티 조회
entityManager.remove(member); // 엔티티 삭제

엔티티를 삭제하려면 삭제 대상 엔티티를 조회하고 엔티티 매니저에 삭제 대상 엔티티를 넘겨주면 해당 엔티티를 삭제한다. 엔티티 등록과 동일하게 삭제 쿼리를 쓰기 지연 SQL 저장소에 등록한 뒤 트랜잭션을 커밋해서 플러시를 호출하면 DB에 삭제쿼리를 전달한다.

4. 플러시

플러시는 영속성 컨텍스트의 변경 내용을 데이터베이스에 반영한다 플러시를 실행하면 아래와 같은 일이 일어난다.

변경 감지가 동작해서 영속성 컨텍스트에 있는 모든 엔티티를 스냅샷과 비교해서 수정된 엔티티를 찾는다. 수정된 엔티티는 수정 쿼리를 만들어 쓰기 지연 SQL 저장소에 등록한다.
쓰기 지연 SQL 저장소의 쿼리를 데이터베이스에 전송한다.

영속성 컨텍스트를 플러시하는 방법은 아래와 같이 3가지 방법이 있다.

4.1 직접호출

entityManager.flush()메서드 직접 호출해서 영속성 컨텍스트를 강제로 플러시 한다. 테스트 또는 다른 프레임워크랑 함께 JPA를 사용할 때를 제외하고 거의 쓰이지 않는다.

4.2 트랜잭션 커밋 시 플러시 자동 호출

DB에 변경 내용을 SQL로 전달하지 않고 트랜잭션만 커밋하면 어떤 데이터도 DB 반영되지 않는다. 그래서 트랜잭션을 커밋하기 전에 플러시를 호출해서 영속성 컨텍스트의 변경 내용을 DB에 반영해야 한다. JPA는 이러한 문제를 예방하기 위해 트랜잭션을 커밋할 때 플러시를 자동 호출한다.

4.3 JPQL 쿼리 실행시 플러시 자동 호출

// 객체 memberA, memberB, memberC 생성
// 엔티티 매니저 생성, 트랜잭션 획득 ...

entityManager.persist(memberA); // 등록
entityManager.persist(memberB); // 등록
entityManager.persist(memberC); // 등록

// JPQL 실행
List<Member> members = entityManager.createQuery("SELECT m FROM Member m", Member.class).getResultList();

// 트랜잭션 커밋 ...

JPQL이나 Criteria 같은 객체지향 쿼리를 호출할 때도 플러시가 실행된다. persist()메서드를 호출해서 엔티티 memberA, memberB, memberC를 영속 상태로 만들고, 영속성 컨텍스트에 있지만 아직 DB에는 반영되지 않았다. 이 때 JPQL을 실행하면 SQL로 변환되어 데이터베이스에서 엔티티를 조회한다. 그런데 memberA, memberB, memberC는 아직 데이터베이스에 없으므로 쿼리 결과로 조회가 되지 않는다. 따라서 쿼리를 실행하기 직전에 영속성 컨텍스트를 플러시해서 변경 내용을 DB에 반영해야만 한다.

JPA는 이런 문제를 예방하기 위해 JPQL을 실행할 때도 플러시를 자동 호출한다. 그래서 memberA, memberB, memberC들도 쿼리 결과에 포함된다.

find()메서드의 경우는 플러시가 실행되지 않는다.

플러시는 영속성 컨텍스트에 보관된 엔티티를 지우는 것이 아니라 영속성 컨텍스트의 내용변경을 데이터베이스에 동기화하는 것이다.

5. 준영속

영속성 컨텍스트가 관리하는 영속상태의 엔티티가 영속성 컨텍스트에서 분리된 것을 준영속 상태라고 한다. 준영속 상태의 엔티티는 영속성 컨텍스트가 제공하는 기능을 사용할 수 없다.

5.1 엔티티를 준영속 상태로 전환 : detach()

// 영속 상태
entityManager.persist(member);

// 회원 엔티티를 영속성 컨텍스트에서 분리, 준영속 상태
entityManager.detach(member);

// 태랜잭션 커밋 ...

detach()메서드는 특정 엔티티를 준영속 상태로 만드는데 위의 코드를 보면 먼저 회원 엔티티를 영속화한 다음 detach()메서드를 호출했다. 영속성 컨텍스트에게 해당 엔티티를 관리하지 말라는 것이다. 이 메서드를 호출하면 1차 캐시, 쓰기 지연 SQL 저장소까지 해당 엔티티를 관리하기 위한 정보가 모두 제거된다.

5.2 영속성 컨텍스트 초기화 : clear()

// 엔티티 조회, 영속 상태
Member member = entityManager.find(Member.class, "id001");

// 영속성 컨텍스트 초기화
entityManager.clear();

// 준영속 상태
member.setAge("28"); // 변경 감지는 독장 하지 않기 때문에 변경되지 않는다.

clear()메서드는 영속성 컨텍스트를 초기화해서 해당 영속성 컨텍스트의 모든 엔티티를 준영속 상태로 만든다. 영속성 컨텍스트를 제거하고 새로 만든것과 같다.

5.3 영속성 컨텍스트 종료 : close()

// 엔티티 매니저 생성, 트랜잭션 획득 ...

transaction.begin(); // 트랜잭션 시작

Member memberA = entityManager.find(Member.class, "id001");
Member memberB = entityManager.find(Member.class, "id002");

transaction.commit(); // 트랜잭션 커밋

entityManager.close(); // 영속성 컨텍스트 닫기

영속성 컨텍스트트 종료하면 해당 영속성 컨텍스트가 관리하던 영속 상태의 엔티티가 모두 준영속 상태가 된다.

5.4 준영속 상태의 특징

준영속 상태의 엔티티의 특징은 아래와 같다.

거의 비영속 상태에 가깝기 때문에 영속성 컨텍스트가 제공하는 어떤 기능도 동작하지 않는다.
비영속 상태는 식별값이 없지만 준영속 상태는 이미 영속 상태였기 때문에 식별자 값을 가지고 있다.
지연로딩을 할 수 없다.(추후 정리예정)

5.5 병합 : merge()

준영속 상태의 엔티티를 다시 영속 상태로 변경하려면 병합을 사용하면 된다. merge()메서드는 준영속 상태의 엔티티를 받아서 그 정보로 새로운 영속 상태의 엔티티를 반환한다.

public class ExamMergeMain {

    // 엔티티 매니저 팩토리 생성
    private static EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("jpa03");

    public static void main(String[] args) {

        // 회원 엔티티 생성 --> 준영속 상태
        Member member = createMember("id001", "doubles", 20);

        // 준영속 상태 --> 회원 정보 변경 : 변경이 이루어지지 않음
        member.setUsername("더블에스");

        // 회원 엔티티 병합
        mergeMember(member);
    }

    // 회원 엔티티 생성 --> 영속성 컨텍스트 종료
    private static Member createMember(String id, String username, int age) {

        // 엔티티 매니저 생성
        EntityManager entityManager1 = entityManagerFactory.createEntityManager();

        // 트랜잭션 획득
        EntityTransaction transaction1 = entityManager1.getTransaction();

        transaction1.begin();   // 트랜잭션 시작

        // 회원 객체 생성
        Member member = new Member();
        member.setId(id);
        member.setUsername(username);
        member.setAge(age);

        // 회원 엔티티 등록
        entityManager1.persist(member);

        transaction1.commit();  // 트랜잭션 커밋

        // 영속성 컨텍스트 종료 ---> 회원 엔티티 준영속 상태로 변경됨
        entityManager1.close();

        return member;
    }

    // 병합
    private static void mergeMember(Member member) {

        // 엔티티 매니저 생성
        EntityManager entityManager2 = entityManagerFactory.createEntityManager();

        // 트랜잭션 획득
        EntityTransaction transaction2 = entityManager2.getTransaction();

        transaction2.begin(); // 트랜잭션 시작

        // 회원 엔티티 병합 ---> 회원 엔티티 변경 감지 DB 반영
        Member mergeMember = entityManager2.merge(member);

        transaction2.commit(); // 트랜잭션 커밋

        System.out.println("member = " + member.getUsername()); // 준영속 상태

        System.out.println("mergeMember = " + mergeMember.getUsername()); // 영속 상태

        System.out.println("entityManager2 contains member = " + entityManager2.contains(member));

        System.out.println("entityManager2 contains mergeMember = " + entityManager2.contains(mergeMember));

        entityManager2.close();
    }

}

위의 코드는 준영속 상태의 엔티티가 어떻게 영속상태로 변경되는지 알아보기 위해 작성된 것으로 큰 흐름은 아래와 같다.

createMember()메서드에서 회원 엔티티를 생성하고, 등록한 뒤에 영속성 컨텍스트를 종료시켜 준영속 상태로 만든다.
준영속 상태의 회원 엔티티를 변경하면 변경사항이 적용되지 않는다.
mergeMember()매서드에서 회원 엔티티를 병합하고, 변경사항을 감지하여 DB에 동기화한다.
반환된 mergeMember와 member가 영속성 컨텍스트에 존재하는지 contains()메서드를 통해 확인한다.

위 코드를 실행하고 나면 콘솔에서 아래와 같이 결과를 확인할 수 있다.

Hibernate:
    /* insert com.doubles.jpa03.Member
        */ insert
        into
            MEMBER
            (age, NAME, ID)
        values
            (?, ?, ?)
Hibernate:
    /* load com.doubles.jpa03.Member */ select
        member0_.ID as ID1_0_0_,
        member0_.age as age2_0_0_,
        member0_.NAME as NAME3_0_0_
    from
        MEMBER member0_
    where
        member0_.ID=?
Hibernate:
    /* update
        com.doubles.jpa03.Member */ update
            MEMBER
        set
            age=?,
            NAME=?
        where
            ID=?
member = 더블에스
mergeMember = 더블에스
entityManager2 contains member = false
entityManager2 contains mergeMember = true

콘솔 화면을 통해 확인할 수 있는 것은 merge()메서드를 통해 반환 받은 mergeMember와 member는 다른 인스턴스라는 것을 알 수 있고, mergeMember는 영속상태이고, member는 여전히 준영속 상태라는 것을 알 수 있다. 이렇게 준영속 엔티티를 참조하던 변수는 영속 엔티티를 참조하도록 변경하는 것이 안전하고 바람직하다.

//Member mergeMember = entityManager2.merge(member); 코드 변경
member = entityManager2.merge(member); // 참조를 변경

merge()메서드는 비영속 엔티티도 영속상태로 만들 수도 있다.

Member member = new Member(); // 비영속 상태
Member newMember = entityManager.merge(member); // 엔티티 병합

병합은 파라미터로 넘어온 엔티티의 식별자로 영속성 컨텍스트를 조회하고 없을 경우 DB를 조회한다. 만약 DB에도 존재하지 않는다면 새로운 엔티티를 생성해서 병합을 하게 된다.

병합은 준영속, 비영속을 가리지 않고 식별자로 조회가 가능하면 불러와 병합하고 없다면 새로 생성해서 병합한다.

6. Summery / Conclusion

영속성 컨텍스트는 엔티티를 영구히 저장하는 환경
엔티티 생명주기
- 비영속 : 관계 없음
- 영속 : 저장된 상태, persist()
- 준영속 : 분리된 상태, detach()
- 삭제 : 삭제된 상태, remove()
영속성 컨텍스트의 장점과 특징
- 1차캐시 : 영속성 컨텍스트에 존재하는 일종의 가상DB, Map처럼 key와 value를 가짐
- 동일성 보장 : 같은 엔티티를 조회할 경우, 컨텍스트에 존재하는 엔티티를 바로 반환, 속도에 이점
- 쓰기지연 : SQL 내부저장소에 모아두었다가 트랜잭션 커밋할 때 DB에 전달
- 변경감지 : 엔티티의 변경사항을 스냅샷을 통해 감지하고, DB에 동기화, UPDATE SQL은 모든필드를 수정하는 SQL을 사용
- 지연로딩 :
플러시 : 트랜잭션 커밋할 때 영속성 컨텍스트가 플러시되고 DB에 변경사항을 동기화
준영속 상태에서는 영속성 컨텍스트가 제공하는 기능을 사용하지 못함

JPA 프로젝트 생성 및 세팅

더블에스님 — Wed, 13 Mar 2019 21:21:48 +0900

ch02-jpa-start.md

본 글은 자바 ORM 표준 JPA 프로그래밍를 읽고 개인적으로 학습한 내용 복습하기 위해 작성된 글로 내용상 오류가 있을 수 있습니다. 오류가 있다면 지적 부탁 드리겠습니다.

JPA 시작

1. JPA 프로젝트 생성 및 설정

1.1 프로젝트 생성

IntelliJ에서 maven 프로젝트를 생성하고 pom.xml을 아래와 같이 작성해준다.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.doubles</groupId>
    <artifactId>jpa02</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!--JPA, 하이버네이트-->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>4.3.10.Final</version>
        </dependency>
        <!--h2 DB-->
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <version>1.4.187</version>
        </dependency>
    </dependencies>
</project>

JPA, 하이버네이트 라이브러리 추가
H2 데이터베이스 라이브러리 추가

1.2 H2 데이터베이스 설치 및 테이블 생성

H2 데이터베이스를 다운받고, 압축을 해제한 뒤 h2/bin 경로에서 아래와 같이 실행 시킨다.

java -jar h2[버전].jar

그리고 http://localhost:8082/로 접속하여 h2 로그인 화면이 나오면 아래의 정보를 입력하고 연결을 진행한다.

드라이버 클래스 : org.h2.driver
JDBC URL : jdbc:h2:tcp://localhost/~/test
사용자명 : sa
비밀번호 : 없음

그리고 예제에 필요한 테이블 생성을 해준다.

CREATE TABLE MEMBER (
  ID VARCHAR(255) NOT NULL,
  NAME VARCHAR(255),
  AGE INTEGER NOT NULL,
  PRIMARY KEY (ID)
)

1.3 persistence.xml 설정

JPA는 persistence.xml을 사용해 필요한 정보를 관리한다. 이 설정 파일이 META-INF/persistence.xml 경로에 있으면 별도의 설정 없이 인식한다.

<?xml version="1.0" encoding="UTF-8"?>
<!--JPA는 persistence.xml을 사용하여 필요한 설정 정보를 관리-->
<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence" version="2.1"> <!-- 버전 명시 -->
    <persistence-unit name="jpa02"> <!-- 데이터베이스당 하나의 영속성 유닛을 등록하기 위해 고유한 이름 부여 -->
        <properties>

            <!-- 필수 속성 -->
            <!--javax.persistence로 시작하는 속성은 JPA 표준속성으로 특정 구현체에 종속되지 X-->
            <!--JPA 표준 속성-->
            <property name="javax.persistence.jdbc.driver" value="org.h2.Driver"/> <!--JDBC 드라이버-->
            <property name="javax.persistence.jdbc.user" value="sa"/> <!--데이터베이스 접속 id-->
            <property name="javax.persistence.jdbc.password" value=""/> <!--데이터베이스 접속 pw-->
            <property name="javax.persistence.jdbc.url" value="jdbc:h2:tcp://localhost/~/test"/> <!--데이터베이스 접속 URL-->

            <!--하이버네이트 속성-->
            <!--hibernate로 시작하는 속성은 하이버네이트 전용 속성으므로 하이버네이트에서만 사용가능-->
            <!--데이터베이스 방언 : 데이터베이스별로 SQL문법과 함수가 조금씩 다른 것을 의미-->
            <!--H2 데이터베이스 방언-->
            <property name="hibernate.dialect" value="org.hibernate.dialect.H2Dialect" />

            <!--
            오라클 10g 데이터베이스 방언
            <property name="hibernate.dialect" value="org.hibernate.dialect.Oracle10gDialect" />
            -->

            <!--
            Mysql 데이터베이스 방언
            <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5InnoDBDialect" />
            -->

            <!-- 옵션 -->
            <property name="hibernate.show_sql" value="true" /> <!--하이버네이트가 실행한 SQL을 출력-->
            <property name="hibernate.format_sql" value="true" /> <!--하이버네이트가 실행한 SQL을 출력할 때 정렬-->
            <property name="hibernate.use_sql_comments" value="true" /> <!--쿼리를 출력할 때 주석도 함께-->
            <property name="hibernate.id.new_generator_mappings" value="true" /> <!--JPA표준에 맞춘 새로운 키 생성 전략 사용-->

            <!--<property name="hibernate.hbm2ddl.auto" value="create" />-->
        </properties>
    </persistence-unit>
</persistence>

1.4 프로젝트 구조

위와 같이 설정을 마무리하고 기본패키지 하위에 앞으로 작성할 클래스를 추가하면 아래와 같이 프로젝트 구조가 이루어진다.

src/main
├── java
|     └── 기본패키지
|             ├── JpaMain.java (실행클래스)
|             └── Member.java (회원 엔티티)
├── resources
|       └── META-INF
|               └── persistence.xml (JPA 설정정보)
pom.xml

2. 객체 매핑

애플리케이션에서 사용할 회원 클래스를 아래와 같이 작성해준다.

// Member 클래스
@Entity // 클래스와 테이블을 매핑하는 것을 알려준다. 엔티티 클래스라 한다.
@Table(name = "MEMBER") // 매핑할 테이블 정보 명시, 생력할 경우 클래스명으로 테이블 이름 매핑
public class Member {

    @Id // 기본키 매핑, 식별자 필드
    @Column(name = "ID") // 필드를 컬럼에 매핑
    private String id;

    @Column(name = "NAME")
    private String username;

    private Integer age; // 매핑 정보가 없을 경우 필드명이 컬럼명으로 매핑 , 대소문자를 구분하는 DB일 경우 명시해줘야한다.

    // getter, setter 생략
}

기본적인 매핑 애너테이션은 추가적으로 정리할 예정

3. 애플리케이션 개발

JPA 애플리케이션을 실행하는 코드는 아래와 같다.

// JpaMain 클래스
public class JpaMain {
    public static void main(String[] args) {

        // 1. 엔티티 매나저 팩토리 생성
        EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("jpa02");

        // 2. 엔티티 매나저 생성
        EntityManager entityManager = entityManagerFactory.createEntityManager();

        // 3. 트랜잭션 획득
        EntityTransaction entityTransaction = entityManager.getTransaction();

        try {
            entityTransaction.begin();  // 4. 트랜잭션 시작
            logic(entityManager);       // 5. 비지니스 로직 수행
            entityTransaction.commit(); // 6. 트랜잭션 커밋
        } catch (Exception e) {
            entityTransaction.rollback();   // 6. 트랜잭션 롤백
        } finally {
            entityManager.close();      // 7. 엔티티 매니저 종료
        }
        entityManagerFactory.close();   // 7. 엔티티 매니저 팩토리 종료
    }

    // 비지니스 로직
    private static void logic(EntityManager entityManager) {

        // 회원 객체 생성
        String id = "id01";
        Member member = new Member();
        member.setId(id);
        member.setUsername("doubles");
        member.setAge(20);

        // 등록
        entityManager.persist(member);

        // 수정
        member.setAge(25);

        // 조회 : 하나의 회원
        Member findMember = entityManager.find(Member.class, id);
        System.out.println("findMember : " + findMember.getUsername() + ", " + findMember.getAge());

        // 조회 : 목록
        List<Member> members = entityManager.createQuery("SELECT m FROM Member m", Member.class).getResultList();
        System.out.println("members.size = " + members.size());

        // 삭제
        entityManager.remove(member);
    }
}

위의 코드는 엔티티 매니저 설정, 트랜잭션 관리, 비지니스 로직 으로 크게 3부분으로 나누어져 있다. 이 세부 내용을 살펴보자.

3.1 엔티티 매니저 설정

엔티티 매니저의 생성과정은 아래와 같은 순서로 진행이 된다.

설정정보 조회(/META-INF/persistence.xml)
엔티티 매니저 팩토리 생성
엔티티 매니저 생성
종료

위의 과정에서 주의해야할 사항들은 아래와 같다.

엔티티 매니저 팩토리는 애플리케이션 전체에 한번만 생성하고 공유해서 사용해야한다.
엔티티 매니저는 데이터베이스 커넥션과 밀접한 관계가 있으므로 스레드가 공유하거나 재사용해서는 안된다.
사용이 끝난 엔티티 매니저는 반드시 종료해야 한다.
애플리케이션을 종료할 때 엔티티 매니저 팩토리도 종료해야 한다.

3.2 트랜잭션 관리

JPA를 사용하면 항상 트랜잭션 안에서 데이터를 변경해야 한다. 트랜잭션 없이 데이터를 변경할 경우 항상 예외가 발생한다. 트랜잭션을 시작하려면 엔티티 매니저에서 트랜잭션 API를 받아와야만 한다.

비지니스 로직이 정상 작동하면 트랜잭션을 커밋(commit)
예외가 발생하면 롤백(rollback)

3.3 비지니스 로직

위의 코드에서 비지니스 로직을 보면 회원 엔티티를 하나 생성하고 엔티티 매니저를 통해 데이터베이스에 등록, 수정, 삭제, 조회를 한다.

등록
- 엔티티를 저장하려면 엔티티 매니저의 persist()메서드에 저장할 엔티티를 넘겨주면 된다.
수정
- JPA는 별도의 수정 메서드가 존재하지 않는다.
- 단순히 엔티티의 값만 변경하면 JPA는 어떤 엔티티가 변경되었는지 추척한다.
삭제
- 엔티티를 삭제하려면 엔티티 매니저의 remove()메서드에 삭제할 엔티티를 넘겨주면 된다.
조회 : 하나의 엔티티
- find()메서드는 조회할 엔티티 타입과 @Id로 DB 테이블의 기본키와 매핑한 식별자 값으로 엔티티 하나를 조회한다.
- 조회한 결과 값으로 엔티티를 생성해 반환한다.
조회 : 엔티티 목록
- 하나 이상의 회원 목록을 조회할 경우 JPQL를 사용한다.

그렇다면 JPQL에 대해 간략하게 알아보자. (JPQL은 추후에 따로 정리할 예정)

JPA는 엔티티 객체를 중심으로 개발하므로 검색할 때도 테이블이 아닌 엔티티 객체를 대상으로 검색해야 한다. 그런데 테이블이 아닌 엔티티 객체를 대상으로 검색하려면 데이터베이스의 모든 데이터를 불러와 엔티티 객체로 변경한 다음 검색을 해야하는데 이는 사실상 불가능하다.

그래서 필요한 데이터만 데이터베이스에 불러오려면 검색조건이 포함된 SQL을 사용해야 한다. JPA는 이러한 문제를 JPQL(Java Persistence Query Language)이라는 쿼리언어로 해결한다.

JPA는 SQL을 추상화한 JPQL을 제공하는데 SQL과 문법이 거의 유사해서 SELECT, FROM, WHERE, GROUP BY, HAVING, JOIN 등을 사용할 수 있다.

JPQL : 엔티티 객체(클래스, 필드)를 대상으로 쿼리
SQL : 데이터베이스 테이블을 대상으로 쿼리

SELECT m FROM Member m

위의 Member는 데이터베이스의 MEMBER 테이블이 아니라 엔티티의 Member이다. JPQL은 데이터베이스 테이블의 MEMBER를 전혀 알지 못하는 것이다.

JPQL을 사용하려면 entityManager.createQuery(JPQL, returnType)메서드를 실행해서 쿼리 객체를 생성한 후에 쿼리객체의 getResultList()메서드를 호출하면 된다.

3.4 애플리케이션 실행 결과

findMember : doubles, 25
Hibernate:
    /* insert com.doubles.jpa02.Member
        */ insert
        into
            MEMBER
            (age, NAME, ID)
        values
            (?, ?, ?)
Hibernate:
    /* update
        com.doubles.jpa02.Member */ update
            MEMBER
        set
            age=?,
            NAME=?
        where
            ID=?
Hibernate:
    /* SELECT
        m
    FROM
        Member m */ select
            member0_.ID as ID1_0_,
            member0_.age as age2_0_,
            member0_.NAME as NAME3_0_
        from
            MEMBER member0_
members.size = 1
Hibernate:
    /* delete com.doubles.jpa02.Member */ delete
        from
            MEMBER
        where
            ID=?

위와 같이 콘솔에 수행한 SQL들이 출력되는 것을 확인할 수 있다.

4. Summery / Conculsion

persistent.xml설정
앤티티 매니저 팩토리 -> 앤티티 매니저 -> 트랜잭션 획득 -> 비지니스 로직 수행 -> 앤티티 매니저 종료 -> 앤티티 매니저 팩토리 종료
매핑 애너테이션 : @Entity, @Table, @Column, @Id
앤티티 매니저 메서드
- persist() : 저장
- remove() : 삭제
- find() : 한건 조회
- JPQL : 목록 조회
  - createQuery() : 쿼리 객체 생성
  - getResultList() : 결과 값 호출

JPA 기본 개념

더블에스님 — Wed, 13 Mar 2019 21:19:42 +0900

ch01-jpa-introduction.md

본 글은 자바 ORM 표준 JPA 프로그래밍를 읽고 개인적으로 학습한 내용 복습하기 위해 작성된 글로 내용상 오류가 있을 수 있습니다. 오류가 있다면 지적 부탁 드리겠습니다.

JPA란?

1. JPA 기본 개념

JPA는 자바 진영의 ORM 기술 표준으로 애플리케이션과 JDBC 사이에서 작동한다. 여기서 ORM(Object-Relational Mapping)은 객체와 관계형 데이터베이스를 매핑한다는 뜻이다.

자바 애플리케이션 --- JPA -- JDBC <-----> DB

ORM 프레임워크는 객체와 테이블을 매핑해서 패러다임의 불일치 문제를 해결해준다. 객체를 데이터베이스에 저장할 때 INSERT SQL을 직접 작성하는 것이 아니라 객체를 마치 자바 컬렉션에 저장하듯이 ORM 프레임워크에 저장하면 된다. 그러면 ORM 프레임워크가 적절한 INSERT SQL을 생성해 데이터베이스에 객체를 저장해준다. 조회할 때도 JPA를 통해 객체를 직접 조회하면 된다.

ORM 프레임워크는 단순히 SQL을 개발자 대신 생성해서 데이터베이스에 전달해주는 것뿐만 아니라 패러다임의 불일치 문제들도 해결해준다. 객체 측먄에서 정교한 모델링을 할 수 있고, 관계형 데이터베이스는 데이터베이스에 맞게 모델링을 하면된다. 이 둘을 어떻게 매핑해야하는지 매핑 방법만 ORM 프레임워크에 알려주면 된다.

이렇게 되면 개발자는 데이터 중심인 관계형 데이터 베이스를 사용하더라도 객체지향 애플리케이션 개발에 집중을 할 수 있다.

2. JPA를 사용해야는 이유?

그렇다면 JPA를 사용해야하는 이유를 알아보자.

2.1 생산성

JPA를 사용하면 자바 컬레션에 객체를 저장하듯 JPA에게 저장할 객체를 전달하면 된다. INSERT SQL을 작성하고 JDBC API를 사용하는 반복적인 작업을 JPA가 대신 처리해준다.

jpa.pesist(member); // 저장
Member member = jpa.find(memberId); // 조회

반복적인 코드와 CRUD SQL을 개발자가 직접 작성하지 않아도 된다.
DDL문을 자동으로 생성해주는 기능도 있다.
위의 기능들을 사용함으로써 데이터베이스 설계 중심의 패러다임을 객체 설계 중심으로 역전시킬 수 있다.

2.2 유지보수

SQL에 의존적인 개발을 하거나 SQL을 직접 다루면 엔티티에 필드를 하나만 추가해도 관련된 등록, 수정, 조회 SQL과 결과를 매핑하기 위한 JDBC API 코드를 모두 변경해야한다. JPA를 사용하게 되면 이러한 과정을 JPA가 대신 처리해주기 때문에 필드를 추가, 삭제하더라도 수정해야할 코드가 줄어든다.

즉 다시말해 객체지향 언어가 가진 장점을 활용하여 유연하고 유지보수하기 좋은 도메인 모델을 편리하게 설계할 수 있다.

2.3 패러다임 불일치 해결

JPA는 상속, 연관관계, 객체 그래프 탐색, 비교와 같은 패러다임의 불일치 문제를 해결해준다.

2.4 성능

JPA는 애플리케이션과 데이터베이스 사이에서 다양한 성능 최적화 기회를 제공해준다.

String memberId = "helloId";
Member member1 = jpa.find(memberId);
Member member2 = jpa.find(memberId);

위와 같이 같은 트랜잭션 안에서 같은 회원을 두번 조회할 경우, JDBC API를 사용해서 해당 코드를 직접 작성했다면 회원을 조회할 때마다 데이터베이스와 SELECT SQL을 통해 두번 통신을 했을 것이다. 하지만 JPA를 사용하면 SQL을 하번만 데이터베이스에 전달하고 두번째는 조회한 객체를 재사용한다.

2.5 데이터 접근 추상화와 벤더 독립성

관계형 데이터베이스는 같은 기능도 벤더마다 사용법이 다른 경우가 많다. 페이징 처리의 경우 데이터베이스마다 달라서 사용법을 각가 배워야만 한다. 결국 애플리케이션은 처음 선택한 데이터베이스 기술에 종속되고 다른 데이터베이스로 변경하기가 어려워지게 된다.

JPA는 애플리케이션과 데이터베이스 사이에 추상화된 데이터 접근 계층을 제공하여 특정 데이터베이스 기술에 종속되지 않도록 한다. 만약 데이터베이스를 변경하면 JPA에게 데이터베이스의 변경을 알려주기만 하면된다. JPA를 사용하면 로컬개발 환경에서는 H2를 사용하고 사용환경은 오라클이나 MySQL을 사용할 수 있다.

JPA --사용--> Dialect <---- MySQLDialect, OracleDialect, H2Dialect

3. Summery / Conclusion

JPA를 사용함으로써 보다 더 객체지향적인 프로그래밍을 설계할 수 있고, 유지보수 및 코드의 변경에 유연하게 대처할 수 있다는 것을 알수 있었다. 하지만 JPA를 사용한다고 해서 SQL과 데이터베이스를 몰라도 되는 것이 아니라 오히려 좀더 깊게 공부를 해야한다는 것도 알았다. 저자의 말처럼 ORM이 객체지향과 관계형데이터베이스라는 두 기둥 위에 있기 때문이다. 그래서 데이터베이스와 객체를 올바르게 매핑하고 사용하기 위해서는 양쪽 모두를 이해하기 위해 좀더 공부를 더 많이 해야겠다.

Git - 커밋 메시지 컨벤션

더블에스님 — Sun, 10 Mar 2019 22:04:31 +0900

02_commit_message_rule.md

Git - Commit Message Convention

커밋 메시지를 작성할 때는 원칙을 정하고 일관성 있게 작성해야 한다. 아래는 유다시티의 커밋 메시지 스타일 가이드를 참조한 내용이다.

1. Commit Message Structure

기본적으로 커밋 메시지는 아래와 같이 제목/본문/꼬리말로 구성한다.

type : subject

body

footer

2. Commit Type

feat : 새로운 기능 추가
fix : 버그 수정
docs : 문서 수정
style : 코드 포맷팅, 세미콜론 누락, 코드 변경이 없는 경우
refactor : 코드 리펙토링
test : 테스트 코드, 리펙토링 테스트 코드 추가
chore : 빌드 업무 수정, 패키지 매니저 수정

3. Subject

제목은 50자를 넘기지 않고, 대문자로 작성하고 마침표를 붙이지 않는다.
과거시제를 사용하지 않고 명령어로 작성한다.
- "Fixed" --> "Fix"
- "Added" --> "Add"

4. Body

선택사항이기 때문에 모든 커밋에 본문내용을 작성할 필요는 없다.
부연설명이 필요하거나 커밋의 이유를 설명할 경우 작성해준다.
72자를 넘기지 않고 제목과 구분되기 위해 한칸을 띄워 작성한다.

선택사항이기 때문에 모든 커밋에 꼬리말을 작성할 필요는 없다.
issue tracker id를 작성할 때 사용한다.

6. Example

feat: Summarize changes in around 50 characters or less

More detailed explanatory text, if necessary. Wrap it to about 72
characters or so. In some contexts, the first line is treated as the
subject of the commit and the rest of the text as the body. The
blank line separating the summary from the body is critical (unless
you omit the body entirely); various tools like `log`, `shortlog`
and `rebase` can get confused if you run the two together.

Explain the problem that this commit is solving. Focus on why you
are making this change as opposed to how (the code explains that).
Are there side effects or other unintuitive consequenses of this
change? Here's the place to explain them.

Further paragraphs come after blank lines.

 - Bullet points are okay, too

 - Typically a hyphen or asterisk is used for the bullet, preceded
   by a single space, with blank lines in between, but conventions
   vary here

If you use an issue tracker, put references to them at the bottom,
like this:

Resolves: #123
See also: #456, #789

7. My Thought / Conclusion / Summery

위와 같이 그동안 커밋을 하면서 메시지에는 몇번째 커밋인지 그리고 뭘 했는지에 대해서만 간략하게 작성했다. 나 나름의 규칙이라고 생각해서 그렇게 작성했던 것 같다. 하지만 커밋 메시지에도 나름의 규칙과 일관성을 가져야 한다는 것을 알면서도 제대로 실처하지 못했다. 그래서 개발을 하고나서 문제점이 발생하고 어떻게 해결했는지를 찾으려면 좀처첨 헷갈려서 찾을 수가 없었던 적이 많았다. 물론 문제점을 해결한 상황을 따로 정리하지 않은 것이 가장 큰 문제이기도 하다.

앞으로는 위의 규칙을 지키면서 커밋 메시지를 작성하는 노력을 기울여 보자. 그렇게 하면 따로 시간을 내서 문제 상황을 해결한 내용들을 정리할 필요도 없어질 듯 하다.