스프링 AOP 구현

💡 김영한님의 스프링 핵심 원리 고급편 강의를 듣고 정리한 내용입니다.

@Aspect 사용하여 AOP 구현

@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);
    }
}

@Slf4j
@Repository
public class OrderRepository {

    public String save(String itemId) {
        log.info("[orderRepository] 실행");
        //저장 로직
        if (itemId.equals("ex")) {
            throw new IllegalStateException("예외 발생!");
        }
        return "ok";
    }
}

@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();
    }
}

@Slf4j
@SpringBootTest
@Import(AspectV1.class)
public class AopTest {

    @Autowired
    OrderService orderService;

    @Autowired
    OrderRepository orderRepository;

    ...

    @Test
    void success() {
        orderService.orderItem("itemA");
    }

    ...

}

joinPoint.proceed()

joinPoint.proceed()의 리턴은 주로 타깃 메서드의 결과다.

타깃 메서드의 결과가 있다면 result를 가지고 여러가지를 할 수 있다.

예를 들어 결과를 로깅할 수도 있고, 결과로 받은 값을 변환해서 다시 클라이언트에 전달해줄 수도 있다.

또한 결과로 받은 값에 대해 검증을 해줄 수도 있다.

return 하는곳

return 하게 되면 해당 타깃 메서드를 호출한 클라이언트에게 전달된다.

예를 들어 타깃 메서드가 반환값이 있는 메서드라면 이를 호출한 클라이언트에서는 반환값을 받아서 처리해야 하기 때문이다.

자동 프록시 등록 과정

스프링 부트 자동 설정으로 "AnnotationAwareAspectJAutoProxyCreator" 이라는 자동 프록시 생성기가 빈 등록되어 있는데, 이 자동 프록시 생성기가 @Aspect가 붙은 클래스를 보고 Advisor(어드바이저)로 변환해 저장해준다. 그리고 이 Advisor(어드바이저)를 보고 포인트컷의 대상이 되는 것들을 "ProxyFactory"에 인자로 넘겨 자동으로 프록시를 생성하고 적용해준다.

 

ProceedingJoinPoint는 무슨 연관관계가 있어서 타겟에 대한 정보들을 알고 있는지?

ProceedingJoinPoint

결국 프록시이기 때문에 타켓에 대한 정보를 가지고 있어야 호출을 할 수 있다. 타켓에 대한 정보가 있으니 이 정보들을 사용하기 편리하게 ProceedingJoinPoint 같은 객체를 만들 수 있다. 참고로 스프링 AOP는 프록시 객체를 생성하고, 이 프록시 객체는 원본 객체의 메서드를 호출하는 동안 추가적인 동작을 수행한다. 이 프록시 객체가 메서드를 호출할 때 ProceedingJoinPoint 객체를 생성하고 이를 advice에 전달한다. 따라서 ProceedingJoinPoint는 프록시가 메서드를 호출하는 시점의 정보를 가지게 된다.

실행 - success()

테스트를 실행해보면 다음과 같이 로그가 잘 출력되는 것을 확인할 수 있다.

[log] void hello.aop.order.OrderService.orderItem(String)
[orderService] 실행
[log] String hello.aop.order.OrderRepository.save(String)
[orderRepository] 실행

실행 흐름

AOP - 포인트컷 분리하기

@Around에 포인트컷 표현식을 직접 넣을 수 도 있지만, @Pointcut 애노테이션을 사용해서 별도로 분리할 수 도 있다.

@Slf4j
@Aspect
public class AspectV2 {

    //hello.aop.order 패키지와 하위 패키지
    @Pointcut("execution(* hello.aop.order..*(..))")
    private void allOrder(){} //pointcut signature

    @Around("allOrder()")
    public Object doLog(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("[log] {}", joinPoint.getSignature()); //join point 시그니처
        return joinPoint.proceed();
    }
}

@Pointcut

@Pointcut에 포인트컷 표현식을 사용한다.

메서드 이름과 파라미터를 합쳐서 포인트컷 시그니처(signature)라 한다.
메서드의 반환 타입은 void여야 한다. 코드 내용은 비워둔다.

포인트컷 시그니처는 allOrder()이다. 이름 그대로 주문과 관련된 모든 기능을 대상으로 하는 포인트컷이다.

@Around 어드바이스에서는 포인트컷을 직접 지정해도 되지만, 포인트컷 시그니처를 사용해도 된다.

여기서는 @Around("allOrder()")를 사용한다

 

private, public 같은 접근 제어자는 내부에서만 사용하면 private을 사용해도 되지만, 다른 애스팩트에서 참고하려면 public을 사용해야 한다. 결과적으로 AspectV1과 같은 기능을 수행한다.

 

이렇게 분리하면 하나의 포인트컷 표현식을 여러 어드바이스에서 함께 사용할 수 있다.

그리고 다른 클래스에 있는 외부 어드바이스에서도 포인트컷을 함께 사용할 수 있다.

 

실행 - success()

테스트를 실행해보면 다음과 같이 로그가 잘 출력되는 것을 확인할 수 있다.

[log] void hello.aop.order.OrderService.orderItem(String) 
[orderService] 실행
[log] String hello.aop.order.OrderRepository.save(String) 
[orderRepository] 실행

AOP - 어드바이스 추가 구현

앞서 로그를 출력하는 기능에 추가로 트랜잭션을 적용하는 코드도 추가해보자.

여기서는 진짜 트랜잭션을 실행하는 것은 아니다. 기능이 동작한 것 처럼 로그만 남기겠다.

@Slf4j
@Aspect
public class AspectV3 {

    //hello.aop.order 패키지와 하위 패키지
    @Pointcut("execution(* hello.aop.order..*(..))")
    private void allOrder(){} //pointcut signature

    //클래스 이름 패턴이 *Service
    @Pointcut("execution(* *..*Service.*(..))")
    private void allService(){}

    @Around("allOrder()")
    public Object doLog(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("[log] {}", joinPoint.getSignature()); //join point 시그니처
        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());
        }
    }
}

allOrder() 포인트컷은 hello.aop.order 패키지와 하위 패키지를 대상으로 한다. allService() 포인트컷은 타입 이름 패턴이 *Service를 대상으로 하는데 쉽게 이야기해서 XxxService처럼 Service로 끝나는 것을 대상으로 한다. *Servi*과 같은 패턴도 가능하다. 여기서 타입 이름 패턴이라고 한 이유는 클래스, 인터페이스에 모두 적용되기 때문이다.

@Around("allOrder() && allService()")

• 포인트컷은 이렇게 조합할 수 있다. &&(AND), ||(OR), !(NOT) 3가지 조합이 가능하다.
• hello.aop.order 패키지와 하위 패키지 이면서 타입 이름 패턴이 *Service인 것을 대상으로 한다.
• 결과적으로 doTransaction() 어드바이스는 OrderService에만 적용된다.
• doLog() 어드바이스는 OrderService, OrderRepository에 모두 적용된다.

포인트컷이 적용된 AOP 결과는 다음과 같다.

• orderService: doLog(), doTransaction() 어드바이스 적용
• orderRepository: 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)

포인트컷 공용으로 사용하기

포인트컷을 공용으로 사용하기 위해 별도의 외부 클래스에 모아두어도 된다.

참고로 외부에서 호출할 때는 포인트컷의 접근 제어자를 public으로 열어두어야 한다.

public class Pointcuts {

    //hello.aop.order 패키지와 하위 패키지
    @Pointcut("execution(* hello.aop.order..*(..))")
    public void allOrder(){} //pointcut signature

    //클래스 이름 패턴이 *Service
    @Pointcut("execution(* *..*Service.*(..))")
    public void allService(){}

    //allOrder && allService
    @Pointcut("allOrder() && allService()")
    public void orderAndService() {}
}

orderAndService(): allOrder() 포인트컷와 allService() 포인트컷을 조합해서 새로운 포인트컷을 만들었다.

@Slf4j
@Aspect
public class AspectV4Pointcut {

    @Around("hello.aop.order.aop.Pointcuts.allOrder()")
    public Object doLog(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("[log] {}", joinPoint.getSignature()); //join point 시그니처
        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());
        }
    }
}

사용하는 방법은 패키지명을 포함한 클래스 이름과 포인트컷 시그니처를 모두 지정하면 된다.

• hello.aop.order.aop.Pointcuts.allOrder()
• 패키지명.클래스이름

포인트컷을 여러 어드바이스에서 함께 사용할 때 이 방법을 사용하면 효과적이다.

AOP - 어드바이스 순서 지정하기

어드바이스는 기본적으로 순서를 보장하지 않는다. 순서를 지정하고 싶으면 @Aspect 적용 단위로 org.springframework.core.annotation.@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()); //join point 시그니처
            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());
            }
        }
    }
}

하나의 애스펙트 안에 있던 어드바이스를 LogAspect, TxAspect 애스펙트로 각각 분리했다.

그리고 각 애스펙트에 @Order 애노테이션을 통해 실행 순서를 적용했다. 참고로 숫자가 작을수록 먼저 실행된다.

실행 결과

[트랜잭션 시작] 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)

 

어드바이스 종류

@Slf4j
@Aspect
public class AspectV6Advice {

    @Around("hello.aop.order.aop.Pointcuts.orderAndService()")
    public Object doTransaction(ProceedingJoinPoint joinPoint) throws Throwable {

        try {
            //@Before
            log.info("[트랜잭션 시작] {}", joinPoint.getSignature());
            Object result = joinPoint.proceed();
            //@AfterReturning
            log.info("[트랜잭션 커밋] {}", joinPoint.getSignature());
            return result;
        } catch (Exception e) {
            //@AfterThrowing
            log.info("[트랜잭션 롤백] {}", joinPoint.getSignature());
            throw e;
        } finally {
            //@After
            log.info("[리소스 릴리즈] {}", 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={}", ex);
    }

    @After(value = "hello.aop.order.aop.Pointcuts.orderAndService()")
    public void doAfter(JoinPoint joinPoint) {
        log.info("[after] {}", joinPoint.getSignature());
    }
}

어드바이스 종류

@Before

• 조인 포인트 실행 전

@AfterReturning

• 메서드 실행이 정상적으로 반환될 때 실행

@AfterThrowing

• 메서드 실행이 예외를 던져서 종료될 때 실행

@After

• 메서드 실행이 종료되면 실행된다. (finally를 생각하면 된다.)
• 정상 및 예외 반환 조건을 모두 처리한다.

• 일반적으로 리소스를 해제하는 데 사용한다.

@Around

• 메서드의 실행의 주변에서 실행된다.
• 메서드 실행 전후에 작업을 수행한다. 가장 강력한 어드바이스
• 어드바이스의 첫 번째 파라미터는 ProceedingJoinPoint를 사용해야 한다.
• proceed()를 통해 대상을 실행한다.
• proceed()를 여러번 실행할 수도 있음(재시도) 

참고 정보 획득

모든 어드바이스는 org.aspectj.lang.JoinPoint를 첫번째 파라미터에 사용할 수 있다. (생략해도 된다.)

단 @Around는 ProceedingJoinPoint을 사용해야 한다.

참고로 ProceedingJoinPoint는 org.aspectj.lang.JoinPoint의 하위 타입이다.

JoinPoint 인터페이스의 주요 기능

• getArgs(): 메서드 인수를 반환합니다
• getThis(): 프록시 객체를 반환합니다.
• getTarget(): 대상 객체를 반환합니다.
• getSignature(): 조언되는 메서드에 대한 설명을 반환합니다.
• toString(): 조언되는 방법에 대한 유용한 설명을 인쇄합니다.

ProceedingJoinPoint 인터페이스의 주요 기능

• proceed(): 다음 어드바이스나 타켓을 호출한다.

실행흐름

순서

• 스프링은 5.2.7 버전부터 동일한 @Aspect안에서 동일한 조인포인트의 우선순위를 정했다.
• 실행 순서: @Around, @Before, @After, @AfterReturning, @AfterThrowing
• 어드바이스가 적용되는 순서는 이렇게 적용되지만, 호출 순서와 리턴 순서는 반대라는 점을 알아두자.
• 물론 @Aspect안에 동일한 종류의 어드바이스가 2개 있으면 순서가 보장되지 않는다.
• 이 경우 앞서 배운 것 처럼 @Aspect를 분리하고 @Order를 적용하자.