Connection conn = dataSource.getConnection();

try {
  // 1. 트랜잭션 시작
  conn.setAutoCommit(false);

  // 2. 비즈니스 로직 실행
  Statement stmt = conn.createStatement();
  stmt.executeUpdate("UPDATE account SET balance = balance - 3000 WHERE id = 1");
  stmt.executeUpdate("UPDATE account set balance = balance + 3000 WHERE id = 2");

  // 3. 성공 시 커밋
  conn.commit();
} catch (Exception e) {
  // 4. 실패 시 롤백
  conn.rollback();
} finally {
  // 5. 나머지 처리
  conn.setAutoCommit(true);
  conn.close();
}

// ❌ 나쁜 예: 트랜잭션 없음
public void transfer(Long fromId, Long toId, int amount) {
  // 각 작업이 독립적으로 자동 커밋
  accountRepository.decrease(fromId, amount); // Auto-commit ✅

  // 여기서 예외가 발생하면?
  throw new RuntimeException("오류!");

  accountRepository.increase(toId, amount); // 실행 안됨! ❌
  // 첫번째 작업은 이미 커밋되어 롤백 불가능!
}

// 😢 트랜잭션 코드가 비즈니스 로직을 압도
public void businessLogic() {
  Connection conn = null;
  try {
    conn = dataSource.getConnection();
    conn.setAutoCommit(false);

    // 실제 비즈니스 로직은 단 2줄
    orderService.createOrder();
    paymentService.processPayment();

    conn.commit();
  } catch (Exception e) {
    if (conn != null) {
      try {
        conn.rollback();
      } catch (SQLException ex) {
        // 롤백도 실패할 수 있음!
      }
    }
  } finally {
    if (conn != null) {
      try {
        conn.close();
      } catch (SQLException e) {
        // close도 예외 처리!
      }
    }
  }
}

// 1. 인터페이스 (공통 계약)
interface Service {
  void execute();
}

// 2. 실제 객체 (Real Object)
class RealService implements Service {
  @Override
  public void execute() {
    System.out.println("핵심 비즈니스 로직 실행!");
  }
}

// 3. 프록시 객체 (Proxy)
class ServiceProxy implements Service {
  private RealService realService;

  public ServiceProxy(RealService realService) {
    this.realService = realService;
  }

  @Override
  public void execute() {
    // 실제 메서드 호출 "전"에 추가 작업
    System.out.println("[프록시] 사전 처리: 로깅, 보안 체크...");
    
    // 실제 객체의 메서드 호출
    this.realService.execute();

    // 실제 메소드 호출 "후"에 추가 작업
    System.out.println("[프록시] 사후 처리: 리소스 정리...");
  }
}

// 4. 클라이언트 사용
Service service = new ServiceProxy(new RealService());
service.execute();

// 문제 코드 예시
@Service
public class OrderService {
  public void processOrder() {
    // ❌ 같은 클래스 내부 메서드 호출 - 트랜잭션 적용 안됨!
    this.createOrder();
  }

  @Transactional
  public void createOrder() {
    // 트랜잭션이 시작되지 않음!
    orderRepository.save(order);
  }
}

// 개발자가 작성한 서비스 (Real Object)
@Service
class OrderService {
  @Transactional // 이 어노테이션이 마법
  public void createOrder() {
    // 비즈니스 로직만 집중
    orderRepository.save(order);
    paymentRepository.save(payment);
  }
}

// 스프링이 자동으로 생성하는 프록시
class OrderServiceProxy extends OrderService {
  private TransactionManager txManager;

  @Override
  public void createOrder() {
    // 1. 트랜잭션 시작
    txManager.begin();

    try {
      // 2. 실제 메서드 호출
      super.createOrder();

      // 3. 트랜잭션 커밋
      txManager.commit();
    } catch (Exception e) {
      // 4. 예외 시 롤백
      txManager.rollback();
      throw e;
    }
  }
}

// ❌ AOP 없이 - 코드 중복 지옥
public void method1() {
  log.info("method1 시작");           // 로깅 (공통)
  transactionManager.begin();         // 트랜잭션 (공통)
  try {
      // 핵심 비즈니스 로직
      businessLogic1();
      transactionManager.commit();    // 트랜잭션 (공통)
      log.info("method1 종료");       // 로깅 (공통)
  } catch (Exception e) {
      transactionManager.rollback();  // 트랜잭션 (공통)
      log.error("method1 실패", e);   // 로깅 (공통)
  }
}

public void method2() {
  log.info("method2 시작");           // 똑같은 코드 반복!
  transactionManager.begin();
  try {
      businessLogic2();
      transactionManager.commit();
      log.info("method2 종료");
  } catch (Exception e) {
      transactionManager.rollback();
      log.error("method2 실패", e);
  }
}

// method3, method4... 계속 반복! 😱

// ✅ AOP 사용 - 깔끔한 비즈니스 로직
@Transactional  // 트랜잭션은 AOP가 처리
@Logging        // 로깅도 AOP가 처리
public void method1() {
  // 핵심 비즈니스 로직만!
  businessLogic1();
}

@Transactional
@Logging
public void method2() {
  businessLogic2();
}

// 컴파일 타임에는 원본 코드 그대로
@Transactional
public void createOrder() {
  orderRepository.save(order);
}

// Runtime에 프록시가 생성되어 실행
// 개발자는 직접 프록시를 작성할 필요 없음!

// ✅ 지원: 메서드 호출 전후
@Transactional
public void method() { }

// ❌ 미지원: 필드 접근, 생성자 호출 등

// ✅ 적용됨: 스프링이 관리하는 빈
@Service
class OrderService {
    @Transactional
    public void createOrder() { }
}

// ❌ 적용 안됨: new로 생성한 객체
OrderService service = new OrderService();
service.createOrder(); // 트랜잭션 없음!

// ❌ AOP 없이 (100줄)
public class OrderService {
    public void createOrder() {
        // 트랜잭션 코드: 15줄
        Connection conn = null;
        try {
            conn = dataSource.getConnection();
            conn.setAutoCommit(false);
            
            // 비즈니스 로직: 3줄
            orderRepository.save(order);
            paymentRepository.save(payment);
            emailService.send(email);
            
            conn.commit();
        } catch (Exception e) {
            if (conn != null) conn.rollback();
            throw e;
        } finally {
            if (conn != null) conn.close();
        }
    }
    
    // 다른 메서드 5개도 똑같이 반복...
}

// ✅ AOP 사용 (10줄)
@Service
public class OrderService {
    
    @Transactional
    public void createOrder() {
        // 비즈니스 로직만: 3줄
        orderRepository.save(order);
        paymentRepository.save(payment);
        emailService.send(email);
    }
    
    // 다른 메서드들도 깔끔!
}