1
2
3
4
// Java SE: EntityManager 하나 = 영속성 컨텍스트 하나
EntityManagerFactory emf = Persistence.createEntityManagerFactory("myPU");
EntityManager em = emf.createEntityManager();
// em이 자신만의 영속성 컨텍스트를 가진다

1
2
3
4
5
6
7
8
// 영속성 컨텍스트가 없는 가상의 JPA
Member member1 = em.find(Member.class, 1L);  // SELECT 실행
Member member2 = em.find(Member.class, 1L);  // 또 SELECT 실행 (중복!)

System.out.println(member1 == member2);  // false (서로 다른 인스턴스!)

member1.setName("변경된이름");
em.update(member1);  // 명시적으로 update를 호출해야 한다

1
2
3
4
5
6
7
8
// 실제 JPA
Member member1 = em.find(Member.class, 1L);  // SELECT 실행
Member member2 = em.find(Member.class, 1L);  // 1차 캐시에서 반환 (SELECT 안 함!)

System.out.println(member1 == member2);  // true (같은 인스턴스!)

member1.setName("변경된이름");
// update() 호출 불필요! 트랜잭션 커밋 시 변경 감지로 자동 UPDATE

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// EntityManagerFactory는 애플리케이션 당 하나 (비용이 크다)
EntityManagerFactory emf = Persistence.createEntityManagerFactory("myPU");

// EntityManager는 요청마다 생성 (비용이 작다)
EntityManager em = emf.createEntityManager();
EntityTransaction tx = em.getTransaction();

try {
    tx.begin();

    Member member = new Member("김철수");
    em.persist(member);    // 영속성 컨텍스트에 저장

    tx.commit();           // 커밋 → flush → DB 반영
} catch (Exception e) {
    tx.rollback();
} finally {
    em.close();            // 영속성 컨텍스트 종료, 엔티티는 준영속 상태
}

// 애플리케이션 종료 시
emf.close();

1
2
3
4
5
6
7
8
9
10
11
12
@Service
@RequiredArgsConstructor
public class MemberService {
    private final MemberRepository memberRepository;

    @Transactional
    public void createMember(String name) {
        Member member = new Member(name);
        memberRepository.save(member);
        // 메서드가 끝나면 자동으로 commit → flush → 영속성 컨텍스트 종료
    }
}

1
2
3
4
5
@Repository
public class MemberRepository {
    @PersistenceContext
    private EntityManager em;  // 싱글톤 빈에 주입! 스레드 안전한가?
}

1
2
3
4
5
6
// 비영속 상태: 그냥 Java 객체일 뿐이다
Member member = new Member();
member.setName("김철수");
member.setAge(25);
// 이 시점에서 member는 JPA가 전혀 관리하지 않는다
// DB에도 저장되지 않았고, 영속성 컨텍스트에도 없다

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
EntityManager em = emf.createEntityManager();
em.getTransaction().begin();

// 방법 1: persist()로 영속 상태로 만든다
Member member = new Member("김철수");
em.persist(member);
// → member는 이제 영속 상태
// → 1차 캐시에 저장됨
// → 스냅샷이 생성됨

// 방법 2: find()로 DB에서 조회하면 자동으로 영속 상태
Member found = em.find(Member.class, 1L);
// → found는 영속 상태
// → DB에서 가져온 데이터가 1차 캐시에 저장됨

// 방법 3: JPQL로 조회해도 영속 상태
List<Member> members = em.createQuery("SELECT m FROM Member m", Member.class)
    .getResultList();
// → 조회된 모든 Member가 영속 상태

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 방법 1: 특정 엔티티를 분리
em.detach(member);
// → member만 영속성 컨텍스트에서 제거

// 방법 2: 영속성 컨텍스트를 완전히 초기화
em.clear();
// → 모든 엔티티가 준영속 상태. 1차 캐시 완전 삭제

// 방법 3: 영속성 컨텍스트를 종료
em.close();
// → 영속성 컨텍스트 자체가 사라짐

// 방법 4: 트랜잭션이 끝난 후 (Spring 환경, OSIV OFF)
@Transactional
public Member getMember(Long id) {
    return memberRepository.findById(id).orElseThrow();
}
// 메서드 종료 후 반환된 Member는 준영속 상태

1
2
3
4
5
6
7
8
9
Member member = em.find(Member.class, 1L);
em.remove(member);
// → member는 삭제 상태
// → 아직 DELETE가 실행되지는 않았다
// → flush() 시점에 DELETE SQL이 실행된다

// 삭제 상태의 엔티티를 다시 persist()하면?
em.persist(member);
// → 다시 영속 상태로 전환된다 (삭제 취소)

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
@Test
void 엔티티_생명주기_테스트() {
    EntityManager em = emf.createEntityManager();
    EntityTransaction tx = em.getTransaction();
    tx.begin();

    // 1. 비영속
    Member member = new Member("김철수");
    System.out.println("비영속: " + em.contains(member));  // false

    // 2. 비영속 → 영속
    em.persist(member);
    System.out.println("영속: " + em.contains(member));    // true

    // 3. 영속 → 준영속
    em.detach(member);
    System.out.println("준영속: " + em.contains(member));  // false

    // 4. 준영속 → 영속 (merge)
    Member merged = em.merge(member);
    System.out.println("merge 반환: " + em.contains(merged));   // true
    System.out.println("원본: " + em.contains(member));          // false! 원본은 여전히 준영속

    // 5. 영속 → 삭제
    em.remove(merged);
    System.out.println("삭제: " + em.contains(merged));   // false

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

1
2
3
4
5
6
7
8
9
10
11
12
Member member1 = em.find(Member.class, 1L);
// 실행 흐름:
// 1. 1차 캐시에서 EntityKey(Member.class, 1L)을 검색
// 2. 없다 → DB에 SELECT 쿼리 실행
// 3. 결과를 엔티티로 변환
// 4. 1차 캐시에 저장 + 스냅샷 생성
// 5. 엔티티 반환

Member member2 = em.find(Member.class, 1L);
// 실행 흐름:
// 1. 1차 캐시에서 EntityKey(Member.class, 1L)을 검색
// 2. 있다! → DB 조회 없이 바로 반환

1
System.out.println(member1 == member2);  // true (같은 인스턴스!)

1
2
3
4
5
6
7
8
9
// find()로 조회 → 1차 캐시에 저장
Member member1 = em.find(Member.class, 1L);

// JPQL로 같은 데이터를 조회
List<Member> members = em.createQuery(
    "SELECT m FROM Member m WHERE m.id = 1", Member.class)
    .getResultList();

Member member2 = members.get(0);

1
2
System.out.println(member1 == member2);  // true!
// JPQL이 DB에서 새로 가져왔지만, 1차 캐시의 기존 인스턴스를 반환했다

1
2
3
4
5
6
7
8
9
10
11
@Transactional
public void method1() {
    Member m = memberRepository.findById(1L).orElseThrow();  // SELECT 실행, 1차 캐시 저장
    Member m2 = memberRepository.findById(1L).orElseThrow(); // 1차 캐시 히트!
}

@Transactional
public void method2() {
    // method1의 1차 캐시는 이미 사라졌다
    Member m = memberRepository.findById(1L).orElseThrow();  // 다시 SELECT 실행
}

1
2
3
4
5
6
// 1차 캐시 활용 O
em.find(Member.class, 1L);  // PK 조회

// 1차 캐시 활용 X (항상 DB 조회)
em.createQuery("SELECT m FROM Member m WHERE m.name = '김철수'");
memberRepository.findByName("김철수");

1
2
3
4
5
6
7
8
@Transactional
public void identityTest() {
    Member m1 = memberRepository.findById(1L).orElseThrow();
    Member m2 = memberRepository.findById(1L).orElseThrow();

    System.out.println(m1 == m2);      // true (같은 인스턴스)
    System.out.println(m1.equals(m2)); // true
}

1
2
3
4
5
6
7
8
9
10
11
12
// Java 컬렉션과 JPA의 동작 유사성
Map<Long, Member> map = new HashMap<>();
map.put(1L, new Member("김철수"));

Member m1 = map.get(1L);
Member m2 = map.get(1L);
System.out.println(m1 == m2);  // true — 같은 인스턴스

// JPA도 동일하게 동작한다
Member m1 = em.find(Member.class, 1L);
Member m2 = em.find(Member.class, 1L);
System.out.println(m1 == m2);  // true — 같은 인스턴스

1
2
3
4
5
6
7
8
9
10
11
Member m1;
Member m2;

// 트랜잭션 1
memberService.method1(); // m1을 조회하고 반환

// 트랜잭션 2
memberService.method2(); // m2를 조회하고 반환 (같은 id=1)

System.out.println(m1 == m2);  // false!
// 서로 다른 영속성 컨텍스트에서 조회했으므로 다른 인스턴스다

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@Entity
public class Member {
    @Id @GeneratedValue
    private Long id;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Member)) return false;
        Member member = (Member) o;
        // id가 null이 아닌 경우에만 비교 (비영속 상태 방어)
        return id != null && id.equals(member.id);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
EntityManager em = emf.createEntityManager();
EntityTransaction tx = em.getTransaction();
tx.begin();

Member memberA = new Member("회원A");
Member memberB = new Member("회원B");

em.persist(memberA);
// INSERT SQL을 쓰기 지연 SQL 저장소에 저장
// 아직 DB에 전송하지 않음!

em.persist(memberB);
// INSERT SQL을 쓰기 지연 SQL 저장소에 저장
// 아직 DB에 전송하지 않음!

System.out.println("=== 커밋 전 ===");

tx.commit();
// 1. flush() 호출 → 쓰기 지연 SQL 저장소의 SQL을 DB에 전송
// 2. 실제 DB 커밋

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Transactional
public void complexLogic() {
    Member member = new Member("김철수");
    em.persist(member);
    // INSERT가 나가지 않았으므로, 이 시점에서 member.id를 사용할 수도 있다
    // (SEQUENCE 전략인 경우)

    // 비즈니스 로직 수행...
    if (someCondition) {
        throw new BusinessException("조건 불충족");
        // 예외 발생 → 롤백 → INSERT가 애초에 DB에 가지 않았으므로
        // 불필요한 INSERT + ROLLBACK 비용이 없다
    }

    // 정상 → 커밋 시점에 INSERT 실행
}

1
2
3
4
5
6
@Entity
public class Member {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
}

1
2
3
4
5
em.persist(member);
// → 즉시! INSERT INTO member (name) VALUES ('김철수');
// → DB가 생성한 id를 반환받아 member.id에 설정
// → 1차 캐시에 저장
System.out.println(member.getId());  // 1 (DB가 할당한 값)

1
2
3
4
5
6
7
8
@Entity
@SequenceGenerator(name = "member_seq_gen", sequenceName = "member_seq",
    allocationSize = 50)
public class Member {
    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "member_seq_gen")
    private Long id;
}

1
2
3
4
5
6
7
8
9
10
11
12
em.persist(memberA);
// 1. SELECT nextval('member_seq') → id = 1 획득
// 2. memberA.id = 1 설정
// 3. 1차 캐시에 저장
// 4. INSERT SQL은 쓰기 지연 SQL 저장소에 저장 (아직 DB 전송 안 함!)

em.persist(memberB);
// 1. SELECT nextval('member_seq') → id = 2 획득
// 2. INSERT SQL은 쓰기 지연 SQL 저장소에 저장

tx.commit();
// 여기서 INSERT 두 개가 한꺼번에 전송!

1
2
3
4
5
6
@Transactional
public void updateMemberName(Long id, String newName) {
    Member member = memberRepository.findById(id).orElseThrow();
    member.setName(newName);  // setter 호출만 했을 뿐!
    // memberRepository.save(member); ← 이 줄이 필요 없다!
}

1
2
3
4
5
6
7
8
9
10
11
12
@Entity
@DynamicUpdate
public class Member {
    @Id @GeneratedValue
    private Long id;
    private String name;
    private int age;
    // 컬럼이 30개 이상인 레거시 테이블
    private String field1;
    private String field2;
    // ... field3 ~ field30
}

1
2
3
4
5
6
@Transactional(readOnly = true)
public List<MemberDto> findMembers() {
    return memberRepository.findAll().stream()
        .map(MemberDto::from)
        .toList();
}

1
2
3
em.persist(member);
em.flush();  // 이 시점에 INSERT SQL이 DB에 전송된다
// 아직 커밋은 안 되었으므로 다른 트랜잭션에서는 안 보인다

1
2
3
tx.begin();
em.persist(member);
tx.commit();  // commit() 내부에서 flush()가 자동 호출된다

1
2
3
4
5
6
em.persist(memberA);  // INSERT SQL이 쓰기 지연 저장소에 대기 중

// JPQL 실행 → 이 전에 flush()가 자동 호출된다!
List<Member> members = em.createQuery(
    "SELECT m FROM Member m", Member.class)
    .getResultList();

1
2
3
4
5
6
7
8
9
10
em.persist(memberA);  // 아직 DB에 INSERT 안 됨
em.persist(memberB);  // 아직 DB에 INSERT 안 됨

// flush 없이 JPQL을 실행하면?
List<Member> members = em.createQuery(
    "SELECT m FROM Member m", Member.class)
    .getResultList();
// JPQL은 DB에 직접 쿼리한다
// memberA, memberB는 아직 DB에 없다!
// → 방금 persist한 데이터가 조회 결과에 빠진다!

1
2
3
4
5
6
7
// FlushMode.AUTO (기본)
// → 커밋 시, JPQL 실행 전에 자동 flush
em.setFlushMode(FlushModeType.AUTO);

// FlushMode.COMMIT
// → 커밋 시에만 flush, JPQL 실행 전에는 flush 안 함
em.setFlushMode(FlushModeType.COMMIT);

1
2
3
4
5
6
7
8
em.persist(member);
em.flush();
// 이 시점: INSERT가 DB에 전송되었지만, 아직 COMMIT 안 됨
// 다른 트랜잭션에서 member를 조회할 수 없음 (READ COMMITTED 이상)
// 여기서 예외가 발생하면 롤백되어 INSERT가 취소됨

tx.commit();
// 이 시점: COMMIT 확정, 다른 트랜잭션에서 조회 가능

1
2
3
4
5
6
7
8
9
10
11
@Transactional
public MemberDto getMember(Long id) {
    return MemberDto.from(memberRepository.findById(id).orElseThrow());
}
// 메서드 종료 → 트랜잭션 종료 → 영속성 컨텍스트 종료 → 엔티티는 준영속 상태

public void updateMember(Long id, String newName) {
    MemberDto dto = getMember(id);
    // dto를 기반으로 엔티티를 수정하고 싶은데...
    // 원본 엔티티는 이미 준영속 상태다!
}

1
2
3
4
5
6
7
8
9
10
@Transactional
public Member getMember(Long id) {
    return memberRepository.findById(id).orElseThrow();
}

// 컨트롤러에서 (OSIV OFF 환경)
Member member = memberService.getMember(1L);
member.getTeam().getName();
// → LazyInitializationException!
// 영속성 컨텍스트가 이미 종료되었으므로 프록시를 초기화할 수 없다

1
2
3
4
5
6
7
8
9
10
@Transactional
public void updateWithMerge(MemberUpdateDto dto) {
    Member detachedMember = new Member();
    detachedMember.setId(dto.getId());     // 식별자 설정
    detachedMember.setName(dto.getName()); // 변경할 값 설정

    Member mergedMember = em.merge(detachedMember);
    // mergedMember는 영속 상태
    // detachedMember는 여전히 준영속 상태!
}

1
2
3
4
5
6
7
8
9
10
// 기존 DB 데이터: {id: 1, name: "김철수", age: 25, email: "kim@test.com"}

Member detached = new Member();
detached.setId(1L);
detached.setName("이영희");
// age와 email은 설정하지 않음 → null

Member merged = em.merge(detached);
// 결과: {id: 1, name: "이영희", age: null, email: null}
// age와 email이 null로 덮어써졌다!!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 방법 1: 변경 감지 (권장)
@Transactional
public void updateMember(Long id, MemberUpdateDto dto) {
    Member member = memberRepository.findById(id).orElseThrow();
    // 필요한 필드만 변경
    member.setName(dto.getName());
    // age, email은 건드리지 않음 → 기존 값 유지
    // 자동으로 변경 감지 → UPDATE
}

// 방법 2: merge (비권장)
@Transactional
public void updateMember(MemberUpdateDto dto) {
    Member detached = new Member();
    detached.setId(dto.getId());
    detached.setName(dto.getName());
    em.merge(detached);
    // 설정하지 않은 필드가 null로 덮어써질 위험!
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@Service
public class OrderService {
    private final MemberRepository memberRepository;
    private final OrderRepository orderRepository;

    @Transactional
    public void createOrder(Long memberId, OrderRequest request) {
        Member member = memberRepository.findById(memberId).orElseThrow();
        Order order = new Order(member, request);
        orderRepository.save(order);

        // 질문: memberRepository와 orderRepository는 서로 다른 빈이다.
        // 각자 내부에서 EntityManager를 사용할 텐데,
        // 같은 영속성 컨텍스트를 공유하는가?
        // member가 1차 캐시에 있으면 order에서도 접근 가능한가?
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Transactional
public void createOrder(Long memberId, OrderRequest request) {
    // memberRepository 내부: SharedEntityManagerCreator가
    // ThreadLocal에서 EntityManager 'em1'을 가져와서 사용
    Member member = memberRepository.findById(memberId).orElseThrow();
    // → member가 em1의 1차 캐시에 저장됨

    // orderRepository 내부: SharedEntityManagerCreator가
    // ThreadLocal에서 같은 EntityManager 'em1'을 가져와서 사용
    Order order = new Order(member, request);
    orderRepository.save(order);
    // → order가 em1의 1차 캐시에 저장됨
    // → member도 같은 1차 캐시에 있으므로 접근 가능
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@Service
public class OrderService {
    @Transactional  // 트랜잭션 시작, EntityManager em1 생성
    public void createOrder(Long memberId) {
        Member member = memberRepository.findById(memberId).orElseThrow();
        // em1의 1차 캐시에 member 저장

        paymentService.processPayment(member);
        // 이 호출은 어떤 EntityManager를 사용하는가?
    }
}

@Service
public class PaymentService {
    @Transactional  // REQUIRED(기본): 기존 트랜잭션에 참여
    public void processPayment(Member member) {
        // 기존 트랜잭션에 참여하므로 같은 em1을 사용!
        // member는 em1의 1차 캐시에 있으므로 영속 상태!
        member.setPoint(member.getPoint() - 100);
        // 변경 감지 정상 동작!
    }
}

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
@Service
public class OrderService {
    @Transactional  // 트랜잭션 T1, EntityManager em1
    public void createOrder(Long memberId) {
        Member member = memberRepository.findById(memberId).orElseThrow();
        // em1의 1차 캐시에 member 저장

        auditService.log("ORDER_CREATED", memberId);
    }
}

@Service
public class AuditService {
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    // 새 트랜잭션 T2, 새 EntityManager em2!
    public void log(String action, Long targetId) {
        // em2는 em1과 완전히 다른 영속성 컨텍스트!
        // em1의 1차 캐시에 있는 member를 em2에서 접근할 수 없다!

        AuditLog auditLog = new AuditLog(action, targetId);
        auditRepository.save(auditLog);
        // em2에 persist → em2의 쓰기 지연 SQL 저장소에 INSERT
    }
    // 메서드 종료 → T2 커밋 → em2.flush() → em2.close()
}

1
2
3
4
5
6
7
8
9
10
11
Member member = em.find(Member.class, 1L);
// SQL: SELECT m.id, m.name, m.team_id FROM member m WHERE m.id = 1

Team team = member.getTeam();
// team은 프록시 객체다 (Team$HibernateProxy$xxx)
// 아직 SELECT 쿼리가 실행되지 않았다!

String teamName = team.getName();
// 이 시점에 프록시가 초기화된다!
// SQL: SELECT t.id, t.name FROM team t WHERE t.id = 1
// 프록시 내부의 target이 실제 Team 엔티티로 채워진다

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Transactional
public Member getMember(Long id) {
    return memberRepository.findById(id).orElseThrow();
    // 트랜잭션 종료 → 영속성 컨텍스트 종료
}

// 서비스 외부 (컨트롤러 등)
Member member = memberService.getMember(1L);
// member는 준영속 상태
// member.team은 초기화되지 않은 프록시

String teamName = member.getTeam().getName();
// → LazyInitializationException!
// "could not initialize proxy - no Session"
// 영속성 컨텍스트(Session)가 이미 닫혔으므로 프록시를 초기화할 수 없다

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// 방법 1: 트랜잭션 내에서 미리 초기화
@Transactional
public Member getMemberWithTeam(Long id) {
    Member member = memberRepository.findById(id).orElseThrow();
    member.getTeam().getName();  // 강제 초기화
    return member;
}

// 방법 2: Fetch Join
@Query("SELECT m FROM Member m JOIN FETCH m.team WHERE m.id = :id")
Optional<Member> findByIdWithTeam(@Param("id") Long id);

// 방법 3: @EntityGraph
@EntityGraph(attributePaths = {"team"})
Optional<Member> findById(Long id);

// 방법 4: DTO로 변환 (권장)
@Transactional(readOnly = true)
public MemberDto getMember(Long id) {
    Member member = memberRepository.findByIdWithTeam(id).orElseThrow();
    return MemberDto.from(member);  // DTO로 변환하여 반환
}

1
2
3
4
5
6
7
8
9
10
11
12
// 프록시 여부 확인
boolean isProxy = member.getTeam() instanceof HibernateProxy;

// 프록시 초기화 여부 확인
boolean isInitialized = Hibernate.isInitialized(member.getTeam());

// 프록시 강제 초기화
Hibernate.initialize(member.getTeam());

// 프록시의 실제 클래스 확인
Class<?> realClass = Hibernate.getClass(member.getTeam());
// Team$HibernateProxy$xxx가 아닌 Team.class를 반환

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
32
// 전략 1: 서비스 계층에서 필요한 데이터를 모두 로딩하여 DTO로 반환
@Transactional(readOnly = true)
public MemberDetailDto getMemberDetail(Long id) {
    Member member = memberRepository.findByIdWithTeamAndOrders(id)
        .orElseThrow();
    // Fetch Join으로 team, orders를 미리 로딩

    return MemberDetailDto.from(member);
    // DTO로 변환하여 반환 → 컨트롤러에서 지연 로딩 필요 없음
}

// 전략 2: 쿼리 서비스 분리 (CQRS 패턴의 간이 버전)
@Service
@RequiredArgsConstructor
public class MemberQueryService {

    @Transactional(readOnly = true)
    public MemberDetailDto getMemberDetail(Long id) {
        // 읽기 전용 쿼리에 최적화된 서비스
        // 필요한 데이터를 Fetch Join/DTO 조회로 가져온다
    }
}

@Service
@RequiredArgsConstructor
public class MemberCommandService {

    @Transactional
    public void updateMember(Long id, MemberUpdateDto dto) {
        // 쓰기 전용 서비스
    }
}

1
2
3
4
5
6
7
8
@Entity
@Cacheable                                    // JPA 표준
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)  // Hibernate
public class Team {
    @Id @GeneratedValue
    private Long id;
    private String name;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
@Transactional
public void bulkUpdateProblem() {
    Member member = memberRepository.findById(1L).orElseThrow();
    System.out.println("변경 전: " + member.getAge());  // 25

    // 벌크 UPDATE: 모든 회원의 나이를 +1
    memberRepository.bulkAgePlus(1);
    // DB에서는 member.age가 26이 되었다

    Member sameMember = memberRepository.findById(1L).orElseThrow();
    System.out.println("변경 후: " + sameMember.getAge());  // 25! (여전히!)
    // 1차 캐시에서 반환하므로 DB의 변경이 반영되지 않았다!
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 방법 1: @Modifying에 clearAutomatically 설정
@Modifying(clearAutomatically = true)
@Query("UPDATE Member m SET m.age = m.age + :value")
int bulkAgePlus(@Param("value") int value);
// 벌크 연산 후 자동으로 em.clear() 호출 → 1차 캐시 초기화

// 방법 2: 수동으로 clear()
@Transactional
public void bulkUpdate() {
    memberRepository.bulkAgePlus(1);
    em.flush();   // 혹시 남은 변경 사항 DB 반영
    em.clear();   // 1차 캐시 초기화

    Member member = memberRepository.findById(1L).orElseThrow();
    // 이제 DB에서 새로 조회하므로 변경된 값(26)이 반영된다
}

1
2
3
4
5
6
7
8
9
10
11
12
@Transactional
public void batchInsert() {
    for (int i = 0; i < 100000; i++) {
        Member member = new Member("회원" + i);
        em.persist(member);

        if (i % 100 == 0) {
            em.flush();  // SQL 전송
            em.clear();  // 1차 캐시 초기화 → 메모리 해제
        }
    }
}

1
2
3
4
5
6
7
8
9
10
// SimpleJpaRepository.save() 내부 구현
@Transactional
public <S extends T> S save(S entity) {
    if (entityInformation.isNew(entity)) {
        em.persist(entity);
        return entity;
    } else {
        return em.merge(entity);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@Entity
public class Item implements Persistable<String> {
    @Id
    private String id;

    @CreatedDate
    private LocalDateTime createdDate;

    @Override
    public String getId() {
        return id;
    }

    @Override
    public boolean isNew() {
        return createdDate == null;  // 생성일이 없으면 새 엔티티
    }
}