Chapter 03. 영속성 관리 - 내부 동작 방식

Spring Framework/[인프런] Java ORM 표준 프로그래밍 - JPA

Chapter 03. 영속성 관리 - 내부 동작 방식

계란💕 2022. 9. 3. 23:33

3.1 영속성 컨텍스트 (1)

JPA에서 가장 중요한 것은?

(1) 객체와 관계형 데이터베이스 매핑하기(ORM)
(2) 영속성 컨텍스트(Persistence Context): entity를 영구 저장하는 환경이라는 뜻이다.
- 논리적인 개념이며 눈에 보이지 않는다.
- EntityManager를 통해 영속성 컨텍스트에 접근한다.
- ex) Entity.Manager.persist(entity) - persist 메서드는 데이터베이스가 아니라 엔티티를 사실 Persist Context에 저장하는 것이다.
- 아래 그림: 고객이 요청할 때마다 Entity manager를 생성한다.
- manager는 내부적으로 데이터베이스 커넥션을 사용해서 DB를 사용한다.

엔티티의 생명 주기

비영속(new / transient): 영속성 컨텍스트와 전혀 관계가 없는 새로운 상태
- JPA와 전혀 관계 없이 객체만 생성한 상태이다. DB에 들어가지도 않는다.

영속(managed): 영속성 컨텍스트에 관리되는 상태 (em.persist() 이후 또는 em.find같은 메서드로 조회했을 때 없는 경우 => 영속 상태가 된다.)
- 엔티티 매니저에 persist()로 멤버를 저장하면 영속 컨텍스트에 객체가 들어가면서 영속 상태가 된다. (1차 캐시에 저장한다.)
- 그런데 사실 이 때 까지는 DB에 저장되지 않는다.
- 트랜잭션에 커밋하는 시점에 쿼리가 날라가기 때문에 persist() 라인은 아직 DB에 반영이 안 된 상태이다.

준영속(detached): 영속성 컨텍스트에 저장되었다가 분리된 상태
- detach()

삭제(removed): 삭제된 상태
- DB에서 지운다.

3.2 영속성 컨텍스트 (2)

엔티티 조회

Ex) 1차 캐시에 찾으려는 값이 있는 경우

영속성 컨텍스트는 내부에 1차 캐시가 있다.
지금은 엔티티 매니저를 영속성 컨텍스트라고 이해해도 된다.
위 사진을 보면 키는 member1, member 객체 자체가 값이 된다.
- 이렇게 하면 어떤 장점이?
- ex) find("member1")을 조회하는 경우, JPA는 DB가 아니라 먼저 1차 캐시에서 값을 찾는다.
- JPA는 영속성 컨텍스트에서 1차로 찾는다.

Ex) 아까와는 다르게 찾으려는 값(member2) 1차 캐시에 값이 없으면?

1차 캐시를 조회하고 없으면 DB를 조회한다.
그 다음 member2를 1차 캐시에 저장한다. 그 다음에 member2를 반환한다.
나중에 member2를 조회하는 경우에는 DB까지 안 가더라도 1차 캐시에서 바로 member2를 바로 꺼내 쓸 수 있다.

<hide/>
package hellojpa;
import java.util.List;
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 findMember1 = em.find(Member.class, 1L);
           Member findMember2 = em.find(Member.class, 1L);
           tx.commit();
        }catch (Exception e) {
            tx.rollback();
        }finally {
            em.close();
        }
        emf.close();    // 팩토리를 나중에 닫는다.
    }
}

Note) 실행 결과

두 번 find를 하면 처음 find()할 때는 DB에서 가져오면서 영속성 컨텍스트에 데이터를 올려 놓는다.
두 번째는 무조건 1차 캐시부터 확인해서 가져오니까 쿼리를 날릴 필요없다.

Ex) 영속성의 엔티티 동일성 보장

<hide/>
package hellojpa;
import java.util.List;
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 findMember1 = em.find(Member.class, 1L);
           Member findMember2 = em.find(Member.class, 1L);
           System.out.println("result: " + (findMember1 == findMember2));
           tx.commit();
        }catch (Exception e) {
            tx.rollback();
        }finally {
            em.close();
        }
        emf.close();    // 팩토리를 나중에 닫는다.
    }
}

Note) 실행 결과 - true

1차 캐시로 반복 가능한 읽기(REPEATABLE READ) 등급의 트랜잭션 격리 수준을 데이터베이스가 아닌 애플리케이션 차원에서 제공한다. (JPA에서 같은 트랜잭션 안에서만 해당한다.)

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

Ex) 트랜잭션을 지원하는 쓰기 지연

JPA는 기본적으로 리플렉션을 쓰기 때문에 동적으로 객체를 생성해내야한다.
기본 생성자가 필요하다.

<hide/>
package hellojpa;
import javax.persistence.Entity;
import javax.persistence.Id;
@Entity
public class Member {

    @Id
    private Long id;
    private String name;

    public Member() {
    }
    public Member(Long id, String name) {
        this.id = id;
        this.name = 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;
    }
}

<hide/>
package hellojpa;
import java.util.List;
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 member1 = new Member(150L, "A");
           Member member2 = new Member(160L, "B");
           em.persist(member1);
           em.persist(member2); // INSERT 쿼리를 데이터베이스에 보내지 않는다.
            System.out.println("=========");
           tx.commit(); // 커밋하는 순간 INSERT SQL을 보낸다.

        }catch (Exception e) {
            tx.rollback();
        }finally {
            em.close();
        }
        emf.close();    // 팩토리를 나중에 닫는다.
    }
}

Note) 실행 결과

batch - 데이터를 한 번에 전송

<property name="hibernate.jdbc.batch_size" value="10"/>

properties 파일에 위와 같은 코드를 추가하면 데이터를 10개씩 보낸다.
버퍼링을 모아서 write 한다.

엔티티 수정 - 변경 감지 (Dirty Checking)

JPA의 목적은 자바 컬렉션 다루듯이 객체를 다루는 것이다.
JPA는 값을 바꾸면 트랜잭션에 커밋되는 시점에 변경 내용을 반영한다.
~~update()~~ 같은 메서드 없이 set() 만 했을 뿐인데 어떻게 UPDATE 쿼리가 실행 될까?
- 영속성 컨텍스트에 비밀이 있다.
- 커밋 => flush() 호출 => 엔티티와 스냅샷(값을 읽어온 최초 시점의 데이터 상태)을 비교한다.
- 비교해서 다른 부분이 있으면 쓰기 지연 SQL 저장소에 UPDATE 쿼리를 만들어둔다.
- 그 다음 UPDATE 쿼리를 데이터베이스에 반영하고 커밋한다.

Ex) 엔티티 수정 - 변경 감지()

<hide/>
package hellojpa;
import java.util.List;
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 = em.find(Member.class, 150L);
           member.setName("ZZZZZ");
           System.out.println("=========");
           tx.commit(); // 커밋하는 순간 INSERT SQL을 보낸다.

        }catch (Exception e) {
            tx.rollback();
        }finally {
            em.close();
        }
        emf.close();    // 팩토리를 나중에 닫는다.
    }
}

Note) 실행 결과

실행 전

실행 후

엔티티 삭제

마찬가지로 트랜잭션 커밋 시점에 DELETE 쿼리가 날아간다.

3.3 플러시(flush)

플러시(flush)

플러시는 영속성 컨텍스트의 변경 내용을 데이터베이스에 반영(동기화)하는 것이다. 단, 플러시 하더라도 영속성 컨텍스트를 비우지는 않는다.
보통 트랜잭션이 커밋될 때, 자동으로 플러시가 발생한다.
플러시를 하더라도 1차 캐시는 유지된다. 오직 쓰기 지연 SQL 저장소에 있는 수정 사항들이 DB에 반영되는 과정이라고 볼 수 있다.
플러시가 발생하고 나면?
- => 변경 감지
- => 수정된 엔티티 쓰기 지연 SQL 저장소에 등록한다.
- => 쓰기 지연 SQL 저장소의 쿼리를 데이터베이스에 전송한다. ( ex) 등록, 수정, 삭제 쿼리)

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

em.flush() - 직접 호출 (자주 쓰지 않는다.)
트랜잭션 커밋 - 플러시 자동 호출
JPQL 쿼리 실행 - 플러시 자동 호출
- JPQL 쿼리 실행 시 플러시 자동 호출되는 이유는?
  - 다음 코드를 부면 A, B, C를 차례로 저장한 경우 아직 커밋하지 않은 상태라서 SELECT 했을 때 A, B, C 가 데이터베이스에서 조회되지 않는 것이 정상이다. INSERT 자체도 수행되지 않았기 때문이다.
  - 그런데, JPQL는 SQL로 번역되서 바로 실행된다. 그래서 A, B, C를 조회할 수 없다.
  - 이런 경우 문제가 생길 수 있다.
  - 따라서, 이를 방지하기 위해 JPA는 JPQL이 실행되기 전에 항상 flush를 날린다.
  - 결론적으로 A, B, C가 조회된다.

플러시 모드 옵션

em.setFlushMode(FlushModeType.COMMIT)
FlushModeType.AUTO - 커밋이나 쿼리를 실행할 때 플러시 (기본값)
FlushModeType.COMMIT - 커밋할 때만 플러시
- 어떤 경우에 쓰일까?
- 예를 들어, 위 코드에 대해 JPQL에서 테이블이 memberA, memberB, memberC와 관련 없는 테이블인 경우, 쿼리를 실행할 때 플러시할 필요 없는 경우에 쓰인다.
- 가급적 손대지 말고 AUTO로 쓰자.

Ex) 플러시

em.persist() 까지는 INSERT 쿼리가 저장소에 담긴 상태이다.
flush()에는 DB에 INSERT 가 바로 반영된다.

<hide/>
package hellojpa;
import java.util.List;
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(200L, "member200");
           em.persist(member);  // 저장은 했는데 데이터베이스까지 정보가 가지는 않은 상태
           em.flush(); // 데이터베이스에 저장 사항이 바로 반영된다. INSERT 쿼리 실행
           System.out.println("=========");
           tx.commit(); // 커밋하는 순간 INSERT SQL을 보낸다.

        }catch (Exception e) {
            tx.rollback();
        }finally {
            em.close();
        }
        emf.close();    // 팩토리를 나중에 닫는다.
    }
}

Note) 실행 결과

3.4 준영속 상태

준영속 상태

영속 상태였다가 영속성 상태에서 빠지는 것을 준영속 상태라고 한다.
- cf) 영속 상태가 되는 케이스
  - (1) em.persist()
  - (2) em.find()로 가져왔는데 영속성 컨텐스트에 없는 경우 DB에서 가져와서 1차 캐시에 올린다.
영속 상태의 엔티티가 영속성 컨텍스트에서 분리(detached)되는 경우
영속성 컨텍스트가 제공하는 기능을 사용하지 못한다.

준영속 상태로 만드는 방법

em.detach(entity) - 특정 엔티티만 준영속 상태로 전환한다.
em.clear() - em 안에 있는 영속성 컨텍스트를 완전히 초기화한다. 모두 지운다.
em.close() - 영속성 컨텍스트를 종료한다.

Ex) 준영속 상태 - detach()

<hide/>
package hellojpa;
import java.util.List;
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 = em.find(Member.class, 150L);
           member.setName("AAAAA");
           em.detach(member);   // 영속성 컨텍스트에서 제거한다. - JPA에서 더 이상 관리하지 않는다.

           System.out.println("=========");
           tx.commit(); // 커밋하는 순간 아무일도 안 일어난다.

        }catch (Exception e) {
            tx.rollback();
        }finally {
            em.close();
        }
        emf.close();    // 팩토리를 나중에 닫는다.
    }
}

Note) 실행 결과

detach() 하는 순간 영속성 컨텍스트에서 빠져버린다. 더 이상 JPA에서 관리하지 않도록 한다.
따라서 SELECT 쿼리만 나오고 데이터를 변경했지만 UPDATE 쿼리는 안 나온다.

H2도 마찬가지로 "AAAAA"로 변경되지 않는 것을 볼 수 있다.

Ex) 준영속 상태 - clear()

<hide/>
package hellojpa;
import java.util.List;
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 = em.find(Member.class, 150L);
           member.setName("AAAAA");
           em.clear();   // 영속성 컨텍스트를 통으로 모두 지운다.
           System.out.println("=========");
           tx.commit(); // 커밋하는 순간 아무일도 안 일어난다.

        }catch (Exception e) {
            tx.rollback();
        }finally {
            em.close();
        }
        emf.close();    // 팩토리를 나중에 닫는다.
    }
}

Note) 실행 결과

똑같은 member를 다시 조회하면?
- clear()에서 1차 캐시를 통으로 지운다.
- 따라서 똑같은 값을 조회하면 새롭게 SELECT 쿼리를 날려서 다시 조회하도록한다.

<hide/>
package hellojpa;
import java.util.List;
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 = em.find(Member.class, 150L);
           member.setName("AAAAA");
           em.clear();   // 영속성 컨텍스트를 통으로 모두 지운다.

           Member member2 = em.find(Member.class, 150L);    // 똑같은 값을 다시 찾는다면?
           System.out.println("=========");
           tx.commit();

        }catch (Exception e) {
            tx.rollback();
        }finally {
            em.close();
        }
        emf.close();    // 팩토리를 나중에 닫는다.
    }
}

Note) 실행 결과

두 개의 쿼리가 나온다.
영속성 컨텍스트에 다시 올리기 때문이다.

출처 - https://www.inflearn.com/course/ORM-JPA-Basic

자바 ORM 표준 JPA 프로그래밍 - 기본편 - 인프런 | 강의

JPA를 처음 접하거나, 실무에서 JPA를 사용하지만 기본 이론이 부족하신 분들이 JPA의 기본 이론을 탄탄하게 학습해서 초보자도 실무에서 자신있게 JPA를 사용할 수 있습니다., - 강의 소개 | 인프런

www.inflearn.com

저작자표시

'Spring Framework > [인프런] Java ORM 표준 프로그래밍 - JPA' 카테고리의 다른 글

Chapter 06. 다양한 연관관계 매핑 (0)	2022.09.05
Chapter 05. 연관 관계 매핑 기초 (0)	2022.09.05
Chapter 04. 엔티티 매핑 (entity mapping) (0)	2022.09.04
Chapter 02. JPA 시작하기 (0)	2022.09.03
Chapter 01. JPA 소개 (2)	2022.09.02

현재글Chapter 03. 영속성 관리 - 내부 동작 방식

Backend Developer lan4250@naver.com https://github.com/goraneee

Stack, SQL, dfs, BFS, 알고리즘, JPA, 자바, 프로그래머스, 백준, 제로베이스 백엔드, 코드업, GIT, 제로베이스 스쿨, mysql, 데이터베이스, Java, Queue, 스프링, dp, DB,

Today :
Yesterday :

일	월	화	수	목	금	토
			1	2	3	4
5	6	7	8	9	10	11
12	13	14	15	16	17	18
19	20	21	22	23	24	25
26	27	28	29	30	31

계란 블로그