Spring AOP - (2) AOP 개념 및 실습

📎  글또 6기 포스팅

1. 미치도록 더웠던 7월의 회고

 

2. 사용자가 게시물을 작성할 때의 트랜잭션 처리

 

3. Spring AOP - (1) 프록시 패턴, 데코레이터 패턴

 

4. [MySQL] - 트랜잭션의 격리 수준(Isolation level)

 

5. Spring AOP - (2) AOP 개념 및 실습

 

6. 인텔리제이(IntelliJ) - 디버깅(Debugging) 하기

 

7. [Java, 디자인패턴] - 싱글턴 패턴(Singleton Pattern)

 

8. 월간 코드리뷰 Ver_0.1: 커리어 성장 CODE 세미나 정리

 

9. 포스트맨(API 테스트) 활용하기

 

10. 뜻깊은 2021년 회고

---

📎  Spring AOP(Aspect Oriented Programming)

포스팅에 작성한 예제 코드는 깃허브에서 확인하실 수 있습니다 :)

 

지난번 정리한 Spring AOP - (1) 프록시 패턴, 데코레이터 패턴 포스팅에 이어 나머지 목차들에 대해 정리를 해보겠습니다.

 

포스팅의 목차 입니다.

• 부가기능을 위임하는 전통적인 방법 1 - 프록시 패턴
• 부가기능을 위임하는 전통적인 방법 2 - 데코레이터 패턴
• Spring AOP 개념
• Spring AOP 특징
• Spring AOP 용어
• Spring AOP 실습 1
• Spring AOP 어노테이션
• Spring AOP 실습 2
• 마무리

지난 포스팅에서는 부가기능을 위임하는 전통적인 방법으로 프록시 패턴 및 데코레이터 패턴에 대해 정리를 했었습니다.

이번 시간에는 부가기능을 처리하는 방법으로 Spring AOP의 개념 및 용어, 실습 등에 대해 알아보겠습니다.

 

 

 

🎯  Spring AOP 개념

---

AOP는 Aspect Oriented Programming의 약자로 관점 지향 프로그래밍이라고도 합니다.

관점은 코드를 바라보는 시각정도로 생각해주시면 될 것 같습니다.

 

관점 지향 프로그래밍은 기능을 구현할 때 핵심적인 기능과 부가적인 기능을 분리하여 각 관점(Aspect)을 기준으로 모듈화를 하는 방식을 의미합니다.

• 핵심적인 기능: 적용하고자 하는 비즈니스 로직
• 부가적인 기능: 데이터베이스 연결 및 트랜잭션 관리, 로깅, 파일 입출력 등

Spring AOP

AOP에서 각 관점을 기준으로 모듈화를 한다는 것은 코드들을 부분적으로 나누어서 모듈화를 한다는 의미입니다.

위 사진과 같이 코드에서 다른 부분에 반복적으로 사용되는 코드들을 발견할 수 있는데

이를 횡단 관심사(Crosscutting Concerns)라고 합니다.

 

위 그림에서 모든 클래스에 공통적으로 사용되고 있는 주황색 기능을 수정해야 하는 일이 발생하면 A, B, C 모든 클래스에서 기능을 수정해주어야 하기 때문에 유지보수면에서도 효율적이지 않습니다.

 

이러한 문제점을 해결하기 위해 나온 기술이 AOP로, 정리해보자면 다음과 같습니다.

'횡단 관심사(Crosscutting Concerns)의 분리를 허용함으로써 모듈성을 증가시키는 것이 목적인 프로그래밍 패러다임'

AOP는 결국 애플리케이션을 다양한 측면에서 독립적으로 모델링하고, 설계하고, 개발할 수 있도록 만들어 주고, 그로인해 애플리케이션을 다양한 관점에서 바라보며 개발할 수 있게 도와줍니다.

 

 

아래는 은행 애플리케이션을 관심사라는 관점으로 표현한 구조입니다.

위 은행 애플리케이션 구조는 각 핵심 기능들(계좌이체, 입출금, 이자계산)이 수행될 때 마다 부가적인 기능들(로깅, 트랜잭션, 보안)이 이루어져야 합니다. 즉, 계좌이체의 관점에서도 로깅, 트랜잭션, 보안을 수행해야 하고 입출금, 이자계산의 관점에서도 동일하게 로깅, 트랜잭션, 보안 기능을 수행해야 합니다.

 

위 구조에서 핵심 기능들을 수행하는데 반드시 실행하는 공통적인(부가적인) 기능들이 로깅, 트랜잭션, 보안 입니다. 이러한 것들을 횡단관심이라고 하는데, 왜 이러한 부가 기능을 분리해야 하는걸까요? 당연하게도, 중복이 발생한다는 문제점과 유지보수의 어려움이 있습니다.

 

간단한 슈도코드(pseudocode)를 통해 문제점에 대해 살펴보겠습니다.

class 로그 {
  static printLog();
}

class 계좌이체 {
  이체() {
    로그.printLog();
    ...
  }
}

class 입출금 {
  입금() {
    로그.printLog();
    ...
  }
}

class 이자계산 {
  이자계산() {
    로그.printLog();
    ...
  }
}

위 예제는 정말 단순하게 작성했기때문에 불편함을 느끼지 못할수도 있습니다.

하지만 위 예제에서 로그를 출력하는 printLog()의 메소드명이 변경되었다면 어떻게 해야할까요?

 

다음과같이 로그를 사용하고 있는 모든 클래스 및 메소드를 찾아가 변경해야 하는 일이 발생합니다.

class 로그 {
  static printLog4j();
}

class 계좌이체 {
  이체() {
    로그.printLog4j();
    ...
  }
}

class 입출금 {
  입금() {
    로그.printLog4j();
    ...
  }
}

class 이자계산 {
  이자계산() {
    로그.printLog4j();
    ...
  }
}

현재는 로그 기능을 사용하고 있는 클래스가 3개밖에 존재하지 않지만, 만약 로그 기능을 사용하고 있는 클래스가 점차 늘어나 3개가 아닌 30개, 100개가 되었을때 위와 같이 수정사항이 발생하면 모든 클래스에 직접 수정을 해야하는 번거로움이 발생합니다.

따라서 스프링 AOP를 통해 관심사를 분리하고 이러한 문제점을 해결해보도록 하겠습니다.

 

 

🎯 Spring AOP 특징

---

• AOP(Aspect Oriented Programming)는 프로그램 구조에 대한 또 다른 사고방식을 제공하여 OOP를 보완합니다.
• OOP에서 모듈화의 핵심 단위는 클래스(역할)이고, AOP에서는 모듈화 단위가 Aspect(관점)입니다.
• Aspect는 여러 유형과 객체에 걸쳐있는 동일한 관심사(ex. 트랜잭션)의 모듈을 가능하게 합니다.
• 스프링 빈에만 AOP를 적용할 수 있습니다.

 

 

🎯 Spring AOP 용어

---

AOP에서 사용되고 있는 용어들에 대해 살펴보겠습니다. 아래 용어들은 Spring에만 국한되는 것이 아닌 AOP 프레임워크 전체에서 사용되는 공용어입니다.

AOP의 용어는 단어 자체로도 굉장히 어렵고 머리가 아프기 때문에 ..😂.. 전부 외우고 이해하려기 보다는 간단하게 용어정도만 읽어본 후 아래 실습을 통해 AOP에 대해 살펴보고 다시 읽어보는 것을 추천드립니다.

 

타겟(Target)

• 부가기능을 부여할 대상을 의미합니다. 
• 위 구조에서는 핵심기능(계좌이체, 입출금, 이자계산)을 담은 클래스를 의미합니다.

애스펙트(Aspect)

• OOP의 클래스와 마찬가지로 애스펙트는 AOP의 기본 모듈입니다.
• 애스펙트는 부가기능을 정의한 어드바이스와 어드바이스를 어디에 적용할지 결정하는 포인트컷의 조합으로 구성됩니다.
• 보통 싱글톤 형태의 오브젝트로 존재합니다.

어드바이스(Advice)

• 실질적으로 부가기능을 담은 구현체를 의미합니다.
• 어드바이스의 경우 타겟 오브젝트에 종속되지 않기 때문에 순수하게 부가기능에만 집중할 수 있습니다.

조인 포인트(Join Point)

• 어드바이스가 적용될 수 있는 위치를 의미합니다.
• 스프링 AOP에서는 메소드 조인포인트만 제공하고 있습니다.
• 따라서, 스프링 프레임워크 내에서의 조인포인트는 메소드를 가리킨다고 생각하셔도 무방합니다.

포인트컷(PointCut)

• 부가기능이 적용될 대상(메소드)를 선정하는 방법을 의미합니다.
• 스프링 AOP의 조인 포인트는 메소드의 실행이므로 스프링의 포인트컷은 메소드를 선정하는 기능을 갖고 있습니다.
• 따라서 포인트컷의 표현식은 메소드의 실행이라는 의미인 execution으로 시작하고, 메소드의 시그니처를 비교하는 방법을 주로 이용합니다.

프록시(Proxy)

• 클라이언트와 타겟 사이에 투명하게 존재하여 부가기능을 제공하는 오브젝트입니다.
• DI를 통해 타겟 대신 클라이언트에게 주입되며, 클라이언트의 메소드 호출을 대신 받아 타겟에 위임해주며 부가기능을 부여합니다.

인트로덕션(Introduction)

• 타겟 클래스에 추가적인 메소드나 필드를 추가하는 기능을 의미합니다.

위빙(Weaving)

• 어드바이스를 핵심 로직 코드에 적용하는 것을 의미합니다.

 

 

 

🎯 Spring AOP 실습 1

---

스프링 AOP를 사용하기 위해 의존성을 추가합니다.

    // Maven
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>
    
    
    // Gradle
    implementation 'org.springframework.boot:spring-boot-starter-aop'

 

의존성을 추가한 후 아래 실습 코드를 작성합니다.

 

Controller & Dto

package com.juhyun.springaop.aop.controller;

import ...

@RestController
@RequestMapping("/api")
public class RestApiController {

    @GetMapping("/{id}")
    public String get(@PathVariable Long id, @RequestParam String name) {
        System.out.println("--------------- @GetMapping ---------------");
//        System.out.println("get method");
//        System.out.println("id: " + id);
//        System.out.println("name: " + name);
        return id + " " + name;
    }

    @PostMapping
    public UserDto post(@RequestBody UserDto userDto) {
        System.out.println("--------------- @PostMapping ---------------");
//        System.out.println("post method");
//        System.out.println("user: " + user);
        return userDto;
    }
}


package com.juhyun.springaop.aop.dto;

import ...

@Getter
@Setter
@ToString
public class UserDto {

    private String id;
    private String password;
    private String email;

}

 

AOP

package com.juhyun.springaop.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

@Aspect
@Component
public class ParameterAop {

    /*
    com.juhyun.springaop.aop.controller 패키지 하위에 있는 메소드가 실행되기 전
     -> @Before 어노테이션이 선언된 before() 메소드가 실행
     -> 정상 실행되고 리턴되면 @AfterReturning 어노테이션이 선언된 afterReturn() 메소드에서 결과를 확인
    */

    // controller 패키지의 하위 메소드를 모두 Aspect로 설정
    @Pointcut("execution(* com.juhyun.springaop.aop.controller..*.*(..))")
    private void cut() {

    }

    // cut() 메소드가 실행되는 지점의 이전에 before() 메소드 수행
    @Before("cut()")
    public void before(JoinPoint joinPoint) {
        System.out.println("--------------- @Before ---------------");
        System.out.println(joinPoint.toString());
        System.out.println(joinPoint.toShortString());
        System.out.println(joinPoint.toLongString());

        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        Method method = methodSignature.getMethod();
        System.out.println("method: " + method.getName());

        Object[] args = joinPoint.getArgs();
        for (Object arg : args) {
            System.out.println("type: " + arg.getClass().getSimpleName());
            System.out.println("value: " + arg);
        }
    }

    // 반환값 확인
    @AfterReturning(value = "cut()", returning = "object")
    public void afterReturn(JoinPoint joinPoint, Object object) {
        System.out.println("--------------- @After ---------------");
        System.out.println(object);
    }

}

 

프로젝트의 구조는 다음과 같습니다.

 

컨트롤러의 Get, Post 메소드에 대해 테스트를 해보면 다음과 같습니다.

GET

 

POST

Controller 코드에 부가기능으로 주석처리된 System.out.println() 출력하는 부분을 AOP로 분리함으로써 컨트롤러는 부가기능(출력)을 할 필요가 없이 본인의 기능만 수행하면 됩니다.

 

 

 

🎯 Spring AOP 어노테이션

---

위 예제에서 사용된 여러 어노테이션(@Aspect, @Component, @Pointcut, @Before, @After) 등등에 대해 알아보겠습니다.

 

@Aspect, @Component

해당 클래스가 Aspect를 나타내는 클래스를 명시하고, 스프링 빈으로 등록하기 위해 @Component 어노테이션을 명시합니다.

 

@Pointcut(포인트컷 표현식)

포인트컷은 위에서 부가기능이 적용될 대상(메소드)를 선정하는 방법이라고 설명을 드렸었는데요, 포인트컷 표현식의 문법구조는 다음과 같습니다.

[] 괄호는 옵션이기 때문에 생략이 가능하며, | 는 OR 조건입니다.

포인트컷 표현식 문법구조

 

위 예제에서 작성한 포인트컷은 다음과 같습니다.

// controller 패키지의 하위 메소드를 모두 Aspect로 설정
@Pointcut("execution(* com.juhyun.springaop.aop.controller..*.*(..))")

위 문법을 해석해보자면 다음과 같습니다.

• execution: 포인트컷 지정자
• *: 모든 타입의 리턴이 가능
• com.~.controller..*.*: (타겟이 되는 메소드) 해당 패키지 하위에 존재하는 모든 메소드들
• (..): 모든 타입의 파라미터에 대해 허용하는 조건

 

만약 위 예제에서 RestApiController 클래스 하위에 존재하는 get() 메소드만 설정하려고 하면 다음과 같이 지정하면 됩니다.

// RestApiController 클래스 하위의 get 메소드를 Aspect로 지정
@Pointcut("execution(* com.juhyun.springaop.aop.controller.RestApiController.get(..))")

테스트를 해보면 get 메소드와는 달리 post 메소드에는 AOP 적용이 되지않은 걸 확인할 수 있습니다.

 

 

포인트컷 표현식 예시

• execution(int minus(int, int)): int 타입의 리턴 값, minus라는 메소드, 두 개의 int 파라미터를 가지는 메소드
• execution(* minus(int, int)): 모든 타입의 리턴, minus라는 메소드, 두 개의 int 파라미터를 가지는 메소드
• execution(* minus(..)): 리턴 타입, 파라미터 종류, 개수에 상관없이 minus라는 메소드 이름을 가진 모든 메소드
• execution(* minus()): 리턴 타입은 상관없이 파라미터가 존재하지 않는 minus 메소드
• execution(* *(..)): 리턴 타입, 파라미터, 메소드 이름에 상관없이 모든 조건을 허용하는 포인트컷 표현식
• execution(* com.juhyun.aop.Target.*(..)): com.juhyun.aop 패키지의 Target 클래스에 존재하는 메소드
• execution(* com.juhyun.aop.*.*(..)): com.juhyun.aop 패키지에 존재하는 모든 클래스

 

@Before

타겟 메소드가 실행하기 이전 어드바이스 기능을 수행

 

@After

타겟 메도스의 결과에 상관없이 실행 후 어드바이스 기능을 수행

 

@AfterReturning

타겟 메소드가 정상적으로 결과값을 반환 후 어드바이스 기능을 수행

 

@AfterThrowing

타겟 메소드가 수행 중 예외를 발생하면 어드바이스 기능을 수행

 

@Around

어드바이스가 타겟 메소드를 감싸서 타겟 메소드 호출전, 후 어드바이스 기능을 수행

Around는 타겟을 실행할 지 혹은 바로 반환할지도 정할 수 있음

 

 

 

🎯 Spring AOP 실습 2

---

이번 실습에서는 특정 메소드의 시간을 기록하는 부가기능을 AOP를 통해 적용해보도록 하겠습니다.

프로젝트 구조 및 전반적인 코드는 위 실습 1과 동일합니다.

// 커스텀 어노테이션
package com.juhyun.springaop.aop.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Timer {
}


// RestApiController

... 생략

    @Timer
    @DeleteMapping("/delete")
    public String delete() throws InterruptedException {
        // DB logic 2초 수행
        Thread.sleep(1000 * 2);
        return "delete";
    }
    

// AOP
package com.juhyun.springaop.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
import org.springframework.util.StopWatch;

@Aspect
@Component
public class TimerAop {

    @Pointcut("execution(* com.juhyun.springaop.aop.controller..*.*(..))")
    private void cut() { }

    @Pointcut("@annotation(com.juhyun.springaop.aop.annotation.Timer)")
    private void enableTimer() { }

    @Around("cut() && enableTimer()")
    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("--------------- @Around ---------------");
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();

        // 타겟 오브젝트의 메서드 실행(controller 패키지 하위 클래스들의 메소드)
        Object result = joinPoint.proceed();
        System.out.println("result: " + result);

        stopWatch.stop();

        System.out.println("Total Time: " + stopWatch.getTotalTimeSeconds());
    }
}

위 예제에서는 ProceddingJoinPoint 라는 클래스가 추가되었는데요, 해당 클래스의 proceed()메소드를 실행함으로서 타겟 오브젝트의 메소드가 실행이 됩니다. 따라서 해당 코드 전후로 부가기능을 위한 코드를 작성하면 됩니다.

※ 주의하실 점은 @Around 어드바이스에서만 ProceedingJoinPoint 를 매개변수로 사용하고, 나머지 @Before, @After, @AfterReturning, @AfterThrowing 어드바이스에서는 JoinPoint를 매개변수로 사용합니다. 이는 Around 어드바이스에서만 proceed() 메소드가 필요하기 때문입니다.

 

또한 Timer라는 어노테이션 기반으로 예제를 작성했습니다. 해당 어노테이션을 사용할 메소드(delete)에 적용하고, AOP에서는 이를 적용하기 위해 적용 범위를 설정하는 cut() 메소드와, Timer 어노테이션을 설정하는 enableTimer() 메소드를 작성합니다.

실행 시간은 타겟 메소드(delete)의 전, 후 에 이루어져야 하기 때문에 @Around 어노테이션을 통해 설정합니다.

around() 메소드에서는 joinPoint.proceed() 코드를 기반으로 위에는 실행 전, 아래는 실행 후 수행하게 됩니다.

 

 

 

🎯  마무리

---

이상으로 스프링 AOP와 프록시 패턴, 데코레이터 패턴에 대해 정리하고 학습해보았습니다.

개인적으로 AOP의 경우 Target, Aspect, Advice, PointCut, Join Point 등등 용어만 봤을때는 이해가 전~혀 되지않았습니다.

하지만 이번 포스팅을 계기로 여러 자료와 문서, 서적 등을 참고하며 AOP에 대해 정리를 해보았습니다. 확실히 이론보다는 실습을 통해 학습하는 것이 이해하기에는 훨씬 더 수월한 것 같습니다.😃

물론 제가 학습한 내용은 지극히 일부이지만, 다음에 AOP를 실무에서 혹은 개인적으로 사용해 볼 기회가 생긴다면 그때 좀 더 추가적으로 정리해보도록 하겠습니다.

 

 

 

 

References

• https://jojoldu.tistory.com/71
• https://fastcampus.co.kr/
• https://docs.spring.io/spring-framework/docs/2.5.x/reference/aop.html
• 토비의 스프링 3.1