EntityManager와 영속성 컨텍스트

// 애플리케이션 전체에서 하나만!
@Configuration
public class HibernateConfig {
    @Bean
    public LocalSessionFactoryBean sessionFactory() { ... }
}

// 요청마다 새로 생성, 짧게 사용
@Transactional
public void doSomething() {
    // 이 메서드 실행 동안 Session/EntityManager가 살아있음
    // 메서드 끝나면 닫힘
}

Transaction tx = session.beginTransaction();
try {
    // 작업
    tx.commit();
} catch (Exception e) {
    tx.rollback();
}

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;  // 내부적으로 EntityManager 사용

    @Transactional  // Session, Transaction 자동 관리
    public void createUser(User user) {
        userRepository.save(user);
        // 트랜잭션 끝나면 자동 commit, Session 자동 close
    }
}

public interface EntityManager extends AutoCloseable {

    ...

}

entityManagerFactory.runInTransaction(entityManager -> {
    // 영속성 컨텍스트에서 작업 수행
    ...
});

@PersistenceContext(unitName="orderMgt")
EntityManager entityManager;

EntityManager entityManager = entityManagerFactory.createEntityManager();
EntityTransaction transaction = entityManager.getTransaction();
try {
    transaction.begin();
    // 작업 수행
    ...
    transaction.commit();
}
catch (Exception e) {
    if (transaction.isActive()) transaction.rollback();
    throw e;
}
finally {
    entityManager.close();
}

// 리소스 로컬 방식
EntityTransaction tx = entityManager.getTransaction();
tx.begin();
// 작업
tx.commit();

@Transactional
public void example() {
    Member member = new Member("홍길동");
    em.persist(member);  // ① 영속성 컨텍스트에만 저장 (DB에 INSERT 아직 안 함)

    // ② 이 시점에 조회하면?
    List<Member> members = em.createQuery("SELECT m FROM Member m", Member.class)
                             .getResultList();
}

@Transactional
public void example() {
    // 1. 새 멤버 저장
    Member member = new Member("홍길동");
    em.persist(member);
    // 이 시점: 영속성 컨텍스트에만 있음, DB에는 아직 없음

    // 2. 이름 변경
    member.setName("김철수");
    // 이 시점: 변경 감지됨, 하지만 UPDATE SQL 아직 안 나감

    // 3. JPQL 쿼리 실행
    List<Member> result = em.createQuery("SELECT m FROM Member m").getResultList();
    // AUTO 모드: 쿼리 직전에 flush!
    // → INSERT INTO member (name) VALUES ('김철수') 실행
    // → SELECT * FROM member 실행
    // → 결과에 "김철수" 포함됨

}  // 트랜잭션 종료 → commit

@Transactional
public void test() {
    Member member = new Member("홍길동");
    em.persist(member);

    System.out.println("=== Foo 조회 전 ===");
    List<Foo> foos = em.createQuery("SELECT f FROM Foo f", Foo.class)
                       .getResultList();
    System.out.println("=== Foo 조회 후 ===");
}

// 콘솔 출력 (Hibernate):
// === Foo 조회 전 ===
// SELECT f FROM Foo f  ← INSERT 없이 바로 SELECT
// === Foo 조회 후 ===
// (커밋 시점에 INSERT 실행)

public class StatefulPersistenceContext implements PersistenceContext {
    private static final CoreMessageLogger LOG = (CoreMessageLogger)Logger.getMessageLogger(CoreMessageLogger.class, StatefulPersistenceContext.class.getName());
    private static final int INIT_COLL_SIZE = 8;
    private final SharedSessionContractImplementor session;
    private EntityEntryContext entityEntryContext;
    private HashMap<EntityKey, EntityHolderImpl> entitiesByKey;

    ...

    private Map<EntityKey, EntityHolderImpl> getOrInitializeEntitiesByKey() {
        if (this.entitiesByKey == null) {
            this.entitiesByKey = CollectionHelper.mapOfSize(8);
        }

        return this.entitiesByKey;
    }

    public void addEntity(EntityKey key, Object entity) {
        this.addEntityHolder(key, entity);
    }

    public EntityHolder addEntityHolder(EntityKey key, Object entity) {
        Map<EntityKey, EntityHolderImpl> entityHolderMap = this.getOrInitializeEntitiesByKey();
        EntityHolderImpl oldHolder = (EntityHolderImpl)entityHolderMap.get(key);
        EntityHolderImpl holder;
        if (oldHolder != null) {
            oldHolder.entity = entity;
            holder = oldHolder;
        } else {
            entityHolderMap.put(key, holder = StatefulPersistenceContext.EntityHolderImpl.forEntity(key, key.getPersister(), entity));
        }

        holder.state = StatefulPersistenceContext.EntityHolderState.INITIALIZED;
        BatchFetchQueue fetchQueue = this.batchFetchQueue;
        if (fetchQueue != null) {
            fetchQueue.removeBatchLoadableEntityKey(key);
        }

        return holder;
    }

    ...
}

public final class EntityKey implements Serializable {
    private final @UnknownKeyFor @NonNull @Initialized Object identifier;
    private final @UnknownKeyFor @NonNull @Initialized int hashCode;
    private final @UnknownKeyFor @NonNull @Initialized EntityPersister persister;

    ...

}