[자바 ORM 표준 JPA 프로그래밍 - 기본편] 2. JPA 시작하기

본 게시글은 김영한님의 [자바 ORM 표준 JPA 프로그래밍 - 기본편]을 수강하며 작성한 글입니다.

 

1. Hello JPA - 프로젝트 생성

IntelliJ 프로젝트 생성을 통해 Maven 기반 프로젝트를 생성한다.

 

1) Maven 설정

• groubId : jpa-basic
• artifactId : ex1-hello-jpa
• version : 1.0.0

 

2) 라이브러리 추가

<?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>jpa-basic</groupId>
    <artifactId>ex1-hello-jpa</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!-- JPA 하이버네이트 -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>5.3.10.Final</version>
        </dependency>
        <!-- H2 데이터베이스 -->
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <version>2.2.222</version>
        </dependency>
    </dependencies>s

</project>

H2database 버전은 PC에 다운받은 버전과 같아야 한다.

 

3) JPA 설정하기 - persistence.xml

<?xml version="1.0" encoding="UTF-8"?> 
<persistence version="2.2" 
 xmlns="http://xmlns.jcp.org/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
 xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_2.xsd"> 
 <persistence-unit name="hello"> 
 <properties> 
 <!-- 필수 속성 --> 
 <property name="javax.persistence.jdbc.driver" value="org.h2.Driver"/> 
 <property name="javax.persistence.jdbc.user" value="sa"/> 
 <property name="javax.persistence.jdbc.password" value=""/> 
 <property name="javax.persistence.jdbc.url" value="jdbc:h2:tcp://localhost/~/test"/> 
 <property name="hibernate.dialect" value="org.hibernate.dialect.H2Dialect"/> 
 
 <!-- 옵션 --> 
 <property name="hibernate.show_sql" value="true"/> 
 <property name="hibernate.format_sql" value="true"/> 
 <property name="hibernate.use_sql_comments" value="true"/> 
 <!--<property name="hibernate.hbm2ddl.auto" value="create" />--> 
 </properties> 
 </persistence-unit> 
</persistence>

• JPA 설정파일은 /META-INF/persistence.xml 위치한다.
  META-INF 패키지는 main/resource/ 아래에 생성한다.
• persistence-unit name으로 이름을 지정한다.
• javax.persistence로 시작: JPA 표준 속성
• hibernate로 시작: 하이버네이트 전용 속성
• 필수 속성
  • javax.persistence.jdbc.*: 데이터베이스의 접근 정보를 입력한다.
  • hibernate.dialect: 데이터베이스의 방언을 입력한다.

💡 데이터베이스 방언
JPA는 특정 데이터베이스에 종속되어 있지 않다.
각각의 데이터베이스 SQL 문법과 함수는 조금씩 다르다.
- 가변 문자 : MySQL은 VARCHAR, Oracle은 VARCHAR2
- 문자열을 자르는 함수 : SQL 표준은 SUBSTRING(), Oracle은 SUBSTR()
- 페이징 : MySQL은 LIMIT, ORACLE은 ROWNUM
이를 데이터베이스 방언이라고 부르며, SQL 표준을 지키지 않는 특정 데이터베이스만의 고유한 기능이다.

 

2. Hello JPA - 애플리케이션 개발

1) JPA 구동 방식

1. Persistence에서 META-INF/persistence.xml에서 설정 정보를 조회해서 EntityManagerFactory를 생성한다.
2. EntityManagerFactory는 EntityManager라는 클래스를 생성해서 사용한다.

 

2) 실습 - JPA 동작 확인

1. JpaMain 클래스 생성

package hellojpa;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

public class JpaMain {

    public static void main(String[] args) {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("hello");
        EntityManager em = emf.createEntityManager();

        // code
        
        em.close();
        emf.close();
    }
}

실제 동작하는 코드는 아직 없다.

 

2. 객체와 테이블을 생성하고 매핑하기

1) h2 데이터베이스에 member 테이블 생성

create table Member (
    id bigint not null,
    name varchar(255),
    primary key (id)
);

 

2) Member.class 생성

package hellojpa;

import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
public class Member {
    @Id
    private Long id;
    private String name;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

• @Entity: JPA가 관리할 객체
• @Id : 데이터베이스 PK와 매핑

 

3) JpaMain 클래스 코드 추가

package hellojpa;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;

public class JpaMain {

    public static void main(String[] args) {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("hello");
        EntityManager em = emf.createEntityManager();

        EntityTransaction tx = em.getTransaction();
        tx.begin();

        try {
            Member member = new Member();
            member.setId(2L);
            member.setName("HelloB");

            em.persist(member); // 생성
			Member findMember = em.find(Member.class, 1L); // 조회
            findMember.setName("HelloJPA"); // 수정
			em.remove(member) // 삭제

            tx.commit();
        } catch (Exception e) {
            tx.rollback();
        } finally {
            em.close();
        }

        emf.close();

    }
}

• EntityTransaction tx = em.getTransaction()
  : 실제 DB는 Transaction 내에서 이뤄져야 하므로 Transaction 객체 하나를 생성한다.
• tx.begin()
  : transaction을 시작한다. 실패 시 tx.rollback()을 수행한다.
• Member member = new Member()
  : 테이블에 넣기 전 Member 객체를 생성한다.
  member.setId(1L);
  member.setName("HelloA");
• em.persist(member)
  : EntityManager를 통해 member를 DB 내에 생성한다.
• em.find(Member.class, 1L)
  : DB 내 값을 조회한다.
• em.remove(member)
  : DB 내 값을 삭제한다.
• setName("helloJPA")
  : Member 객체에 setter를 통해 테이블 내 값을 수정한다.
  → JPA가 Entity를 관리하기 때문에 하나의 트랜잭션 안에서 커밋하는 시점의 변경사항을 모두 확인하고 반영한다.
• tx.commit()
  : transaction commit을 날려 DB에 변경사항을 반영한다.
• em.close();, emf.close();
  : 사용한 자원을 반환한다.

🚨 주의
1. 엔티티 매니저 팩토리는 하나만 생성해서 애플리케이션 전체에서 공유해야 한다.
2. 엔티티 매니저는 쓰레드 간(요청 단위)에 절대 공유하면 안된다. (사용하고 버려야 한다.)
3. JPA의 모든 데이터 변경은 트랜잭션 안에서만 실행해야 한다. 

 

3) JPQL 소개

• JPA를 사용하면 엔티티 객체를 중심으로 개발한다.
• 문제는 검색 쿼리인데, 검색을 할 때도 테이블이 아닌 엔티티 객체를 대상으로 검색한다.
• 모든 DB 데이터를 객체로 변환해서 검색하는 것은 불가능하다.
• 애플리케이션이 필요한 데이터만 DB에서 불러오려면 결국 검색 조건이 포함된 SQL이 필요하다.
  그러므로 SQL을 추상화한 JPQL이라는 객체지향 쿼리 언어를 제공한다.
• SQL과 문법이 유사하며 GROUP BY, HAVING, JOIN 등 지원하고, 테이블이 아닌 엔티티 객체를 대상으로 쿼리한다. (SQL은 데이터베이스 테이블을 대상으로 쿼리한다.)
• DB 방언을(MySql, Oracle 등) 변경하면 쿼리 문법도 자동으로 변경되어 실행된다.

 

- 가장 단순한 조회

• EntityManager.find()
• 객체 그래프 탐색(a.getB().getC())

 

- 모든 회원 정보 조회

• 단순 조회

List<Member> result = em.createQuery("select m from Member as m", Member.class)
                            .getResultList();

• 페이징 조회

List<Member> result = em.createQuery("select m from Member as m", Member.class)
                    .setFirstResult(1)
                    .setMaxResults(5)
                    .getResultList();