Spring | AOP에 대해 알아보자 !!

1. AOP의 정의 및 원리

---

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

- 관점 지향은 어떤 로직을 기준으로 핵심적인 관점, 부가적인 관점으로 나누어서 보고 그 관점을 기준으로 모듈화하는 것

 

핵심적인 관점은 비즈니스 로직으로 볼 수 있고, 부가적인 관점은 핵심 로직을 실행하기 위해 행해지는 데이터베이스 연결, 로깅, 파일 입출력 등이 있다.

 

AOP에서 각 관점을 기준으로 로직을 모듈화한다는 것은 코드들을 부분적으로 나누어서 모듈화하겠다는 의미이다. 이때, 소스 코드상에서 다른 부분에 계속 반복해서 쓰는 코드들을 발견할 수 있는 데 이것을 흩어진 관심사 (Crosscutting Concerns)라고 한다.

 

이와 같이 AOP를 사용하면 코드의 가독성과 유지 보수성을 높일 수 있다.

 

📌 AOP의 이해를 돕기 위한 예시

 

예를 들어, 첫번째 그림에서 Class A, B, C에는 공통적인 내용이 포함되어 있다. 이러한 공통적인 내용을 색깔로 구분하여 표현하였으며, 이러한 공통적인 내용에는 메서드나 필드 등이 있다. 공통적인 부분이 다른 클래스들 내부에 존재한다면, 같은 블록을 수정하는데 여러 클래스의 블록들을 따로 수정해야 하는 상황이 발생한다.

 

이와 같은 문제는 SOLID원칙을 위배하며 유지보수를 어렵게 만든다. 이때의 주황, 파랑, 빨강 블록을 흩어진 관심사(Crosscutting Concerns)라고 한다. 이러한 흩어진 관심사들을 모듈화하고 해당 기능이 필요한 블럭에 적용해주는 것이 AOP의 원리이다. 이때, 모듈화 시켜놓은 블럭을 Aspect라고 한다. 

 

두번째 그림에서 계좌이체, 대출승인, 이자계산 등은 핵심로직에 해당된다고 볼 수 있고, 로깅이나 보안, 트랜잭션 등의 공통되는 기능들은 부가 기능이라고 볼 수 있다. 

 

---

2. AOP 용어 정리

---

1) Advice: 부가기능을 수행할 메서드 생성

2) Pointcut: 부가 기능을 적용할 핵심로직을 결정합니다.

3) Aspect: 부가 기능과 해당 부가 기능을 어디에 적용할지 정의한 것입니다. (클래스 생성 Advice + Pointcut)

4) Joinpoint : 부가기능이 핵심로직 실행전에 실행될지 후에 실행될지를 결정합니다.

 

[ex] 로그인 메서드가 있다. 메서드의 이름은 login() 이고 이 메서드는 핵심로직이다. 로그인 메서드가 실행될 때 마다 로그를 남기고 싶다면 (>> 부가기능), 로그를 남길 메서드를 만들어야 한다. 이것을 부가로직이라고 한다. 

 

🖥️ 핵심로직, 부가로직

login(){} // 핵심로직

log(){ // 부가로직
	System.out.println("로그 실행됨");
}

 

이제 부가로직에 pointcut을 적용하여 login() 메서드가 실행될때마다 발동하게 한다.

 

pointcut(login()) // point cut : 부가로직 실행할 핵심로직 결정
log(){
	System.out.println("로그 실행됨");
}

 

마지막으로 joinpoint를 통해서 언제 실행될지 결정한다.

 

Before // join point : 핵심 로직 전 or 후 결정
pointcut(login())
log(){
	System.out.println("로그 실행됨");
}

 

위 방식으로 작성하게 되면 join() 메서드가 실행될때 로그를 남길수는 없다. 그래서 어노테이션을 만드는 것이 좋다. 아래와 같이 적용하면 @MyLog 어노테이션이 붙어있으면 로그가 실행한다.

 

@MyLog
login(){} // login 메서드가 실행될 때

@MyLog
join(){} // join 메서드가 실행될 때

After
pointcut(@MyLog)
log(){
	System.out.println("로그 실행됨");
}

 

---

3. AOP 적용방법 3가지

---

1) 첫번째 방법 - 어노테이션 생성

 

• 어노테이션을 만들고 그 에너테이션을 PointCut으로 등록한다.
• Advice를 만든다. (메서드 행위)
• JoinPoint를 적용한다

 

위의 예시에서 설명한 방법과 같다.

 

@Target(ElementType.METHOD) // method에 부착가능
@Retention(RetentionPolicy.RUNTIME) // 런타임 시점까지 어노테이션의 메모리를 가져감
public @interface Hello {
}

@Aspect
@Component
public class HelloAdvice {

    // 포인트 컷을 어노테이션에 적용
    @Pointcut("@annotation(Hello)")
    public void hello(){}
    
    // JoinPoint 적용
    @Before("hello()")
    public void helloAdvice(JoinPoint jp) throws Throwable {
        Object[] args = jp.getArgs();
        
        if(args.length < 1){
            System.out.println("아무개님 안녕");
        }
        else{
            for (Object arg : args) {
                if(arg instanceof String){
                    String username = (String) arg;
                    System.out.println(username+"님 안녕");
                }
            }
        }
        
    }
}

 

2) 두번째 방법 - PointCut만 등록

 

• 이미 만들어져 있는 어노테이션에 PointCut 등록 한다.
• Advice를 만든다. (메서드 행위)
• JoinPoint를 적용한다 

 

@Aspect
@Component
public class ValidAdvice {

    @Pointcut("@annotation(org.springframework.web.bind.annotation.PostMapping)")
    public void postMapping() {}
    
    @Pointcut("@annotation(org.springframework.web.bind.annotation.PutMapping)")
    public void putMapping() {}
    
    @Before("postMapping() || putMapping()")
    public void validationAdvice(JoinPoint jp) throws Throwable {
    
        Object[] args = jp.getArgs();
        
        for (Object arg : args) {
        
            if (arg instanceof BindingResult) {
                Errors errors = (Errors) arg;
                
                    if (errors.hasErrors()) {
                    Map<String, String> errorMap = new HashMap<>();
                    
                    for (FieldError error : errors.getFieldErrors()) {
                        errorMap.put(error.getField(),
                        error.getDefaultMessage());
                    }
                    
                throw new MyValidationException(errorMap);
                
                }
            }
        }
    }
}

 

3) 세번째 방법 - 에너테이션 x, 특정 패턴

 

깃발을 생성하지 않고, 특정한 패턴이 수행될 때 정의된 advice를 실행하게 할 수도 있다.

 

Spring Framework에서는 XML을 이용하여 Aspect-Oriented Programming (AOP)을 설정하는 방법이 있다.

그러나 Spring Boot에서는 주로 어노테이션 기반의 AOP를 사용하며, execution expression을 이용하여 pointcut을 등록할 수 있다.

 

하지만, 직접적으로 execution expression을 이용하여 pointcut을 등록하려면 여러가지 설정을 해 주어야 한다. 대신, Spring Boot에서는 AspectJ를 사용하여 간편하게 pointcut을 등록할 수 있는 기능을 제공한다.

 

AspectJ는 Java와 비슷한 문법을 가지며, execution expression을 이용하여 pointcut을 등록하는 방법이 있다.

 

Execution Expression	Point Cut
execution(* onj.spring.aop..(..))	패키지의 모든 메소드가 포인트 컷
execution(* onj.spring.aop...(..))	onj.spring.aop 패키지와 하위 패키지의 모든 메소드가 포인트 컷
execution(public void insert*(..))	public에 리턴값, 패키지명 없고 메서드 이름은 insert로 시작, 인자값은 0개 이상인 메서드가 포인트 컷
execution(public * *(..))	public 메소드가 포인트 컷
execution(* onj.spring.aop..())	리턴형 관계없고 onj.spring.aop 패키지의 모든 클래스, 인자값이 없는 모든 메서드가 포인트 컷
execution(* onj.spring.aop...(..))	리턴형 관계없고 onj.spring.aop 패키지 및 하위 패키지에 있는 모든 클래스, 인자값이 0개 이상인 메서드가 포인트 컷
execution(* delete())	메서드 이름이 delete으로 시작하는 인자값이 1개인 메서드가 포인트 컷
execution(* delete(,*))	메서드 이름이 delete로 시작하는 인자값이 2개인 메서드가 포인트 컷

 

특정 어노테이션의 파라미터로 있는 메소드를 pointcut으로 잡으려면, execution expression을 이용하여 어노테이션이 적용된 메소드를 대상으로 pointcut을 작성한다. 다만, 이 경우에는 @annotation 대신에 @args 키워드를 사용해야 한다.

 

---

4. @Before, @After, @Around

---

AOP에서 Before, After, Around는 각각 다른 시점에서 AOP 어드바이스를 실행하는 방법이다.

 

1. @Before

: 메서드 실행 전에 어드바이스를 실행한다. 이 시점에서 JoinPoint 객체를 통해 메 서드의 인자, 클래스, 메서드 이름 등의 정보를 가져올 수 있다. @Before 어노테이션을 사용하여 선언한다.

 

@Before("execution(* com.example.myapp.service.MyService.*(..))")
public void beforeAdvice(JoinPoint joinPoint) {
	System.out.println("Before Advice: " + joinPoint.getSignature().getName());
}

 

@Before 어노테이션을 사용하여 com.example.myapp.service.MyService 클래스의 모든 메서드에 적용될 어드바이스를 작성한다. 메서드 실행 전에 해당 메서드의 시그니처 정보를 출력하는 기능을 수행한다.

 

2. @After

: 메서드 실행 후에 어드바이스를 실행. 이 시점에서 JoinPoint 객체를 사용할 수 있으며, 메서드의 실행 결과나 예외 정보 등을 가져올 수 있다. @After 어노테이션을 사용하여 선언한다.

 

@After("execution(* com.example.myapp.service.MyService.*(..))")
public void afterAdvice(JoinPoint joinPoint) {
	System.out.println("After Advice: " + joinPoint.getSignature().getName());
}

 

@After 어노테이션을 사용하여 com.example.myapp.service.MyService 클래스의 모든 메서드에 적용될 어드바이스를 작성한다. 메서드 실행 후 해당 메서드의 시그니처 정보를 출력 하는 기능을 수행합니다.

 

3. @Around

: 메서드 실행 전후 모두 어드바이스를 실행한다. 이 시점에서 ProceedingJoinPoint 객체를 사용하여 메서드 실행을 수행하고, 실행 결과를 반환할 수 있다. @Around 어노테이션을 사용하여 선언하며, 메서드 실행 전후에 추가적인 로직을 수행 할 수 있다.

 

@Around("execution(* com.example.myapp.service.MyService.*(..))")
public Object aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {
    System.out.println("Before Advice: " + joinPoint.getSignature().getName());
    Object result = joinPoint.proceed();
    System.out.println("After Advice: " + joinPoint.getSignature().getName());
    return result;
}

 

@Around 어노테이션을 사용하여 com.example.myapp.service.MyService 클래스 의 모든 메서드에 적용될 어드바이스를 작성한다. 메서드 실행 전후에 해당 메서드의 시그니처 정보를 출력하고, 메서드 실행을 수행한 후 실행 결과를 반환합니다.

 

---

즉, @Before 는 메서드 실행 전에 추가적인 로직을 수행하는 어드바이스이고 @After 는 메서드 실행 후에 추가적인 로직을 수행하는 어드바이스이다. @Around 는 메서드 실행 전후에 추가적인 로직을 수행할 수 있는 가장 범용적인 어드바이스에 해당한다.

 

AOP에서 메서드의 파라미터 값을 검사하거나 변경하는 작업을 수행할 때는 @Before 어노테이션을 사용하고, 메서드 실행 시에 새로운 값을 주입하거나, 결과를 가공하는 작업을 수행할 때는 @Around 어노테이션을 사용하는 것이 일반적이다

 

---

참고자료

---

1. https://code-lab1.tistory.com/193

[Spring] AOP(Aspect Oriented Programming)란? 스프링 AOP란?

2. https://engkimbs.tistory.com/746

[Spring] 스프링 AOP (Spring AOP) 총정리 : 개념, 프록시 기반 AOP, @AOP