[Spring] AOP, AOP Proxy

💡 Spring 핵심 개념 인터뷰 Q&A

요약

AOP를 적용할 대상 객체(Bean)가 인터페이스를 구현하고 있으면, 스프링은 JDK 동적 프록시를 사용한다.

프록시란

• 프록시(proxy)는 “진짜 객체(원래 로직)” 앞에 서서 대신 일 처리를 해주는 대리 객체
• 비유하면 비서(프록시), 대표(실제 객체)이다.
• 스프링은 AOP를 할 때 기존 로직을 건드리지 않고, 메서드 호출 전후에 로직을 추가하고 싶어한다.
• 그걸 가능하게 해주는 게 프록시객체이다.
  
  

프록시 동작

[클라이언트] -> [프록시] -> [실제객체]

프록시를 왜 만들까

• 스프링 AOP동작

실제객체를 프록시객체로 감싸서 
메서드 실행 전후 로그 
트랜잭션을 추가하기 위해 스프링은 프록시 객체를 생성한다.

• 로그인메서드 프록시 적용된 예시

login() 메서드 실행 → 로그 찍고 → 진짜 login 실행 → 다시 로그 찍기

프록시 패턴

스프링에서 프록시 생성방법

• JDK로 생성하는 방법, JDK Dynamic Proxy객체생성
• CGLIB로 생성하는 방법, CGLIB Proxy객체 생성
• AOP를 적용할 대상 클래스(빈 인스턴스)가 인터페이스를 implements 하고 있는지가 선택 기준이다.
  
  
  

JDK Dynamic Proxy생성

Proxy.newProxyInstance() 

JDK Dynamic Proxy객체 생성 방식

1. 유저서비스단을 인터페이스로 선언하였다.

public interface MemberService {
    void login(String name);
}

2. MemberService 인터페이스를 상속한 객체 (MemberServiceImpl)

public class MemberServiceImpl implements MemberService {
    public void login(String name) {
        System.out.println(name + " 로그인");
    }
}

3. 프록시 생성

MemberService target = new MemberServiceImpl();

MemberService proxy = (MemberService) Proxy.newProxyInstance(
        MemberService.class.getClassLoader(),
        new Class[]{MemberService.class}, // ★ 인터페이스가 반드시 필요
        (proxyObj, method, args) -> {
            System.out.println(">> 호출 전");
            Object result = method.invoke(target, args);
            System.out.println(">> 호출 후");
            return result;
        } );

• 위 코드를 보면 proxy는 인터페이스타입으로 선언되어 인터페이스 역할을 한다.
• 이때 프록시 객체는 MemberService인터페이스만 흉내냅니다.
• target 객체를 직접 상속하거나 클래스 구조를 복제하는 건 전혀 불가능합니다.
  
  
  

JDK Proxy 구조

[클라이언트] -> [JDK Proxy] -> [MemberServiceImpl(실제객체)]

JDK Proxy 역할

• JDK 프록시가 하는 일은 인터페이스를 대신 구현해서, 진짜 객체에게 호출을 전달(delegation)하는 것!

프록시 객체 생성 시점

• Spring AOP는 런타임에 실제 클래스의 프록시 객체를 자동으로 생성합니다. 이 객체는 둘 중 하나로 만들어진다. (JDK Dynamic Proxy, CGLIB Proxy)
• 생성 시 선택 기준 : 인터페이스 구현 유무
• AOP를 적용할 대상 Bean이 인터페이스를 구현하고 있다면 → 자바 내장 객체인 JDK 동적 프록시를 사용한다.

왜 JDK 프록시는 "인터페이스"가 반드시 필요한지

• JDK 동적 프록시는 인터페이스를 구현한 객체만 프록시로 만들 수 있다.
• 클래스 자체에 대한 프록시를 만들려면 CGLIB이 필요합니다.

CGLIB Proxy객체 생성 방식

사용목적

• 만약 인터페이스가 없다면? 이런 클래스는 JDK Proxy를 만들 수 없습니다.
• 왜냐하면 JDK Proxy는 반드시 인터페이스를 기반으로 생성되기 때문입니다.

public class MemberService {
    public void login(String name) { ... }
}

• 여기서 jdk를 쓰면 에러가 납니다.

java.lang.IllegalArgumentException: com.example.MemberService is not an interface

• CGLIB은 인터페이스가 없어도 되게 만들기 위해 클래스를 직접 상속해서 자식 클래스를 동적으로 생성합니다.

// MemberService → MemberService$$CGLIB$$Proxy 라는 클래스를 만들어서 login()을 오버라이드

CGLIB Proxy란?

• CGLIB은 클래스 자체를 상속해서 자식 클래스를 만들고, 메서드를 오버라이딩해서 가로채는 방식으로 프록시를 만듭니다.

• 즉, 인터페이스가 없어도 프록시를 만들 수 있습니다.

  
  
  

CGLIB 예제 : Java + CGLIB 라이브러리)

• cglib 의존성 추가
• 실제클래스이고 인터페이스 없음

1.실제클래스

public class MemberService {
    public void login(String name) {
        System.out.println(name + " 로그인 완료");
    }
}

2. CGLIB 프록시 생성 코드

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class CglibProxyTest {
    public static void main(String[] args) {
    
        Enhancer enhancer = new Enhancer();
        
        enhancer.setSuperclass(MemberService.class);
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
                System.out.println(">> 로그인 시도 (Before)");
                Object result = proxy.invokeSuper(obj, args); // 원본 메서드 호출
                System.out.println(">> 로그인 완료 (After)");
                return result; }
        }
    );

   MemberService proxy = (MemberService) enhancer.create(); // 프록시 객체 생성
   proxy.login("iamUser");
   
   }
}

3. CGLIB 내부동작

class MemberService$$EnhancerByCGLIB extends MemberService {
    public void login(String name) {
        System.out.println(">> Before");
        super.login(name);
        System.out.println(">> After");
    }
}

• MemberService$$EnhancerByCGLIB를 런타임에 바이트코드로 생성합니다:
  
  
  

4. 실행결과

>> 로그인 시도 (Before)
iamUser 로그인 완료
>> 로그인 완료 (After)

CGLIB이 쓰이는 예시

• 클래스만 정의되어 있는 서비스
• @Transactional, @Async, @Cacheable 같은 AOP 어노테이션 적용 시 인터페이스가 없으면 CGLIB 사용
• Spring Boot 기본값은 인터페이스 있으면 JDK Proxy, 없으면 자동으로 CGLIB

---

Spring AOP에서 CGLIB 프록시가 실제로 어떻게 작동하는지

예시

1. 프로젝트 구조

com.example.demo
├── AppConfig.java
├── MemberService.java
├── LogAspect.java
└── DemoApplication.java

2. 의존성 (Spring Boot + AOP)
3. AOP 대상 클래스 → 인터페이스 없음

package com.example.demo;

import org.springframework.stereotype.Service;

@Service
public class MemberService {
    public void login(String name) {
        System.out.println(name + " 로그인 성공");
    }
}

4. AOP 설정: Aspect 정의

package com.example.demo;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LogAspect {

    @Before("execution(* com.example.demo.MemberService.*(..))")
    public void logBefore() {
        System.out.println(">> AOP: 로그인 전에 로그 출력");
    }
}

5. 실행

package com.example.demo;

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

    @Bean
    public CommandLineRunner runner(MemberService memberService) {
        return args -> {
            System.out.println("프록시 클래스: " + memberService.getClass());
            memberService.login("iamUserser");
        };
    }
}

6. 실행결과

프록시 클래스: class com.example.demo.MemberService$$SpringCGLIB$$0
>> AOP: 로그인 전에 로그 출력
iamUserser 로그인 성공

---

CGLIB 프록시 생성

Enhancer.create()

CGLIB 프록시 특징

프록시 클래스 이름	$$SpringCGLIB$$이 붙음 → CGLIB 사용
로그 출력 순서	@Before Aspect가 login() 실행 전에 작동함
인터페이스 없음	그래서 JDK 프록시가 아닌 CGLIB 방식 사용

---

AOP 미적용 대표 케이스

결론

• AOP는 프록시 객체가 외부에서 호출받을 때만 작동합니다.
• 클래스 내부에서 this.메서드()로 호출하면 프록시를 거치지 않고 직접 메서드를 실행하기 때문에 AOP가 작동하지 않습니다.
  
  
  

예제

@Service
public class MemberService {

    public void login() {
        System.out.println("로그인 처리");
        validate(); // 내부 메서드 호출
    }

    public void validate() {
        System.out.println("유효성 검사");
    }
}

@Aspect
@Component
public class LogAspect {

    @Before("execution(* com.example.demo.MemberService.validate(..))")
    public void beforeValidate() {
        System.out.println("AOP: validate() 호출 전 로그");
    }
}

실행결과

• AOP 작동 안 함
• 왜냐하면 this.validate()는 프록시를 안 거치고 그냥 자기 자신을 호출했기 때문입니다.

이유

• AOP 작동 구조

  [Client]
  ↓
  [프록시 객체] → Advice 실행 → Target 객체의 메서드 호출
  

• 프록시 실패하게 되는 this호출(자기자신호출)

  [자기 클래스 안에서]
      ↓
  [바로 자기 메서드 호출] → 프록시 안 거침 → AOP 적용 안 됨

해결 방법 (외부에서 호출하도록 구조 변경)

• 메서드를 분리하고, 외부에서 호출하게 만들기
• 이렇게 하면 memberService는 프록시를 통해 메서드가 호출되므로 AOP가 작동함

@Component
public class LoginManager {

    @Autowired
    private MemberService memberService;

    public void loginProcess() {
        memberService.login(); // 프록시를 통해 호출
    }
}

정리

• AOP는 나 자신(this)을 감싸는 게 아니라, 외부에서 나를 감싸는 것이다.
• 그래서 자기 자신 안에서의 메서드 호출에는 AOP가 작동하지 않습니다.
  
  
  

---

@Transactional 에서의 AOP 미적용 사례

• @Transactional은 프록시 기반 AOP로 동작합니다.
• 즉, 프록시 객체를 통해 메서드가 호출될 때만 트랜잭션이 시작됩니다.
• 그런데 자기 자신(this) 안에서 this.save()처럼 직접 호출하면 프록시를 우회하게 되어 트랜잭션이 적용되지 않습니다
  
  

안되는 예시

@Service
public class OrderService {

    @Transactional
    public void save() { ... }

    public void process() {
        save(); // this.save() → 프록시 안 거침 → @Transactional 무효
    }
}

해결법 : 호출을 외부 Bean으로 분리

@Service
public class OrderProcessor {

    @Autowired
    private OrderService orderService;

    public void process() {
        orderService.save(); // 프록시 통해 호출됨 → @Transactional 적용됨
    }
}

@Transactional 동작 순서

1. 클라이언트가 스프링 Bean 메서드 호출
2. 스프링이 프록시 객체를 먼저 받음
3. 프록시가 메서드 실행 전 TransactionManager.begin() 호출
4. 실제 타겟 객체의 메서드 실행
5. 정상 종료 시 commit(), 예외 시 rollback()

• 프록시가 트랜잭션의 시작과 끝을 책임진다. 그래서 프록시를 거치지 않으면 트랜잭션도 없다.