AOP 동작 원리 — 코드를 건드리지 않고 기능을 추가하는 방법

public class OrderService {
    public void createOrder(OrderRequest request) {
        TransactionStatus tx = txManager.getTransaction(new DefaultTransactionDefinition());
        try {
            // 핵심 로직
            Order order = new Order(request);
            orderRepository.save(order);
            paymentService.pay(order);

            txManager.commit(tx);
        } catch (Exception e) {
            txManager.rollback(tx);
            throw e;
        }
    }

    // 모든 메서드에 동일한 트랜잭션 코드 반복...
}

Aspect     = 횡단 관심사를 모듈화한 것 (예: 트랜잭션 관리)
Join Point = 어드바이스가 적용될 수 있는 지점 (스프링에서는 메서드 실행)
Pointcut   = 어드바이스를 적용할 조인포인트를 선별하는 표현식
Advice     = 실제로 실행할 부가 기능 (Before, After, Around 등)
Advisor    = Pointcut + Advice (하나의 포인트컷과 하나의 어드바이스 조합)
Weaving    = 어드바이스를 핵심 로직에 적용하는 과정

클라이언트 → 프록시 → [Before Advice] → 원본 메서드 → [After Advice] → 응답

// 인터페이스가 있는 경우
public interface OrderService { void createOrder(); }

@Service
public class OrderServiceImpl implements OrderService {
    public void createOrder() { ... }
}

// 인터페이스가 없는 경우
@Service
public class OrderService {
    public void createOrder() { ... }
}

@Aspect
@Component
public class LoggingAspect {

    // 메서드 실행 전
    @Before("execution(* com.example.service.*.*(..))")
    public void before(JoinPoint joinPoint) {
        log.info("호출: {}", joinPoint.getSignature());
    }

    // 메서드 정상 반환 후
    @AfterReturning(pointcut = "execution(* com.example.service.*.*(..))",
                    returning = "result")
    public void afterReturning(JoinPoint joinPoint, Object result) {
        log.info("반환: {}", result);
    }

    // 예외 발생 시
    @AfterThrowing(pointcut = "execution(* com.example.service.*.*(..))",
                   throwing = "ex")
    public void afterThrowing(JoinPoint joinPoint, Exception ex) {
        log.error("예외: {}", ex.getMessage());
    }

    // 항상 실행 (finally)
    @After("execution(* com.example.service.*.*(..))")
    public void after(JoinPoint joinPoint) {
        log.info("완료: {}", joinPoint.getSignature());
    }

    // 메서드 실행 전/후 모두 제어 (가장 강력)
    @Around("execution(* com.example.service.*.*(..))")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        try {
            Object result = joinPoint.proceed(); // 원본 메서드 실행
            return result;
        } finally {
            long elapsed = System.currentTimeMillis() - start;
            log.info("{} 실행 시간: {}ms", joinPoint.getSignature(), elapsed);
        }
    }
}

// 특정 패키지의 모든 메서드
@Pointcut("execution(* com.example.service.*.*(..))")

// 특정 어노테이션이 붙은 메서드
@Pointcut("@annotation(com.example.annotation.LogExecutionTime)")

// 특정 어노테이션이 붙은 클래스의 모든 메서드
@Pointcut("@within(org.springframework.stereotype.Service)")

// 특정 빈의 모든 메서드
@Pointcut("bean(orderService)")

// 조합
@Pointcut("execution(* com.example.service.*.*(..)) && !execution(* com.example.service.InternalService.*(..))")

// 커스텀 어노테이션
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface LogExecutionTime {}

// Aspect 구현
@Aspect
@Component
public class ExecutionTimeAspect {

    @Around("@annotation(LogExecutionTime)")
    public Object measureTime(ProceedingJoinPoint joinPoint) throws Throwable {
        String methodName = joinPoint.getSignature().toShortString();
        long start = System.nanoTime();

        try {
            return joinPoint.proceed();
        } finally {
            long elapsed = (System.nanoTime() - start) / 1_000_000;
            log.info("[실행시간] {} = {}ms", methodName, elapsed);
        }
    }
}

// 사용
@Service
public class OrderService {
    @LogExecutionTime
    public Order createOrder(OrderRequest request) {
        // 비즈니스 로직만 집중
    }
}

@Aspect
@Component
@Order(1) // 먼저 실행
public class SecurityAspect {
    @Before("execution(* com.example.service.*.*(..))")
    public void checkAuth(JoinPoint joinPoint) {
        // 인증 체크
    }
}

@Aspect
@Component
@Order(2) // 나중에 실행
public class LoggingAspect {
    @Before("execution(* com.example.service.*.*(..))")
    public void log(JoinPoint joinPoint) {
        // 로깅
    }
}

SecurityAspect.around() 시작
  LoggingAspect.around() 시작
    원본 메서드 실행
  LoggingAspect.around() 종료
SecurityAspect.around() 종료

@Aspect
@Component
public class Pointcuts {

    @Pointcut("execution(* com.example.service.*.*(..))")
    public void serviceLayer() {}

    @Pointcut("execution(* com.example.repository.*.*(..))")
    public void repositoryLayer() {}

    @Pointcut("serviceLayer() || repositoryLayer()")
    public void businessLogic() {}
}

@Aspect
@Component
public class LoggingAspect {

    // 다른 Aspect에서 정의한 포인트컷 참조
    @Around("com.example.aop.Pointcuts.businessLogic()")
    public Object log(ProceedingJoinPoint joinPoint) throws Throwable {
        // ...
    }
}

클라이언트 → 프록시
  → SecurityAdvice (Order 1)
    → LoggingAdvice (Order 2)
      → TransactionAdvice (Order 3)
        → 원본 메서드
      ← TransactionAdvice
    ← LoggingAdvice
  ← SecurityAdvice
← 프록시 → 클라이언트