[ JPA ] 영속성 컨텍스트와 엔티티 생명주기

📌목차   1. 엔티티 매니저 팩토리와 엔티티 매니저  2. 영속성 컨텍스트와 엔티티 생명주기   3. 영속성 컨텍스트의 특징

1. 엔티티 매니저 펙토리와 엔티티 매니저

• JPA에서 Entity Manager는 Entity에 대한 조회, 수정, 삭제, 저장 등 Entity와 관련된 모든 일을 처리합니다.
• Entity Manager Factory 는 Entity Manager를 생성하는 역할을 하며 생성하는 비용이 큽니다.
• 데이터 베이스를 하나만 사용하는 어플리케이션에서는 일반적으로 Entity Manager Factory를 하나만 생성하여 이를 공유하며 사용합니다.  
• Entity Manager Factory는 Thread safe 합니다. ( 서로 다른 스레드가 동시에 접근해도 안전합니다. )
• Entity Manager가 필요할 때마다 Entity Manager Factory로 생성하며, Thread safe 하지 않습니다.
  ( 서로 다른 스레드가 동시 접근하면 동시성 문제가 발생 ) 
  
  

2. 영속성 컨텍스트와 엔티티 생명주기

영속성 컨텍스트( Persistence Context ) 란 무엇일까요? 

영속성 컨텍스트란 '엔티티를 영구 저장하는 환경' 이라는 뜻입니다.
엔티티 매니저는 영속성 컨텍스트에 엔티티를 보관하고 관리합니다. 
논리적인 개념에 가까우며 여러 엔티티 매니저가 같은 영속성 컨텍스트에 접근할 수도 있습니다. 

엔티티 생명주기

1. 비영속 ( new / transient )  

2. 영속 ( managed )           
3. 준영속 (detached )
4. 삭제 ( removed ) 

 

1. 비영속 ( new / transient ) 
: 순수한 객체 상태로 영속성 컨텍스트로 관리되기 전의 상태

Member member = new Member();	// 순수한 Java객체 생성
member.setName("홍길동");	// 변경 감지의 대상이 아니며, 실제 DB의 엔티티와 무관한 상태입니다.

2. 영속 ( managed )

 : 영속성 컨텍스트에 의해 관리되는 상태입니다.

em.persist(member);	// 영속성 컨텍스트에 객체를 저장한 상태 ( 영속 )

* em.find () , JPQL의 쿼리 등으로 DB로부터 조회한 엔티티도 마찬가지로 영속상태입니다.

3. 준영속 ( detached )
: 영속 상태의 엔티티를 더이상 영속성 컨텍스트가 관리하지 않는 상태 

em.detach(member);	// 1.member 엔티티를 영속성 컨텍스트에서 분리하는 메서드

# 아래 두가지 경우에도 준영속 상태가 됩니다. 
em.close();	// 영속성 컨텍스트를 닫는 메서드
em.clear();	// 영속성 컨텍스트를 초기화하는 메서드

4.  삭제 ( removed ) 
: 엔티티를 영속성 컨텍스트와 데이터베이스에서 삭제하는 경우의 상태

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

3. 영속성 컨텍스트의 특징

• 영속성 컨텍스트와 식별자 값  : 엔티티를 식별자 값으로 구분하므로 영속 상태는 반드시 식별자 값이 있어야 합니다. 
• 영속성 컨텍스트와 데이터베이스 저장 : 영속성 컨텍스트에 저장된 엔티티는 트랜잭션을 커밋하는 순간 DB에 반영되며 이것을 Flush라고 합니다.   
• 영속성 컨텍스트가 엔티티를 관리하여 생기는 이점
  
  • 1차 캐시 
  • 동일성 보장
  • 트랜잭션을 지원하는  쓰기 지연
  • 변경 감지
  • 지연 로딩

엔티티 조회

• 영속성 컨텍스트 내부에 캐시( Map )가 있으며 이를 1차 캐시라고 합니다. ( 메모리에 존재 )
• 1차 캐시의 Key로는 @Id로 매핑한 식별자가 사용되며 Value은 엔티티 인스턴스입니다.
• 영속 상태의 엔티티는 모두 1차 캐시에 저장되어 있습니다.
• 엔티티를 조회하는 경우 먼저 1차 캐시에서 엔티티를 찾고 만약 1차 캐시에 없으면 데이터베이스를 조회하여 엔티티를 생성합니다. 이후 1차 캐시에 엔티티를 저장한 후 영속 상태의 엔티티를 반환합니다.
• 영속성 컨텍스트는 식별자를 통해 1차 캐시에서 같은 엔티티 인스턴스를 반환하므로 성능상 이점과 엔티티의 동일성을 보장합니다. ( 아래 경우 참고 ) 

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

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

결과 : true

엔티티 등록

• 엔티티 매니저는 트랜잭션을 커밋하기 직전까지 DB에 엔티티를 저장하지 않고 쓰기 지연 SQL 저장소에 INSERT SQL을 모아두고 트랜잭션 커밋할 때 모아둔 쿼리를 DB에 보냅니다. 이것을 쓰기 지연( Transactional write-behind )이라 합니다.

엔티티 수정

• 엔티티 삭제, 조회, 저장과는 다르게 엔티티를 수정하는 별도의 메서드( em.update() 등 )는 존재하지 않습니다. 
• 변경 감지( Dirty Checking ) 기능을 통하여 엔티티의 수정 사항을 데이터베이스에 반영합니다.
• 변경 감지란 엔티티를 영속성 컨텍스트에 보관할 때 ( 저장 또는 DB에서 조회했을 때 ), 최초의 상태를 복사해서 저장해둡니다. 이를 스냅샷( Snap shot ) 이라 하며, Flush 시점에 스냅샷과 엔티티를 비교하여 변경된 엔티티를 찾고 변경된 엔티티에 대한 수정 쿼리를  쓰기 지연 SQL 저장소에 보냅니다.
• 변경 감지는 영속 상태의 엔티티에만 적용됩니다.

JPA의 업데이트 전략

• JPA는 기본적으로 엔티티의 모든 필드를 업데이트하는 전략을 사용하며, 아래의 이점을 가지고 있습니다. 
  • 모든 필드를 사용하면 수정 쿼리가 항상 같고, 따라서 애플리케이션 로딩 시점에 수정 쿼리를 미리 생성해두고 재사용할 수 있습니다.
  • 데이터베이스에 동일한 쿼리를 보내면 데이터베이스는 이전에 한 번 파싱된 쿼리를 재사용할 수 있습니다.  
• 필드가 많거나 저장되는 내용이 너무 큰 경우 수정된 데이터만 사용하여 동적으로 UPDATE 쿼리를 생성하는 전략도 존재합니다. 이 경우에는 Entity 클래스에 @DynamicUpdate 어노테이션을 사용하면 됩니다.

@Entity
@DynamicUpdate		// 동적으로 UPDATE SQL을 생성
public class Member{
	
    ...

}

엔티티 삭제

• 엔티티를 삭제하려면 삭제 대상 엔티티를 조회해야 합니다.
• em.remove(member) 시 member 엔티티 DELETE SQL을 쓰기 지연 SQL 저장소에 등록합니다.
• em.remove(member) 를 호출하는 순간 member은 영속성 컨텍스트에서 제거됩니다.

Member member = em.find(Member.class , "member");	// 삭제 대상 엔티티 조회
em.remove(member);	// 엔티티 삭제 : 엔티티 삭제 SQL을 쓰기 지연 저장소로 보내고, 영속성 컨텍스트에서 제거

플러시 ( Flush )

• 플러시는 영속성 컨텍스트의 변경 내용을 데이터베이스로 반영하는 메서드입니다.
• 플러시는 영속성 컨텍스트의 변경 내용을 데이터베이스에 동기화하는 것이지 영속성 컨텍스트에 보관된 엔티티를 지우는 것이 아닙니다. ( 플러시라는 이름에 오해하지 맙시다. )  
• 플러시를 실행하는 경우 다음과 같은 일이 일어납니다.
  
  1. 변경 감지가 동작해서 영속성 컨텍스트에 있는 모든 엔티티를 스냅샷과 비교해서 수정된 엔티티를 찾는다.
     수정된 엔티티는 수정 쿼리를 만들어 쓰기 지연 SQL 저장소에 등록한다.
  2. 쓰기 지연 SQL 저장소의 쿼리를 데이터베이스에 전송한다. ( 등록, 수정, 삭제 쿼리 ) 

플러시를 호출하는 방법 3가지

• 직접  호출
  엔티티 매니저의 flush() 를 직접 호출하여 영속성 컨텍스트를 강제로 플러시한다. 테스트나 다른 프레임워크와 JPA를 함께 사용할 때를 제외하고 거의 사용하지 않습니다.
• 트랜잭션 커밋 시 플러시 자동 호출
  데이터베이스의 변경 내용을  SQL로 전달하지 않고 트랜잭션만 커밋하면 어떤 데이터도 데이터베이스에 반영되지 않습니다. 따라서 트랜잭션을 커밋하기 전에 꼭 플러시를 호출해서 영속성 컨텍스트의 변경 내용을 데이터베이스에 반영해야 합니다. JPA는 이런 문제를 예방하기 위해 트랜잭션을 커밋할 때 플러시를 자동으로 호출합니다.
• JPQL 쿼리 실행 시 플러시 자동 호출
  JPQL이나 Criteria 같은 객체지향 쿼리를 호출할 때도 플러시가 실행됩니다. ( SQL로 변환되어 데이터베이스를 조회 ) 
• 식별자를 기준으로 조회하는 find()의 경우에는 플러시가 실행되지 않습니다.

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

// JPA에서 중간에 JPQL로 조회하는 경우 DB에 memberA, memberB, memberC 가 반영되지 않아 
// 쿼리 결과로 조회되지 않는 것들을 예방하기 위하여 플러시를 자동으로 호출함 
query = em.createQuery("SELECT m FROM Member m", Member.class);
List<Member> members = query.getResultList();

플러시 모드 옵션

• FlushModeType.AUTO : 커밋이나 쿼리를 실행할 때 플러시 ( 기본값 )
• FlushModeType.COMMIT : 커밋할 때만 플러시
• COMMIT 모드는 성능 최적화를 위해 사용할 수 있다고 합니다.

em.setFlushMode(FlushModeType.COMMIT) // 플러시 모드를 직접 설정

준영속

• 영속 상태의 엔티티가 영속성 컨텍스트에서 분리된( detached ) 것을 준영속 상태라 합니다. 따라서 준영속 상태의 엔티티는 영속성 컨텍스트가 제공하는 기능을 사용할 수 없습니다.
• 크게 3가지 메서드를 사용하여 영속 상태의 엔티티를 준영속 상태로 만들 수 있습니다. detach() / clear() / close() 

엔티티를 준영속 상태로 전환 : detach( entity )

• 특정 엔티티만 준영속 상태로 만드는 메서드입니다. 
• 이 메서드를 호출하는 순간 1차 캐시부터 쓰기 지연 SQL 저장소까지 해당 엔티티를 관리하기 위한 모든 정보가 제거됩니다.
• 영속성 컨텍스트가 더이상 관리하지 않으므로 트랜잭션을 커밋해도 데이터베이스에 저장되지 않습니다.

# detach() 메서드 정의
public void detach(Object entity);

# 사용 예시
em.persist(member);	// member 엔티티 영속 상태
...				
em.detach(member)	// 영속성 컨텍스트에서 분리, member 엔티티 준영속 상태

영속성 컨텍스트 초기화 : clear( )

• 영속성 컨텍스트를 초기화해서 해당 영속성 컨텍스트의 모든 엔티티를 준영속 상태로 만드는 메서드입니다
  .( 영속성 컨텍스트를 제거하고 새로 만드는 것과 같은 효과 )
• 영속성 컨텍스트가 관리하지 않으므로 다음 코드의 setUsername()에 대한 변경 감지가 동작하지 않습니다.

// 엔티티 조회, 영속 상태가 됨
Member member = em.find(Member.class, "memberA");

em.clear();	// 영속성 컨텍스트 초기화

// 준영속 상태
member.setUsername("changeName");

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

• 영속성 컨텍스트를 종료시키는 메서드입니다.
• 영속성 컨텍스트를 종료하면 영속성 컨텍스트가 관리하던 모든 엔티티가 준영속 상태가 됩니다.

영속 상태의 엔티티는 주로 영속성 컨텍스트가 종료되면서 준영속 상태가 됩니다. 개발자가 직접 준영속 상태로 만드는 일은 드물다고 합니다. 

준영속 상태의 특징

• 거의 비영속 상태에 가깝습니다.
  ( 1차 캐시, 쓰기 지연, 변경 감지, 지연 로딩을 포함한 영속성 컨텍스트가 제공하는 어떤 기능도 동작하지 않습니다. ) 
• 식별자 값을 가지고 있습니다.
  ( 비영속 상태는 식별자 값이 없을 수 있지만 준영속 상태는 이미 한 번 영속 상태였으므로 반드시 식별자 값을 가지고 있습니다. 기본키 생성 전략을 IDENTITY로 사용하는 경우 persist() 시 DB에 접근 )
• 지연 로딩을 할 수 없습니다.

병합 : merge( entity )

• 준영속 상태의 엔티티를 다시 영속 상태로 변경하려면 병합을 사용하면 됩니다.
• merge() 메서드는 준영속 상태의 엔티티를 받아 그 정보로 새로운 영속 상태의 엔티티를 반환합니다.
• 파라미터로 사용된 엔티티는 merge()이후에도 준영속 상태로 남아있습니다.

public class ExamMergeMain{
	
    public static void main(String[] args){
    
    	Member member = createMember("memberA", "회원1");
        
        member.setUsername("회원명변경");	// 준영속 상태에서 변경
        
        mergeMember(member);
    }
	
    static Member createMember(String id, String userName){
    	// 영속성 컨택스트 1 시작 
        EntityManager em1 = emf.createEntityManager();
        EntityTransaction tx1 = em1.getTransaction();
        tx1.begin();
        
        Member member = new Member();
        member.setId(id);
        member.setUserName(userName);
        
        em1.persist(member);
        tx1.commit();	// member 엔티티가 db에 반영됨
      
        em1.close();	// 영속성 컨택스트 1 종료, member 엔티티가 준영속 상태가 됨
        
        return member;
    }

	static void mergeMember(Member member){
    	// 영속성 컨택스트 2 시작
        EntityManager em2 = emf.createEntityManager();
        EntityTransaction tx2 = em2.getTransaction();
        
        tx2.begin();
        em2.merge(member);	// 준영속 상태의 member에 merge() 수행 
        tx2.commit();

	// 준영속 상태
        System.out.println("member = " + member.getUsername());

        // 영속 상태
        System.out.println("mergeMember = " + mergeMember.getUsername());
        System.out.println("em2 contains member = " + em2.contains(member));
        System.out.println("em2 contains mergeMember = " + em2.contains(mergeMember));
        
        em2.close();	// 영속성 컨택스트 2 종료
    }

}


# 출력 결과
member = 회원명변경
mergeMember = 회원명변경
em2 contains member = false
em2 contains mergeMember = true

 

• main 메서드에서 setUserName()을 호출하였지만 이미 em1이 종료된 상태이므로 member은 준영속 상태이고, 변경 감지가 일어나지 못하는 상황입니다.
• mergeMember()메서드에서 member의 식별자를 기반으로 한 새로운 영속 상태의 엔티티를 반환하고, 이 과정에서 변경 감지가 발생하였습니다. 
• contains는 영속성 컨텍스트가 엔티티를 관리하는지 확인하는 메서드입니다.
  ( 출력 결과 member은 em2에 관리되고 있지 않습니다. 즉, 여전히 준영속 상태이며 새로운 인스턴스를 생성하였다는 것을 확인할 수 있습니다. ) 

이제 merge( )의 동작 과정을 구체적으로 살펴보겠습니다. 

1. merge( )를 실행한다.
2. 파라미터로 넘어온 준영속 엔티티의 식별자 값으로 1차 캐시에서 엔티티를 조회한다.
   • 만약 1차 캐시에 엔티티가 없으면 데이터베이스에서 엔티티를 조회하고 1차 캐시에 저장한다. 
     ( 이 과정에서 1차 캐시에 snapshot이 저장되고, 이후 변경 감지가 수행되는 것 같습니다. ) 
3. 조회한 영속 엔티티( mergeMember )에 member 엔티티의 값을 채워 넣는다. 
   ( member 엔티티의 모든 값을 mergeMember에 밀어 넣는다. 이때 mergeMember의 "회원1"이라는 이름이 "회원명변경"으로 바뀐다. )
4. mergeMember를 반환한다.

비영속 병합

• merge( )는 비영속 엔티티도 영속 상태로 만들 수 있습니다. 
• 파라미터로 넘어온 엔티티의 식별자 값으로 영속성 컨텍스트를 조회하고 찾는 엔티티가 없으면 데이터베이스에서 조회합니다. ( db에도 없으면 새로운 엔티티를 생성해서 병합합니다. )

정리하자면 병합은 식별자 값으로 엔티티를 조회할 수 있으면 불러서 병합하고 조회할 수 없으면 새로 생성해서 병합합니다. 즉, save or update 기능을 수행합니다. 

---

# 글에 사용된 설명과 코드는 김영한님의 "자바 ORM 표준 JPA 프로그래밍"을 정리한 내용입니다.