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

※ 영속성 컨텍스트 1

 

JPA 에서 가장 중요한 2 가지

① 객체와 관계형 데이터베이스 매핑(Object Relational Mapping)

② 영속성 컨텍스트

 

 

영속성 컨텍스트란 ?

 

- JPA 를 이해하는데 가장 중요한 용어이다.

- 엔티티를 영구 저장하는 환경이라는 뜻이다.

- EntityManager.persist(entity);

- 영속성 컨텍스트는 논리적인 개념이다. 

- 눈에 보이지 않는다.

- 엔티티 매니저를 통해서 영속성 컨텍스트에 접근한다.

 

J2SE 환경에서 엔티티 매니저와 영속성 컨텍스트가 1:1 이다.

 

 

J2EE, 스프링 프레임워크 같은 컨테이너 환경에서 엔티티 매니저와 영속성 컨텍스가 N:1 이다.

 

 

엔티티의 생명주기는?

 

- 비영속 (new/transient)

   영속성 컨텍스트와 전혀 관계 없는 새로운 상태이다.

 

- 영속 (managed)

   영속성 컨텍스트에 관리되는 상태이다.

 

- 준영속 (detached)

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

 

- 삭제 (removed)

   삭제된 상태

 

 

비영속 상태는 아래와 같다.

 

 

// 객체를 생성한 상태 (비영속)
Member member = new Member();
member.setId("member1");
member.setUsername("회원1");

 

영속 상태는 아래와 같다.

 

 

// 객체를 생성한 상태(비영속)
Member member = new Member();
member.setId("member1");
member.setUsername("회원1");

EntityManager em = emf.createEntityManager();
em.getTransaction().begin();

// 객체를 저장한 상태(영속)
em.persist(member);

 

em.persist(member) 를 수행할 때 SQL 문이 실행되는지를 확인해본다.

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(100L);
            member.setName("HelloJPA");

            // 영속
            System.out.println("=== BEFORE ===");
            em.persist(member);
            System.out.println("=== AFTER ===");

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

 

 

실행 결과, persist 메서드를 통해서 바로 데이터를 삽입하는 것은 아님을 확인할 수 있다.

 

준영속, 삭제는 아래와 같다.

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

// 객체를 삭제한 상태(삭제)
em.remove(member);

 

 

☆ 영속성 컨텍스트의 장점

 

- 1차 캐시

- 동일성(identity) 보장

- 트랜잭션을 지원하는 쓰기 지연 (transactional write-behind)

- 변경 감지 (Dirty Checking)

- 지연 로딩 (Lazy Loading)

 

 

※ 영속성 컨텍스트 2

 

엔티티 조회, 1차 캐시

 

 

// 엔티티를 생성한 상태(비영속)
Member member = new Member();
member.setId("member1");
member.setUsername("회원1");

// 엔티티를 영속
em.persist(member);

 

1차 캐시에서 조회를 할 수 있는 이점이 있다.

 

// 엔티티를 생성한 상태(비영속)
Member member = new Member();
member.setId("member1");
member.setUsername("회원1");

// 엔티티를 영속
em.persist(member);

// 1차 캐시에서 조회
Member findMember = em.find(Member.class, "member1");

 

 

이번엔 1차 캐시에서 조회하는 것이 아닌, 데이터베이스에서 조회하는 과정이다.

 

Member findMember2 = em.find(Member.class, "member2");

 

 

이번엔 위 과정을 코드를 통해서 확인해보도록 한다.

 

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(101L);
            member.setName("HelloJPA");

            // 영속
            System.out.println("=== BEFORE ===");
            em.persist(member);
            System.out.println("=== AFTER ===");

            Member findMember = em.find(Member.class, 101L);
            System.out.println("findMember.id = " + findMember.getId());
            System.out.println("findMember.name = " + findMember.getName());

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

 

 

신기하게도 Select 문이 적용되지 않고 1차 캐시에서 조회한 객체의 필드값을 출력하는 것을 확인할 수 있다.

이번엔 DB 조회를 하여 1차 캐시에 저장되서 SQL 문이 딱 한번만 수행되는 것을 확인해본다.

 

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, 101L);
            Member findMember2 = em.find(Member.class, 101L);

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

 

 

1차 캐시는 비즈니스 로직이 복잡할 때 조금이나마 효율적으로 수행될 수 있다.

그러나 현업에서 큰 도움을 주지는 못한다고 한다.

 

 

영속 엔티티의 동일성 보장

 

Member a = em.find(Member.class, "member1");
Member b = em.find(Member.class, "member1");

System.out.println(a == b); // 동일성 비교 true

 

 

1차 캐시로 반복 가능한 읽기(REPEATABLE READ) 등급의 트랜잭션 격리 수준을 데이터베이스가 아닌

애플리케이션 차원에서 제공해준다.

 

 

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

 

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);

// em.update(member) 이런 코드가 있어야 할거 같은데...

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

 

 

엔티티 삭제

 

// 삭제 대상 엔티티 조회
Member memberA = em.find(Member.class, "memberA");

em.remove(memberA); // 엔티티 삭제

 

 

※ 플러시

 

플러시란 영속성 컨텍스트의 변경내용을 데이터베이스에 반영하는 것을 의미한다.

예를 들어 printf 함수에서 버퍼에 '\n' 을 제외한 문자들을 버퍼링하다가 flush 하면 화면에 바로

출력되는 것과 같은 느낌이다.

그러면 실제로 printf 함수에서의 flush 와 같은지 알아보도록 하자.

 

 

플러시 발생했을때?

 

- 변경을 감지한다.

- 수정된 엔티티 쓰기 지연 SQL 저장소에 등록한다.

- 쓰기 지연 SQL 저장소의 쿼리를 데이터베이스에 전송한다. (등록, 수정, 삭제 쿼리)

 

 

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

 

- em.flush() : 직접 호출하는 방법이 있다.

- 트랜잭션 커밋 : 플러시를 자동으로 호출해준다.

- JPQL 쿼리 실행 : 플러시를 자동으로 호출해준다.

 

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();
            System.out.println("====================");

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

 

 

이번엔 직접 flush 를 호출함으로써 insert SQL 이 먼저 수행된 것을 확인할 수 있다.

즉, printf 함수에서 flush 와 동일한 매커니즘으로 이해하면 쉬울것 같다.

 

 

 

flush 를 할 경우 1차 캐시에 보존되어 있던 데이터들이 날라가나요?

 

다행스럽게도 flush 를 할 경우 1차 캐시에 보존되어 있던 데이터들이 날라가지 않는다고 한다.

즉, 1차 캐시에 데이터들이 그대로 유지된 상태에서 데이터베이스에 데이터가 올라가게 된다.

복잡한 시스템에서 좀 더 효율적임을 알 수 있겠다.

 

 

JPQL 쿼리 실행시 플러시가 자동으로 호출되는 이유?

아래 코드를 살펴보도록 한다.

em.persist(memberA);
em.persist(memberB);
em.persist(memberC);

// 중간에 JPQL 실행
query = em.createQuery("select m from Member m", Member.class);
List<Member> members = query.getResultList();

 

만약 위와 같은 코드에서 memberA, B, C 에 대한 객체를 삽입한다고 할 때, flush 를 안했으므로

1차 캐시에는 존재하지만 데이터베이스에는 직접적으로 반영되지 못했다.

그 때 em.createQuery 를 수행해서 모든 member 를 가져오는 쿼리를 수행한다고 할 때,

memberA, B, C 에 대한 데이터는 flush 를 하지 못했으므로 가져오지 못하는 문제가 발생한다.

 

따라서 JPQL 쿼리를 실행할 때 자동적으로 flush 를 호출하여 기존에 쌓아뒀던 SQL 쿼리문들을 실행시켜서

정상적으로 데이터를 처리할 수 있도록 한다.

 

 

플러시는 ...

- 영속성 컨텍스트를 비우지 않는다.

- 영속성 컨텍스트의 변경내용을 데이터베이스에 동기화한다.

- 트랜잭션이라는 작업 단위가 중요 -> 커밋 직전에만 동기화 하면 된다.

 

 

※ 준영속 상태

 

영속 상태의 엔티티가 영속성 컨텍스트에서 분리(detached)되는 것을 의미한다.

영속성 컨텍스트가 제공하는 기능을 사용하지 못한다.

 

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);
            System.out.println("==================");

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

 

 

em.detach() 를 통해서 업데이트 하고자 할 member 객체를 영속성 컨텍스트에서 분리시켜버린다.

즉, find() 을 할 때 select 문은 정상적으로 수행되었으나 setName() 을 하여 업데이트를 시도했지만 

detach() 를 하여 영속성 컨텍스트에서 분리시켰기 때문에 update 문은 수행되지 않는다.

 

 

준영속 상태로 만드는 방법

- em.detach(entity) : 특정 엔티티만 준영속 상태로 전환

- em.clear() : 영속성 컨텍스트를 완전히 초기화 (1차 캐시 비움)

- em.close() : 영속성 컨텍스트를 종료