[내일배움캠프_Spring Boot 입문주차] JPA CORE

JPA란?

DB를 직접 다룰 때의 문제점

1. 애플리케이션에서 아래 형태의 객체 데이터를 DB에 저장해서 관리해야 한다면?

public class Memo {
    private Long id;
    private String username;
    private String contents;
}

DB 테이블 생성
애플리케이션에서 SQL 작성
SQL을 JDBC를 사용해서 직접 실행
SQL 결과를 객체로 직접 만들기

2. 위와 같은 방법은 SQL 의존적이라 변경에 취약함

메모 데이터에 비밀번호를 추가해야 한다면
SQL을 직접 수정해야함
MemoResponseDto 객체에 값을 넣어주는 부분도 당연히 추가해줘야함

즉, ORM이 없는 환경에서는 개발자가 비즈니스 로직 개발보다는 SQL 작성 및 수정에 더 많은 노력을 들였어야 했음

ORM(Object-Relational Mapping)

Object: "객체"지향 언어(자바, 파이썬)
Relational: "관계형" 데이터베이스(H2, MySQL)

즉, ORM은 객체와 데이터베이스를 맵핑해주는 도구

반복적이고 번거로운 애플리케이션 단의 SQL 작업을 줄여주기 위해 등장

JPA(Java Persistence API)

Java ORM 기술의 대표적인 표준 명세

Hibernate: JPA를 실제로 구현한 프레임워크

Entity 이해하기

Entity는 JPA에서 관리되고 있는 Class, 즉 객체를 의미함.

Entity Class는 데이터베이스의 table과 맵핑이 되어서 JPA에 의해서 관리되고 있음

Java 환경에서 JPA 사용하기

1. persistence.xml 파일과 build.gradle 파일 수정

2. Entity 생성

package com.sparta.entity;

import jakarta.persistence.*;

@Entity // JPA가 관리할 수 있는 Entity 클래스 지정
@Table(name = "memo") // 매핑할 테이블의 이름을 지정
public class Memo {
    @Id // table의 기본 키 지정
    @GeneratedValue(strategy = GenerationType.IDENTITY) // AUTO_INCREMENT 옵
    private Long id;

    // nullable: null 허용 여부
    // unique: 중복 허용 여부 (false 일때 중복 허용)
    @Column(name = "username", nullable = false, unique = true)
    private String username;

    // length: 컬럼 길이 지정
    @Column(name = "contents", nullable = false, length = 500)
    private String contents;
}

@Entity: JPA가 관리할 수 있는 Entity 클래스로 지정
- @Entity(name="Memo"): Entity 클래스 이름 지정 가능(default: 클래스명)
- JPA가 Entity 클래스를 인스턴스화할 때 기본 생성자를 사용하기 때문에 현재 Entity 클래스에서 기본 생성자가 되고 있는지 확인해야 함
@Table: 매핑할 테이블 지정
- @Table(name="memo"): 매핑할 테이블의 이름 지정 가능(default: Entity 명)
@Column
- @Column(name="username"): 필드와 매핑할 테이블의 컬럼 지정 가능(default: 객체의 필드명)
- @Column(nullable=false): 데이터의 null 값 허용 여부 지정(default: true)
- @Column(unique=true): 데이터의 중복 값 허용 여부 지정(default: false → null 값 허용 O)
- @Column(length=500): 데이터 값(문자)의 길이에 제약조건 걸 수 있음(default: 255)
@Id: 테이블의 기본 키를 지정
- 기본 키는 영속성 컨텍스트에서 Entity를 구분하고 관리할 때 사용되는 식별자 역할 수행함. 따라서 기본 키 즉, 식별자를 넣어주지 않고 저장하면 오류 발생함
- @Id 옵션만 설정하면 기본 키 값을 개발자가 직접 확인하고 넣어줘야 하는 불편함 발생함
- @GeneratedValue 옵션을 추가하면 기본 킨 생성을 DB에 위임 가능
- @GeneratedValue(strategy = GenerationType.IDENTITY): 자동으로 순서에 맞게 기본 키 추가됨

3. Entity로 테이블 만들어냄

🗣️ JPA 기본 키 생성 @GeneratedValue strategy 옵션

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

strategy 옵션은 데이터베이스에서 자동으로 ID를 생성하는 방법 지정

1. AUTO

옵션을 선택하지 않는 경우 디폴트 값
JPA가 사용 중인 데이터베이스에 따라 자동으로 가장 적절한 방법 선택
ex) MySQL에는 IDENTITY, Oracle은 SEQUENCE 선택

2. IDENTITY

데이터베이스가 직접 ID를 생성해 번호를 매기는 것
ID 어노테이션으로 기본키를 만들 때 가장 많이 사용한 옵션
데이터베이스에서 새로 저장되는 데이터마다 자동으로 숫자가 1씩 증가하는 방식으로 ID를 생성
주로 MySQL, SQL Server 등의 데이터베이스에서 사용됨

3. SEQUENCE

데이터베이스의 '시퀀스'라는 객체를 사용해서 기본 키 값을 생성함, 시퀀스 객체는 데이터베이스에서 미리 정의
ID를 미리 만들어 관리 가능
여러 엔티티에서 동일한 시퀀스를 공유할 수 있음
성능 우수
주로 Oracle, PostgreSQL 같은 데이터베이스에서 사용됨

4. TABLE

별도의 테이블을 만들어 ID 관리
모든 데이터베이스에서 사용, 동일하게 동작
데이터베이스 독립적
다소 복잡하고 성능이 떨어질 수 있음

🗣️ hibernate.hbm2ddl.auto 속성

데이터베이스 스키마 자동 생성
- DDL을 애플리케이션 실행 시점에 자동 생성함
- 테이블 중심에서 객체 중심으로 이동
- 데이터베이스 방언을 활용해 데이터베이스에 맞는 적절한 DDL 생성
- 생성된 DLL은 개발 단계에서만 사용됨(운영 서버에는 적절히 다듬은 후 사용)

1. create: 기존 테이블 삭제 후 다시 생성(DROP+CREATE)

2. create-drop: CREATE와 같지만 종료 시점에(DROP)

3. update: 변경 분만 반영(추가만 되고 지워지는 것은 안됨)

4. validate: 엔티티와 테이블이 정상 매핑 되었는지만 확인

5. none: 사용하지 않음

‼️ 주의할 점

- 운영장비에는 절대 create, create-drop, update 사용하면 안됨!(데이터가 없어질 위험 존재)

- 개발 초기 단계는 create 또는 update

- 테스트 서버는 update 또는 validate

- 운영 서버는 validate 또는 none

영속성 컨텍스트(Persistence)

Persistence는 영속성, 지속성이라는 뜻으로,

객체의 관점으로 해석하면, '객체가 생명(객체가 유지되는 시간)이나 공간(객체의 위치)을 자유롭게 유지하고 이동할 수 있는 객체의 성질을 의미

즉, Entity 객체를 효율적으로 쉽게 관리하기 위해 만들어진 공간임

개발자들은 SQL을 작성하지 않아도 JPA를 사용해 DB에 데이터를 저장하거나 조회할 수 있으며, 수정과 삭제도 가능함
이러한 일련의 과정을 효율적을 처리하기 위해 JPA는 영속성 컨텍스트에 Entity 객체들을 저장하여 관리하면서 DB와 소통함

EntityManager

영속성 컨텍스트에 접근해 Entity 객체를 조작하기 위해서는 EntityManager가 필요함

EntityManager는 Entity를 관리하는 관리자

개발자들은 EntityManager를 사용해 Entity를 저장하고 조회하고 수정하고 삭제할 수 있음
EntityManager는 EntityManagerFactory를 통해 생성해 사용할 수 있음

EntityManagerFactory

EntityManagerFactory는 일반적으로 DB 하나에 하나만 생성되어 애플리케이션이 동작하는 동안 사용됨

EntityManagerFactory를 만들기 위해서는 DB에 대한 정보를 전달해야함
정보를 전달하기 위해서는 /resources/META-INF/ 위치에 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="memo">
        <class>com.sparta.entity.Memo</class>
        <properties>
            <property name="jakarta.persistence.jdbc.driver" value="com.mysql.cj.jdbc.Driver"/>
            <property name="jakarta.persistence.jdbc.user" value="root"/>
            <property name="jakarta.persistence.jdbc.password" value="{비밀번호}"/>
            <property name="jakarta.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/memo"/>

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

            <property name="hibernate.show_sql" value="true"/>
            <property name="hibernate.format_sql" value="true"/>
            <property name="hibernate.use_sql_comments" value="true"/>
        </properties>
    </persistence-unit>
</persistence>

EntityManagerFactory emf = Persistence.createEntityManagerFactory("memo"); // persistence-unit 이름
EntityManager em = emf.createEntityManager(); // EntityManager 생성

JPA 트랜잭션

트랜잭션

DB 데이터들의 무결성과 정합성을 유지하기 위한 하나의 논리적 개념으로, 즉 DB의 데이터들을 안전하게 관리하기 위해서 생겨난 개념

여러 개의 SQL이 하나의 트랜잭션에 포함될 수 있음
모든 SQL이 성공적으로 수행이 되면 DB에 영구적으로 변경을 반영하지만 SQL 중 단 하나라도 실패한다면 모든 변경을 되돌림

START TRANSACTION; # 트랜잭션을 시작합니다.

INSERT INTO memo (id, username, contents) VALUES (1, 'Robbie', 'Robbie Memo');
INSERT INTO memo (id, username, contents) VALUES (2, 'Robbert', 'Robbert Memo');
SELECT * FROM memo;

COMMIT; # 트랜잭션을 커밋합니다.

SELECT * FROM memo;

COMMIT을 해야지 데이터베이스에 반영됨

﹡JPA는 DB의 트랜잭션 개념을 사용해 효율적으로 Entity를 관리하고 있음

JPA 트랜잭션

DB에서 하나의 트랜잭션에 여러 개의 SQL을 포함하고 있다가 마지막에 영구적으로 변경을 반영하는 것처럼,

JPA에서도 영속성 컨텍스트로 관리하고 있는 변경이 발생한 객체들의 정보를 쓰기 지연 저장소에 전부 가지고 있다가 마지막에 SQL을 한번에 DB에 요청해 변경을 반영함

Entity트랜잭션 성공 테스트

import com.sparta.entity.Memo;
import jakarta.persistence.EntityManager;
import jakarta.persistence.EntityManagerFactory;
import jakarta.persistence.EntityTransaction;
import jakarta.persistence.Persistence;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

public class EntityTest {

    EntityManagerFactory emf;
    EntityManager em;

    @BeforeEach
    void setUp() {
        emf = Persistence.createEntityManagerFactory("memo");
        em = emf.createEntityManager();
    }

    @Test
    @DisplayName("EntityTransaction 성공 테스트")
    void test1() {
        EntityTransaction et = em.getTransaction(); // EntityManager 에서 EntityTransaction 을 가져옵니다.

        et.begin(); // 트랜잭션을 시작합니다.

        try { // DB 작업을 수행합니다.

            Memo memo = new Memo(); // 저장할 Entity 객체를 생성합니다.
            memo.setId(1L); // 식별자 값을 넣어줍니다.
            memo.setUsername("Robbie");
            memo.setContents("영속성 컨텍스트와 트랜잭션 이해하기");

            em.persist(memo); // EntityManager 사용하여 memo 객체를 영속성 컨텍스트에 저장합니다.

            et.commit(); // 오류가 발생하지 않고 정상적으로 수행되었다면 commit 을 호출합니다.
            // commit 이 호출되면서 DB 에 수행한 DB 작업들이 반영됩니다.
        } catch (Exception ex) {
            ex.printStackTrace();
            et.rollback(); // DB 작업 중 오류 발생 시 rollback 을 호출합니다.
        } finally {
            em.close(); // 사용한 EntityManager 를 종료합니다.
        }

        emf.close(); // 사용한 EntityManagerFactory 를 종료합니다.
    }

}

Entity트랜잭션 실패 테스트

@Test
@DisplayName("EntityTransaction 실패 테스트")
void test2() {
    EntityTransaction et = em.getTransaction(); // EntityManager 에서 EntityTransaction 을 가져옵니다.

    et.begin(); // 트랜잭션을 시작합니다.

    try { // DB 작업을 수행합니다.

        Memo memo = new Memo(); // 저장할 Entity 객체를 생성합니다.
        memo.setUsername("Robbert");
        memo.setContents("실패 케이스");

        em.persist(memo); // EntityManager 사용하여 memo 객체를 영속성 컨텍스트에 저장합니다.

        et.commit(); // 오류가 발생하지 않고 정상적으로 수행되었다면 commit 을 호출합니다.
        // commit 이 호출되면서 DB 에 수행한 DB 작업들이 반영됩니다.
    } catch (Exception ex) {
        System.out.println("식별자 값을 넣어주지 않아 오류가 발생했습니다.");
        ex.printStackTrace();
        et.rollback(); // DB 작업 중 오류 발생 시 rollback 을 호출합니다.
    } finally {
        em.close(); // 사용한 EntityManager 를 종료합니다.
    }

    emf.close(); // 사용한 EntityManagerFactory 를 종료합니다.
}

영속성 컨텍스트의 기능

기능 1) 1차 캐시

영속성 컨텍스트는 내부적으로 캐시 저장소를 가지고 있음

저장하는 Entity 객체들이 1차 캐시 즉, 캐시 저장소에 저장됨
캐시 저장소는 Map 자료구조 형태로 되어있음
- key에는 @Id로 매핑한 기본 키인 식별자 값을 저장함
- value에는 해당 Entity 클래스의 객체를 저장함
- 영속성 컨텍스트는 캐시 저장소 Key에 저장한 식별자값을 사용해 Entity 객체를 구분하고 관리함

영속성 컨텍스트의 캐시 저장소 활용

Entity 저장

em.persist(memo); 메서드가 호출되면 memo Entity 객체를 캐시 저장소에 저장함

@Test
@DisplayName("1차 캐시 : Entity 저장")
void test1() {
    EntityTransaction et = em.getTransaction();

    et.begin();

    try {

        Memo memo = new Memo();
        memo.setId(1L);
        memo.setUsername("Robbie");
        memo.setContents("1차 캐시 Entity 저장");

        em.persist(memo);

        et.commit();

    } catch (Exception ex) {
        ex.printStackTrace();
        et.rollback();
    } finally {
        em.close();
    }

    emf.close();
}

em > persistenceContext > entitiesBykey를 확인하면 key-value 형태로 정보가 저장되어 있는 걸 볼 수 있음

Entity 조회

1. 캐시 저장소에 조회하는 Id가 존재하지 않은 경우

em.find(Memo.class, 1); 호출 시 캐시 저장소를 확인한 후 해당 값이 없으면, DB에 SELECT 조회 후 해당 값을 캐시 저장소에 저장하고 반환함

@Test
@DisplayName("Entity 조회 : 캐시 저장소에 해당하는 Id가 존재하지 않은 경우")
void test2() {
    try {

        Memo memo = em.find(Memo.class, 1);
        System.out.println("memo.getId() = " + memo.getId());
        System.out.println("memo.getUsername() = " + memo.getUsername());
        System.out.println("memo.getContents() = " + memo.getContents());


    } catch (Exception ex) {
        ex.printStackTrace();
    } finally {
        em.close();
    }

    emf.close();
}

2. 캐시 저장소에 조회하는 Id가 존재하는 경우

em.find(Memo.class, 1); 호출 시 캐시 저장소에 식별자 값이 1이면서 Memo Entity 타입인 값이 있는지 조회 후, 값이 있다면 해당 Entity 객체를 반환함

@Test
@DisplayName("Entity 조회 : 캐시 저장소에 해당하는 Id가 존재하는 경우")
void test3() {
    try {

        Memo memo1 = em.find(Memo.class, 1);
        System.out.println("memo1 조회 후 캐시 저장소에 저장\n");

        Memo memo2 = em.find(Memo.class, 1);
        System.out.println("memo2.getId() = " + memo2.getId());
        System.out.println("memo2.getUsername() = " + memo2.getUsername());
        System.out.println("memo2.getContents() = " + memo2.getContents());


    } catch (Exception ex) {
        ex.printStackTrace();
    } finally {
        em.close();
    }

    emf.close();
}

1차 캐시 사용의 장점

1. DB 조회 횟수 줄임

2. '1차 캐시'를 사용해 DB row 1개 당 객체 1개가 사용되는 것을 보장(객체 동일성 보장)

@Test
@DisplayName("객체 동일성 보장")
void test4() {
    EntityTransaction et = em.getTransaction();

    et.begin();
    
    try {
        Memo memo3 = new Memo();
        memo3.setId(2L);
        memo3.setUsername("Robbert");
        memo3.setContents("객체 동일성 보장");
        em.persist(memo3);

        Memo memo1 = em.find(Memo.class, 1);
        Memo memo2 = em.find(Memo.class, 1);
        Memo memo  = em.find(Memo.class, 2);

        System.out.println(memo1 == memo2);
        System.out.println(memo1 == memo);

        et.commit();
    } catch (Exception ex) {
        ex.printStackTrace();
        et.rollback();
    } finally {
        em.close();
    }

    emf.close();
}

Entity 삭제

1. 삭제할 Entity를 조회한 후 캐시 저장소에 없다면 DB에 조회해서 저장함

2. em.remove(entity);

em.remove(entity); 호출 시 삭제할 Entity를 DELETED 상태로 만든 후 트랜잭션 commit 후 Delete SQL이 DB에 요청됨

@Test
@DisplayName("Entity 삭제")
void test5() {
    EntityTransaction et = em.getTransaction();

    et.begin();

    try {

        Memo memo = em.find(Memo.class, 2);

        em.remove(memo);

        et.commit();

    } catch (Exception ex) {
        ex.printStackTrace();
        et.rollback();
    } finally {
        em.close();
    }

    emf.close();
}

기능 2) 쓰기 지연 저장소(ActionQueue)

JPA가 트랜잭션처럼 SQL을 모아서 한 번에 DB에 반영하는데, 이를 구현하기 위해 쓰기 지연 저장소를 만들어 SQL을 모아두고 있다가 트랜잭션 commit 후 한 번에 DB에 반영함

@Test
@DisplayName("쓰기 지연 저장소 확인")
void test6() {
    EntityTransaction et = em.getTransaction();

    et.begin();

    try {
        Memo memo = new Memo();
        memo.setId(2L);
        memo.setUsername("Robbert");
        memo.setContents("쓰기 지연 저장소");
        em.persist(memo);

        Memo memo2 = new Memo();
        memo2.setId(3L);
        memo2.setUsername("Bob");
        memo2.setContents("과연 저장을 잘 하고 있을까?");
        em.persist(memo2);

        System.out.println("트랜잭션 commit 전");
        et.commit();
        System.out.println("트랜잭션 commit 후");

    } catch (Exception ex) {
        ex.printStackTrace();
        et.rollback();
    } finally {
        em.close();
    }

    emf.close();
}

flush()

et.commit(); 하면 commit이 되고 쓰기 지연 저장소에 있던 SQL들이 한 번에 요청이 됨
트랜잭션 commit이 된 다음에 추가적인 동작이 em.flush();임. 즉, flush method 호출
flush method는 영속성 컨텍스트의 변경 내용들을 데이터베이스에 반영하는 역할 수행
즉, 쓰기 지연 저장소(actionQueue)의 SQL들을 데이터베이스에 요청을 해주는 메서드

@Test
@DisplayName("flush() 메서드 확인")
void test7() {
    EntityTransaction et = em.getTransaction();

    et.begin();

    try {
        Memo memo = new Memo();
        memo.setId(4L);
        memo.setUsername("Flush");
        memo.setContents("Flush() 메서드 호출");
        em.persist(memo);

        System.out.println("flush() 전");
        em.flush(); // flush() 직접 호출
        System.out.println("flush() 후\n");
        

        System.out.println("트랜잭션 commit 전");
        et.commit();
        System.out.println("트랜잭션 commit 후");

    } catch (Exception ex) {
        ex.printStackTrace();
        et.rollback();
    } finally {
        em.close();
    }

    emf.close();
}

⭐️Insert, Update, Delete와 같이 데이터를 변경하는 SQL을 데이터베이스에 요청 및 반영하기 위해서는 트랜잭션 환경이 반드시 필요함!

기능 3) 변경 감지(Dirty Checking)

영속성 컨텍스트에 저장된 Entity가 변경될 때마다 Update SQL이 쓰기 지연 저장소에 저장된다면,
하나의 Update SQL로 처리할 수 있는 상황을 여러번 Update SQL을 요청하게 되기 때문에 비효율적임

JPA는 영속성 컨텍스트에 Entity를 저장할 때 최초 상태(LoadedState)를 저장함
트랜잭션이 commit되고 em.flush();가 호출되면 Entity의 현재 상태와 저장한 최초 상태를 비교함
변경 내용이 있다면 Update SQL을 생성해 쓰기 지연 저장소에 저장하고 모든 쓰기지연 저장소의 SQL을 DB에 요청함
마지막으로 DB 트랜잭션이 commit되면서 반영됨
즉, 변경하고 싶은 데이터가 있다면 먼저 데이터를 조회하고 해당 Entity 객체의 데이터를 변경하면 자동으로 Update SQL이 생성되고 DB에 반영됨 → 이러한 과정을 변경 감지, Dirty Checking이라고 부름

@Test
@DisplayName("변경 감지 확인")
void test8() {
    EntityTransaction et = em.getTransaction();

    et.begin();

    try {
        System.out.println("변경할 데이터를 조회합니다.");
        Memo memo = em.find(Memo.class, 4);
        System.out.println("memo.getId() = " + memo.getId());
        System.out.println("memo.getUsername() = " + memo.getUsername());
        System.out.println("memo.getContents() = " + memo.getContents());

        System.out.println("\n수정을 진행합니다.");
        memo.setUsername("Update");
        memo.setContents("변경 감지 확인");

        System.out.println("트랜잭션 commit 전");
        et.commit();
        System.out.println("트랜잭션 commit 후");

    } catch (Exception ex) {
        ex.printStackTrace();
        et.rollback();
    } finally {
        em.close();
    }

    emf.close();
}

변경할 내용이 없다면 DB 접근 X(예시: 오른쪽 사진)

Entity의 상태

영속성과 비영속성

비영속성 상태: 영속성 컨텍스트 즉 JPA가 관리하고 있는 엔티티가 아닌 순수한 Entity Class 상태

persist method의 파라미터로 Entity Class 객체를 던져서 영속 상태로 만듦

import com.sparta.entity.Memo;
import jakarta.persistence.EntityManager;
import jakarta.persistence.EntityManagerFactory;
import jakarta.persistence.EntityTransaction;
import jakarta.persistence.Persistence;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

public class EntityStateTest {
    EntityManagerFactory emf;
    EntityManager em;

    @BeforeEach
    void setUp() {
        emf = Persistence.createEntityManagerFactory("memo");
        em = emf.createEntityManager();
    }

    @Test
    @DisplayName("비영속과 영속 상태")
    void test1() {
        EntityTransaction et = em.getTransaction();

        et.begin();

        try {

            Memo memo = new Memo(); // 비영속 상태
            memo.setId(1L);
            memo.setUsername("Robbie");
            memo.setContents("비영속과 영속 상태");

            // 관리되게 하고 싶은 Entity Class 객체를 persist method의 파라미터로 던져서 호출하면
            // 영속성 컨텍스트에 저장됨
            em.persist(memo); // 비영속 상태의 Entity → 영속성 컨텍스트에 저장 → 영속 상태의 Entity

            et.commit();

        } catch (Exception ex) {
            ex.printStackTrace();
            et.rollback();
        } finally {
            em.close();
        }

        emf.close();
    }
}

준영속(Detached)

영속성 컨텍스트에 저장되어 관리되다가 분리된 상태

영속 상태 → 준영속 상태 3가지 방법

1. detach(entity): 특정 Entity를 준영속 상태로 전환해줌

@Test
@DisplayName("준영속 상태 : detach()")
void test2() {
    EntityTransaction et = em.getTransaction();

    et.begin();

    try {

        Memo memo = em.find(Memo.class, 1);
        System.out.println("memo.getId() = " + memo.getId());
        System.out.println("memo.getUsername() = " + memo.getUsername());
        System.out.println("memo.getContents() = " + memo.getContents());

        // em.contains(entity) : Entity 객체가 현재 영속성 컨텍스트에 저장되어 관리되는 상태인지 확인하는 메서드
        System.out.println("em.contains(memo) = " + em.contains(memo));

        System.out.println("detach() 호출");
        em.detach(memo);
        System.out.println("em.contains(memo) = " + em.contains(memo));

        System.out.println("memo Entity 객체 수정 시도");
        memo.setUsername("Update");
        memo.setContents("memo Entity Update");

        System.out.println("트랜잭션 commit 전");
        et.commit();
        System.out.println("트랜잭션 commit 후");

    } catch (Exception ex) {
        ex.printStackTrace();
        et.rollback();
    } finally {
        em.close();
    }

    emf.close();
}

영속성 컨텍스트에 의해서 관리되고 있는 Entity Class를 수정했을 때 변경 감지가 이루어지지만,
detach() 호출해서 더 이상 관리되지 않는 Entity Class는 변경 감지가 이루어지지 않음

2. clear(): 컨텍스트를 완전히 초기화함. 영속성 컨텍스트에 들어있던 모든 Entity를 전부 준영속 상태로 전환함

영속성 컨텍스트의 틀은 유지함(내용만 비워진 새로운 상태로 만듦)

@Test
@DisplayName("준영속 상태 : clear()")
void test3() {
    EntityTransaction et = em.getTransaction();

    et.begin();

    try {

        Memo memo1 = em.find(Memo.class, 1);
        Memo memo2 = em.find(Memo.class, 2);

        // em.contains(entity) : Entity 객체가 현재 영속성 컨텍스트에 저장되어 관리되는 상태인지 확인하는 메서드
        System.out.println("em.contains(memo1) = " + em.contains(memo1));
        System.out.println("em.contains(memo2) = " + em.contains(memo2));

        System.out.println("clear() 호출");
        em.clear();
        System.out.println("em.contains(memo1) = " + em.contains(memo1));
        System.out.println("em.contains(memo2) = " + em.contains(memo2));

        System.out.println("memo#1 Entity 다시 조회");
        Memo memo = em.find(Memo.class, 1);
        System.out.println("em.contains(memo) = " + em.contains(memo));
        System.out.println("\n memo Entity 수정 시도");
        memo.setUsername("Update");
        memo.setContents("memo Entity Update");

        System.out.println("트랜잭션 commit 전");
        et.commit();
        System.out.println("트랜잭션 commit 후");

    } catch (Exception ex) {
        ex.printStackTrace();
        et.rollback();
    } finally {
        em.close();
    }

    emf.close();
}

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

해당 영속성 컨텍스트가 관리하던 영속성 상태의 Entity들을 모두 준영속 상태로 변경
영속성 컨텍스트가 종료되었기 때문에 계속해서 영속성 컨텍스트 사용할 수 없음

@Test
@DisplayName("준영속 상태 : close()")
void test4() {
    EntityTransaction et = em.getTransaction();

    et.begin();

    try {

        Memo memo1 = em.find(Memo.class, 1);
        Memo memo2 = em.find(Memo.class, 2);

        // em.contains(entity) : Entity 객체가 현재 영속성 컨텍스트에 저장되어 관리되는 상태인지 확인하는 메서드
        System.out.println("em.contains(memo1) = " + em.contains(memo1));
        System.out.println("em.contains(memo2) = " + em.contains(memo2));

        System.out.println("close() 호출");
        em.close();
        Memo memo = em.find(Memo.class, 2); // Session/EntityManager is closed 메시지와 함께 오류 발생
        System.out.println("memo.getId() = " + memo.getId());

    } catch (Exception ex) {
        ex.printStackTrace();
        et.rollback();
    } finally {
        em.close();
    }

    emf.close();
}

준영속 상태 → 영속 상태 방법

merge(entity): 전달받은 Entity를 사용해 새로운 영속 상태의 Entity를 반환함

merge(entity) 동작) 파라미터로 전달된 Entity의 식별자 값으로 영속성 컨텍스트 조회

해당 Entity가 영속성 컨텍스트에 없다면,
- DB에서 새롭게 조회
- 조회한 Entity를 영속성 컨텍스트에 저장
- 전달받은 Entity의 값을 사용해 병합
- Update SQL이 수행(수정)
만약 DB에도 없다면,
- 새롭게 생성한 Entity를 영속성 컨텍스트에 저장
- Insert SQL이 수행(저장)

따라서 merge(entity)는 비영속, 준영속 모두 파라미터로 받을 수 있으며 상황에 따라 저장 혹은 수정할 수 있음

1. merge(entity) 저장

@Test
@DisplayName("merge() : 저장")
void test5() {
    EntityTransaction et = em.getTransaction();

    et.begin();

    try {

        Memo memo = new Memo();
        memo.setId(3L);
        memo.setUsername("merge()");
        memo.setContents("merge() 저장");

        System.out.println("merge() 호출");
        Memo mergedMemo = em.merge(memo);

        System.out.println("em.contains(memo) = " + em.contains(memo));
        System.out.println("em.contains(mergedMemo) = " + em.contains(mergedMemo));

        System.out.println("트랜잭션 commit 전");
        et.commit();
        System.out.println("트랜잭션 commit 후");

    } catch (Exception ex) {
        ex.printStackTrace();
        et.rollback();
    } finally {
        em.close();
    }

    emf.close();
}

2. merge(entity) 수정

@Test
@DisplayName("merge() : 수정")
void test6() {
    EntityTransaction et = em.getTransaction();

    et.begin();

    try {

        Memo memo = em.find(Memo.class, 3);
        System.out.println("memo.getId() = " + memo.getId());
        System.out.println("memo.getUsername() = " + memo.getUsername());
        System.out.println("memo.getContents() = " + memo.getContents());

        System.out.println("em.contains(memo) = " + em.contains(memo));

        System.out.println("detach() 호출");
        em.detach(memo); // 준영속 상태로 전환
        System.out.println("em.contains(memo) = " + em.contains(memo));

        System.out.println("준영속 memo 값 수정");
        memo.setContents("merge() 수정");

        System.out.println("\n merge() 호출");
        Memo mergedMemo = em.merge(memo);
        System.out.println("mergedMemo.getContents() = " + mergedMemo.getContents());

        System.out.println("em.contains(memo) = " + em.contains(memo));
        System.out.println("em.contains(mergedMemo) = " + em.contains(mergedMemo));

        System.out.println("트랜잭션 commit 전");
        et.commit();
        System.out.println("트랜잭션 commit 후");

    } catch (Exception ex) {
        ex.printStackTrace();
        et.rollback();
    } finally {
        em.close();
    }

    emf.close();
}

'백엔드 > spring&springboot' 카테고리의 다른 글

[내일배움캠프_Spring Boot 숙련주차] Bean (0)	2026.06.26
[내일배움캠프_Spring Boot 입문주차] Spring Data JPA (0)	2026.06.26
[내일배움캠프_Spring Boot 입문주차] IoC와 DI (1)	2026.06.25
[내일배움캠프_Spring Boot 입문주차] 3 Layer Architecture (0)	2026.06.25
[내일배움캠프_Spring Boot 입문주차] Database와 SQL (0)	2026.06.24

차곡차곡🐿️

[내일배움캠프_Spring Boot 입문주차] JPA CORE

JPA란?

ORM(Object-Relational Mapping)

JPA(Java Persistence API)

Entity 이해하기

Java 환경에서 JPA 사용하기

영속성 컨텍스트(Persistence)

EntityManager

EntityManagerFactory

JPA 트랜잭션

영속성 컨텍스트의 기능

기능 1) 1차 캐시

영속성 컨텍스트의 캐시 저장소 활용

기능 2) 쓰기 지연 저장소(ActionQueue)

기능 3) 변경 감지(Dirty Checking)

Entity의 상태

영속성과 비영속성

준영속(Detached)

'백엔드 > spring&springboot' 카테고리의 다른 글

티스토리툴바

[내일배움캠프_Spring Boot 입문주차] JPA CORE

JPA란?

ORM(Object-Relational Mapping)

JPA(Java Persistence API)

Entity 이해하기

Java 환경에서 JPA 사용하기

영속성 컨텍스트(Persistence)

EntityManager

EntityManagerFactory

JPA 트랜잭션

영속성 컨텍스트의 기능

기능 1) 1차 캐시

영속성 컨텍스트의 캐시 저장소 활용

기능 2) 쓰기 지연 저장소(ActionQueue)

기능 3) 변경 감지(Dirty Checking)

Entity의 상태

영속성과 비영속성

준영속(Detached)

'백엔드 > spring&springboot' 카테고리의 다른 글

관련글

티스토리툴바