[LG U+ 유레카 3기]순수 JPA 실습 엔티티 생명주기 (persist / find / merge / detach / remove)

🧩 JPA 실습 ③ — 엔티티 생명주기 (persist / find / merge / detach / remove)

이번 실습은 JPA 엔티티의 전체 생명주기를 다루며, 각 메서드가 영속성 컨텍스트에 어떤 영향을 주는지를 직접 확인한다.
결과적으로 JPA의 작동 원리를 완전히 이해할 수 있는 핵심 단계다.

---

❶ 실습 목표

• persist() : 새로운 객체를 영속성 컨텍스트에 등록
• find() : DB 데이터를 객체화하여 1차 캐시에 저장
• merge() : 존재하면 update, 없으면 insert 수행
• detach() : 엔티티를 영속성 컨텍스트에서 분리
• remove() : 엔티티 삭제 (1차 캐시 및 DB 반영)

---

❷ 코드 구성

src/main/java/
 ├─ config/MyPersistenceUnitInfo.java
 ├─ entity/Employee.java
 └─ Test.java

---

📄 Employee.java

package entity;

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

@Entity
// @Table(name = "emp")
public class Employee {
	@Id
//  @Column(name="emp_id")
	private int id;
	
	private String name;
	private String address;
	
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
	@Override
	public String toString() {
		return "Employee [id=" + id + ", name=" + name + ", address=" + address + "]";
	}
}

@Table / @Column 어노테이션 간단 정리

엔티티 클래스의 테이블명과 컬럼명을 DB와 다르게 지정하고 싶을 때 사용하는 매핑 어노테이션이다.

간단한 어노테이션 실습도 진행하기위해 기존의 employee테이블과 똑같은 테이블인 emp테이블을 만들어준뒤 실습진행함.

✅ @Table

• 클래스 레벨에서 사용된다.
• DB의 실제 테이블 이름을 지정한다.

@Entity
@Table(name = "emp")  // 실제 테이블명을 emp로 지정
public class Employee { ... }

👉 생략 시 클래스명(Employee)이 테이블명으로 자동 매핑된다.

---

✅ @Column

• 필드(속성) 단위로 사용된다.
• DB의 실제 컬럼 이름, 길이, 제약 조건 등을 지정한다.

@Id
@Column(name = "emp_id", length = 10, nullable = false)
private int id;

속성 설명 👇

속성명	설명
name	DB 컬럼명 지정
length	문자열 컬럼 길이 지정 (기본 255)
nullable	false로 설정 시 NOT NULL 제약조건 적용
unique	유니크 제약조건 설정
insertable / updatable	SQL INSERT/UPDATE 시 포함 여부 제어

---

💡 예시

@Entity
@Table(name = "emp_table")
public class Employee {
    @Id
    @Column(name = "emp_id")
    private int id;

    @Column(name = "emp_name", length = 30)
    private String name;

    @Column(name = "emp_address", nullable = false)
    private String a

---

📄 Test.java

import java.util.HashMap;
import config.MyPersistenceUnitInfo;
import entity.Employee;
import jakarta.persistence.EntityManager;
import jakarta.persistence.EntityManagerFactory;
import org.hibernate.jpa.HibernatePersistenceProvider;

public class Test {
    public static void main(String[] args) {
        EntityManagerFactory emf = new HibernatePersistenceProvider()
                .createContainerEntityManagerFactory(new MyPersistenceUnitInfo(), new HashMap<>());

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

        // #1. persist()
        // 새로운 객체를 영속성 컨텍스트에 등록 (DB insert는 commit 시점)
        // Employee e1 = new Employee();
        // e1.setId(1);
        // e1.setName("홍길동");
        // e1.setAddress("서울");
        // em.persist(e1);

        // #2. find()
        // Employee e = em.find(Employee.class, 1);
        // System.out.println(e);
        // e.setAddress("대전"); // update X
        // System.out.println(e); // commit() 시점에 update O

        // #3. merge()
        // Employee e = new Employee();
        // e.setId(2);
        // e.setName("이길동");
        // e.setAddress("광주");
        // em.merge(e); // id=2가 없으면 insert

        // Employee e2 = new Employee();
        // e2.setId(2);
        // e2.setName("이길동");
        // e2.setAddress("부산");
        // em.merge(e2); // id=2가 존재하면 update

        // #4. detach()
        // Employee e = em.find(Employee.class, 2);
        // System.out.println(e);
        // em.detach(e); // 영속성 컨텍스트에서 분리
        // e.setAddress("강릉"); // update X (더 이상 관리 X)
        // System.out.println(e);

        // #5. remove()
        // Employee e = em.find(Employee.class, 2);
        // em.remove(e); // DB에서 삭제됨 (commit 시점)
        
        // 아래는 예외 발생 예시 (비영속 객체 remove)
        Employee e = new Employee();
        e.setId(1);
        em.remove(e); // IllegalArgumentException: detached instance

        em.getTransaction().commit();
        em.close();
    }
}

❹ 주요 메서드별 동작 원리

✅ ① persist()

• 새 객체를 영속성 컨텍스트(1차 캐시)에 등록한다.
• DB에 즉시 INSERT 되지 않고, commit() 시점에 flush()되면서 SQL 실행.

✅ ② find()

• DB 데이터를 조회해 객체로 변환 후 1차 캐시에 저장한다.
• 같은 ID로 다시 find()를 호출하면 캐시에서 반환되어 DB 조회 X.

✅ ③ merge()

• 비영속 상태의 엔티티를 영속성 컨텍스트에 병합한다.
• DB에 존재하지 않으면 INSERT, 존재하면 UPDATE 수행.
• merge()는 항상 새로운 영속 객체를 반환한다.

✅ ④ detach()

• 영속성 컨텍스트에서 엔티티를 분리시킨다.
• 이후 필드 변경은 감지되지 않으며, commit 시점에 update SQL X.

✅ ⑤ remove()

• 엔티티를 삭제 상태로 표시한다.
• commit 시점에 DELETE SQL 실행.
• 비영속 객체를 remove()하면 IllegalArgumentException 발생.

---

❺ 예외 상황 정리

1️⃣ 동일한 ID로 persist() → 
java.sql.SQLIntegrityConstraintViolationException: Duplicate entry '1' for key 'PRIMARY'

2️⃣ 비영속 객체 remove() → 
java.lang.IllegalArgumentException: Removing a detached instance entity.Employee#1

---

❻ 실습 핵심 요약

메서드	상태 변화	DB 반영 시점	비고
persist()	비영속 → 영속	commit()	1차 캐시에 등록
find()	DB → 영속	즉시 (SELECT)	1차 캐시 재사용
merge()	비영속 → 영속	commit()	DB 없으면 insert, 있으면 update
detach()	영속 → 준영속	-	더 이상 관리되지 않음
remove()	영속 → 삭제	commit()	DELETE SQL 실행

---

❼ 핵심 한 줄 요약

JPA의 진짜 본질은 SQL 실행기가 아니라 “엔티티 상태 관리 시스템”이다.
persist()로 등록되고, find()로 조회된 객체는 모두 JPA가 감시하고 있다.
commit() 시점에 flush() → 변경 감지 → SQL 생성 → DB 반영이 일어난다.

---

📚 용어 정리

용어	설명
영속성 컨텍스트	엔티티를 저장·관리하는 1차 캐시 공간
비영속 (Transient)	JPA가 아직 관리하지 않는 단순 객체
영속 (Managed)	JPA가 추적 중인 객체 (persist, find 결과)
준영속 (Detached)	더 이상 관리되지 않는 객체 (detach 후)
삭제 (Removed)	commit 시 DELETE SQL 실행 예정 상태