Spring AOP와 Dynamic Proxy 동작 원리-JDK Proxy와 CGLIB

Controller → Proxy(Service) → 실제 Service

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
 
// 1. 인터페이스 (POJO의 핵심)
interface Hello {
    void sayHello(String name);
}
 
// 2. 실제 비즈니스 로직 (원본 객체)
class HelloTarget implements Hello {
    public void sayHello(String name) {
        System.out.println("본체 로직 수행: 안녕, " + name);
    }
}
 
// 3. 부가 기능을 담당하는 핸들러 (프록시가 호출할 내용)
class LogHandler implements InvocationHandler {
    private final Object target; // 실제 객체
 
    public LogHandler(Object target) {
        this.target = target;
    }
 
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println(">>> [LOG] 메서드 시작: " + method.getName()); // 부가 기능(공통)
        
        Object result = method.invoke(target, args); // 실제 본체 로직 실행 (리플렉션 사용)
        
        System.out.println("<<< [LOG] 메서드 종료"); // 부가 기능(공통)
        return result;
    }
}
 
public class ProxyExample {
    public static void main(String[] args) {
        Hello target = new HelloTarget(); // 원본
 
        // 4. 런타임에 가짜(Proxy) 객체 생성
        Hello proxyInstance = (Hello) Proxy.newProxyInstance(
                Hello.class.getClassLoader(), // 프록시 클래스를 로딩할 로더
                new Class[]{Hello.class}, // 프록시 객체가 구현할 인터페이스 목록
                new LogHandler(target) // 프록시는 LogHandler 기능 수행
        );
 
        // 5. 프록시 호출 (사용자는 원본인지 프록시인지 모름)
        // 프록시 객체는 invoke를 호출
        proxyInstance.sayHello("Spring");
    }
}

proxy.sayHello()  
→ InvocationHandler.invoke()  
→ method.invoke(target)  
→ 실제 메서드 실행

@Transactional  
@Service  
public class OrderService {  
  
    public void order() {  
        System.out.println("주문 처리");  
    }  
  
}

Controller → Transaction Proxy → OrderService

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
 
// 실제 비즈니스 로직 클래스 (원본 객체)
class HelloService {
    public void sayHello(String name) {
        System.out.println("본체 로직 수행: 안녕, " + name);
    }
}
 
// CGLIB 인터셉터
// 프록시 객체에서 메서드가 호출될 때 실행되는 로직
class LogInterceptor implements MethodInterceptor {
 
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
 
        // 부가 기능 실행 (AOP 공통 로직)
        System.out.println("LOG 시작: " + method.getName());
 
        // 실제 메서드 호출
        // invokeSuper는 프록시가 상속한 부모 클래스의 메서드를 실행한다
        Object result = proxy.invokeSuper(obj, args);
 
        // 부가 기능 실행
        System.out.println("LOG 종료");
 
        return result;
    }
}
 
public class CglibProxyExample {
    public static void main(String[] args) {
 
        // CGLIB 프록시 생성을 위한 Enhancer 객체
        Enhancer enhancer = new Enhancer();
 
        // 프록시가 상속할 대상 클래스 지정
        enhancer.setSuperclass(HelloService.class);
 
        // 메서드 호출을 가로챌 인터셉터 등록
        enhancer.setCallback(new LogInterceptor());
 
        // 런타임에 HelloService를 상속한 Proxy 클래스 생성
        HelloService proxy = (HelloService) enhancer.create();
 
        // 프록시 객체의 메서드 호출
        proxy.sayHello("Spring");
    }
}

proxy.sayHello()
→ intercept()
→ invokeSuper()
→ HelloService.sayHello()