오늘은 Spring AOP에 대해 정리해볼려고 한다.
프로젝트를 하다 보면 핵심 로직 말고도 로깅, 권한 체크, 예외 처리 같은 부가적인 기능을 넣어야 할 때가 많다. 그런데 이런 코드들이 여기저기 섞여버리면 나중에 관리하기가 너무 힘들어진다.
그래서 “이런 공통적인 작업들을 깔끔하게 따로 관리할 수 없을까?” 라는 고민에서 Spring AOP를 공부하게 되었고, 이번에 정리한 내용을 바탕으로 실제 내 프로젝트에도 적용해보려고 한다.

🤔 관점지향 프로그래밍(Aspect Oriented Programming )

AOP 는 프로그램 전반에 걸쳐 공통적으로 사용되는 기능을 모듈화하여 코드의 복잡도를 감소 시키고, 유지보수를 쉽게 만드는 것을 목표로 한다.

AOP 의 필요성을 이해하는데 가장 기초가 되는 개념은 관심사의 분리(Separation of Concerns) 이다.

서로 다른 관심사(Concerns)가 한 코드에 섞여 있다면, 하나의 기능을 수정할 경우, 의도치 않은 다른 기능에 영향을 미칠 수 있다.

따라서 AOP는 핵심 관심사(Core Concern) 와 횡단 관심사(Cross-cutting Concern) 를 나누어서 관리를 한다.

📌 Spring AOP

핵심 관심사(Core Concern), 횡단 관심사(Cross-cutting Concern)... 솔직히 이렇게 말하면 우리 개발자들은 "뭔 소리야?" 라는 말이 나올 수도 있다.

코드로 한번 이해해보자! 👇

📝 실제 상황으로 이해하기

😋 처음엔 괜찮았어

회원가입을 하는 간단한 코드를 가져와봤다. 여기까지는 문제가 없다.

@Transactional
public Member signUp(String name, String email) {
    // 핵심 로직: 회원 정보 저장
    Member member = new Member(name, email);
    return memberRepository.save(member);
}

핵심 로직만 깔끔하게 있어서 보기도 좋고, 이해하기도 쉽다. ✨

---

악덕 사장님 등장 👿

하지만 악덕 사장님이 "거기 신입! 메서드가 실행되는 시간 측정해봐!" 이렇게 요구를 하면 우리는 이렇게 측정을 해야 한다.

@Transactional
public Member signUp(String name, String email) {
    long start = System.currentTimeMillis(); // 시작 시간 측정
    
    // 핵심 로직: 회원 정보 저장
    Member member = new Member(name, email);
    Member savedMember = memberRepository.save(member);
    
    long end = System.currentTimeMillis(); // 끝 시간 측정
    System.out.println("signUp 메서드 실행 시간: " + (end - start) + "ms");
    
    return savedMember;
}

음... 솔직히 여기까지는 괜찮다. 코드가 좀 지저분해졌지만 할 만하다.

---

지옥의 시작 🔥

하지만 악덕 사장님이 "아니 회원가입 말고 탈퇴, 수정, 회원 조회도 다 측정해봐! 아 그리고 주문, 주문 취소, 배송, 결제도!" 라고 하면...

@Transactional
public void withdrawMember(Long memberId) {
    long start = System.currentTimeMillis();
    // 핵심 로직
    memberRepository.deleteById(memberId);
    long end = System.currentTimeMillis();
    System.out.println("withdrawMember 실행 시간: " + (end - start) + "ms");
}

@Transactional
public void updateMember(Long memberId, String name) {
    long start = System.currentTimeMillis();
    // 핵심 로직
    Member member = memberRepository.findById(memberId);
    member.updateName(name);
    long end = System.currentTimeMillis();
    System.out.println("updateMember 실행 시간: " + (end - start) + "ms");
}

@Transactional
public Order createOrder(Long memberId, Long productId) {
    long start = System.currentTimeMillis();
    // 핵심 로직
    Order order = new Order(memberId, productId);
    orderRepository.save(order);
    long end = System.currentTimeMillis();
    System.out.println("createOrder 실행 시간: " + (end - start) + "ms");
}

@Transactional
public void cancelOrder(Long orderId) {
    long start = System.currentTimeMillis();
    // 핵심 로직
    Order order = orderRepository.findById(orderId);
    order.cancel();
    long end = System.currentTimeMillis();
    System.out.println("cancelOrder 실행 시간: " + (end - start) + "ms");
}

손이 아프다... 😭 그리고 이건 시간 측정만 추가한 건데, 만약 여기에 로깅, 보안 체크, 트랜잭션 처리까지 추가하라고 하면?

---

😱 문제점 정리

이렇게 모든 메서드에 똑같은 코드를 복사-붙여넣기 하다 보면:

• 코드 중복 → 100개 메서드면 100번 복붙
• 유지보수 지옥 → 시간 측정 방식 바꾸려면 100개 다 수정
• 핵심 로직 파악 어려움 → 정작 중요한 비즈니스 로직이 부가 기능에 묻혀버림
• 실수하기 쉬움 → 한두 군데 빼먹으면 끝

---

💡 AOP가 해결책이다!

바로 이럴 때 AOP(Aspect-Oriented Programming, 관점 지향 프로그래밍)가 필요하다!

AOP를 사용하면 이렇게 바뀐다:

// 핵심 로직만 깔끔하게!
@Transactional
public Member signUp(String name, String email) {
    Member member = new Member(name, email);
    return memberRepository.save(member);
}

@Transactional
public void withdrawMember(Long memberId) {
    memberRepository.deleteById(memberId);
}

@Transactional
public Order createOrder(Long memberId, Long productId) {
    Order order = new Order(memberId, productId);
    return orderRepository.save(order);
}

시간 측정 로직은 딱 한 곳에만!

@Aspect
@Component
public class ExecutionTimeAspect {
    
    @Around("execution(* com.example.service..*(..))")
    public Object measureExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        
        Object result = joinPoint.proceed(); // 실제 메서드 실행
        
        long end = System.currentTimeMillis();
        String methodName = joinPoint.getSignature().getName();
        System.out.println(methodName + " 실행 시간: " + (end - start) + "ms");
        
        return result;
    }
}

---

🎯 핵심 정리

• 핵심 관심사(Core Concern): 실제 비즈니스 로직 (회원가입, 주문 등)
• 횡단 관심사(Cross-cutting Concern): 여러 메서드에 공통으로 적용되는 기능 (시간 측정, 로깅, 보안 등)

AOP는 횡단 관심사를 핵심 로직에서 분리해서 한 곳에서 관리할 수 있게 해준다!

이제 악덕 사장님이 "로깅도 추가해!" 라고 해도 당황하지 않아도 된다. 😎

---

📚 간단 AOP 용어 정리

1. Target (타겟)

말 그대로 Target, 즉, 부가 기능을 부여할 대상을 의미한다.

예를 들어 시간 측정 기능을 적용할 MemberService, OrderService 같은 클래스들이 바로 Target이다.

// 이 클래스가 바로 Target!
@Service
public class MemberService {
    public Member signUp(String name, String email) {
        // 비즈니스 로직
    }
}

---

2. Advice (어드바이스)

타깃에게 제공할 부가기능을 담은 모듈을 의미한다.

쉽게 말해서 "무슨 기능? 어느 시점에?"를 정의한다. 시간 측정 코드, 로깅 코드가 바로 Advice다.

Advice 종류:

• @Before: 메서드 실행 전
• @After: 메서드 실행 후 (예외 발생 여부 상관없이)
• @AfterReturning: 메서드 정상 종료 후
• @AfterThrowing: 예외 발생 시
• @Around: 메서드 실행 전후 (가장 강력함!)

@Around("execution(* com.example.service..*(..))")
public Object measureExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
    // 이 메서드 전체가 Advice!
    long start = System.currentTimeMillis();
    Object result = joinPoint.proceed();
    long end = System.currentTimeMillis();
    return result;
}

---

3. Join Point (조인 포인트)

Advice가 적용될 수 있는 위치를 의미한다.

메서드 실행 시점, 생성자 호출 시점, 필드 값 접근 시점 등이 될 수 있다. Spring AOP에서는 주로 메서드 실행 시점을 사용한다.

public Object advice(ProceedingJoinPoint joinPoint) throws Throwable {
    // joinPoint를 통해 실행되는 메서드 정보를 알 수 있음
    String methodName = joinPoint.getSignature().getName(); // 메서드 이름
    Object[] args = joinPoint.getArgs(); // 메서드 파라미터
    
    return joinPoint.proceed(); // 실제 메서드 실행
}

---

4. Pointcut (포인트컷)

Advice를 적용할 Join Point를 선별하는 기능이다.

쉽게 말해서 "어떤 메서드에 적용할 것인가"를 정의하는 필터 역할을 한다.

// service 패키지의 모든 클래스, 모든 메서드에 적용
@Around("execution(* com.example.service..*(..))")

// MemberService의 모든 메서드에 적용
@Around("execution(* com.example.service.MemberService.*(..))")

// signUp으로 시작하는 모든 메서드에 적용
@Around("execution(* com.example.service.*Service.signUp*(..))")

Pointcut 표현식 예시:

• execution(* com.example.service..*(..)): service 패키지와 하위 패키지의 모든 메서드
• execution(public * *(..)): 모든 public 메서드
• execution(* save*(..)): save로 시작하는 모든 메서드

---

5. Aspect (애스펙트)

Advice + Pointcut을 합친 것이다.

"어디에(Pointcut), 무엇을(Advice) 적용할 것인가"를 하나로 묶은 모듈이다.

@Aspect  // 이 클래스가 Aspect!
@Component
public class ExecutionTimeAspect {
    
    // Pointcut + Advice = Aspect
    @Around("execution(* com.example.service..*(..))")  // Pointcut
    public Object measureExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {  // Advice
        long start = System.currentTimeMillis();
        Object result = joinPoint.proceed();
        long end = System.currentTimeMillis();
        System.out.println(joinPoint.getSignature().getName() + " 실행 시간: " + (end - start) + "ms");
        return result;
    }
}

---

6. Weaving (위빙)

Pointcut으로 지정한 Target에 Advice를 적용하는 과정을 의미한다.

쉽게 말해서 핵심 로직에 부가 기능을 "짜 넣는" 작업이다.

Weaving 시점:

• 컴파일 시점: .java → .class 파일 생성 시 (AspectJ)
• 클래스 로딩 시점: 클래스를 JVM에 로드할 때 (AspectJ)
• 런타임 시점: 실행 중에 프록시 객체를 생성해서 적용 (Spring AOP 방식!)

// Spring AOP는 런타임 위빙 사용
// 실제로는 프록시 객체가 만들어져서 실행됨

MemberService memberService = new MemberService(); // 원본 객체
// 하지만 실제로 주입되는 것은...
MemberService$$EnhancerBySpringCGLIB$$... // 프록시 객체!

---

🎯 용어 관계도

Aspect = Pointcut + Advice

Target ← (Pointcut으로 선별) ← Advice 적용 (Weaving)
     ↓
 Join Point (실제 실행 지점)

한 줄 요약:

• Target: 부가 기능을 적용할 대상
• Advice: 부가 기능 코드 (언제, 무엇을)
• Join Point: 적용 가능한 지점
• Pointcut: Join Point 중에서 실제 적용할 지점을 선별 (어디에)
• Aspect: Advice + Pointcut을 모듈화한 것
• Weaving: 실제로 적용하는 과정

---

Spring AOP 동작 원리

Spring에서 AOP는 프록시 방식으로 동작한다.
프록시 패턴이란, 어떤 객체(타겟)를 직접 참조하지 않고, 대신 그 객체를 대신 수행하는 프록시(proxy) 객체를 통해 접근하는 방식을 말한다.

먼저 BeanPostProcessor에 대해 알아보자

BeanPostProcessor(빈 후처리기)

생성된 빈 객체를 스프링 컨테이너에 등록하기 전에 조작하는 객체

쉽게 말해서, 빈이 생성되고 나서 "잠깐! 이 빈을 그대로 등록하지 말고 내가 손 좀 봐야겠어!" 하고 중간에 끼어드는 역할을 한다.

public interface BeanPostProcessor {
    
    // Bean 초기화 전에 실행
    default Object postProcessBeforeInitialization(Object bean, String beanName) 
            throws BeansException {
        return bean;
    }
    
    // Bean 초기화 후에 실행 ⭐ (AOP는 여기서 프록시로 바꿈!)
    default Object postProcessAfterInitialization(Object bean, String beanName) 
            throws BeansException {
        return bean;
    }
}

하는일
1. 생성된 빈 전달
2. 빈 교체 대상 확인
3. 빈 교체 대상이 맞다면 이를 조작 또는 교체
4. 교체하거나 전달받은 빈을 반환한다.
5. 반환된 빈 객체를 컨텍스트에 등록

스프링 AOP에서 의미하는 프록시(proxy)는 부가기능을 추가할 때 사용하는 패턴이다.

1. 빈 객체를 생성한 뒤 빈 후처리기에게 전달한다.

2. 빈 후처리기는 어드바이저를 싹 훑어본다. 그리고 어드바이저 내의 포인트 컷(Pointcut)를 이용해 전달받은 빈이 프록시 적용 대상인지 확인한다.

3. 적용 대상인지 확인하면 '아 얘는 부가기능을 부여할만한 대상이야' 라고 판단되면 프록시 생성기에 전달해준다. 그리고 프록시 생성 대상 빈들을 대상으로 프록시 객체를 생성한다.

4. 프록시를 생성한 빈이라면 프록시 객체를, 프록시를 생성하지 않은 빈이라면 그냥 빈을 반환한다.

5. 빈 후처리기에 전달받은 객체를 컨테이너 빈으로 등록한다.

스프링 AOP 구현 예시

스프링 AOP를 구현하는 방식은 좀 다양하지만 나는 가장 많이 사용하고 책에서도 권장하는 방식인 @AspectJ를 사용해보겠다.

1. 의존성 추가

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-aop'
}

2. 포인트컷과 표현식 & 지시자

AspectJ는 포인트컷을 편리하게 표현하기 위한 특별한 표현식을 제공한다.

Spring AOP 주요 포인트컷 종류

• execution

  • 메서드 실행 지점을 매칭
  • 스프링 AOP에서 가장 많이 사용하며, 매우 유연하고 복잡한 표현 가능

• within

  • 특정 클래스나 타입 안의 모든 조인 포인트를 매칭

• args

  • 메서드의 인자가 지정한 타입일 때 매칭

• this

  • Spring AOP 프록시 객체를 대상으로 매칭

• target

  • 프록시가 가리키는 실제 객체(Target)를 대상으로 매칭

• @target

  • 실행 객체 클래스에 특정 어노테이션이 있을 때 매칭

• @within

  • 특정 어노테이션이 붙은 클래스 내부의 조인 포인트를 매칭

• @annotation

  • 메서드에 특정 어노테이션이 붙은 경우 매칭

• @args

  • 전달된 실제 인수의 런타임 타입에 특정 어노테이션이 있을 때 매칭

• bean

  • Spring 전용 포인트컷
  • 빈 이름으로 포인트컷을 지정할 수 있음

포인트컷은 “Advice를 어디에 적용할지 지정하는 기준”이고,
execution, within, args, annotation 등 다양한 방식으로 대상을 선택할 수 있다.

가장 많이 사용하는 execution 을 살펴보자

execution(접근제어자? 반환타입 패키지.클래스.메서드(파라미터) 예외?)

• ? 표시는 생략 가능
• * 는 모든 값을 의미
• .. 는 0개 이상을 의미

// 1. 모든 public 메서드
execution(public * *(..))

// 2. 반환 타입이 void인 모든 메서드
execution(void *(..))

// 3. 메서드 이름이 set으로 시작하는 모든 메서드
execution(* set*(..))

// 4. service 패키지의 모든 메서드
execution(* com.example.service.*.*(..))

// 5. service 패키지와 하위 패키지의 모든 메서드
execution(* com.example.service..*.*(..))

// 6. MemberService 클래스의 모든 메서드
execution(* com.example.service.MemberService.*(..))

// 7. 정확히 int minus(int, int) 메서드만
// 반환 타입은 int 이고, 두 개의 int 타입 파리미터를 전달받는 minus라는 이름의 메서드
execution(int minus(int, int))

// 반환 타입과는 상관 없고, 두 개의 int 타입 파라미터를 전달받는 minus라는 이름의 메서드
execution(* minus(int, int)

// 8. 파라미터가 String 하나인 모든 메서드
execution(* *(String))

// 9. 첫 번째 파라미터가 String인 모든 메서드
execution(* *(String, ..))

// 10. Member 타입을 반환하는 모든 메서드
execution(com.example.domain.Member *(..))

AspectJ 어드바이스

(1) After: 메소드가 반환되거나 예외 상황이 발생한 이후에 호출

(2) AfterReturning: 메소드가 반환된 이후에 호출

(3) AfterThrowing: 메소드가 예외 상황을 발생시킨 이후에 호출

(4) Before: 메소드가 호출되기 이전에 호출

(5) Around: 메소드의 호출 전과 반환되거나 예외 상황 이후에 호출

3. 어드바이저를 생성 , 정의

• @AspectJ 애너테이션을 사용해 어드바이저를 생성하면 이를 빈으로 등록해야한다.

• 개발자가 직접 정의한 클래스를 인자 타입으로 받을 때는 패키지명도 추가해야한다.

@Aspect // 어드바이저 생성
@Component // 빈 등록
public class CartExecutionTimeAspect {

    // 포인트컷 설정
    @Pointcut("execution(void putItemIntoCart(Long, cart.dto.AuthorizationInformation))")
    public void pointcut() {}

    // 어드바이스 정의 + 포인트컷 설정
    @Around("pointcut()")
    public Object advice(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        long start = System.currentTimeMillis(); // 시작 시간 체크

        Object result = proceedingJoinPoint.proceed(); // 타깃 메소드 호출

        long end = System.currentTimeMillis(); // 끝나는 시간 체크
        System.out.printf("%s 메소드의 실행 시간: %d 밀리 초%n",
                proceedingJoinPoint.getSignature().getName(), (end - start)); // 실행시간 출력

        return result; // 타깃 메소드의 결과 반환
    }
}

4. Configuration에 @EnableAspectJAutoProxy를 추가

@Configuration
@EnableAspectJAutoProxy
public class AopConfiguration {
}

putItemIntoCart 메소드의 실행 시간: 153 밀리 초

참고 :

• Spring AOP의 이해
• [Spring] 스프링 AOP 포인트컷(Pointcut) 표현식 정리
• [10분 테코톡] 콩하나의 스프링 AOP