public class TransactionInterceptor extends TransactionAspectSupport implements MethodInterceptor, Serializable {  

    @Override  
    @Nullable   
    public Object invoke(MethodInvocation invocation) throws Throwable {  
       // Work out the target class: may be {@code null}.  
       // The TransactionAttributeSource should be passed the target class
       // as well as the method, which may be from an interface.       
       Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);  
  
       // Adapt to TransactionAspectSupport's invokeWithinTransaction...  
       return invokeWithinTransaction(invocation.getMethod(), targetClass, new CoroutinesInvocationCallback() {  
          @Override  
          @Nullable          public Object proceedWithInvocation() throws Throwable {  
             return invocation.proceed();  
          }  
          @Override  
          public Object getTarget() {  
             return invocation.getThis();  
          }  
          @Override  
          public Object[] getArguments() {  
             return invocation.getArguments();  
          }  
       });  
    }
}

// 트랜잭션 시작 또는 기존 트랜잭션 참여
TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);

Object retVal;
try {
    // 실제 @Transactional 대상 메서드 실행
    retVal = invocation.proceedWithInvocation();
}
catch (Throwable ex) {
    // 예외 발생 시 rollback 또는 commit 판단
    completeTransactionAfterThrowing(txInfo, ex);
    throw ex;
}
finally {
    // ThreadLocal 에 저장된 TransactionInfo 정리
    // 여기서 DB commit/rollback 하는 것은 아님
    cleanupTransactionInfo(txInfo);
}

// 정상 종료 시 commit
commitTransactionAfterReturning(txInfo);

return retVal;

protected void commitTransactionAfterReturning(@Nullable TransactionInfo txInfo) {  
    if (txInfo != null && txInfo.getTransactionStatus() != null) {  
       if (logger.isTraceEnabled()) {  
          logger.trace("Completing transaction for [" + txInfo.getJoinpointIdentification() + "]");  
       }  
       txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());  
    }  
}

@Override  
public final void commit(TransactionStatus status) throws TransactionException {  
    if (status.isCompleted()) {  
       throw new IllegalTransactionStateException(  
             "Transaction is already completed - do not call commit or rollback more than once per transaction");  
    }  
  
    DefaultTransactionStatus defStatus = (DefaultTransactionStatus) status;  
    if (defStatus.isLocalRollbackOnly()) {  
       if (defStatus.isDebug()) {  
          logger.debug("Transactional code has requested rollback");  
       }  
       processRollback(defStatus, false);  
       return;  
    }  
  
    if (!shouldCommitOnGlobalRollbackOnly() && defStatus.isGlobalRollbackOnly()) {  
       if (defStatus.isDebug()) {  
          logger.debug("Global transaction is marked as rollback-only but transactional code requested commit");  
       }  
       processRollback(defStatus, true);  
       return;  
    }  
  
	// 실제 커밋 프로세스 시작
    processCommit(defStatus);  
}

private void processCommit(DefaultTransactionStatus status) throws TransactionException {
    try {
        boolean beforeCompletionInvoked = false;

        try {
            boolean unexpectedRollback = false;
            prepareForCommit(status);

            // BEFORE_COMMIT 이벤트 트리거: 아직 DB 커밋 전
            triggerBeforeCommit(status);

            // BEFORE_COMPLETION 콜백 트리거: DB 커밋 직전
            triggerBeforeCompletion(status);
            beforeCompletionInvoked = true;

            if (status.hasSavepoint()) {
                if (status.isDebug()) {
                    logger.debug("Releasing transaction savepoint");
                }
                unexpectedRollback = status.isGlobalRollbackOnly();

                // Savepoint 해제: 물리 DB 커밋은 아님
                status.releaseHeldSavepoint();
            }
            else if (status.isNewTransaction()) {
                if (status.isDebug()) {
                    logger.debug("Initiating transaction commit");
                }
                unexpectedRollback = status.isGlobalRollbackOnly();

                // 실제 DB 트랜잭션 커밋 수행
                doCommit(status);
            }
            else if (isFailEarlyOnGlobalRollbackOnly()) {
                unexpectedRollback = status.isGlobalRollbackOnly();
            }

            if (unexpectedRollback) {
                throw new UnexpectedRollbackException(
                        "Transaction silently rolled back because it has been marked as rollback-only");
            }
        }
        catch (UnexpectedRollbackException ex) {
            // 롤백 완료 후 AFTER_COMPLETION 콜백 트리거
            triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK);
            throw ex;
        }
        catch (TransactionException ex) {
            if (isRollbackOnCommitFailure()) {
                // 커밋 실패 시 롤백 처리
                doRollbackOnCommitException(status, ex);
            }
            else {
                // 커밋 결과 불명 상태로 AFTER_COMPLETION 콜백 트리거
                triggerAfterCompletion(status, TransactionSynchronization.STATUS_UNKNOWN);
            }
            throw ex;
        }
        catch (RuntimeException | Error ex) {
            if (!beforeCompletionInvoked) {
                // 예외 발생 시 BEFORE_COMPLETION 미실행 상태면 먼저 호출
                triggerBeforeCompletion(status);
            }

            // 커밋 전 예외 발생으로 롤백 처리
            doRollbackOnCommitException(status, ex);
            throw ex;
        }

        try {
            // AFTER_COMMIT 이벤트 트리거: DB 커밋 완료 후, Spring cleanup 전
            triggerAfterCommit(status);
        }
        finally {
            // AFTER_COMPLETION 콜백 트리거: 커밋 성공/실패와 관계없이 완료 통지
            triggerAfterCompletion(status, TransactionSynchronization.STATUS_COMMITTED);
        }

    }
    finally {
        // Spring 트랜잭션 정리: EntityManager unbind/close, 동기화 자원 정리
        cleanupAfterCompletion(status);
    }
}

private void triggerAfterCommit(DefaultTransactionStatus status) {  
    if (status.isNewSynchronization()) {  
       TransactionSynchronizationUtils.triggerAfterCommit();  
    }  
}

private void cleanupAfterCompletion(DefaultTransactionStatus status) {  
    status.setCompleted();  
    if (status.isNewSynchronization()) {  
       // 모든 트랜잭션 자원을 초기화
       TransactionSynchronizationManager.clear();  
    }  
    if (status.isNewTransaction()) {  
       doCleanupAfterCompletion(status.getTransaction());  
    }  
    if (status.getSuspendedResources() != null) {  
       if (status.isDebug()) {  
          logger.debug("Resuming suspended transaction after completion of inner transaction");  
       }  
       Object transaction = (status.hasTransaction() ? status.getTransaction() : null);  
       resume(transaction, (SuspendedResourcesHolder) status.getSuspendedResources());  
    }  
}

@Override  
protected void doCommit(DefaultTransactionStatus status) {  
    JpaTransactionObject txObject = (JpaTransactionObject) status.getTransaction();  
    if (status.isDebug()) {  
       logger.debug("Committing JPA transaction on EntityManager [" +  
             txObject.getEntityManagerHolder().getEntityManager() + "]");  
    }  
    try {  
       EntityTransaction tx = txObject.getEntityManagerHolder().getEntityManager().getTransaction();  
       tx.commit();  
    }  
    catch (RollbackException ex) {  
       if (ex.getCause() instanceof RuntimeException runtimeException) {  
          DataAccessException dae = getJpaDialect().translateExceptionIfPossible(runtimeException);  
          if (dae != null) {  
             throw dae;  
          }  
       }  
       throw new TransactionSystemException("Could not commit JPA transaction", ex);  
    }  
    catch (RuntimeException ex) {  
       // Assumably failed to flush changes to database.  
       throw DataAccessUtils.translateIfNecessary(ex, getJpaDialect());  
    }  
}

public interface EntityTransaction {    
     /**  
      * Commit the current resource transaction, writing any      * unflushed changes to the database.    
	  * @throws IllegalStateException if <code>isActive()</code> is false  
      * @throws RollbackException if the commit fails  
      */    
      public void commit();
}

doCommit(status); // 실제 DB commit

try {
    triggerAfterCommit(status); // commit 성공 후 콜백
}
finally {
    triggerAfterCompletion(status, STATUS_COMMITTED); // 최종 완료 콜백
}

cleanupAfterCompletion(status); // Spring 리소스 정리