AOP와 Spring AOP에 대해 알아보자

1. AOP란?

AOP는 Aspect Oriented Programming의 약자로, 관점 지향 프로그래밍을 의미한다.

핵심적인 비즈니스 로직으로부터 횡단 관심사를 분리하는 것을 목적으로 한다.

 

로깅, 보안, 트랜잭션 처리와 같이 비즈니스 핵심적인 기능이 아니지만 애플리케이션 코드가 중복되고 강력하게 결합되어 있어 다른 로직과 분리할 수 없는 애플리케이션 로직을 의미한다.

 

다시 말하면, AOP란 핵심적인 관점과 부가적인 관점을 나누어보고 그 관점을 기준으로 각각 분리하는 것을 의미한다.

쉽게 말해 부가적인 기능들을 따로 관리한다는 뜻이다.

횡단 관심사

 

 

2. AOP, 뭐가 좋을까?

먼저 코드 전체에 흩어져 있는 관심 사항이 하나의 장소로 응집된다. 그렇기 때문에 중복되는 코드를 줄일 수 있다.

두 번째로, 비즈니스 로직은 자신의 관심사에 대한 코드만 포함하기 때문에 코드가 깔끔해지고 유지보수가 용이해진다.

 

결국 AOP는 객체지향적으로 코드를 짤 수 있게 돕는다.

 

3. 프록시

코드 중복을 제거하고 AOP를 사용하기 위해 프록시(Proxy)를 사용한다.

 

프록시란, 자신이 클라이언트가 사용하려고 하는 실제 대상(타깃)인 것처럼 위장하여 클라이언트의 요청을 대신 받아주는 것을 의미한다.

 

프록시는 사용 목적에 따라 2가지로 나눌 수 있다.

1. 클라이언트가 타깃에 접근하는 방법을 제어하기 위함 > 프록시 패턴
2. 타깃에 부가적인 기능을 부여해주기 위함 > 데코레이터 패턴

 

프록시 예제 - 계산기

간단한 계산기 예제로 프록시를 이해해보자.

Calculator라는 인터페이스가 있고, 팩토리얼을 각각 반복문과 재귀로 구현한 BasicCalculator와 RecursiveCalculator 클래스가 Calculator 인터페이스를 상속받는다.

public interface Calculator {

    long factorial(long num);
}

public class BasicCalculator implements Calculator {
    
    @Override
    public long factorial(final long num) {
        long result = 1;
        
        for (long i = 1; i <= num; i++) {
            result *= i;
        }
        
        return result;
    }
}

public class RecursiveCalculator implements Calculator {

    @Override
    public long factorial(final long num) {
        if (num == 0) {
            return 1;
        }
        return num * factorial(num - 1);
    }
}

 

이 때, 구현한 factorial의 실행시간을 구하고 싶다는 요구사항이 추가되었다.

만약 프록시를 사용하지 않는다면, BasicCalculator와 RecursiveCalculator 클래스의 factorial 메서드 실행 앞 뒤에 실행시간 측정 로직을 추가해야 하고, 중복된 클래스가 생기게 된다.

 

프록시를 활용해서 실행시간 측정 로직을 분리해보자.

ExecutionTimeCalcultor라는 객체는 외부에서 구현체의 의존성을 delegate로 주입받는다.

factorial 메서드를 오버라이딩을 통해 실행 시간 측정 로직을 구현하고, 팩토리얼 계산 로직은 외부에서 주입받은 객체에게 위임한다.

public class ExecutionTimeCalculator implements Calculator {

    // 구현체의 의존성을 주입받을 필드
    private Calculator delegate;

    // 외부에서 구현체의 의존성을 주입
    public ExecutionTimeCalculator(final Calculator calculator) {
        this.delegate = calculator;
    }

    @Override
    public long factorial(final long num) {
        // 실행 시간 측정
        long start = System.currentTimeMillis();

        // 외부에서 주입받은 객체에게 위임
        long result = delegate.factorial(num);

        // 실행 시간 측정
        long end = System.currentTimeMillis();
        System.out.printf("%s의 factorial(%d) 실행 시간 > %d\n",
                delegate.getClass().getSimpleName(),
            num,
            (end - start));

        return result;
    }
}

public class Main {

    public static void main(String[] args) {

        Calculator proxyCalculator1 = new ExecutionTimeCalculator(new BasicCalculator());
        System.out.println(proxyCalculator1.factorial(20));

        Calculator proxyCalculator2 = new ExecutionTimeCalculator(new RecursiveCalculator());
        System.out.println(proxyCalculator2.factorial(20));
    }
}

 

ExecutionTimeCalculator를 통해

• factorial 메서드의 로직을 변경하지 않고 실행 시간을 출력하고
• 중복될뻔한 실행 시간 측정 로직을 하나로 응집할 수 있었다

 

4. AOP 관련 주요 키워드

이는 스프링에서만 사용되는 용어가 아닌, AOP 전반에서 사용되는 키워드이다.

 

용어	정의	예시
target	부가 기능을 부여할 대상 (클래스 혹은 객체)	BasicCalculator, RecursiveCalculator
Aspect	Advice + Pointcut	-
Advice	타깃에게 제공할 부가기능을 담은 모듈 (무슨 기능을 어느 시점에 주입할지를 포함)	메소드 실행 시간 측정
Join Point	어드바이스가 적용될 수 있는 위치	factorial 메서드
Point Cut	어드바이스를 적용할 조인 포인트를 선별하는 작업 (어떤 메서드에 적용할지?)	메소드의 이름이 factorial인 경우
Advisor	포인트 컷과 어드바이스를 하나씩 가지고 있는 오브젝트 (스프링 AOP에서만 사용)	-
Weaving	조인 포인트에 어드바이스를 적용하는 방법	스프링AOP는 Runtime Weaving을 통해 런타임 도중 AOP를 적용해줌

 

 

5. AOP를 구현하는 방법

AOP를 구현하는 방법은 3가지가 있다.

• 컴파일 시점에 코드에 공통 기능 삽입
• 클래스 로딩 시점에 바이트 코드에 공통 기능 삽입
• 런타임 시점에 프록시 객체를 생성하여 공통 기능 삽입

 이 때, 컴파일 시점이나 클래스 로딩 시점에 AOP를 사용하기 위해서는 AspectJ 컴파일러나 AspectJ 클래스 로더 조작기와 같이 새로운 의존성을 추가해야 한다.

	Spring AOP	AspectJ
목표	간단한 AOP 기능 제공	완벽한 AOP 기능 제공
Join Point	메서드 레벨만 지원	생성자, 필드, 메서드 등 다양하게 지원
Weaving	런타임 시에만 가능	런타임은 제공하지 않음 compile time, post-compile, load-time 제공
대상	스프링 컨테이너가 관리하는 Bean	모든 Java Object

 

 스프링에서는 런타임 시점에 프록시 객체를 생성하여 공통 기능을 삽입하는 방법을 사용하고 있다.

 프록시는 메서드 오버라이딩 개념으로 동작하기 때문에, 스프링 AOP는 메서드 실행 시점에만 AOP를 적용할 수 있다. 또한, 스프링 AOP는 스프링 컨테이너가 관리할 수 있는 빈에만 AOP를 적용할 수 있다.

 

 스프링에서는 IoC/DI 컨테이너, Dynamic Proxy, 데코레이터 패턴/프록시 패턴, 자동 프록시 생성 기법, 빈 오브젝트 후처리 조작 기법 등 다양한 기술들이 스프링 AOP를 지원하기 위해 사용되고 있다. 

 

6. Spring AOP 적용

위에서 프록시로 구현한 계산기 예제 중 BasicCalculator에 Spring AOP를 적용시켜보자.

 

먼저 AOP 관련 의존성을 추가해준다.

implementation 'org.springframework.boot:spring-boot-starter-aop'

 

스프링 AOP에서는 스프링 컨테이너가 관리하는 빈에만 적용할 수 있으므로, @Component 어노테이션을 추가하여 빈으로 등록해준다.

@Component
public class BasicCalculator implements Calculator {

    @Override
    public long factorial(final long num) {
        long result = 1;

        for (long i = 1; i <= num; i++) {
            result *= i;
        }

        return result;
    }
}

 

다음으로 Aspect를 정의해준다.

@Aspect을 사용하며, Aspect도 빈으로 등록해주어야 한다.

@Pointcut을 사용하여 포인트컷을 정의해주고, @Around으로 메서드 실행 전, 후에 실행되도록 해주었다.

@Component
@Aspect
public class ExecutionTimeAspect {

    // 메서드 이름이 facotrial인 경우를 Pointcut으로 정의
    @Pointcut("execution(* aop.Calculator.factorial(..))")
    private void publicTarget() {
    }

    // Advice 정의
    // @Around는 메서드 실행 전후에 실행되는 Advice
    @Around("publicTarget()")
    public Object measure(ProceedingJoinPoint joinPoint) throws Throwable {
        // 실행 시간 측정
        final long start = System.nanoTime();
        try {
            // 타깃 호출
            Object result = joinPoint.proceed();
            return result;
        } finally { // 실행 시간 측정
            final long finish = System.nanoTime();
            Signature sig = joinPoint.getSignature();
            System.out.printf("%s.%s(%s) 실행 시간 > %d\n",
                joinPoint.getTarget().getClass().getSimpleName(),
                sig.getName(),
                Arrays.toString(joinPoint.getArgs()),
                (finish - start)
            );
        }
    }
}

 

@Around 외에도 아래와 같은 종류의 Advice가 존재한다.

종류	설명
@Around	메서드 호출 전후 또는 예외 발생 시점에 수행
@Before	조인 포인트 실행 이전에 실행
@AfterReturning	조인 포인트가 정상 완료된 후 실행
@AfterThrowing	메서드가 예외를 던지는 경우 실행
@After	조인 포인트가 정상 또는 예외에 관계없이 실행

 

@SpringBootTest
class ExecutionTimeAspectTest {

    @Autowired
    private Calculator basicCalculator;

    @Test
    void test() {
        long factorial = basicCalculator.factorial(20);
        System.out.printf("factorial 결과: %d \n", factorial);
    }
}

 

factorial 메서드를 호출했을 때 AOP로 구현한 실행 시간 측정 로직이 적용된 모습을 볼 수 있다.

 

마치며

이제까지 AOP라는 단어를 들었을 때 어려운 개념인줄 알고 지레 겁먹고 무시(?)하였는데, AOP에 대해 알고 나니 매우 유용한 기능인 것 같다.

평소 로깅을 할 때 '이걸 다 일일이 적어야 하나?'라고 생각이 들었는데 AOP를 적용하면 그런 고민을 쉽게 해결할 수 있을 것 같다 :)

 

Reference

https://youtu.be/hjDSKhyYK14?si=Vw1-zgUs-a9cdz7-

https://youtu.be/7BNS6wtcbY8?si=GZgsCTRZs07Rfz34

https://willseungh0.tistory.com/61

https://catsbi.oopy.io/fb62f86a-44d2-48e7-bb9d-8b937577c86c