
이제 직접 코드를 작성하면서 이전에 알아봤던 용어들이 실제 코드의 어디에 해당하는지 하나씩 확인해 보도록 하자. 그 전에 먼저 AOP를 적용할 대상으로 아주 단순한 서비스와 리포지토리를 만들었다.
package hello.aop.order;
@Slf4j
@Repository
public class OrderRepository {
public String save(String itemId) {
log.info("[orderRepository] 실행");
// 저장 로직
if (itemId.equals("ex")) {
throw new IllegalStateException("예외 발생!");
}
return "ok";
}
}
itemId로 "ex"가 들어오면 예외를 던진다. 뒤에서 예외 상황의 AOP 동작을 확인할 때 쓴다.
package hello.aop.order;
@Slf4j
@Service
public class OrderService {
private final OrderRepository orderRepository;
public OrderService(OrderRepository orderRepository) {
this.orderRepository = orderRepository;
}
public void orderItem(String itemId) {
log.info("[orderService] 실행");
orderRepository.save(itemId);
}
}
호출 흐름은 단순하다.
클라이언트 → orderService.orderItem() → orderRepository.save()
package hello.aop;
@Slf4j
@SpringBootTest
public class AopTest {
@Autowired OrderService orderService;
@Autowired OrderRepository orderRepository;
@Test
void aopInfo() {
log.info("isAopProxy, orderService={}", AopUtils.isAopProxy(orderService));
log.info("isAopProxy, orderRepository={}", AopUtils.isAopProxy(orderRepository));
}
@Test
void success() {
orderService.orderItem("itemA");
}
@Test
void exception() {
assertThatThrownBy(() -> orderService.orderItem("ex"))
.isInstanceOf(IllegalStateException.class);
}
}
aopInfo(): AopUtils.isAopProxy(...)로 빈이 AOP 프록시인지 확인한다.success(): 정상 흐름을 실행한다.exception(): "ex"를 넘겨서 예외가 그대로 밖으로 던져지는지 확인한다.
아직 애스펙트가 없으니 테스트를 돌려보면 프록시가 아닌 원본 객체가 그대로 빈으로 등록되어 있는 것을 볼 수 있다. 이제부터 이 값과 로그를 보면서 AOP가 어떻게 걸리는지 추적해 볼 것이다.
isAopProxy, orderService=false
isAopProxy, orderRepository=false
스프링 AOP를 구현하는 가장 일반적인 방법은 @Aspect를 사용하는 것이다. 먼저 가장 단순한 애스펙트부터 만들어 보자.
package hello.aop.order.aop;
@Slf4j
@Aspect
public class AspectV1 {
// hello.aop.order 패키지와 하위 패키지
@Around("execution(* hello.aop.order..*(..))")
public Object doLog(ProceedingJoinPoint joinPoint) throws Throwable {
log.info("[log] {}", joinPoint.getSignature()); // join point 시그니처
return joinPoint.proceed();
}
}
이 짧은 코드에 개념 글에서 정리한 용어가 전부 들어 있다.
| 코드 | AOP 용어 | 역할 |
|---|---|---|
@Aspect가 붙은 AspectV1 | 애스펙트 | 어드바이스 + 포인트컷을 묶은 모듈 |
"execution(* hello.aop.order..*(..))" | 포인트컷 | 어디에 적용할지 |
doLog() | 어드바이스 | 무엇을 적용할지 |
ProceedingJoinPoint | 조인 포인트 | 지금 호출되고 있는 메서드의 정보 |
joinPoint.proceed() | - | 다음 어드바이스 또는 실제 타겟 호출 |
포인트컷 execution(* hello.aop.order..*(..))은 hello.aop.order 패키지와 그 하위 패키지(..)의 모든 메서드를 대상으로 하는 AspectJ 포인트컷 표현식이다. 표현식 문법은 다음 글에서 자세히 다루고, 지금은 "이 패키지 아래 전부" 라고만 이해하면 충분하다.
doLog()는 로그를 남긴 뒤 joinPoint.proceed()로 실제 메서드를 호출하고, 그 결과를 그대로 반환한다. 이 반환값을 return 해줘야 호출한 쪽이 결과를 받을 수 있다.
이제 OrderService, OrderRepository의 모든 메서드가 AOP 적용 대상이 된다.
그런데 @Aspect는 애스펙트라는 일종의 표식일 뿐, 컴포넌트 스캔이 되는 건 아니다. 따라서 스프링 빈으로 직접 등록해 줘야 한다. 방법은 세 가지다.
@Bean으로 직접 등록
@Component로 컴포넌트 스캔에 걸리게 해서 자동 등록
@Import로 등록 (주로 @Configuration 같은 설정 클래스를 추가할 때 쓰지만, 일반 클래스도 빈으로 등록할 수 있다)
지금은 버전을 계속 바꿔 끼울 거라 테스트 클래스에 @Import를 쓰는 게 가장 편하다.
@Slf4j
@Import(AspectV1.class) // 추가
@SpringBootTest
public class AopTest {
// ...
}
이렇게 애스펙트가 빈으로 등록되면, 이전 글에서 본 자동 프록시 생성기(AnnotationAwareAspectJAutoProxyCreator)가 @Aspect를 찾아 어드바이저로 바꾸고, 포인트컷에 걸리는 빈들을 프록시로 바꿔서 스프링 컨테이너에 등록한다.
테스트를 돌려보면 아래와 같이 로그가 출력된다.
// aopInfo() 테스트
isAopProxy, orderService=true
isAopProxy, orderRepository=true
// success() 테스트
[log] void hello.aop.order.OrderService.orderItem(String)
[orderService] 실행
[log] String hello.aop.order.OrderRepository.save(String)
[orderRepository] 실행

보다시피 두 빈 모두 프록시로 바뀌었고, 각 메서드가 실행되기 직전에 [log]가 찍힌다. AOP가 잘 걸렸다. 흐름으로 그리면 이렇다.
클라이언트 → [doLog] → orderService.orderItem() → [doLog] → orderRepository.save()
@Around에 포인트컷 표현식을 직접 넣을 수도 있지만, @Pointcut을 사용해서 포인트컷을 별도의 메서드로 분리할 수도 있다.
@Slf4j
@Aspect
public class AspectV2 {
// hello.aop.order 패키지와 하위 패키지
@Pointcut("execution(* hello.aop.order..*(..))") // pointcut expression
private void allOrder() {} // pointcut signature
@Around("allOrder()")
public Object doLog(ProceedingJoinPoint joinPoint) throws Throwable {
log.info("[log] {}", joinPoint.getSignature());
return joinPoint.proceed();
}
}
@Pointcut의 규칙은 아래와 같다.
@Pointcut에 포인트컷 표현식을 넣는다.
메서드 이름과 파라미터를 합쳐서 포인트컷 시그니처(signature)라고 부른다. 여기서는 allOrder()가 포인트컷 시그니처다.
메서드의 반환 타입은 void여야 한다.
메서드 본문은 비워 둔다.
같은 애스펙트 안에서만 쓸 거면 private, 다른 애스펙트에서 참조할 거면 public을 쓴다.
어드바이스에서는 @Around("allOrder()")처럼 표현식 대신 포인트컷 시그니처를 넣으면 된다.
@Import(AspectV2.class) // AopTest의 @Import를 교체
실행 결과는 AspectV1과 완전히 같다. 하는 일은 같지만 이렇게 분리해 두면 얻는 것이 있다.
포인트컷에 allOrder라는 이름이 붙어서 "주문 관련 전부" 라는 의도가 드러난다.
하나의 포인트컷을 여러 어드바이스에서 재사용할 수 있다.
뒤에서 보듯 다른 클래스에서도 참조할 수 있다.
이제 로그 어드바이스에 더해 트랜잭션 어드바이스를 추가해 보자. 진짜 트랜잭션은 아니고 로그로 흐름만 흉내 내는 수준이다. 실제 트랜잭션은 보통 이렇게 동작한다.
핵심 로직 실행 직전에 트랜잭션 시작
핵심 로직 실행
정상 완료되면 커밋
예외가 발생하면 롤백
마지막엔 성공/실패와 관계없이 리소스 정리
@Slf4j
@Aspect
public class AspectV3 {
// hello.aop.order 패키지와 하위 패키지
@Pointcut("execution(* hello.aop.order..*(..))")
private void allOrder() {}
// 클래스 이름 패턴이 *Service
@Pointcut("execution(* *..*Service.*(..))")
private void allService() {}
@Around("allOrder()")
public Object doLog(ProceedingJoinPoint joinPoint) throws Throwable {
log.info("[log] {}", joinPoint.getSignature());
return joinPoint.proceed();
}
// hello.aop.order 패키지와 하위 패키지 이면서 클래스 이름 패턴이 *Service
@Around("allOrder() && allService()")
public Object doTransaction(ProceedingJoinPoint joinPoint) throws Throwable {
try {
log.info("[트랜잭션 시작] {}", joinPoint.getSignature());
Object result = joinPoint.proceed();
log.info("[트랜잭션 커밋] {}", joinPoint.getSignature());
return result;
} catch (Exception e) {
log.info("[트랜잭션 롤백] {}", joinPoint.getSignature());
throw e;
} finally {
log.info("[리소스 릴리즈] {}", joinPoint.getSignature());
}
}
}
새로 추가된 allService()는 패키지가 아니라 타입 이름으로 대상을 고른다. 표현식을 조각내 보면 이렇다.
| 조각 | 의미 |
|---|---|
* (맨 앞) | 반환 타입 상관없음 |
*.. | 패키지 상관없음 |
*Service | 이름이 Service로 끝나는 타입 |
.* | 그 타입의 모든 메서드 |
(..) | 파라미터 상관없음 |
쉽게 말해 OrderService, MemberService처럼 XxxService로 끝나는 타입이 전부 대상이다. 클래스뿐 아니라 인터페이스에도 적용되기 때문에 타입 이름 패턴이라고 부른다. *Servi*처럼 중간에 *를 넣는 패턴도 가능하다.
포인트컷은 &&(AND), ||(OR), !(NOT) 세 가지로 조합할 수 있다. doTransaction()에는 allOrder() && allService()를 지정했으니, hello.aop.order 패키지 아래에 있으면서 이름이 Service로 끝나는 타입에만 적용된다.
| 대상 | allOrder() | allService() | 적용되는 어드바이스 |
|---|---|---|---|
| OrderService | O | O | doLog, doTransaction |
| OrderRepository | O | X | doLog |
테스트 실행 결과는 아래와 같다.
// success() 테스트
[log] void hello.aop.order.OrderService.orderItem(String)
[트랜잭션 시작] void hello.aop.order.OrderService.orderItem(String)
[orderService] 실행
[log] String hello.aop.order.OrderRepository.save(String)
[orderRepository] 실행
[트랜잭션 커밋] void hello.aop.order.OrderService.orderItem(String)
[리소스 릴리즈] void hello.aop.order.OrderService.orderItem(String)
// exception() 테스트
[log] void hello.aop.order.OrderService.orderItem(String)
[트랜잭션 시작] void hello.aop.order.OrderService.orderItem(String)
[orderService] 실행
[log] String hello.aop.order.OrderRepository.save(String)
[orderRepository] 실행
[트랜잭션 롤백] void hello.aop.order.OrderService.orderItem(String)
[리소스 릴리즈] void hello.aop.order.OrderService.orderItem(String)
예외가 나면 커밋 대신 롤백이 찍히고, finally의 리소스 릴리즈는 어느 쪽이든 실행된다. 전체 흐름을 그려 보면 아래와 같다.

orderService에는 doLog(), doTransaction() 두 어드바이스가, orderRepository에는 doLog() 하나만 적용된 것을 확인할 수 있다.
그런데 로그가 [doLog → doTransaction] 순서로 찍히고 있다. 만약 실행 시간을 측정하는데 트랜잭션에 걸린 시간은 빼고 측정하고 싶다면, 트랜잭션이 먼저 시작되고 그 안에서 로그가 찍히도록 [doTransaction → doLog] 순서로 바뀌어야 한다. 게다가 지금 순서도 보장된 게 아니다. 같은 애스펙트 안의 같은 종류 어드바이스는 실행 순서가 정해져 있지 않아서, 실행 환경에 따라 다르게 나올 수 있다.
이 순서 문제는 V5에서 다루고, 먼저 포인트컷을 외부로 빼는 방법부터 보자.
포인트컷을 여러 애스펙트에서 공용으로 쓰고 싶다면 별도의 외부 클래스에 모아 두면 된다. 이때는 외부에서 참조해야 하므로 접근 제어자를 public으로 열어야 한다.
package hello.aop.order.aop;
public class Pointcuts {
// hello.aop.order 패키지와 하위 패키지
@Pointcut("execution(* hello.aop.order..*(..))")
public void allOrder() {}
// 클래스 이름 패턴이 *Service
@Pointcut("execution(* *..*Service.*(..))")
public void allService() {}
// allOrder && allService
@Pointcut("allOrder() && allService()")
public void orderAndService() {}
}
orderAndService()처럼 포인트컷끼리 조합한 새 포인트컷을 미리 정의해 둘 수도 있다. 이렇게 하면 어드바이스 쪽에서는 조합 조건을 매번 적을 필요 없이 이름 하나만 가져다 쓰면 된다.
@Slf4j
@Aspect
public class AspectV4Pointcut {
@Around("hello.aop.order.aop.Pointcuts.allOrder()")
public Object doLog(ProceedingJoinPoint joinPoint) throws Throwable {
log.info("[log] {}", joinPoint.getSignature());
return joinPoint.proceed();
}
@Around("hello.aop.order.aop.Pointcuts.orderAndService()")
public Object doTransaction(ProceedingJoinPoint joinPoint) throws Throwable {
try {
log.info("[트랜잭션 시작] {}", joinPoint.getSignature());
Object result = joinPoint.proceed();
log.info("[트랜잭션 커밋] {}", joinPoint.getSignature());
return result;
} catch (Exception e) {
log.info("[트랜잭션 롤백] {}", joinPoint.getSignature());
throw e;
} finally {
log.info("[리소스 릴리즈] {}", joinPoint.getSignature());
}
}
}
사용법은 패키지명을 포함한 클래스 이름 + 포인트컷 시그니처를 문자열로 지정하는 것이다. 포인트컷 표현식은 애노테이션 안의 문자열이라서 자바의 import가 적용되지 않는다. 그래서 다른 클래스의 포인트컷을 참조할 때는 패키지명까지 적어 준다.
실행 결과는 AspectV3와 완전히 같다. 포인트컷을 어디에 정의해 두고 참조하느냐만 바뀌었기 때문이다.
어드바이스는 기본적으로 실행 순서를 보장하지 않는다. 순서를 지정하려면 @Aspect 단위로 org.springframework.core.annotation.@Order를 붙여야 한다.
문제는 @Order가 어드바이스(메서드) 단위가 아니라 클래스 단위로만 적용된다는 점이다. 지금처럼 하나의 애스펙트 안에 어드바이스가 여러 개 있으면 그 사이의 순서는 보장받을 수 없다. 따라서 애스펙트를 별도의 클래스로 분리해야 한다.
지금은 [doLog → doTransaction] 순서로 찍히고 있으니, 이걸 [doTransaction → doLog]로 바꿔서 트랜잭션이 먼저 시작되고 그 안에서 로그가 남도록 해 보자.
@Slf4j
public class AspectV5Order {
@Aspect
@Order(2)
public static class LogAspect {
@Around("hello.aop.order.aop.Pointcuts.allOrder()")
public Object doLog(ProceedingJoinPoint joinPoint) throws Throwable {
log.info("[log] {}", joinPoint.getSignature());
return joinPoint.proceed();
}
}
@Aspect
@Order(1)
public static class TxAspect {
@Around("hello.aop.order.aop.Pointcuts.orderAndService()")
public Object doTransaction(ProceedingJoinPoint joinPoint) throws Throwable {
try {
log.info("[트랜잭션 시작] {}", joinPoint.getSignature());
Object result = joinPoint.proceed();
log.info("[트랜잭션 커밋] {}", joinPoint.getSignature());
return result;
} catch (Exception e) {
log.info("[트랜잭션 롤백] {}", joinPoint.getSignature());
throw e;
} finally {
log.info("[리소스 릴리즈] {}", joinPoint.getSignature());
}
}
}
}
바깥쪽 AspectV5Order에는 @Aspect가 없다. 두 어드바이스를 각각 내부 정적 클래스 LogAspect, TxAspect로 쪼개고, 거기에 @Aspect와 @Order를 붙였다. 하나의 파일에 두었을 뿐, 스프링 입장에서는 서로 다른 애스펙트 두 개다.
@Order의 숫자가 작을수록 먼저 실행된다. 여기서는 TxAspect(1) → LogAspect(2) 순서다.
내부 클래스에서 log를 쓸 수 있는 건, 바깥 클래스의 @Slf4j가 만든 static 필드 log에 정적 내부 클래스가 접근할 수 있기 때문이다.
빈으로 등록할 때는 바깥 클래스가 아니라 안쪽 클래스 각각을 지정한다.
@Import({AspectV5Order.LogAspect.class, AspectV5Order.TxAspect.class})
테스트 실행 결과는 아래와 같다.
// success() 테스트
[트랜잭션 시작] void hello.aop.order.OrderService.orderItem(String)
[log] void hello.aop.order.OrderService.orderItem(String)
[orderService] 실행
[log] String hello.aop.order.OrderRepository.save(String)
[orderRepository] 실행
[트랜잭션 커밋] void hello.aop.order.OrderService.orderItem(String)
[리소스 릴리즈] void hello.aop.order.OrderService.orderItem(String)

이번엔 트랜잭션 어드바이스가 먼저 실행되어, 로그를 포함한 안쪽 전체를 트랜잭션이 감싸는 구조가 되었다. 의도한 순서를 이제는 보장받을 수 있다는 점이 V3와의 차이다.
지금까지는 @Around만 썼지만, 어드바이스에는 여러 종류가 있다.
| 어드바이스 | 실행 시점 |
|---|---|
| @Around | 메서드 호출 전후. 가장 강력하다. 조인 포인트 실행 여부 선택, 전달 값 변환, 반환 값 변환, 예외 변환 등이 모두 가능 |
| @Before | 조인 포인트 실행 이전 |
| @AfterReturning | 조인 포인트가 정상 완료된 후 |
| @AfterThrowing | 메서드가 예외를 던진 경우 |
| @After | 정상이든 예외든 관계없이 실행 (finally) |
@Slf4j
@Aspect
public class AspectV6Advice {
@Around("hello.aop.order.aop.Pointcuts.orderAndService()")
public Object doTransaction(ProceedingJoinPoint joinPoint) throws Throwable {
try {
// @Before
log.info("[around][트랜잭션 시작] {}", joinPoint.getSignature());
Object result = joinPoint.proceed();
// @AfterReturning
log.info("[around][트랜잭션 커밋] {}", joinPoint.getSignature());
return result;
} catch (Exception e) {
// @AfterThrowing
log.info("[around][트랜잭션 롤백] {}", joinPoint.getSignature());
throw e;
} finally {
// @After
log.info("[around][리소스 릴리즈] {}", joinPoint.getSignature());
}
}
@Before("hello.aop.order.aop.Pointcuts.orderAndService()")
public void doBefore(JoinPoint joinPoint) {
log.info("[before] {}", joinPoint.getSignature());
}
@AfterReturning(value = "hello.aop.order.aop.Pointcuts.orderAndService()", returning = "result")
public void doReturn(JoinPoint joinPoint, Object result) {
log.info("[return] {} return={}", joinPoint.getSignature(), result);
}
@AfterThrowing(value = "hello.aop.order.aop.Pointcuts.orderAndService()", throwing = "ex")
public void doThrowing(JoinPoint joinPoint, Exception ex) {
log.info("[ex] {} message={}", joinPoint.getSignature(), ex.getMessage());
}
@After(value = "hello.aop.order.aop.Pointcuts.orderAndService()")
public void doAfter(JoinPoint joinPoint) {
log.info("[after] {}", joinPoint.getSignature());
}
}
doTransaction()의 주석을 보자. try 블록의 proceed() 앞이 @Before, 뒤가 @AfterReturning, catch가 @AfterThrowing, finally가 @After의 자리다. 즉 @Around 하나로 다른 어드바이스가 하는 일을 전부 할 수 있고, 나머지 어드바이스들은 @Around의 기능 중 일부만 떼어낸 것이라고 보면 된다.
테스트 결과는 아래와 같다.
// success() 테스트
[around][트랜잭션 시작] void hello.aop.order.OrderService.orderItem(String)
[before] void hello.aop.order.OrderService.orderItem(String)
[orderService] 실행
[orderRepository] 실행
[return] void hello.aop.order.OrderService.orderItem(String) return=null
[after] void hello.aop.order.OrderService.orderItem(String)
[around][트랜잭션 커밋] void hello.aop.order.OrderService.orderItem(String)
[around][리소스 릴리즈] void hello.aop.order.OrderService.orderItem(String)
// exception() 테스트
[around][트랜잭션 시작] void hello.aop.order.OrderService.orderItem(String)
[before] void hello.aop.order.OrderService.orderItem(String)
[orderService] 실행
[orderRepository] 실행
[ex] void hello.aop.order.OrderService.orderItem(String) message=예외 발생!
[after] void hello.aop.order.OrderService.orderItem(String)
[around][트랜잭션 롤백] void hello.aop.order.OrderService.orderItem(String)
[around][리소스 릴리즈] void hello.aop.order.OrderService.orderItem(String)
이번엔 AspectV6Advice 하나만 등록했고 모든 어드바이스가 orderAndService()만 대상으로 하므로, orderRepository에는 아무 어드바이스도 걸리지 않았다. orderItem()은 반환 타입이 void라서 return=null로 찍힌다.
모든 어드바이스는 첫 번째 파라미터로 org.aspectj.lang.JoinPoint를 받을 수 있다. 필요 없으면 생략해도 된다. 단, @Around는 반드시 ProceedingJoinPoint를 써야 한다. ProceedingJoinPoint는 JoinPoint의 하위 타입으로, 이름 그대로 진행시킬 수 있는 조인 포인트다. proceed()가 있어야 다음 대상을 호출할 수 있기 때문이다.
| 메서드 | 반환 |
|---|---|
getArgs() | 메서드에 전달된 인수 |
getThis() | 프록시 객체 |
getTarget() | 실제 대상 객체 (원본) |
getSignature() | 호출되는 메서드의 시그니처 정보 |
toString() | 호출되는 메서드에 대한 설명 |
getThis()가 프록시, getTarget()이 원본이라는 점은 개념 글에서 본 프록시 구조 그대로다.
| 메서드 | 기능 |
|---|---|
proceed() | 다음 어드바이스나 타겟을 호출 |
@Before("hello.aop.order.aop.Pointcuts.orderAndService()")
public void doBefore(JoinPoint joinPoint) {
log.info("[before] {}", joinPoint.getSignature());
}
@Around와 달리 작업 흐름을 바꿀 수 없다.
proceed() 자체를 쓰지 않는다. 메서드가 끝나면 자동으로 다음 타겟이 호출된다. (물론 @Before 안에서 예외가 발생하면 다음 코드는 호출되지 않는다.)
@AfterReturning(value = "hello.aop.order.aop.Pointcuts.orderAndService()", returning = "result")
public void doReturn(JoinPoint joinPoint, Object result) {
log.info("[return] {} return={}", joinPoint.getSignature(), result);
}
returning 속성에 적은 이름과 어드바이스 메서드의 파라미터 이름이 같아야 반환값이 바인딩된다.
파라미터 타입과 맞는 값을 반환하는 메서드에만 실행된다. 부모 타입을 지정하면 모든 자식 타입이 포함된다. 예를 들어 위 코드의 Object result를 String result로 바꾸면, void를 반환하는 orderItem()에는 실행되지 않는다.
@Around와 달리 반환 객체를 다른 객체로 바꿀 수는 없다. 반환된 객체의 내부 값을 조작하는 것은 가능하다. 반환 객체 자체를 바꾸고 싶으면 @Around를 써야 한다.
@AfterThrowing(value = "hello.aop.order.aop.Pointcuts.orderAndService()", throwing = "ex")
public void doThrowing(JoinPoint joinPoint, Exception ex) {
log.info("[ex] {} message={}", joinPoint.getSignature(), ex.getMessage());
}
throwing 속성에 적은 이름과 파라미터 이름이 같아야 예외가 바인딩된다.
파라미터 타입과 맞는 예외에만 실행된다. 부모 타입을 지정하면 모든 자식 타입이 포함된다. 여기서는 Exception이라 IllegalStateException도 잡힌다.
정상 반환이든 예외든 모두 처리한다.
일반적으로 리소스를 해제하는 데 쓴다.
조인 포인트를 실행할지 말지 선택: joinPoint.proceed() 호출 여부
전달 값 변환: joinPoint.proceed(args[])
반환 값 변환
예외 변환
트랜잭션처럼 try ~ catch ~ finally가 모두 필요한 구문 처리
첫 번째 파라미터는 반드시 ProceedingJoinPoint
proceed()를 여러 번 호출할 수도 있다 (재시도)
스프링 5.2.7 버전부터, 같은 @Aspect 안에서 같은 조인 포인트에 대해 다음 우선순위가 정해졌다.
@Around→@Before→@After→@AfterReturning→@AfterThrowing
이건 들어갈 때의 순서다. 호출 순서와 리턴 순서는 반대라는 점에 주의하자. 우선순위가 높은 어드바이스일수록 바깥쪽을 감싸기 때문에, 들어갈 때는 먼저 실행되고 나올 때는 나중에 실행된다.

들어갈 때: around(1) → before(2) → 타겟
나올 때: 예외 시 afterThrowing(3) 또는 정상 시 afterReturning(4) → after(5) → around(6)
물론 하나의 @Aspect 안에 같은 종류의 어드바이스가 2개 이상 있으면 여전히 순서가 보장되지 않는다. 이때는 V5에서 본 것처럼 애스펙트를 분리하고 @Order를 적용한다.
@Around 하나면 다른 어드바이스가 하는 일을 전부 할 수 있다. 그런데도 굳이 여러 종류가 있는 이유는 무엇일까? 아래 코드를 보자.
@Around("hello.aop.order.aop.Pointcuts.orderAndService()")
public void doBefore(ProceedingJoinPoint joinPoint) {
log.info("[before] {}", joinPoint.getSignature());
}
의도는 "타겟 호출 전에 로그를 찍고 싶다" 였다. 그런데 이 코드는 타겟을 호출하지 않는다. @Around는 반드시 joinPoint.proceed()를 직접 호출해야 다음 대상이 실행되는데, 그걸 빼먹었기 때문이다. 그 결과 주문 로직 자체가 실행되지 않는 치명적인 버그가 된다.
같은 일을 @Before로 하면 이렇다.
@Before("hello.aop.order.aop.Pointcuts.orderAndService()")
public void doBefore(JoinPoint joinPoint) {
log.info("[before] {}", joinPoint.getSignature());
}
@Before는 proceed()를 신경 쓸 필요가 없다. 메서드가 끝나면 자동으로 타겟이 호출되므로, 애초에 위와 같은 실수를 할 수가 없다.
@Around가 가장 강력한 건 맞다. 하지만 강력하다는 건 그만큼 실수할 여지도 많다는 뜻이다. 반면 @Before, @After는 할 수 있는 일이 적지만, 그 덕분에
@Before라는 애노테이션 하나만 봐도 "이 코드는 타겟 실행 전에 한정해서 뭔가를 하는구나" 가 바로 보인다.
만약 @Around로 작성했는데, 나중에 다른 개발자가 코드를 고치다가 proceed() 호출을 빼먹었다면? 큰 장애로 이어졌을 것이다. 처음부터 @Before를 썼다면 이런 문제 자체가 생기지 않는다.
제약은 실수를 미연에 방지하는 일종의 가이드다. 제약 덕분에 역할이 명확해지고, 코드를 읽는 사람이 고민해야 할 범위도 줄어든다. 그러니 꼭 필요한 경우가 아니라면 목적을 달성할 수 있는 어드바이스 중 가장 제약이 많은 것을 고르는 게 좋다.
안녕하세요, 개념 글에서 본 용어가 코드 어디에 해당하는지 표로 이어 주셔서 정리가 잘 됐어요. 애스펙트를 붙이기 전과 후에 AopUtils.isAopProxy 결과로 프록시 여부를 직접 확인하는 방식이 이해하기 좋았어요. 같은 클래스 안에서 메서드를 내부 호출하면 AOP가 안 걸리는 문제도 이번 정리에서 다뤄 보셨는지 궁금해요. 저도 백엔드를 공부하면서 Velog에 실험·트러블슈팅 기록을 올리고 있어요. 좋은 글 잘 읽고 팔로우하고 가요. 시간 되실 때 제 글도 한번 봐 주세요. 감사합니다!