Spring AOP는 어떻게 동작할까: 프록시부터 CGLIB까지

// 1. 공통 인터페이스
public interface OrderService {
    void order();
}

// 2. 진짜 객체: 핵심 로직만
public class OrderServiceImpl implements OrderService {
    public void order() {
        // 주문 로직
    }
}

// 3. 프록시: 같은 인터페이스를 구현하고, 진짜 객체를 품고 있음
public class OrderServiceTimeProxy implements OrderService {
    private final OrderService target;   // 진짜 객체

    public OrderServiceTimeProxy(OrderService target) {
        this.target = target;
    }

    public void order() {
        long start = System.currentTimeMillis();       // 부가 기능 (앞)
        target.order();                                 // 진짜 객체에 위임
        log.info("took {}ms", System.currentTimeMillis() - start);   // 부가 기능 (뒤)
    }
}

// 4. 클라이언트: 프록시를 주입받지만 OrderService로만 알고 있음
OrderService service = new OrderServiceTimeProxy(new OrderServiceImpl());
service.order();

public class TimeInvocationHandler implements InvocationHandler {
    private final Object target;   // 진짜 객체 (타입이 Object → 어떤 서비스든 가능)

    public TimeInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        long start = System.currentTimeMillis();                   // 부가 기능 (앞)
        Object result = method.invoke(target, args);                // 리플렉션으로 진짜 메서드 호출
        log.info("{} took {}ms", method.getName(), System.currentTimeMillis() - start);  // 부가 기능 (뒤)
        return result;
    }
}

OrderService proxy = (OrderService) Proxy.newProxyInstance(
        OrderService.class.getClassLoader(),        // 클래스 로더
        new Class[]{OrderService.class},            // 구현할 인터페이스 ← 반드시 인터페이스
        new TimeInvocationHandler(new OrderServiceImpl())           // 부가 기능
);

proxy.order();   // → TimeInvocationHandler.invoke() → 시간 측정 → target.order()

MemberService memberProxy = (MemberService) Proxy.newProxyInstance(
        MemberService.class.getClassLoader(),
        new Class[]{MemberService.class},
        new TimeInvocationHandler(new MemberServiceImpl())   // 같은 Handler 재사용
);

// 인터페이스 없는 구체 클래스
public class OrderService {
    public void order() {
        // 주문 로직
    }
}

import org.springframework.cglib.proxy.MethodInterceptor;   // Spring에 내장된 CGLIB

public class TimeMethodInterceptor implements MethodInterceptor {
    private final Object target;

    public TimeMethodInterceptor(Object target) {
        this.target = target;
    }

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        long start = System.currentTimeMillis();                    // 부가 기능 (앞)
        Object result = methodProxy.invoke(target, args);            // 진짜 메서드 호출
        log.info("{} took {}ms", method.getName(), System.currentTimeMillis() - start);  // 부가 기능 (뒤)
        return result;
    }
}

Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(OrderService.class);                        // 이 클래스를 상속해라 ← 인터페이스 아님!
enhancer.setCallback(new TimeMethodInterceptor(new OrderService())); // 부가 기능
OrderService proxy = (OrderService) enhancer.create();             // 프록시 생성

proxy.order();                                          // → intercept() → 시간 측정 → target.order()
System.out.println(proxy.getClass());                   // OrderService$$SpringCGLIB$$0 (Spring 6 기준)

public class OrderService$$SpringCGLIB$$0 extends OrderService {   // 상속!
    private MethodInterceptor interceptor;

    @Override
    public void order() {                                           // 오버라이드!
        interceptor.intercept(this, order 메서드 정보, args, methodProxy);
    }
}

@Service
public class OrderService {

    public void order() {
        // ...
        validate();   // 내부 호출 → 부가 기능 적용 안 됨
    }

    @LogExecutionTime   // 실행 시간을 측정하는 AOP가 적용된 메서드
    public void validate() {
        // ...
    }
}

@Aspect                                        // AspectJ 어노테이션
@Component
public class TimeAspect {
    @Around("execution(* com.shop..*(..))")    // AspectJ 포인트컷 문법
    public Object measure(ProceedingJoinPoint jp) throws Throwable { ... }
}