💻 코딩 일기 : [Spirng] 'AOP' 편

🔔 'AOP'에 대해서 알아보자!

💟 AOP(Aspect Oriented Programming, 관점 지향 프로그랭)

핵심적인 비즈니스 로직(핵심 관점)으로부터 횡단 관심사(부가기능)를 분리하여 모듈화합니다. 즉 AOP는 부가기능을 따로 관리하는 것을 의미합니다.

• 횡단 관심사란? 여러 서비스에 걸쳐서 동작해야 하는 코드를 의미합니다. 핵심기능이 아닌 중간에 삽입되는 기능이라고 할 수 있습니다.
• 모듈화 : 어떤 공통된 로직이나 기능을 하나의 단위로 묶는 것을 말합니다.

장점 :

• 여러 객체에 공통으로 적용할 수 있는 기능을 분리해서 개발자는 중복 제거로 인한 반복 작업을 줄일 수 있습니다.
• 핵심 기능 개발에만 집중할 수 있습니다.
• 유지보수 용이합니다.

🟦 AOP 예제

Calculator(팩토리얼)

public interface Calculator {
    long factorial(long num);
}

BasicCalculator(for문)

public class BasicCalculator implements Calculator{
    @Override
    public long factorial(long num) {
        long result = 1;

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

RecursiveCalculator(재귀함수)

public class RecursiveCalculator implements Calculator{
    @Override
    public long factorial(long num) {
        if(num == 0){
            return 1;
        }
        return num * factorial(num -1);
    }
}

👉 요구사항 : 두 클래스에 실행 시간을 구하는 코드를 추가해주세요

문제점
기존 코드의 수정이 필요하고 코드 중복 발생합니다.

해결방법
프록시 : 자신이 클라이어트가 사용하려고 하는 실제 대상인 것 처럼 위장해서 클라이언트의 요청을 받아주는 것입니다. (대리인, 대리자)

프록시 패턴 적용

public class ExecutionTimeCalculator implements Calculator{

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

    // 외부에서 구현체의 의존성을 주입
    public ExecutionTimeCalculator(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) Execution Time > %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));
    }
}

1. Main 클래스에서 ExecutionTimeCalculator를 생성하고, 생성자를 통해 BasicCalculator 객체를 주입합니다.
2. 클라이언트가 factorial(20)으로 호출합니다.
3. 이 때 BasicCalculator가 받는 것이 아니라 ExecutionTimeCalculator가 요청을 받습니다.
4. 실행 전 시간(start)을 구합니다.
5. delegate.factorial(num) : ExecutionTimeCalculator는 외부에서 주입된 Calculator 구현체에 대해 팩토리얼 연산을 직접 수행하지 않고, 대신에 이를 Calculator 구현체에게 위임하여 실행합니다. 따라서 ExecutionTimeCalculator는 팩토리얼 연산에 대한 주도적인 역할을 수행하는 것이 아니라, 단순히 주어진 입력값에 대해 주입된 Calculator 구현체에게 연산을 위임하는 역할을 합니다.
6. BasicCalculator가 팩토리얼 연산을 하고 이 결과값을 다시 ExecutionTimeCalculator에 반환하고 다시 실행 시간을 구하고 실행 시간을 출력해줍니다.
7. 마지막으로 팩토리얼 연산값을 클라이언트에게 반환해줍니다.

따라서 AOP란❓

• 핵심 기능에 따라 공통 기능을 삽입하는 것
• 핵심 기능의 코드를 수정하지 않으면서 공통 기능의 구현을 추가하는 것

💟 AOP 용어

1. @Target : 부가기능을 부여할 대상을 지정합니다. 어느 대상에 부가기능을 적용할지를 명시합니다.

2. @Advice : 타겟에 제공할 부가기능을 담은 모듈을 정의하는 어노테이션입니다. Advice를 정의할 때, 어떤 기능을 하는지와 어느 시점에 적용할 것인지를 정의해야 합니다.

3. @JoinPoint : 어드바이스가 적용될 수 있는 위치를 지정합니다. 어느 시점에서 부가기능을 적용할지를 정의합니다.

4. @Pointcut : 어드바이스를 적용할 조인 포인트를 선별하는 작업을 정의하는 어노테이션입니다. 부가 기능이 적용될 메서드를 선별하는 용도로 사용됩니다.

5. @Aspect : 부가 기능을 정의하는 Advice와 어느 Join Point(연결 지점)에서 해당 Advice가 실행될지를 결정하는 Pointcut을 선언할 수 있습니다.

6. @Weaving : 조인 포인트에서 어드바이스를 적용하는 방법을 정의하는 어노테이션입니다. 어떻게 부가기능을 조인 포인트에 적용할지를 지정할 수 있습니다.

🟦 @Advice(부가기능)의 종류

• @After : 메소드가 반환되거나 예외 상황이 발생한 이후에 호출됩니다.
• @AfterReturning : 메소드가 반환된 이후에 호출됩니다.
• @AfterThrowing : 메소드가 예외 상활을 발생시킨 이후에 호출됩니다.
• @Before : 메소드가 호출되기 이전에 호출됩니다.
• @Around : 메소드의 호출 전과 호출이 완료되고 반환되거나 예외 상황 이후에 호출됩니다.

💟 Spring AOP 구현

BasicCalculator 빈 등록

@Component
public class BasicCalculator implements Calculator{
    @Override
    public long factorial(long num) {
        long result = 1;

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

RecursiveCalculator 빈 등록

@Component
public class RecursiveCalculator implements Calculator{
    @Override
    public long factorial(long num) {
        if(num == 0){
            return 1;
        }
        return num * factorial(num -1);
    }
}

ExecutionTimeAspect - AOP 구현

@Component //빈 등록
@Aspect //AOP 구현
public class ExecutionTimeAspect {

    @Pointcut("execution(* fact*(..))") //부가 기능을 적용할 대상(fact이름 들어간) 설정
    private void publicTarget(){}

    // 타깃 호출 전, 후에 실행 시간 측정
    @Around("publicTarget()") // 포인트컷 참조
    public Object measure(ProceedingJoinPoint joinPoint) throws Throwable{
        long start = System.currentTimeMillis(); // 시작 시간 체크
        try {
            Object result = joinPoint.proceed(); // 타켓 호출
            return result;
        } finally {
            long finish = System.currentTimeMillis(); // 끝나는 시간 체크
            Signature signature = joinPoint.getSignature();
            System.out.printf("%s.%s(%s) 실행시간 : %d \n",
                    joinPoint.getTarget().getClass().getSimpleName(),
                    signature.getName(),
                    Arrays.toString(joinPoint.getArgs()),
                    (finish-start));
        }
    }
}

1. @Component : 빈으로 등록합니다.

2. @Aspect : Aspect 애너테이션으로, 해당 클래스가 Aspect로 동작함을 나타냅니다. Aspect는 부가적인 기능을 적용할 대상을 정의하고, 이에 대한 어드바이스를 제공합니다.

3. @Pointcut("execution(* fact*(..))") : 어드바이스가 적용될 대상을 지정하는 포인트컷을 정의하는 어노테이션입니다. 여기서는 이름이 "fact"으로 시작하는 메서드들을 대상으로 지정합니다.

4. private void publicTarget() {} : 위에서 정의한 포인트컷을 사용하기 위한 메서드입니다. 이 메서드는 실제로 호출되지 않으며, 포인트컷을 참조하기 위한 용도로 사용됩니다.

5. @Around("publicTarget()") : 어드바이스를 정의하는 어노테이션으로, 메서드 실행 전과 후에 공통 기능을 적용하는 Around 어드바이스를 지정합니다. 여기서는 위에서 정의한 포인트컷을 사용하여 메서드 호출 전후에 어드바이스를 적용합니다.

이러한 방식으로 위의 Aspect는 fact로 시작하는 메서드의 실행 시간을 측정하여 출력하는 부가기능을 제공합니다.

@SpringBootTest
public class ExecutionTimeAspectTest {

    @Autowired
    private Calculator basicCalculator;

    @Autowired
    private Calculator recurCalculator;

    @Test
    public void test(){
        long factorialAnswer = basicCalculator.factorial(5);
        System.out.printf("factorial 결과 : %d \n", factorialAnswer);
        System.out.printf("실행된 객체 : %s \n", basicCalculator.getClass().getName());

        System.out.println("=======================================");

        long factorialAnswer2 = recurCalculator.factorial(5);
        System.out.printf("factorial 결과 : %d \n", factorialAnswer2);
        System.out.printf("실행된 객체 : %s \n", recurCalculator.getClass().getName());

    }
}