AOP 완전 정복

void    주문받기()      → r = null               // 반환값 없으면 null
String  메뉴가져오기()   → r = "페퍼로니"          // String이면 String
User    회원조회()      → r = User{name="라희"}  // 객체면 객체
int     재고확인()      → r = 42                  // 기본형은 박싱돼서 담김

@Around("execution(* PizzaService.*(..))")
public Object 실수(ProceedingJoinPoint jp) throws Throwable {
    System.out.println("실행 전");
    // ❌ jp.proceed()를 깜빡했다!
    return null;
    // 결과: 주문받기() 호출했는데 피자가 영원히 안 만들어짐 😱
}

jp.getSignature().getName()()   → "주문받기" (메서드 이름)               
jp.getArgs()()                  → ["페퍼로니", 2] (파라미터)          
jp.getTarget()()                → 진짜 PizzaService 객체  
jp.proceed()                    → 진짜 메서드 실행!                  
  

@Aspect      // ← "나 AOP야!"
@Component   // ← "스프링아 나 좀 써줘!" — 이 둘은 항상 같이 붙임
public class MyAOP {
    // 여기에 끼어드는 코드 작성
}

// Spring Boot는 아래 생략 가능 (자동 활성화됨)
@EnableAspectJAutoProxy
@Configuration
public class AppConfig { }

@Around("execution(* PizzaService.*(..))")
'''
여기서 따옴표 안에 있는 이게 PointCut이에요.
'''

execution(* PizzaService.*(..))
          ↑              ↑
     모든 반환타입      모든 메서드, 모든 파라미터
'''

쉽게 보면
'''
PizzaService 안에 있는
모든 메서드에 끼어들어줘!

// ① 내 커스텀 애너테이션 만들기
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface 시간측정필요 {}

// ② 적용하고 싶은 메서드에만 붙이기
public class PizzaService {
    @시간측정필요                      // ← AOP 적용 O
    public void 주문받기() { ... }
    public void 재고확인() { ... }   // ← AOP 적용 X
}

// ③ AOP에서 @annotation으로 연결
@Around("@annotation(시간측정필요)")
public Object 시간측정(ProceedingJoinPoint jp) throws Throwable {
    // @시간측정필요가 붙은 메서드에만 자동 적용!
}

@Aspect @Component
public class PizzaAOP {

    // 이름 붙이기 — 빈 메서드, 이름 역할만 함
    @Pointcut("execution(* PizzaService.*(..))")
    public void 피자서비스전체() {}

    // 재사용 ①
    @After("피자서비스전체()")
    public void 호출로그(JoinPoint jp) { ... }

    // 재사용 ②
    @Around("피자서비스전체()")
    public Object 시간측정(ProceedingJoinPoint jp) throws Throwable { ... }
}

@Before("execution(* PizzaService.*(..))")
public void 로그(JoinPoint jp) {

    String 메서드 = jp.getSignature().getName();
    System.out.println("실행된 메서드: " + 메서드);
    // → 실행된 메서드: 주문받기

    Object[] 파라미터 = jp.getArgs();
    System.out.println("파라미터: " + Arrays.toString(파라미터));
    // → 파라미터: [페퍼로니, 2판]

    String 클래스 = jp.getTarget().getClass().getSimpleName();
    System.out.println("클래스: " + 클래스);
    // → 클래스: PizzaService
}

@Aspect
@Component
public class PizzaAOP {

    /* ─── @Pointcut: 이름 붙여서 재사용 ─── */
    @Pointcut("execution(* PizzaService.*(..))")
    public void 피자서비스전체() {}


    /* ─── ① 항상 남기는 호출 로그 (@After + JoinPoint 활용) ─── */
    @After("피자서비스전체()")
    public void 호출로그(JoinPoint jp) {
        String 메서드 = jp.getSignature().getName();
        Object[] 파라미터 = jp.getArgs();
        System.out.println(메서드 + " 호출됨 / 파라미터: " + Arrays.toString(파라미터));
    }


    /* ─── ② 에러나면 슬랙 알림 (@AfterThrowing) ─── */
    @AfterThrowing(pointcut="피자서비스전체()", throwing="e")
    public void 에러알림(Exception e) {
        System.out.println("🚨 에러! 슬랙 전송: " + e.getMessage());
    }


    /* ─── ③ 시간 측정 (@Around + jp.proceed()) ─── */
    @Around("피자서비스전체()")
    public Object 시간측정(ProceedingJoinPoint jp) throws Throwable {
        long start = System.currentTimeMillis();

        Object r = jp.proceed();            // 원래 메서드 실행, 결과를 r에 저장

        System.out.println("⏱ " + (System.currentTimeMillis() - start) + "ms");
        return r;                          // 원래 반환값 그대로 돌려줌
    }
}

/* 실행 결과:
   ⏱ 2ms                              ← @Around
   주문받기 호출됨 / 파라미터: []      ← @After + JoinPoint
   ⏱ 5ms                              ← @Around
   피자만들기 호출됨 / 파라미터: []    ← @After + JoinPoint
   🚨 에러! 슬랙 전송: ...            ← @AfterThrowing (에러시만)
*/