FORDO가 가는 개발자의 길

JPA(11) - 스키마 자동 생성

fordo — Thu, 14 Sep 2023 14:43:05 +0900

이 글은 김영한 선생님의 자바 ORM 표준 JPA 프로그래밍 - 기본편 4-2강을 듣고 정리한 글입니다.

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

DDL을 애플리케이션 실행 시점에 자동 생성
테이블 중심 → 객체 중심
데이터베이스 방언을 활용해서 데이터베이스에 맞는 적절한 DDL 생성
이렇게 생성된 DDL은 개발 장비에서만 사용
생성된 DDL은 운영서버에서는 사용하지 않거나, 적절히 다듬은 후 사용

데이터베이스 스키마 자동 생성 - 속성

create : 기존테이블 삭제 후 다시 생성(DROP + CREATE)
create-drop : create와 같으나 종료시점에 테이블 drop
update : 변경분만 반영(운영DB에는 사용하면 안됨)
validate : 엔티티와 테이블이 정상 매핑되었는지만 확인
none : 사용하지 않음

데이터베이스 스키마 자동 생성 - 주의

운영 장비에는 절대 create, create-drop, update 사용하면 안된다.
개발 초기 단계는 create 또는 update
테스트 서버는 update 또는 validate
스테이징과 운영 서버는 validate 또는 none

DDL 생성 기능

제약조건 추가 : 회원 이름은 필수, 10자 초과X
- @Column(nullable = false, length = 10)
유니크 제약조건 추가
- @Table(uniqueConstraints = {@UniqueConstraint( name = "NAME_AGE_UNIQUE", columnNames = {"NAME", "AGE"})})
DDL 생성 기능은 DDL을 자동 생상할 때만 사용되고 JPA의 실행 로직에는 영향을 주지 않는다.

JPA(10) - 객체와 테이블 매핑

fordo — Thu, 14 Sep 2023 09:30:25 +0900

이 글은 김영한 선생님의 자바 ORM 표준 JPA 프로그래밍 - 기본편 4-1강을 듣고 정리한 글입니다.

@Entity

@Entity가 붙은 클래스는 JPA가 관리, 엔티티라 한다.
JPA를 사용해서 테이블과 매핑할 클래스는 @Entity 필수
주의
- 기본 생성자 피루(파라미터가 없는 public 또는 protected 생성자)
- final 클래스, enum, interface, inner 클래스 사용 X
- 저장할 필드에 final 사용 X

@Entity 속성 정리

name
- JPA에서 사용할 엔티티 이름을 지정한다.
- 기본값 : 클래스 이름을 그대로 사용
- 같은 클래스 이름이 없으면 가급적 기본값을 사용한다.

@Table

@Table은 엔티티와 매핑할 테이블 지정

@Table 속성 정리

name
- 매핑할 데이터 이름
catalog
- 데이터베이스 catalog 매핑
schema
- 데이터베이스 schema 매핑
uniqueConstraints(DDL)
- DDL 생성 시에 유니크 제약 조건 생성

JPA(9) - 준영속 상태

fordo — Wed, 13 Sep 2023 12:04:19 +0900

이 글은 김영한 선생님의 자바 ORM 표준 JPA 프로그래밍 - 기본편 3-4강을 듣고 정리한 글입니다.

준영속 상태

영속 → 준영속
영속 상태의 엔티티가 영속성 컨텍스트에서 분리(detached)
영속성 컨텍스트가 제공하는 기능을 사용 못함

준영속 상태로 만드는 방법

em.detach(entity) - 특정 엔티티만 준영속 상태로 전환
em.clear() - 영속성 컨텍스트를 완전히 초기화
em.close() - 영속성 컨텍스트를 종료

JPA(8) - 플러시

fordo — Wed, 13 Sep 2023 11:41:49 +0900

이 글은 김영한 선생님의 자바 ORM 표준 JPA 프로그래밍 - 기본편 3-3강을 듣고 정리한 글입니다.

플러시

- 영속성 컨텍스트의 변경내용을 데이터베이스에 반영

플러시 발생

변경 감지
수정된 엔티티 쓰기 지연 SQL 저장소에 등록
쓰기 지연 SQL 저장소의 쿼리를 데이터베이스에 전송 (등록, 수정, 삭제 쿼리)

영속성 컨텍스트를 플러시하는 방법

em.flush() - 직접 호출
트랜잭션 커밋 - 플러시 자동 호출
JPQL 쿼리 실행 - 플러시 자동 호출

플러시 모드 옵션

FlushModeType.AUTO - 커밋이나 쿼리를 실행할 떄 플러시 (기본값)
FlushModeType.COMMIT - 커밋할 때만 플러시

플러시는?

영속성 컨텍스를 비우지 않음
영속성 컨텍스트의 변경내용을 데이터베이스에 동기화
트랜잭션이라는 작업 단위가 중요 → 커밋 직전에만 동기화하면 됨

JPA(7) - 영속성 컨텍스트2

fordo — Wed, 13 Sep 2023 11:25:43 +0900

이 글은 김영한 선생님의 자바 ORM 표준 JPA 프로그래밍 - 기본편 3-2강을 듣고 정리한 글입니다.

1차 캐시

Member member = new Member();
member.setId("member1");
member.setUsername("회원1");
//1차 캐시에 저장됨
em.persist(member);
//1차 캐시에서 조회
Member findMember = em.find(Member.class, "member1");

em.persist를 하면 영속 컨텍스트에 등록을 하는 개념이다.

그다음 em.find를 하게되면 먼저 1차 캐시에서 조회를 하게 된다. 없다면 DB에서 조회한 후 가져오게 된다. 이때에도 영속 컨텍스트에 등록이 된다.

영속 엔티티의 동일성 보장

Member a = em.find(Member.class, "member1"); 
Member b = em.find(Member.class, "member1");
System.out.println(a == b); //동일성 비교 true

영속 컨텍스트에 member1이 등록되어있다고 가정하면 a와 b는 같은 객체를 가지고 오기 때문에 비교를 했을 때 true를 반환한다. 내가 알고 있는 mybatis에서는 DB에 종속되어있기 때문에 DB에서 조회한 후 객체에 넣기 때문에 a == b를 했을 때는 false를 반환한다.

엔티티 등록 - 트랜잭션을 지원하는 쓰기 지연

EntityManager em = emf.createEntityManager();
EntityTransaction transaction = em.getTransaction();
//엔티티 매니저는 데이터 변경시 트랜잭션을 시작해야 한다.
transaction.begin();
em.persist(memberA);
em.persist(memberB);
//여기까지 INSERT SQL을 데이터베이스에 보내지 않는다.
//커밋하는 순간 데이터베이스에 INSERT SQL을 보낸다.
transaction.commit();

엔티티 수정 - 변경 감지

EntityManager em = emf.createEntityManager();
EntityTransaction transaction = em.getTransaction();
transaction.begin();
// 영속 엔티티 조회
Member memberA = em.find(Member.class, "memberA");
// 영속 엔티티 데이터 수정
memberA.setUsername("hi");
memberA.setAge(10);
transaction.commit();

em.find해서 찾아온 객체를 em.persist할 필요없이 객체의 필드를 변경하게 되면 commit이 이뤄질 때 영속 컨텍스트에 있는 객체와 비교하여 자동으로 변경을 감지해 update 구문을 실행한다.

이점은 JPA가 참 편한 것 같다. 계속해서 mybatis와 비교하게 되는데 나는 처음 배울때부터 지금 현업을 할 때까지 mybatis 밖에 사용하지 않았기 때문에 더 차이를 느끼는 것 같다. mybatis에서는 update 쿼리를 직접 짜두고 수정이 필요할 때마다 해당 서비스를 호출해 직접 update를 시켰지만 JPA는 위와 같이 영속 컨텍스트에 있는 것과 자동으로 비교해서 update 쿼리를 실행하니 말이다.

엔티티 수정이 되는 과정

스냅샷은 처음에 조회했을 때의 정보를 나타낸다.

변경된 엔티티와 스냅샷과 비교한 후 update 쿼리를 생성해 마지막 commit되는 시점에 쿼리를 실행시킨다.

JPA(6) - 영속성 컨텍스트

fordo — Tue, 12 Sep 2023 15:40:04 +0900

이 글은 김영한 선생님의 자바 ORM 표준 JPA 프로그래밍 - 기본편 3-1강을 듣고 정리한 글입니다.

영속성 컨텍스트

엔티티를 영구 저장하는 환경
EntityManager.persist(entity);
영속성 컨텍스트는 논리적인 개념
엔티티 매니저를 통해서 영속성 컨텍스트에 접근

J2SE 환경 - 엔티티매니저와 영속성 컨텍스트가 1:1 관계

엔티티의 생명주기

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

영속성 컨텍스트의 이점

1차 캐시
동일성(identity) 보장
트랜잭션을 지원하는 쓰기 지연(transactional write-behind)
변경 감지(Dirty Checking)
지연 로딩(Lazy Loading)

JPA(5)

fordo — Tue, 12 Sep 2023 15:27:29 +0900

이 글은 김영한 선생님의 자바 ORM 표준 JPA 프로그래밍 - 기본편 2-2강을 듣고 정리한 글입니다.

MEMBER TABLE 생성

id 컬럼과 name 컬럼을 생성해주고 id는 primary key(pk)로 지정한다.

MemberVO 생성

package hellojpa.VO;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "MEMBER")
public class Member {
    @Id
    private Long Id;

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

    public Long getId() {
        return Id;
    }

    public void setId(Long id) {
        Id = id;
    }

    public String getName() {
        return name;
    }

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

@Entity - 테이블과 매핑할 클래스에 사용하여 JPA가 해당 클래스를 관리하게한다.

@Table - 테이블명과 객체명이 서로 다른 경우 테이블 이름을 지정해 매핑할 수 있다.

@Column - 컬럼명과 필드명이 서로 다른 경우 컬럼명을 지정해 매핑할 수 있다.

@Id - 테이블의 기본키가 지정된 컬럼과 매핑된 필드에 사용한다.

JPA 기본 문법

1. 데이터 Insert

package hellojpa;

import hellojpa.VO.Member;

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

public class Main {
    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(1L);
            member.setName("HelloA");
            em.persist(member);
            tx.commit();
        }catch (Exception e){
            tx.rollback();
        } finally {
            em.close();
        }
       
        emf.close();
        System.out.println("Hello world!");
    }
}

EntityManagerFactory는 절대 공유해선 안되고 상황에 따라 만들어야한다. - 동시에 접근이 가능하게하면 하나를 수정하고 있을 때 다른 사용자도 수정할 수 있기 때문. 사용이 끝나면 close()로 만납해야한다.

EntityManager는 Entity를 관리하는 역할이다. 엔티티 매니저 내부에 영속성 컨텍스트를 만들어서 관리한다. 사용이 끝나면 close()로 반납해야한다.

EntityTransaction은 하나의 트랜잭션을 생성한다. tx.begin()을 통해 트랜잭션 시작을 알리고 로직을 수행 후 commit 또는 rollback을 해주어야한다.

2.데이터 Update

package hellojpa;

import hellojpa.VO.Member;

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

public class Main {
    public static void main(String[] args) {

        // 서비스에 단 한번
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("hello");

        EntityManager em = emf.createEntityManager();

        EntityTransaction tx = em.getTransaction();

        tx.begin();
        try {
            Member member = em.find(Member.class, 1L);
            member.setName("HelloB");
            tx.commit();
        }catch (Exception e){
            tx.rollback();
        } finally {
            em.close();
        }

        emf.close();
    }
}

다른 점은 위에서 설명한 것과 같고 try-catch-finally 구문을 구면 em.find로 해당 객체를 조회한 후 객체의 필드를 변경하고 commit하면 update 구문이 실행된다.

3. 데이터 Delete

package hellojpa;

import hellojpa.VO.Member;

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

public class Main {
    public static void main(String[] args) {

        // 서비스에 단 한번
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("hello");

        EntityManager em = emf.createEntityManager();

        EntityTransaction tx = em.getTransaction();

        tx.begin();
        try {
            Member member = em.find(Member.class, 1L);
            em.remove(member);
        }catch (Exception e){
            tx.rollback();
        } finally {
            em.close();
        }

        emf.close();
    }
}

em.find로 해당 데이터를 조회 한 후 em.remove()를 실행하면 데이터가 삭제된다.

JPQL

- JPA를 사용하면 엔티티 객체를 중심으로 개발

- 문제는 검색 쿼리

- 검색을 할 때도 테이블이 아닌 엔티티 객체를 대상으로 검색

- 모든 DB 데이터를 객체로 변환해서 검색하는 것은 불가능

- 애플리케이션이 필요한 데이터만 DB에서 불러오려면 결국 검색 조건이 포함된 SQL이 필요

package hellojpa;

import hellojpa.VO.Member;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;
import java.util.List;

public class Main {
    public static void main(String[] args) {

        // 서비스에 단 한번
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("hello");

        EntityManager em = emf.createEntityManager();

        EntityTransaction tx = em.getTransaction();

        tx.begin();
        try {
            List<Member> result = em.createQuery("select m from Member as m where name = 'HelloB'", Member.class)
                    .getResultList();
            System.out.println(result.get(0).getName());
            tx.commit();
        }catch (Exception e){
            tx.rollback();
        } finally {
            em.close();
        }

        emf.close();
    }
}

JPA(4)

fordo — Tue, 12 Sep 2023 13:57:03 +0900

이 글은 김영한 선생님의 자바 ORM 표준 JPA 프로그래밍 - 기본편 2-1을 듣고 정리한 글입니다.

프로젝트 생성

프로젝트 - 새로만들기 - 프로젝트

프로젝트 명 : ex_hello_jpa

그룹 ID : org.jpa-basic

아티팩트ID : ex1_hello_jpa

porm.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>jpa-basic</groupId>
    <artifactId>ex1-hello-jpa</artifactId>
    <version>1.0</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>1.4.200</version>
        </dependency>
    </dependencies>

</project>

JPA 하이버네이트와 H2 데이터 베이스 라이브러리를 빌드 시켜준다.

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/./jpaBasic"/>
            <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>

H2 데이터 베이스의 드라이버, 유저명, 패스워드, URL 모두 기입해준다.

아래의 옵션은 다음에 기술하겠다.

JPA(3)

fordo — Mon, 11 Sep 2023 11:51:17 +0900

이 글은 김영한 선생님의 자바 ORM 표준 JPA 프로그래밍 - 기본편 1-2강을 듣고 정리한 글입니다.

ORM이란?

Object-relational mapping (객체 관계 매핑)
객체는 객체대로 설계
관계형 데이터베이스는 관계형 데이터베이스대로 설계
ORM 프레임워크가 중간에서 매핑
대중적인 언어에는 대부분 ORM 기술이 존재

JPA는 애플리케이션과 JDBC 사이에서 동작

기존 다른 프레임워크와 비슷한 형태를 지닌다.

JPA 동작 - 저장

JPA 동작 - 조회

JPA이 탄생하기까지

EJB -엔티티 빈(자바 표준)

- 실용성이 매우 떨어져 잘 사용하지 않았다.

↓

하이버네이트(오픈 소스)

- 개빈 킹(Gavin King)이 개발

- EJB에 비해 복잡한 테이블 관계도 적합하다.

↓

JPA(자바 표준)

JPA는 표준 명세

- JPA는 인터페이스의 모음

- JPA 표준 명세를 구현한 3가지 구현체 → 하이버네이트, ElipseLink, DataNucleus

JPA를 사용해야하는 이유

- SQL 중심적인 개발에서 객체 중심으로 개발

- 생산성

- 유지보수

- 패러다임의 불일치 해결

- 성능

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

- 표준

JPA(2)

fordo — Fri, 8 Sep 2023 14:22:30 +0900

이 글은 김영한 선생님의 자바 ORM 표준 JPA 프로그래밍 - 기본편 1-1강을 듣고 정리한 글입니다.

SQL 중심적인 개발의 문제점

- 무한 반복, 지루한 코드

객체를 영구 보관하는 다양한 저장소

1. RDB

2. NoSQL

3. File

4. OODB

객체를 관계형 데이터 베이스에 저장

객체와 관계형 데이터베이스의 차이

1. 상속

2. 연관관계

3. 데이터 타입

4. 데이터 식별 방법

연관관계

- 객체는 참조를 사용

ex) member.getTeam()

- 테이블은 외래 키를 사용

ex) JOIN ON M.TEAM_ID = T.TEAM_ID

객체답게 모델링를 할수록 ? → 매핑 작업만 늘어난다.

그렇다면 객체를 자바 컬렉션에 저장 하듯이 DB에 저장할 수는 없을까? → JPA