@Transactional
public <S extends T> S save(S entity) {
    Assert.notNull(entity, "Entity must not be null.");
    // 새로운 엔티티인지 판단한다
    if (this.entityInformation.isNew(entity)) {
        this.em.persist(entity);
        return entity;
    } else {
        return this.em.merge(entity);
    }
}

@Transient
public boolean isNew() {
    return null == this.getId();
}

@SpringBootTest
class SaveTest {
    PostRepository repository;

    @SpyBean
    EntityManager entityManager;

    @BeforeEach
    void setUp() {
        JpaRepositoryFactory factory = new JpaRepositoryFactory(entityManager);
        repository = factory.getRepository(PostRepository.class);
    }

    @Test
    @Transactional
    void save_메소드는_ID가_없으면_persist를_호출한다() {
        Post post = new Post();
        post.setTitle("제목1");

        repository.save(post);

        verify(entityManager).persist(post);
        verify(entityManager, never()).merge(post);
    }

    @Test
    @Transactional
    void save_메소드는_ID가_있으면_merge를_호출한다() {
        Post post = new Post();
        post.setId(2L);

        repository.save(post);

        verify(entityManager, never()).persist(post);
        verify(entityManager).merge(post);
    }
}

// 인스턴스 동일 여부 테스트

@Test
@Transactional
void persist에서_반환한_인스턴스는_동일하다() {
    Post post = new Post();

    Post savedPost = repository.save(post);

    verify(entityManager).persist(post);
    assertEquals(post, savedPost);
}

@Test
@Transactional
void merge에서_반환한_인스턴스는_다르다() {
    Post post = new Post();
    post.setId(1L);

    Post savedPost = repository.save(post);

    verify(entityManager).merge(post);
    assertNotEquals(post, savedPost);
}

@Service
@Transactional
public class PostService {
	private final PostRepository repository;

	public PostService(PostRepository repository) {
		this.repository = repository;
	}

	public void updatePost(PostDto dto) {
		Post post = new Post();
		post.setId(dto.getId());
		post.setTitle(dto.getTitle());

		repository.save(post);
	}

	public void updateFoundPost(PostDto dto) {
		Post post = repository.findById(dto.getId()).orElseThrow();

		post.setTitle(dto.getTitle());

		repository.save(post);
	}

	public void saveWithId(Long id) {
		Post post = new Post();
		post.setId(id);

		repository.save(post);
	}

	public void saveWithoutId() {
		Post post = new Post();

		repository.save(post);
	}
}

// Case 1: 준영속 엔티티를 수정할 때
// 1. ID 수정 이후 Save를 하면, Merge 호출!
// 2. 모든 필드가 새로운 Entity 값으로 교체!
@Test
@Transactional
void case_1() {
    Post savedPost = savePostById(ID);
    PostDto postDto = createPostDtoByIdAndTitle(savedPost.getId(), TITLE);

    sut.updatePost(postDto);

    verify(entityManager, atLeastOnce()).merge(any(Post.class));
}

// Case 2: 엔티티 값이 없을 때
// 1. ID 값이 없으면 새로 생성
@Test
@Transactional
void case_2_persist() {
    Post savedPost = savePostById(ID);
    long beforeCount = repository.count();
    PostDto newPostDto = new PostDto(savedPost.getId() + 1L, TITLE);

    sut.updatePost(newPostDto);

    assertEquals(beforeCount + 1L, repository.count());
    verify(entityManager, atLeastOnce()).merge(any(Post.class));
}

// Case 1, 2 Solution: 의도치 않은 생성 또는 필드 교체 방지
// 1. 조회 후 Save 또는 더티체킹으로 UPDATE!
// 2. 트랜잭션 종료 시 Title만 변경!
@Test
@Transactional
void case_1_2_solution() {
    Post savedPost = savePostById(ID);
    PostDto postDto = createPostDtoByIdAndTitle(savedPost.getId(), TITLE);

    sut.updateFoundPost(postDto);

    verify(entityManager, atLeastOnce()).merge(any(Post.class));
}

// Case 1, 2 Solution: 의도치 않은 생성 또는 필드 교체 방지
// 1. ID 값이 없는 경우 Throw
@Test
@Transactional
void case_1_2_solution_throw() {
    PostDto notFoundPostDto = createPostDtoByIdAndTitle(ID, TITLE);

    assertThrows(RuntimeException.class, () -> sut.updateFoundPost(notFoundPostDto));
}

// Case 3: 저장 시 ID값 직접 설정할 때
// 1. Merge가 호출되면서 불필요한 SELECT 쿼리가 날아감
@Test
@Transactional
void case_3_save_with_id_is_merge() {
    sut.saveWithId(1L);

    verify(entityManager, atLeastOnce()).merge(any(Post.class));
}

// Case 3 Solution: 불필요 쿼리 호출 제거
// 1. ID 생성은 DB에게 위임
// 2. persist 메소드를 통해 insert 쿼리 한 번만 호출
@Test
@Transactional
void case_3_solution() {
    sut.saveWithoutId();

    verify(entityManager, never()).merge(any(Post.class));
    verify(entityManager, atLeastOnce()).persist(any(Post.class));
}

@SpringBootTest
public class PersistenceContextTest {
	@PersistenceContext
	private EntityManager entityManager;

	@Test
	@Transactional
	void 영속성_컨텍스트_기본_동작() {
		Post post = new Post();
		assertThat(entityManager.contains(post)).isFalse();

		entityManager.persist(post);
		assertThat(entityManager.contains(post)).isTrue();

		entityManager.flush();
	}
}

@Test
@Transactional
void 일차_캐시_테스트() {
	// 1. 엔티티 저장 시 1차 캐시에 저장됨
	Post post = new Post();
	entityManager.persist(post);

	// 2. 조회 시 1차 캐시에서 조회
	Post cachedPost = entityManager.find(Post.class, post.getId());  // SELECT 쿼리 발생 안함
	assertEquals(post, cachedPost);

	// 3. 1차 캐시에 없는 엔티티는 DB에서 조회
	Post dbPost = entityManager.find(Post.class, 999L);  // SELECT 쿼리 발생
	assertNull(dbPost);

	// 4. 1차 캐시 초기화
	entityManager.clear();
	Post reloadedPost = entityManager.find(Post.class, post.getId());  // SELECT 쿼리 발생
	assertNotEquals(reloadedPost, post);
}

@Test
@Transactional
void 쓰기_지연_테스트() {
	Post post1 = new Post();
	Post post2 = new Post();

	entityManager.persist(post1);
	entityManager.persist(post2);

	// 1. persist 호출 후에는 DB에 데이터가 없어야 함
	Session session = entityManager.unwrap(Session.class);
	assertEqualsCountWithSession(session, 0);

	// 2. flush 후에는 DB에 데이터가 있어야 함
	entityManager.flush();
	assertEqualsCountWithSession(session, 2);
}

private void assertEqualsCountWithSession(Session session, int firstExpected) {
	session.doWork(connection -> {
		try (PreparedStatement ps = connection.prepareStatement("SELECT COUNT(*) FROM post")) {
			long count = getCount(ps);
			assertEquals(firstExpected, count);
		}
	});
}

private long getCount(PreparedStatement ps) throws SQLException {
	ResultSet resultSet = ps.executeQuery();
	resultSet.next();
	return resultSet.getLong(1);
}

@Test
@Transactional
void 변경_감지_테스트() {
	String firstTitle = "제목1";
	String secondTitle = "제목2";
	Post post = new Post();
	post.setTitle(firstTitle);
	
	entityManager.persist(post);
	entityManager.flush();

	// 1. DB에서 현재 데이터 확인
	Session session = entityManager.unwrap(Session.class);
	assertEqualsTitleByIdWithSession(session, post.getId(), firstTitle);

	// 2. 엔티티 수정
	post.setTitle(secondTitle);
	entityManager.flush();

	// 3. DB에서 변경된 데이터 확인
	assertEqualsTitleByIdWithSession(session, post.getId(), secondTitle);
}

private static void assertEqualsTitleByIdWithSession(Session session, Long id, String title) {
	session.doWork(connection -> {
		try (PreparedStatement ps = connection.prepareStatement("SELECT title FROM post WHERE id = ?")) {
			String selectedTitle = selectTitle(id, ps);
			assertEquals(title, selectedTitle);
		}
	});
}

private static String selectTitle(Long id, PreparedStatement ps) throws SQLException {
	ps.setLong(1, id);
	ResultSet resultSet = ps.executeQuery();
	resultSet.next();
	return resultSet.getString("title");
}

@Test
@Transactional
void 지연_로딩_테스트() {
	PersistenceUnitUtil persistenceUnitUtil = entityManager.getEntityManagerFactory().getPersistenceUnitUtil();

	Post post = new Post();
	entityManager.persist(post);

	Comment comment1 = new Comment();
	comment1.setPost(post);
	entityManager.persist(comment1);

	Comment comment2 = new Comment();
	comment2.setPost(post);
	entityManager.persist(comment2);

	entityManager.flush();
	entityManager.clear();

	Post foundPost = entityManager.find(Post.class, post.getId());  // SELECT post만 실행

	// comments는 아직 초기화되지 않음
	assertFalse(persistenceUnitUtil.isLoaded(foundPost, "comments"));

	// comments 실제 호출 & 초기화 완료
	assertEquals(2, foundPost.getComments().size());
	assertTrue(persistenceUnitUtil.isLoaded(foundPost, "comments"));
}

@SpringBootTest
public class PersistenceContextLifeCycleTest {
	@PersistenceContext
	private EntityManager entityManager;

	@Test
	@Transactional
	void 엔티티_생명주기_테스트() {
		String firstTitle = "제목1";

		// 1. 비영속 (new/transient)
		Post post = new Post();
		post.setTitle(firstTitle);
		assertFalse(entityManager.contains(post));
		assertNull(post.getId());

		// 2. 영속 (managed)
		entityManager.persist(post);
		assertTrue(entityManager.contains(post));
		assertNotNull(post.getId());

		// DB 저장 확인
		entityManager.flush();
		entityManager.clear();

		Post managedPost = entityManager.find(Post.class, post.getId());
		assertNotNull(managedPost);

		// 3. 준영속 (detached)
		entityManager.detach(managedPost);
		assertFalse(entityManager.contains(managedPost));

		// 준영속 상태에서는 변경 감지가 동작하지 않음
		String updatedTitle = "변경된 제목";
		managedPost.setTitle(updatedTitle);
		entityManager.flush();

		Post foundPost = entityManager.find(Post.class, managedPost.getId());
		assertNotEquals(updatedTitle, foundPost.getTitle());

		// 4. 삭제 (removed)
		entityManager.remove(foundPost);
		assertFalse(entityManager.contains(foundPost));

		// DB에서도 삭제되었는지 확인
		entityManager.flush();
		assertNull(entityManager.find(Post.class, foundPost.getId()));
	}
}

@SpringBootTest
class PersistenceContextProblemTest {
    @PersistenceContext
    EntityManager entityManager;

    @BeforeEach
    @Transactional
    void setUp() {
        Post post1 = new Post();
        entityManager.persist(post1);

        Comment comment1 = new Comment();
        comment1.setPost(post1);
        entityManager.persist(comment1);

        Comment comment2 = new Comment();
        comment2.setPost(post1);
        entityManager.persist(comment2);

        post1.getComments().add(comment1);
        post1.getComments().add(comment2);

        Post post2 = new Post();
        entityManager.persist(post2);

        Comment comment3 = new Comment();
        comment3.setPost(post2);
        entityManager.persist(comment3);

        Comment comment4 = new Comment();
        comment4.setPost(post2);
        entityManager.persist(comment4);

        post2.getComments().add(comment3);
        post2.getComments().add(comment4);

        entityManager.flush();
        entityManager.clear();
    }

    @Test
    @Transactional
    void N플러스1_문제_발생_테스트() {
        List<String> sqlLogs = new ArrayList<>();

        List<Post> posts = entityManager.createQuery("select p from Post p", Post.class)
                .getResultList();

        logCapture(() -> {
            for (Post post : posts) {
                post.getComments().size();
            }
        }, sqlLogs);

        List<String> selectQueries = getSelectQueries(sqlLogs);

        assertEquals(2, selectQueries.size());
    }

    @Test
    @Transactional
    void 페치_조인으로_해결() {
        List<String> sqlLogs = new ArrayList<>();

        List<Post> posts = entityManager
                .createQuery("select distinct p from Post p join fetch p.comments", Post.class)
                .getResultList();

        logCapture(() -> {
            for (Post post : posts) {
                post.getComments().size();
            }
        }, sqlLogs);

        List<String> selectQueries = getSelectQueries(sqlLogs);

        assertEquals(0, selectQueries.size());
    }

    @Test
    @Transactional
    void EntityGraph로_해결() {
        List<String> sqlLogs = new ArrayList<>();

        List<Post> posts = entityManager.createQuery("select p from Post p", Post.class)
                .setHint("javax.persistence.fetchgraph", entityManager.getEntityGraph("Post.withComments"))
                .getResultList();

        logCapture(() -> {
            for (Post post : posts) {
                post.getComments().size();
            }
        }, sqlLogs);

        List<String> selectQueries = getSelectQueries(sqlLogs);

        assertEquals(0, selectQueries.size());
    }

    private List<String> getSelectQueries(List<String> sqlLogs) {
        return sqlLogs.stream()
                .filter(sql -> sql.trim().toUpperCase().startsWith("SELECT"))
                .toList();
    }

    private void logCapture(Runnable runnable, List<String> sqlLogs) {
        Logger logger = (Logger) LoggerFactory.getLogger("org.hibernate.SQL");
        ListAppender<ILoggingEvent> listAppender = new ListAppender<>();
        listAppender.start();
        logger.addAppender(listAppender);

        try {
            runnable.run();
            sqlLogs.addAll(listAppender.list.stream()
                    .map(ILoggingEvent::getMessage)
                    .toList());
        } finally {
            logger.detachAppender(listAppender);
        }
    }
}

public void withoutTransaction() {
     Post post = new Post();
     post.setTitle("트랜잭션 테스트");

     Comment comment1 = new Comment();
     comment1.setContent("첫 번째 댓글");
     comment1.setPost(post);

     Comment comment2 = new Comment();
     comment2.setContent("두 번째 댓글");
     comment2.setPost(post);

     postRepository.save(post);
     commentRepository.save(comment1);

     throw new RuntimeException("예외 발생!");

     commentRepository.save(comment2);
}

@Test
void 트랜잭션이_없으면_데이터_정합성이_깨진다() {
      assertThrows(RuntimeException.class, () -> transactionService.withoutTransaction());
      
      assertEquals(1, postRepository.count());
      assertEquals(1, commentRepository.count());
}

@Transactional
public void withTransaction() {
		Post post = new Post();
		post.setTitle("트랜잭션 테스트");

		Comment comment1 = new Comment();
		comment1.setContent("첫 번째 댓글");
		comment1.setPost(post);

		Comment comment2 = new Comment();
		comment2.setContent("두 번째 댓글");
		comment2.setPost(post);

		postRepository.save(post);
		commentRepository.save(comment1);

		throw new RuntimeException("예외 발생!");

		commentRepository.save(comment2);
}

@Test
void 트랜잭션이_있으면_데이터_정합성이_유지된다() {
   assertThrows(RuntimeException.class, () -> transactionService.withTransaction());
   
   assertEquals(0, postRepository.count());
}

// 트랜잭션 매니저 - 실제 트랜잭션을 관리하는 핵심 클래스
public abstract class AbstractPlatformTransactionManager implements PlatformTransactionManager {
    
    @Override
    public final TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException {
        // 현재 트랜잭션이 존재하는지 확인
        Object transaction = doGetTransaction();
        
        if (definition == null) {
            definition = new DefaultTransactionDefinition();
        }

        // 이미 트랜잭션이 존재하는 경우
        if (isExistingTransaction(transaction)) {
            return handleExistingTransaction(definition, transaction);
        }

        // 타임아웃 설정 확인
        if (definition.getTimeout() < TransactionDefinition.TIMEOUT_DEFAULT) {
            throw new InvalidTimeoutException("Invalid transaction timeout", definition.getTimeout());
        }

        // 새 트랜잭션 필요한 경우
        if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
            throw new IllegalTransactionStateException("No existing transaction found for transaction marked with propagation 'mandatory'");
        }
        else if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||
                definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||
                definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
            
            // 새로운 트랜잭션 생성
            DefaultTransactionStatus status = newTransactionStatus(definition, transaction, true);
            doBegin(transaction, definition);
            prepareSynchronization(status, definition);
            return status;
        }
        else {
            // 트랜잭션 없이 실행
            boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
            return prepareTransactionStatus(definition, null, true, newSynchronization, debugEnabled);
        }
    }

    // 트랜잭션 커밋
    @Override
    public final void commit(TransactionStatus status) throws TransactionException {
        if (status.isCompleted()) {
            throw new IllegalTransactionStateException("Transaction is already completed");
        }

        DefaultTransactionStatus defStatus = (DefaultTransactionStatus) status;
        if (defStatus.isLocalRollbackOnly()) {
            processRollback(defStatus);
            return;
        }

        if (!shouldCommitOnGlobalRollbackOnly() && defStatus.isGlobalRollbackOnly()) {
            processRollback(defStatus);
            return;
        }

        processCommit(defStatus);
    }
}

public enum Isolation {
    DEFAULT(-1),
    READ_UNCOMMITTED(1),
    READ_COMMITTED(2),
    REPEATABLE_READ(4),
    SERIALIZABLE(8);

    private final int value;

    private Isolation(int value) {
        this.value = value;
    }

    public int value() {
        return this.value;
    }
}

public interface Connection  extends Wrapper, AutoCloseable {
    int TRANSACTION_NONE             = 0;
    int TRANSACTION_READ_UNCOMMITTED = 1;
    int TRANSACTION_READ_COMMITTED   = 2;
    int TRANSACTION_REPEATABLE_READ  = 4;
    int TRANSACTION_SERIALIZABLE     = 8;
}

public class TransactionInterceptor extends TransactionAspectSupport implements MethodInterceptor {
    @Override
    public Object invoke(final MethodInvocation invocation) throws Throwable {
        // TransactionAttribute에는 isolation level 정보가 포함되어 있음
        TransactionAttribute txAttr = getTransactionAttributeSource()
            .getTransactionAttribute(invocation.getMethod(), targetClass);
        ...
}

public class DataSourceTransactionManager extends AbstractPlatformTransactionManager
		implements ResourceTransactionManager, InitializingBean {
	@Override
	protected void doBegin(Object transaction, TransactionDefinition definition) {
		DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
		Connection con = null;
	
		try {
			if (!txObject.hasConnectionHolder() ||
					txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
				Connection newCon = obtainDataSource().getConnection();
				if (logger.isDebugEnabled()) {
					logger.debug("Acquired Connection [" + newCon + "] for JDBC transaction");
				}
				txObject.setConnectionHolder(new ConnectionHolder(newCon), true);
			}
	
			txObject.getConnectionHolder().setSynchronizedWithTransaction(true);
			con = txObject.getConnectionHolder().getConnection();
	
			**Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);
			txObject.setPreviousIsolationLevel(previousIsolationLevel);
			txObject.setReadOnly(definition.isReadOnly());**
			
			if (con.getAutoCommit()) {
				txObject.setMustRestoreAutoCommit(true);
				if (logger.isDebugEnabled()) {
					logger.debug("Switching JDBC Connection [" + con + "] to manual commit");
				}
				con.setAutoCommit(false);
			}
	
			prepareTransactionalConnection(con, definition);
			txObject.getConnectionHolder().setTransactionActive(true);
	
			int timeout = determineTimeout(definition);
			if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
				txObject.getConnectionHolder().setTimeoutInSeconds(timeout);
			}
	
			if (txObject.isNewConnectionHolder()) {
				TransactionSynchronizationManager.bindResource(obtainDataSource(), txObject.getConnectionHolder());
			}
		}
	
		catch (Throwable ex) {
			if (txObject.isNewConnectionHolder()) {
				DataSourceUtils.releaseConnection(con, obtainDataSource());
				txObject.setConnectionHolder(null, false);
			}
			throw new CannotCreateTransactionException("Could not open JDBC Connection for transaction", ex);
		}
	}
}

@Transactional(isolation = Isolation.READ_COMMITTED)
public void readCommittedTransaction() throws InterruptedException {
	Post post = postRepository.findById(1L).orElseThrow();
	System.out.println("조회된 Post 제목: " + post.getTitle());

	sleep(3000);
	entityManager.clear();

	Post foundPost = postRepository.findById(1L).orElseThrow();
	System.out.println("다시 조회된 Post 제목: " + foundPost.getTitle());
}

public void updatePostTitle() throws InterruptedException {
	sleep(1000);

	Post post = postRepository.findAll().get(0);
	post.setTitle("B");
	postRepository.save(post);

	System.out.println("Thread B - 제목 변경 후 커밋 완료");
}

@Test
void readCommittedTest() throws InterruptedException {
	Post post = new Post();
	post.setTitle("A");
	postRepository.save(post);

	Thread threadA = new Thread(this::readCommittedTransaction);
	Thread threadB = new Thread(this::updatePostTitle);

	threadA.start();
	threadB.start();

	threadA.join();
	threadB.join();
}

Thread A - 조회된 Post 제목: ?
Thread B - 제목 변경 후 커밋 완료
Thread A - 다시 조회된 Post 제목: ?

Thread A - 조회된 Post 제목: A
Thread B - 제목 변경 후 커밋 완료
Thread A - 다시 조회된 Post 제목: B

@Transactional(isolation = Isolation.REPEATABLE_READ)
public void repeatableReadTransaction() throws InterruptedException {
	Post post = postRepository.findById(1L).orElseThrow();
	System.out.println("조회된 Post 제목: " + post.getTitle());

	sleep(3000);

	Post foundPost = postRepository.findById(1L).orElseThrow();
	System.out.println("다시 조회된 Post 제목: " + foundPost.getTitle());
}

public void updatePostTitle() throws InterruptedException {
	sleep(1000);

	Post post = postRepository.findAll().get(0);
	post.setTitle("B");
	postRepository.save(post);

	System.out.println("Thread B - 제목 변경 후 커밋 완료");
}

@Test
void repeatableReadTest() throws InterruptedException {
	Post post = new Post();
	post.setTitle("A");
	postRepository.save(post);

	Thread threadA = new Thread(this::repeatableReadTransaction);
	Thread threadB = new Thread(this::updatePostTitle);

	threadA.start();
	threadB.start();

	threadA.join();
	threadB.join();
}

Thread A - 조회된 Post 제목: ?
Thread B - 제목 변경 후 커밋 완료
Thread A - 다시 조회된 Post 제목: ?

Thread A - 조회된 Post 제목: A
Thread B - 제목 변경 후 커밋 완료
Thread A - 다시 조회된 Post 제목: A

@Entity
public class PostWithVersion {
    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE)
    private Long id;

    private String title;

    @Version
    private int version;
    
    // Getter & Setter
}

@Service
public class PostWithVersionService {
	@Autowired
	private PostWithVersionRepository repository;

	@Transactional
	public void optimisticLockTest(Long postId) {
		PostWithVersion post = repository.findById(postId).orElseThrow();
		System.out.println("[Thread A] 조회된 Post 제목: " + post.getTitle());

		sleep(3000);

		post.setTitle("낙관적 락 테스트 - 변경된 제목");
		repository.save(post);
		System.out.println("[Thread A] 변경 후 저장 완료");
	}

	@Transactional
	public void optimisticLockConflictTest(Long postId) {
		sleep(1000);

		PostWithVersion post = repository.findById(postId).orElseThrow();
		System.out.println("[Thread B] 조회된 Post 제목: " + post.getTitle());

		sleep(3000);

		post.setTitle("낙관적 락 테스트 - 충돌 발생");
		try {
			repository.save(post);
			System.out.println("[Thread B] 변경 후 저장 완료");
		} catch (OptimisticLockException e) {
			System.out.println("[Thread B] 낙관적 락 충돌 발생!");
		}
	}

	private void sleep(long millis) {
		try {
			Thread.sleep(millis);
		} catch (InterruptedException e) {
			throw new RuntimeException(e);
		}
	}
}

@Test
void 낙관적_락_테스트() throws InterruptedException {
	PostWithVersion post = new PostWithVersion();
	post.setTitle("초기 제목");
	repository.save(post);

	Thread threadA = new Thread(() -> service.optimisticLockTest(post.getId()));
	Thread threadB = new Thread(() -> service.optimisticLockConflictTest(post.getId()));

	threadA.start();
	threadB.start();

	threadA.join();
	threadB.join();
}

Thread A - 조회된 Post 제목: 초기 제목
Thread B - 조회된 Post 제목: 초기 제목
Thread A - 변경 후 저장 완료
Thread B - 변경 후 저장 완료

// 그 후... Exception 발생
binding parameter [1] as [VARCHAR] - [낙관적 락 테스트 - 충돌 발생]
"Thread-5" org.springframework.orm.ObjectOptimisticLockingFailureException

@Transactional
@Interceptor
class TransactionalInterceptor {

	@Inject
	@Any
	private EntityManager entityManager;

	@AroundInvoke
	public Object runInTransaction(InvocationContext ctx) throws Exception {
		...
		try {
			if (isNew) {
				entityTransaction.begin();
			}
			Object result = ctx.proceed();
			if (isNew) {
				entityTransaction.commit();
			
			...
	}
	...
}

public class JdbcResourceLocalTransactionCoordinatorImpl implements TransactionCoordinator {
	@Override
		public void commit() {
			try {
				...
				JdbcResourceLocalTransactionCoordinatorImpl.this.beforeCompletionCallback();
				...
}

public class EntityVerifyVersionProcess implements BeforeTransactionCompletionProcess {

	private final Object object;

	public EntityVerifyVersionProcess(Object object) {
		this.object = object;
	}

	@Override
	public void doBeforeTransactionCompletion(SessionImplementor session) {
		final EntityEntry entry = session.getPersistenceContext().getEntry( object );

		if ( entry != null ) {
			final Object latestVersion = entry.getPersister().getCurrentVersion( entry.getId(), session );
			if ( !entry.getVersion().equals( latestVersion ) ) {
				throw new OptimisticEntityLockException(
						object,
						"Newer version ["
								+ latestVersion
								+ "] of entity ["
								+ MessageHelper.infoString( entry.getEntityName(), entry.getId() )
								+ "] found in database"
				);
			}
		}
	}
}

public interface PostRepository extends JpaRepository<Post, Long> {
	@Lock(LockModeType.PESSIMISTIC_WRITE)
	@Query("SELECT p FROM Post p WHERE p.id = :id")
	Optional<Post> findByIdWithLock(@Param("id") Long id);
}

@Service
public class PessimisticPostService {
	@Autowired
	private PostRepository repository;

	@Transactional
	public void pessimisticLockTest(Long postId) {
		Post post = repository.findByIdWithLock(postId).orElseThrow();
		System.out.println("Thread A - 조회된 Post 제목: " + post.getTitle());

		sleep(5000);

		post.setTitle("비관적 락 테스트 - 변경된 제목");
		repository.save(post);
		System.out.println("Thread A - 변경 후 저장 완료");
	}

	@Transactional
	public void pessimisticLockBlockingTest(Long postId) {
		sleep(1000);

		Post post = repository.findByIdWithLock(postId).orElseThrow();
		System.out.println("Thread B - 조회된 Post 제목: " + post.getTitle());

		post.setTitle("비관적 락 테스트 - 충돌 발생");
		repository.save(post);
		System.out.println("Thread B - 변경 후 저장 완료");
	}

	private void sleep(long millis) {
		try {
			Thread.sleep(millis);
		} catch (InterruptedException e) {
			throw new RuntimeException(e);
		}
	}
}

@Test
void 비관적_락_테스트() throws InterruptedException {
	Post post = new Post();
	post.setTitle("초기 제목");
	postRepository.save(post);

	Thread threadA = new Thread(() -> pessimisticPostService.pessimisticLockTest(post.getId()));
	Thread threadB = new Thread(() -> pessimisticPostService.pessimisticLockBlockingTest(post.getId()));

	threadA.start();
	threadB.start();

	threadA.join();
	threadB.join();
}

public class PessimisticReadUpdateLockingStrategy implements LockingStrategy {
	@Override
	public void lock(Object id, Object version, Object object, int timeout, EventSource session) {
		if ( !lockable.isVersioned() ) {
			throw new HibernateException( "write locks via update not supported for non-versioned entities [" + lockable.getEntityName() + "]" );
		}

		final SessionFactoryImplementor factory = session.getFactory();
		try {
			try {
				final JdbcCoordinator jdbcCoordinator = session.getJdbcCoordinator();
				final PreparedStatement st = jdbcCoordinator.getStatementPreparer().prepareStatement( sql );
				try {
					lockable.getVersionType().nullSafeSet( st, version, 1, session );
					int offset = 2;

					lockable.getIdentifierType().nullSafeSet( st, id, offset, session );
					offset += lockable.getIdentifierType().getColumnSpan( factory );

					if ( lockable.isVersioned() ) {
						lockable.getVersionType().nullSafeSet( st, version, offset, session );
					}

					final int affected = jdbcCoordinator.getResultSetReturn().executeUpdate( st, sql );
					// todo:  should this instead check for exactly one row modified?
					if ( affected < 0 ) {
						final StatisticsImplementor statistics = factory.getStatistics();
						if ( statistics.isStatisticsEnabled() ) {
							statistics.optimisticFailure( lockable.getEntityName() );
						}
						throw new StaleObjectStateException( lockable.getEntityName(), id );
					}

				}
				finally {
					jdbcCoordinator.getLogicalConnection().getResourceRegistry().release( st );
					jdbcCoordinator.afterStatementExecution();
				}

			}
			catch ( SQLException e ) {
				throw session.getJdbcServices().getSqlExceptionHelper().convert(
						e,
						"could not lock: " + MessageHelper.infoString( lockable, id, session.getFactory() ),
						sql
				);
			}
		}
		**catch (JDBCException e) {
			throw new PessimisticEntityLockException( object, "could not obtain pessimistic lock", e );
		}**
	}
}
	

public class PessimisticWriteUpdateLockingStrategy implements LockingStrategy {
	@Override
	public void lock(Object id, Object version, Object object, int timeout, EventSource session) {
		if ( !lockable.isVersioned() ) {
			throw new HibernateException( "write locks via update not supported for non-versioned entities [" + lockable.getEntityName() + "]" );
		}

		final SessionFactoryImplementor factory = session.getFactory();
		try {
			try {
				final JdbcCoordinator jdbcCoordinator = session.getJdbcCoordinator();
				final PreparedStatement st = jdbcCoordinator.getStatementPreparer().prepareStatement( sql );
				try {
					lockable.getVersionType().nullSafeSet( st, version, 1, session );
					int offset = 2;

					lockable.getIdentifierType().nullSafeSet( st, id, offset, session );
					offset += lockable.getIdentifierType().getColumnSpan( factory );

					if ( lockable.isVersioned() ) {
						lockable.getVersionType().nullSafeSet( st, version, offset, session );
					}

					final int affected = jdbcCoordinator.getResultSetReturn().executeUpdate( st, sql );
					// todo:  should this instead check for exactly one row modified?
					if ( affected < 0 ) {
						final StatisticsImplementor statistics = factory.getStatistics();
						if ( statistics.isStatisticsEnabled() ) {
							statistics.optimisticFailure( lockable.getEntityName() );
						}
						throw new StaleObjectStateException( lockable.getEntityName(), id );
					}

				}
				finally {
					jdbcCoordinator.getLogicalConnection().getResourceRegistry().release( st );
					jdbcCoordinator.afterStatementExecution();
				}
			}
			catch ( SQLException e ) {
				throw session.getJdbcServices().getSqlExceptionHelper().convert(
						e,
						"could not lock: " + MessageHelper.infoString( lockable, id, session.getFactory() ),
						sql
				);
			}
		}
		**catch (JDBCException e) {
			throw new PessimisticEntityLockException( object, "could not obtain pessimistic lock", e );
		}**
	}
}

@Service
public class DirtyCheckingService {
	@Autowired
	PostRepository postRepository;

	@Transactional
	public void updateTitleWithSave(Long postId, String newTitle) {
		Post post = postRepository.findById(postId)
			.orElseThrow(() -> new IllegalArgumentException("Post not found"));

		post.setTitle(newTitle);

		postRepository.save(post);
	}

	@Transactional
	public void updateTitleWithoutSave(Long postId, String newTitle) {
		Post post = postRepository.findById(postId)
			.orElseThrow(() -> new IllegalArgumentException("Post not found"));

		post.setTitle(newTitle);
	}
}

@SpringBootTest
public class DirtyCheckingBasicTest {
    public static final String OLD_TITLE = "원본 제목";
    public static final String NEW_TITLE = "변경된 제목";
    
    @PersistenceContext
    private EntityManager entityManager;

    @Autowired
    private PostRepository postRepository;

    @Autowired
    private DirtyCheckingService sut;

    private Long testPostId;

    @BeforeEach
    public void setUp() {
        postRepository.deleteAll();

        Post post = new Post();
        post.setTitle(OLD_TITLE);
        Post savedPost = postRepository.save(post);
        testPostId = savedPost.getId();
    }

    @Test
    void 더티체킹_없이_수정한다() {
        sut.updateTitleWithSave(testPostId, NEW_TITLE);

        Post actual = postRepository.findById(testPostId).get();

        assertEquals(NEW_TITLE, actual.getTitle());
    }

    @Test
    void 더티체킹으로_수정한다() {
        sut.updateTitleWithoutSave(testPostId, NEW_TITLE);

        Post actual = postRepository.findById(testPostId).get();

        assertEquals(NEW_TITLE, actual.getTitle());
    }
}

update post
	set title=? 
	where id=?

@Transactional
public void processOrder(Long orderId) {
    // 복잡한 객체 그래프 변경 예시
    Order order = orderRepository.findById(orderId).orElseThrow();
    order.confirm();  // 상태 변경

    // 연관 엔티티들 변경
    for (OrderItem item : order.getItems()) {
        Product product = item.getProduct();
        product.decreaseStock(item.getQuantity());

        // 여러 엔티티가 연쇄적으로 변경되는 상황
        if (product.isLowStock()) {
            product.requestRestock();
        }
    }

    // 명시적 save()를 사용한다면 모든 변경된 엔티티마다 save() 호출 필요
}

// EntityEntry 클래스 (Hibernate 내부 구현)
public class EntityEntry implements Serializable {
    private final Object[] loadedState;  // 스냅샷 데이터
    private final Object id;
    private final Object version;
    private final EntityPersister persister;
    private final Status status;
    private final LockMode lockMode;
    // ...
}

// DefaultLoadEventListener.java (Hibernate)
@Override
protected void postLoad(
        final LoadEvent event,
        final EntityPersister persister,
        final EntityKey keyToLoad,
        final Object entity) {

    // 1. 영속성 컨텍스트 가져오기
    PersistenceContext persistenceContext = event.getSession().getPersistenceContextInternal();

    // 2. 엔티티 현재 상태 추출
    Object[] values = persister.getPropertyValues(entity);

    // 3. 이벤트 리스너 호출
    event.getSession().getInterceptor().onLoad(
        entity,
        keyToLoad.getIdentifier(),
        values,
        persister.getPropertyNames(),
        persister.getPropertyTypes()
    );

    // 4. 엔티티 영속화 및 스냅샷 생성
    persistenceContext.addEntity(
        entity,
        Status.MANAGED,
        values,  // 이 값들이 스냅샷으로 저장됨
        keyToLoad,
        persister.getVersion(entity),
        LockMode.NONE,
        true,
        persister,
        true
    );

    // 연관 관계 처리 등 추가 로직...
}

// AbstractFlushingEventListener.java (Hibernate)
protected void flushEntities(final FlushEvent event) {
    LOG.trace("Flushing entities and processing referenced collections");

    // 더티 체킹 및 SQL 준비 단계
    prepareEntityFlushes(event);

    // 콜렉션 처리
    flushCollections(event);

    // 실제 엔티티 플러시 실행
    performEntityFlushes(event);

    // 추가 후처리
    postFlush(event);
}

// 더티 체킹의 핵심 - 엔티티 플러시 준비
protected void prepareEntityFlushes(FlushEvent event) {
    final EventSource source = event.getSession();
    final PersistenceContext persistenceContext = source.getPersistenceContextInternal();

    // 영속성 컨텍스트에서 모든 엔티티와 엔트리 가져오기
    persistenceContext.prepareEntityFlushes();

    // DefaultFlushEntityEventListener 호출하여 더티 체킹 수행
    final Iterable<EntityEntry> list = persistenceContext.reentrantSafeEntityEntries();
    for (EntityEntry entry : list) {
        final Object entity = persistenceContext.getEntity(entry);
        final EntityPersister persister = entry.getPersister();
        final Status status = entry.getStatus();

        if (status != Status.DELETED && status != Status.GONE) {
            // 더티 체킹 이벤트 생성 및 처리
            FlushEntityEvent entityEvent =
                new FlushEntityEvent(source, entity, entry);
            source.getEventListenerManager()
                .flushEntity(entityEvent);
        }
    }
}

// DefaultFlushEntityEventListener 클래스의 핵심 메서드입니다.
// 이 메서드는 엔티티의 변경 사항을 감지하는 실제 로직을 담고 있습니다.
protected void dirtyCheck(final FlushEntityEvent event) throws HibernateException {
    // 1. 필요한 정보 추출
    final Object entity = event.getEntity();              // 실제 엔티티 객체
    final Object[] values = event.getPropertyValues();    // 현재 프로퍼티 값
    final SessionImplementor session = event.getSession();
    final EntityEntry entry = event.getEntityEntry();     // 엔티티 관련 메타데이터
    final Object[] loadedState = entry.getLoadedState();  // 저장된 스냅샷

    // 2. 인터셉터를 통한 변경 감지 시도
    int[] dirtyProperties = session.getInterceptor().findDirty(
            entity,
            entry.getId(),
            values,
            loadedState,
            persister.getPropertyNames(),
            persister.getPropertyTypes()
    );

    // 3. 인터셉터로 감지 실패 시 다른 방법 시도
    if (dirtyProperties == null) {
        // 바이트코드 향상된 엔티티 처리(SelfDirtinessTracker)
        if (entity instanceof SelfDirtinessTracker) {
            // 생략...
        }
        else {
            // 커스텀 전략 처리
            // 생략...
        }
    }

    // 4. 여전히 감지 실패 시 기본 비교 로직 사용
    if (dirtyProperties == null) {
        // 기본 비교 알고리즘으로 변경 사항 감지
        dirtyProperties = persister.findDirty(values, loadedState, entity, session);
    }

    // 5. 변경 사항이 있으면 dirtyProperties에 저장됨
    event.setDirtyProperties(dirtyProperties);
}

// TypeHelper 클래스의 findDirty 메서드
public static int[] findDirty(
        Property[] properties,
        Object[] currentState,
        Object[] previousState,
        boolean[] propertyColumnUpdateable,
        SharedSessionContractImplementor session) {

    int[] results = null;
    int count = 0;
    int span = properties.length;

    // 모든 프로퍼티를 순회하며 비교
    for (int i = 0; i < span; i++) {
        // 1. 빠른 참조 비교 (== 연산자)
        // 2. 타입별 심층 비교
        final boolean dirty = currentState[i] != previousState[i] &&
                (
                    previousState[i] == null ||
                    currentState[i] == null ||
                    propertyColumnUpdateable[i] &&
                    !properties[i].getType().isSame(
                        currentState[i],
                        previousState[i],
                        session.getFactory()
                    )
                );

        if (dirty) {
            if (results == null) {
                results = new int[span];
            }
            results[count++] = i;  // 변경된 프로퍼티 인덱스 저장
        }
    }

    // 변경된 프로퍼티가 없으면 null 반환
    if (count == 0) {
        return null;
    }
    else {
        // 배열 크기 조정 후 반환
        int[] trimmed = new int[count];
        System.arraycopy(results, 0, trimmed, 0, count);
        return trimmed;
    }
}

public boolean isSame(Object x, Object y) {
    return x == y || (x != null && y != null && x.equals(y));
}

@Entity
public class PostWithTransient {
    @Id
    private Long id;

    private String title;

    @Transient
    private String transientTitle;

    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getTitle() { return title; }
    public void setTitle(String title) { this.title = title; }
    public String getTransientTitle() { return transientTitle; }
    public void setTransientTitle(String transientTitle) { this.transientTitle = transientTitle; }
}

@Transactional
public void updateTransientField(Long postId, String newTitle) {
	Post post = postRepository.findById(postId)
			.orElseThrow(() -> new IllegalArgumentException("Post not found"));

	PostWithTransient postWithTransient = new PostWithTransient();
	postWithTransient.setId(post.getId());
	postWithTransient.setTitle(post.getTitle());
	postWithTransient.setTransientTitle(post.getTitle());  // 초기값 설정

	em.persist(postWithTransient);
	em.flush();

	postWithTransient.setTransientTitle(newTitle);
}

@Transactional(readOnly = true)
public PostWithTransient findPostWithTransientById(Long id) {
	return em.find(PostWithTransient.class, id);
}

@Test
public void 준영속_상태_엔티티_변경은_감지되지_않음() {
    sut.updateDetached(testPostId, NEW_TITLE);

    Post actual = postRepository.findById(testPostId).get();

    assertEquals(OLD_TITLE, actual.getTitle());
}

@Test
public void 비영속_필드_변경은_감지되지_않음() {
    sut.updateTransientField(testPostId, NEW_TITLE);

    PostWithTransient actual = sut.findPostWithTransientById(testPostId);

    assertEquals(OLD_TITLE, actual.getTransientTitle());
}

@Test
public void loadEntityAndTrackChanges() {
    // 브레이크포인트 1: 엔티티 로드 직전
    Post post = postRepository.findById(1L).get();

    // 브레이크포인트 2: 엔티티 로드 직후
    post.setTitle("변경된 제목");

    // 브레이크포인트 3: 변경 직후
    // 이 시점에서는 아직 SQL이 생성되지 않음
}

@Test
@Transactional
public void flushTriggeredByJPQL() {
    // 브레이크포인트 1: 엔티티 변경 전
    Post post = postRepository.findById(1L).get();
    post.setTitle("변경된 제목");
    
    // 브레이크포인트 2: JPQL 쿼리 실행 직전 (자동 플러시 발생 지점)
    List<Post> allPosts = postRepository.findAll();
    
    // 브레이크포인트 3: 쿼리 실행 후
}

@Test
@Transactional
public void dirtyCheckingProcess() {
    // 브레이크포인트 1: 트랜잭션 시작
    Post post = postRepository.findById(1L).get();
    
    // 브레이크포인트 2: 여러 필드 변경
    post.setTitle("새 제목");
    post.setContent("새 내용");
    
    // 브레이크포인트 3: 트랜잭션 종료 직전 (커밋 시점)
} // 트랜잭션 종료 - 자동 플러시 발생

// 전통적인 JDBC 접근 방식
User user = findUserById(1);
user.setName("새이름");

// 개발자가 명시적 UPDATE 쿼리 작성 필요
String sql = "UPDATE users SET name = ? WHERE id = ?";
PreparedStatement stmt = connection.prepareStatement(sql);
stmt.setString(1, user.getName());
stmt.setLong(2, user.getId());
stmt.executeUpdate();

// Hibernate 2.x의 더티 체킹 (2003년경)
private void compareWithSnapshot(SessionImpl session) {
    Object[] currentState = getPropertyValues();
    Type[] types = getPersister().getPropertyTypes();

    boolean[] dirty = new boolean[currentState.length];
    int dirtyCount = 0;

    for (int i = 0; i < currentState.length; i++) {
        if (!types[i].isEqual(currentState[i], snapshot[i])) {
            dirty[i] = true;
            dirtyCount++;
        }
    }

    if (dirtyCount > 0) {
        markDirty(dirty, currentState);
    }
}

// MyBatis 접근법 - 명시적 매핑과 수동 업데이트
@Update("UPDATE users SET name = #{name}, email = #{email} WHERE id = #{id}")
int updateUser(User user);

// 사용자 코드
User user = userMapper.getUserById(1);
user.setName("새이름");
userMapper.updateUser(user);  // 명시적 업데이트 호출 필요

// Hibernate 접근법 - 자동 변경 감지
@Transactional
public void updateUser(Long id, String newName) {
    User user = userRepository.findById(id).get();
    user.setName(newName);  // 명시적 save() 불필요
}

// JDBC 방식
Person person = findPerson(id);
person.setName("새이름");
person.setAge(30);

// UPDATE 쿼리 직접 작성
String sql = "UPDATE Person SET name = ?, age = ? WHERE id = ?";
PreparedStatement stmt = connection.prepareStatement(sql);
stmt.setString(1, person.getName());
stmt.setInt(2, person.getAge());
stmt.setLong(3, person.getId());
stmt.executeUpdate();

Person person = findPerson(id);
person.setName("새이름");
person.setAge(30);

@Transactional
public void transferMoney(Account from, Account to, BigDecimal amount) {
    from.withdraw(amount);
    to.deposit(amount);
}

// 객체 세계: 자연스러운 상태 변경
person.setName("새이름");

// JDBC 세계: 명시적 업데이트 필요
preparedStatement.executeUpdate("UPDATE person SET name = ? WHERE id = ?");

// JPA 세계: 객체 변경만으로 충분 (더티체킹)
person.setName("새이름");  // 트랜잭션 종료 시 자동 반영

// 도메인 로직에 집중
@Transactional
public void approveOrder(Order order) {
    order.approve();  // 도메인 로직
    order.getItems().forEach(item -> {
        item.allocateInventory();  // 연관 객체 도메인 로직
    });
    // 데이터베이스 작업 신경 쓸 필요 없음
}

// 문제 상황: OOM 발생 위험
@Transactional
public void updateAllPrices() {
    List<Product> allProducts = productRepository.findAll(); // 수백만 건
    allProducts.forEach(p -> p.increasePrice(0.1));
}

// 해결책: 페이징 + 배치 처리
@Transactional
public void updateAllPricesSafely() {
    int pageSize = 1000;
    int page = 0;
    long total;

    do {
        List<Product> products = productRepository.findAllPaged(page, pageSize);
        total = products.size();

        for (int i = 0; i < total; i++) {
            products.get(i).increasePrice(0.1);
            if (i % 100 == 0) {
                entityManager.flush();
                entityManager.clear();
            }
        }

        page++;
    } while (total == pageSize);
}

@Transactional
public int updateCategoryPrices(String category, BigDecimal increase) {
    return entityManager.createQuery(
            "UPDATE Product p SET p.price = p.price * :factor " +
            "WHERE p.category = :category")
            .setParameter("factor", new BigDecimal("1.1"))
            .setParameter("category", category)
            .executeUpdate();
}