public interface PlatformTransactionManager extends TransactionManager {

	TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException;
	
	void commit(TransactionStatus status) throws TransactionException;
	
	void rollback(TransactionStatus status) throws TransactionException;

}

public abstract class AbstractPlatformTransactionManager implements PlatformTransactionManager, ConfigurableTransactionManager, Serializable {
	
	@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;  
	       boolean commitListenerInvoked = false;  
	  
	       try {  
	          boolean unexpectedRollback = false;  
	          prepareForCommit(status);  
	          //커밋 준비
	          
	          triggerBeforeCommit(status);  
	          //TrasnactionSynchronization에 beforeCommit() 콜백 호출
	          triggerBeforeCompletion(status);  
	          //beforeCompletion 콜백 실행(flush 등)
	          beforeCompletionInvoked = true;  
	  
	          if (status.hasSavepoint()) {  
	          //savePoint 있으면
	             if (status.isDebug()) {  
	                logger.debug("Releasing transaction savepoint");  
	             }  
	             unexpectedRollback = status.isGlobalRollbackOnly();  
	             this.transactionExecutionListeners.forEach(listener -> listener.beforeCommit(status));  
	             commitListenerInvoked = true;  
	             
	             status.releaseHeldSavepoint();  
	             //쥐고 있는 savePoint release
	          }  
	      
	          else if (status.isNewTransaction()) {  
			  //신규 트랜잭션이면 
	             if (status.isDebug()) {  
	                logger.debug("Initiating transaction commit");  
	             }  
	             unexpectedRollback = status.isGlobalRollbackOnly();  
	             this.transactionExecutionListeners.forEach(listener -> listener.beforeCommit(status));  
	             commitListenerInvoked = true;  
	             doCommit(status);  
	          }  
	      
	          else if (isFailEarlyOnGlobalRollbackOnly()) {  
	      //예기치 않은 롤백
	             unexpectedRollback = status.isGlobalRollbackOnly();  
	          }  
	  
	          // Throw UnexpectedRollbackException if we have a global rollback-only  
	          // marker but still didn't get a corresponding exception from commit.          if (unexpectedRollback) {  
	             throw new UnexpectedRollbackException(  
	                   "Transaction silently rolled back because it has been marked as rollback-only");  
	          }  
	       }  
	       catch (UnexpectedRollbackException ex) {  
	          triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK);  
	          this.transactionExecutionListeners.forEach(listener -> listener.afterRollback(status, null));  
	          //롤백된 경우 afterCompletion 콜백 실행
	          throw ex;  
	       }  
	       catch (TransactionException ex) {  
	       //커밋 실패 -> 롤백 
	          if (isRollbackOnCommitFailure()) {  
	             doRollbackOnCommitException(status, ex);  
	          }  
	          else {  
	             triggerAfterCompletion(status, TransactionSynchronization.STATUS_UNKNOWN);  
	             if (commitListenerInvoked) {  
	                this.transactionExecutionListeners.forEach(listener -> listener.afterCommit(status, ex));  
	             }  
	          }  
	          throw ex;  
	       }  
	       catch (RuntimeException | Error ex) {  
	          if (!beforeCompletionInvoked) {  
	          //commit중 예외 발생시
	             triggerBeforeCompletion(status);  
	          }  
	          doRollbackOnCommitException(status, ex);  
	          throw ex;  
	       }  
	  
	       // Trigger afterCommit callbacks, with an exception thrown there  
	       // propagated to callers but the transaction still considered as committed.       try {  
	          triggerAfterCommit(status);  
	          //커밋 이후 afterCommit 콜백 
	       }  
	       finally {  
	          triggerAfterCompletion(status, TransactionSynchronization.STATUS_COMMITTED);  
	          if (commitListenerInvoked) {  
	             this.transactionExecutionListeners.forEach(listener -> listener.afterCommit(status, null));  
	          }  
	       }  
	  
	    }  
	    finally {  
	    //트랜잭션 ThreadLocal 리소스 해제
	       cleanupAfterCompletion(status);  
	    }  
	}  








	@Override  
	public final void rollback(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;  
	    롤백 진입
	        processRollback(defStatus, false);  
	}  
	  
	  
	  
	  private void processRollback(DefaultTransactionStatus status, boolean unexpected) {  
	    try {  
	       boolean unexpectedRollback = unexpected;  
	       boolean rollbackListenerInvoked = false;  
	  
	       try {  
	       //beforeCompletion 콜백
	          triggerBeforeCompletion(status);  
	          if (status.hasSavepoint()) {  
				//savePoint 있다면(중첩트랜잭션)
	             if (status.isDebug()) {  
	                logger.debug("Rolling back transaction to savepoint");  
	             }  
	             this.transactionExecutionListeners.forEach(listener -> listener.beforeRollback(status));  
	             rollbackListenerInvoked = true;  
	             status.rollbackToHeldSavepoint();  
	          }  
	      
	          else if (status.isNewTransaction()) {
	          //신규 트랜잭션이라면  
	             if (status.isDebug()) {  
	                logger.debug("Initiating transaction rollback");  
	             }  
	             this.transactionExecutionListeners.forEach(listener -> listener.beforeRollback(status));  
	             rollbackListenerInvoked = true;  
	             doRollback(status); 
	             //doRollback (DB, JPA) 
	          }  
	      
	          else {  
		      //외부에서 참여한 트랜잭션이면 
	             // Participating in larger transaction  
	             if (status.hasTransaction()) {  
	                if (status.isLocalRollbackOnly() || isGlobalRollbackOnParticipationFailure()) {  
	                   if (status.isDebug()) {  
	                      logger.debug("Participating transaction failed - marking existing transaction as rollback-only");  
	                   }  
	               //rolebackOnly 마킹
	                   doSetRollbackOnly(status);  
	                }  
	                
	                else {  
	                //아니면 그냥 둠
	                   if (status.isDebug()) {  
	                      logger.debug("Participating transaction failed - letting transaction originator decide on rollback");  
	                   }  
	                }  
	             }  
	             else {  
	                logger.debug("Should roll back transaction but cannot - no transaction available");  
	             }  
	             // Unexpected rollback only matters here if we're asked to fail early  
	             if (!isFailEarlyOnGlobalRollbackOnly()) {  
	             //예기치 않은 롤맥은 earlyException
	                unexpectedRollback = false;  
	             }  
	          }  
	       }  
	       catch (RuntimeException | Error ex) {  
	          triggerAfterCompletion(status, TransactionSynchronization.STATUS_UNKNOWN);  
	          if (rollbackListenerInvoked) {  
	             this.transactionExecutionListeners.forEach(listener -> listener.afterRollback(status, ex));  
	          }  
	          throw ex;  
	       }  
	  
	       triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK);  
	       //롤백 이후 afterCompletion 콜백, afterRollback 콜백
	       if (rollbackListenerInvoked) {  
	          this.transactionExecutionListeners.forEach(listener -> listener.afterRollback(status, null));  
	       }  
	  
	       // Raise UnexpectedRollbackException if we had a global rollback-only marker  
	       if (unexpectedRollback) {  
	       //예기치 않은 롤백이면 예외
	          throw new UnexpectedRollbackException(  
	                "Transaction rolled back because it has been marked as rollback-only");  
	       }  
	    }  
	    finally {  
	       cleanupAfterCompletion(status);  
	       //ThreadLocal 등 트랜잭션 자원 정리
	    }  
	}
	


	private void cleanupAfterCompletion(DefaultTransactionStatus status) {  
	//상태 객체 완료로 변경
	    status.setCompleted();  
	    
	    if (status.isNewSynchronization()) {  
	    //새롭게 synchronization을 활성화 했다면
	       TransactionSynchronizationManager.clear();  
	       //콜백, ThreadLocal, 플래그 등 정리
	    }  
	    if (status.isNewTransaction()) {  
	    //새로운 트랜잭션이면
	       doCleanupAfterCompletion(status.getTransaction());  
	       //JDBC 커넥션, EntityManager 정리 등
	       
	    }  
	    
	    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());  
	       //복구
	    }  
	}

	protected void doCleanupAfterCompletion(Object transaction) {  
	}


}

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...  

		/**
		 * 1. 트랜잭션 시작
		 * 2. try {
		 *   비즈니스 로직 실행
		 *   commit();
		 * }
		 * catch(Exception e) {
		 *   rollback();
		 * }
		 */

	    return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed);  
	}

	@Nullable  
	protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,  
	       final InvocationCallback invocation) throws Throwable {  
	  
	    // If the transaction attribute is null, the method is non-transactional.  
	
	    TransactionAttributeSource tas = getTransactionAttributeSource();  
	    //TransactionAttribute 조회
	    final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);  
	    final TransactionManager tm = determineTransactionManager(txAttr);  
	    //TransactionManager 결정
	  
	    if (this.reactiveAdapterRegistry != null && tm instanceof ReactiveTransactionManager rtm) {  
	       boolean isSuspendingFunction = KotlinDetector.isSuspendingFunction(method);  
	       boolean hasSuspendingFlowReturnType = isSuspendingFunction &&  
	             COROUTINES_FLOW_CLASS_NAME.equals(new MethodParameter(method, -1).getParameterType().getName());  
	  
	       ReactiveTransactionSupport txSupport = this.transactionSupportCache.computeIfAbsent(method, key -> {  
	          Class<?> reactiveType =  
	                (isSuspendingFunction ? (hasSuspendingFlowReturnType ? Flux.class : Mono.class) : method.getReturnType());  
	          ReactiveAdapter adapter = this.reactiveAdapterRegistry.getAdapter(reactiveType);  
	          if (adapter == null) {  
	             throw new IllegalStateException("Cannot apply reactive transaction to non-reactive return type [" +  
	                   method.getReturnType() + "] with specified transaction manager: " + tm);  
	          }  
	          return new ReactiveTransactionSupport(adapter);  
	       });  
	  
	       return txSupport.invokeWithinTransaction(method, targetClass, invocation, txAttr, rtm);  
	    }  
	    //Reactive
	  
	    PlatformTransactionManager ptm = asPlatformTransactionManager(tm);  
		//PlatformTransactionManger로 형 변환 (JDBC/ JPA/ JTA)

	    final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);  
	  
	    if (txAttr == null || !(ptm instanceof CallbackPreferringPlatformTransactionManager cpptm)) {  
	       // Standard transaction demarcation with getTransaction and commit/rollback calls.  
	       TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);  
	   //시작
	  
	       Object retVal;  
	       try {  
	          // This is an around advice: Invoke the next interceptor in the chain.  
	          // This will normally result in a target object being invoked.          
	          retVal = invocation.proceedWithInvocation();  
	          //비즈니스 로직 실행
	       }  
	       catch (Throwable ex) {  
	          // target invocation exception  
	          completeTransactionAfterThrowing(txInfo, ex);
	          //예외 발생시 롤백 트리거  
	          throw ex;  
	       }  
	       finally {  
	          cleanupTransactionInfo(txInfo);  
	          //트랜잭션 정보 정리
	       }  
	  
	       if (retVal != null && txAttr != null) {  
	   //비동기 반환 값 예외도 롤백 전파 처리
	          TransactionStatus status = txInfo.getTransactionStatus();  
	          if (status != null) {  
	             if (retVal instanceof Future<?> future && future.isDone()) {  
	             //Future 예외 발생
	                try {  
	                   future.get();  
	                }  
	                catch (ExecutionException ex) {  
	                   if (txAttr.rollbackOn(ex.getCause())) {  
	                      status.setRollbackOnly();  
	                   }  
	                }  
	                catch (InterruptedException ex) {  
	                   Thread.currentThread().interrupt();  
	                }  
	             }  
	             
	             else if (vavrPresent && VavrDelegate.isVavrTry(retVal)) {  
	             //Vavr 라이브러리 등에서 예외 전파 대응
	                // Set rollback-only in case of Vavr failure matching our rollback rules...  
	                retVal = VavrDelegate.evaluateTryFailure(retVal, txAttr, status);  
	             }  
	          }  
	       }  
	  
	       commitTransactionAfterReturning(txInfo);
	       //트랜잭션 정상 종료 -> 커밋  
	       return retVal;  
	    }  
	  
	    else {  
	//CallbackPreferringPlatformTransactionManager
	//트랜잭션 경계를 콜백 형태로 실행할 수 있도록 설계됨
	//트랜잭션 시작/종료는 매니저가 알아서 하고
	//중간 실제 로직은 콜백으로 실행하라는 패턴
	
	       Object result;  
	       final ThrowableHolder throwableHolder = new ThrowableHolder();  
	  
	       // It's a CallbackPreferringPlatformTransactionManager: pass a TransactionCallback in.  
	       try {  
	          result = cpptm.execute(txAttr, status -> {  
	             TransactionInfo txInfo = prepareTransactionInfo(ptm, txAttr, joinpointIdentification, status);  
	             try {  
	                Object retVal = invocation.proceedWithInvocation();  
	                if (retVal != null && vavrPresent && VavrDelegate.isVavrTry(retVal)) {  
	                   // Set rollback-only in case of Vavr failure matching our rollback rules...  
	                   retVal = VavrDelegate.evaluateTryFailure(retVal, txAttr, status);  
	                }  
	                return retVal;  
	             }  
	             catch (Throwable ex) {  
	                if (txAttr.rollbackOn(ex)) {  
	                   // A RuntimeException: will lead to a rollback.  
	                   if (ex instanceof RuntimeException runtimeException) {  
	                      throw runtimeException;  
	                   }  
	                   else {  
	                      throw new ThrowableHolderException(ex);  
	                   }  
	                }  
	                else {  
	                   // A normal return value: will lead to a commit.  
	                   throwableHolder.throwable = ex;  
	                   return null;  
	                }  
	             }  
	             finally {  
	                cleanupTransactionInfo(txInfo);  
	             }  
	          });  
	       }  
	       catch (ThrowableHolderException ex) {  
	          throw ex.getCause();  
	       }  
	       catch (TransactionSystemException ex2) {  
	          if (throwableHolder.throwable != null) {  
	             logger.error("Application exception overridden by commit exception", throwableHolder.throwable);  
	             ex2.initApplicationException(throwableHolder.throwable);  
	          }  
	          throw ex2;  
	       }  
	       catch (Throwable ex2) {  
	          if (throwableHolder.throwable != null) {  
	             logger.error("Application exception overridden by commit exception", throwableHolder.throwable);  
	          }  
	          throw ex2;  
	       }  
	  
	       // Check result state: It might indicate a Throwable to rethrow.  
	       if (throwableHolder.throwable != null) {  
	          throw throwableHolder.throwable;  
	       }  
	       return result;  
	    }  
	}
}