Connection conn = dataSource.getConnection();

try {
  // 1. Start transaction
  conn.setAutoCommit(false);

  // 2. Execute business logic
  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. Commit on success
  conn.commit();
} catch (Exception e) {
  // 4. Rollback on failure
  conn.rollback();
} finally {
  // 5. Remaining cleanup
  conn.setAutoCommit(true);
  conn.close();
}

// ❌ Bad example: No transaction
public void transfer(Long fromId, Long toId, int amount) {
  // Each operation is independently auto-committed
  accountRepository.decrease(fromId, amount); // Auto-commit ✅

  // What if an exception occurs here?
  throw new RuntimeException("Error!");

  accountRepository.increase(toId, amount); // Not executed! ❌
  // The first operation is already committed and cannot be rolled back!
}

// 😢 Transaction code overwhelms business logic
public void businessLogic() {
  Connection conn = null;
  try {
    conn = dataSource.getConnection();
    conn.setAutoCommit(false);

    // Actual business logic is only 2 lines
    orderService.createOrder();
    paymentService.processPayment();

    conn.commit();
  } catch (Exception e) {
    if (conn != null) {
      try {
        conn.rollback();
      } catch (SQLException ex) {
        // Rollback can also fail!
      }
    }
  } finally {
    if (conn != null) {
      try {
        conn.close();
      } catch (SQLException e) {
        // close also needs exception handling!
      }
    }
  }
}

// 1. Interface (Common Contract)
interface Service {
  void execute();
}

// 2. Real Object
class RealService implements Service {
  @Override
  public void execute() {
    System.out.println("Executing core business logic!");
  }
}

// 3. Proxy Object
class ServiceProxy implements Service {
  private RealService realService;

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

  @Override
  public void execute() {
    // Additional tasks "before" calling the actual method
    System.out.println("[Proxy] Pre-processing: Logging, security check...");
    
    // Call the actual object's method
    this.realService.execute();

    // Additional tasks "after" calling the actual method
    System.out.println("[Proxy] Post-processing: Resource cleanup...");
  }
}

// 4. Client Usage
Service service = new ServiceProxy(new RealService());
service.execute();

// Problematic code example
@Service
public class OrderService {
  public void processOrder() {
    // ❌ Calling an internal method of the same class - transaction not applied!
    this.createOrder();
  }

  @Transactional
  public void createOrder() {
    // Transaction not started!
    orderRepository.save(order);
  }
}

// Service written by developer (Real Object)
@Service
class OrderService {
  @Transactional // This annotation is magic
  public void createOrder() {
    // Focus only on business logic
    orderRepository.save(order);
    paymentRepository.save(payment);
  }
}

// Proxy automatically generated by Spring
class OrderServiceProxy extends OrderService {
  private TransactionManager txManager;

  @Override
  public void createOrder() {
    // 1. Start transaction
    txManager.begin();

    try {
      // 2. Call the actual method
      super.createOrder();

      // 3. Commit transaction
      txManager.commit();
    } catch (Exception e) {
      // 4. Rollback on exception
      txManager.rollback();
      throw e;
    }
  }
}

// ❌ Without AOP - Code duplication hell
public void method1() {
  log.info("method1 start");           // Logging (cross-cutting)
  transactionManager.begin();         // Transaction (cross-cutting)
  try {
      // Core business logic
      businessLogic1();
      transactionManager.commit();    // Transaction (cross-cutting)
      log.info("method1 end");       // Logging (cross-cutting)
  } catch (Exception e) {
      transactionManager.rollback();  // Transaction (cross-cutting)
      log.error("method1 failed", e);   // Logging (cross-cutting)
  }
}

public void method2() {
  log.info("method2 start");           // Same code repeated!
  transactionManager.begin();
  try {
      businessLogic2();
      transactionManager.commit();
      log.info("method2 end");
  } catch (Exception e) {
      transactionManager.rollback();
      log.error("method2 failed", e);
  }
}

// method3, method4... endless repetition! 😱

// ✅ With AOP - Clean business logic
@Transactional  // Transaction handled by AOP
@Logging        // Logging also handled by AOP
public void method1() {
  // Only core business logic!
  businessLogic1();
}

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

// At compile time, original code remains as is
@Transactional
public void createOrder() {
  orderRepository.save(order);
}

// At runtime, a proxy is created and executed
// Developers don't need to write the proxy directly!

// ✅ Supported: before/after method calls
@Transactional
public void method() { }

// ❌ Not supported: field access, constructor calls, etc.

// ✅ Applied: Spring-managed bean
@Service
class OrderService {
    @Transactional
    public void createOrder() { }
}

// ❌ Not applied: object created with 'new'
OrderService service = new OrderService();
service.createOrder(); // No transaction!

// ❌ Without AOP (100 lines)
public class OrderService {
    public void createOrder() {
        // Transaction code: 15 lines
        Connection conn = null;
        try {
            conn = dataSource.getConnection();
            conn.setAutoCommit(false);
            
            // Business logic: 3 lines
            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 other methods also repeat the same...
}

// ✅ With AOP (10 lines)
@Service
public class OrderService {
    
    @Transactional
    public void createOrder() {
        // Only business logic: 3 lines
        orderRepository.save(order);
        paymentRepository.save(payment);
        emailService.send(email);
    }
    
    // Other methods are clean too!
}