[스프링 핵심 원리 - 고급편] #11. 스프링 AOP 구현(2)

[Pracrobo]

스프링 AOP 구현4 - 포인트 컷 참조

다음과 같이 포인트컷을 공용으로 사용하기 위해 별도의 외부 클래스에 모아두어도 된다. 참고로 외부에서 호출할때는 포인트컷의 접근 제어자를 'public'으로 열어두어야 한다.

pointcut

package hello.aop.order.aop;

import org.aspectj.lang.annotation.Pointcut;

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() {}
}

AspectV4Pointcut

package hello.aop.order.aop;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.factory.annotation.Autowired;

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

    }

    //hello.aop.order 패키지와 하위 패키지면서 클래스 이름 패턴이 *Service
    @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());
        }
    }

}

사용하는 방법은 패키지명을 포함한 클래스 이름과 포인트컷 시그니처를 모두 지정하면 된다.
포인트컷을 여러 어드바이스에서 함께 사용할 때 이 방법을 사용하면 효과적이다.

AopTest : 수정

@Import(AspectV4Pointcut.class) 
@SpringBootTest
public class AopTest {
    
}

• AspectV4Pointcut.class를 실행하기 위해서 다음 처리를 하자.
• @Import(AspectV3.class) : 주석처리
• @Import(AspectV4Pointcut.clasS) : 추가

실행 결과는 같다.

스프링 AOP 구현 5 - 어드바이스 순서

어드바이스는 기본적으로 순서를 보장하지 않는다. 순서를 지정하고 싶으면 @Aspect 적용 단위로 org.springframework.core.annotation.@Order 애노테이션을 적용해야 한다. 문제는 이것을 어드바이스 단위가 아니라 클래스 단위로 적용할 수 있다는 점이다.
그래서 지금처럼 하나의 Aspect에 여러 어드바이스가 있으면 순서를 보장받을 수 없다. 따라서 "Aspect를 별도의 클래스로 분리해야 한다."

현재 로그를 남기는 순서가 아마도 [doLog() -> doTransaction()] 이 순서로 남을 것이다.
(참고로 이 순서로 실행되지 않는 분도 있을 수 있다. JVM이나 실행환경에 따라 달라질 수 있다.)
로그를 남기는 순서를 바꾸어서 [doTransaction() -> doLog()] 트랜잭션이 먼저 처리되고 이후에 로그가 남도록 변경해보자.

AspectV5Order

package hello.aop.order.aop;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.core.annotation.Order;

@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 {
        //hello.aop.order 패키지와 하위 패키지면서 클래스 이름 패턴이 *Service
        @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());
            }
        }
    }


}

AopTest

package hello.aop;

import hello.aop.order.OrderRepository;
import hello.aop.order.OrderService;
import hello.aop.order.aop.AspectV5Order;
import lombok.extern.slf4j.Slf4j;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import org.springframework.aop.support.AopUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.annotation.Import;

@Slf4j
@SpringBootTest
@Import({AspectV5Order.LogAspect.class, AspectV5Order.TxAspect.class})
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() {
        orderService.orderItem("ex");
        Assertions.assertThatThrownBy(() -> orderService.orderItem("ex")).isInstanceOf(IllegalStateException.class);
    }
}

@Import({AspectV5Order.LogAspect.class, AspectV5Order.TxAspect.class}) 부분 추가

실행

트랜잭션 어드바이스가 먼저 실행된다.

• 들어오는 순서랑 나가는 순서가 다르다.

스프링 AOP 구현6 - 어드바이스 종류

어드바이스는 앞서 살펴본 @Around 외에도 여러가지 종류가 있다.

어드바이스 종류

• @Around : 메서드 호출 전후에 수행, 가장 강력한 어드바이스, 조인 포인트 실행 여부 선택, 반환 값 변환, 예외 변환 등이 가능
• @Before : 조인 포인트 실행 이전에 실행
• @After Returning : 조인 포인트가 정상 완료 후 실행
• @After Throwing : 메서드가 예외를 던지는 경우 실행
• @After : 조인 포인트가 정상 또는 예외에 관계없이 실행(finally)

예제를 만들면서 학습해보자.

package hello.aop.order.aop;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@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={}", joinPoint.getSignature(),
                ex.getMessage());
    }

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

    }
}

• doTransaction() 메서드에 남겨둔 주석을 보자
• 복잡해 보이지만 사실 @around를 제외한 나머지 어드바이스들은 @around가 할 수 있는 일의 일부만 제공할 뿐이다. 따라서 @around 어드바이스만 사용해도 필요한 기능을 모두 수행할 수 있다.

참고 정보 획득

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

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

JoinPoint 인터페이스의 주요 기능

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

ProceedingJoinPoint 인터페이스의 주요 기능

• proceed() : 다음 어드바이스나 타겟을 호출한다.
  추가로 호출시 전달한 매개변수를 파라미터를 통해서도 전달 받을 수 있는데 이 부분은 뒤에서 설명한다.

어드바이스 종류

@before
조인 포인트 실행 전

@Before("hello.aop.order.aop.Pointcuts.orderAndService()")
public void doBefore(JoinPoint joinPoint) {
    log.info("[before] {} ", joinPoint.getSignature());
}

• @around와 다르게 작업 흐름을 변경할 수는 없다.
• @around는 ProceedingJoinPoint.proceed()를 호출해야 다음 대상이 호출된다. 만약 호출하지 않으면 다음 대상이 호출되지 않는다.
• 반면에 @before 는 ProceedingJoinPoint.proceed()자체를 사용하지 않는다. 메서드 종료시 자동으로 다음 타겟이 호출된다. 물론 예외가 발생하면 다음 코드가 호출되지는 않는다.

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

@AfterReturing(value = "hello.aop.order.aop.Pointcuts.orderAndService()", throwing="ex")
public void doReturn(JoinPoint joinPoint, Object result ) {
    log.info("[return] {} return={}", joinPoint.getSignature(), result);
}

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

@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

• 메서드 실행이 종료되면 실행된다.
• 정상 및 예외 반환 조건을 모두 처리한다.
• 일반적으로 리소스를 해제하는데 사용한다.

@around

• 메서드의 실행의 주변에서 실행된다. 메서드 실행 전후에 작업을 수행한다.
• 가장 강력한 어드바이스
  • 조인 포인트 실행 여부 선택 joinPoint.proceed() 호출 여부 선택
  • 전달 값 변환 : joinPoint.proceed(args[])
  • 반환 값 변환
  • 예외 변환
  • 트랜잭션처럼 trycatchfinally 모두 들어가는 구문 처리 가능
• 어드바이스의 첫번째 파라미터는 ProceedingJoinPoint를 사용해야 한다.
• proceed()를 통해 대상을 실행한다.
• proceed()를 여러번 실행할 수 도 있다.

AopTest - 변경

@Import(AspectV6Advice.class)
@SpringBootTest
public class AopTest{
    
}

• AspectV6Order를 실행하기 위해서 다음 처리ㄹ를 한다.
• @import({AspectV5Order.LogAspect.class, AspectV5Order.TxAspect.class}) 주석처리
• @import(AspectV6Advice.class)추가

실행

순서

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

@around 외에 다른 어드바이스가 존재하는 이유
@around하나만 있어도 모든 기능을 수행할 수 있다. 그런데 다른 어드바이스들이 존재하는 이유는 무엇일까?

 @Around("hello.aop.order.aop.Pointcuts.orderAndService()")
 public void doBefore(ProceedingJoinPoint joinPoint) {
    log.info("[before] {}", joinPoint.getSignature());
}

이 코드의 문제점을 찾을 수 있겠는가? 이 코드는 타켓을 호출하지 않는 문제가 있다.
이 코드를 개발한 의도는 타켓 실행 전에 로그를 출력하는 것이다. 그런데 '@around'는 항상
joinPoint.proceed()를 호출해야 한다. 만약 실수로 호출하지 않으면 타켓이 호출되지 않는 치명적인 버그가 발생한다.

 @Before("hello.aop.order.aop.Pointcuts.orderAndService()")
 public void doBefore(JoinPoint joinPoint) {
    log.info("[before] {}", joinPoint.getSignature());
 }

@before는 joinPoint.proceed()를 호출하는 고민을 하지 않아도 된다.
@around가 가장 넓은 기능을 제공하는 것은 맞지만, 실수할 가능성이 있다.
반면에 @before, @after같은 어드바이스는 기능은 적지만 실수할 가능성이 낮고, 코드도 단순하다.
그리고 가장 중요한 점이 있는데, 바로 이 코드를 작성한 의도가 명확하게 드러난다는 점이다.
@before 애노테이션을 보는 순간 타겟실행전에 한정해서 어떤 일을 하는 코드구나 라는 것이 드러난다.

좋은 설계는 제약이 있는 것이다
좋은 설계는 제약이 있는 것이다.
@around만 있으면 되는데 왜 제약을 두는가? 제약은 실수를 미연에 방지한다.
일종의 가이드 역할을 한다. 만약 @around를 사용했는데 중간에 다른 개발자가 해당 코드를 수정해서 호출하지 않았다면?
큰 장애가 발생했을 것이다. 처음부터 @before를 사용했다면 이런 문제 자체가 발생하지 않는다.
제약 덕분에 역할이 명확해진다. 다른 개발자도 이 코드를 보고 고민해야 하는 범위가 줄어들고 코드의 의도도 파악하기
쉽다