[Spring] AOP 완벽 가이드

🌀 Spring AOP 완벽 가이드: 원리, 수동/자동 구현 비교 분석

📌 AOP(Aspect-Oriented Programming)란?

한 줄 정의
비즈니스 로직과 공통기능(로깅, 트랜잭션, 보안 등)을 분리하여 관리하는 프로그래밍 기법

AOP는 비즈니스 로직과 횡단 관심사(Cross-cutting Concerns)를 분리해 유지보수를 쉽게 하고 코드의 재사용성을 높여줍니다.

---

🎯 AOP는 왜 필요할까?

• 중복 코드 감소
• 유지보수 용이성 증가
• 관심사 분리로 코드 가독성 및 품질 향상
• 트랜잭션, 로깅과 같은 부가 기능의 관리 편리성 증가

 

 

🚀 AOP 구현 방식 비교: 수동 vs 자동

🔸 (1) AOP 수동 구현

가장 기본적인 형태로 AOP를 흉내 내는 방법은 Java의 Reflection API를 사용하는 것입니다. 특정 규칙(메서드 이름 패턴, 어노테이션 등)에 따라 부가 기능(Advice)을 핵심 로직 호출 전후에 실행시키는 방식입니다.

 

예제 코드 살펴보기:

• MyClass.java: 핵심 비즈니스 로직을 담고 있는 클래스입니다. aaa(), aaa2(), bbb() 메서드를 가집니다. aaa() 메서드에는 @Transactional 어노테이션이 붙어 있습니다.
• MyAdvice.java: 부가 기능(Advice)을 담당하는 클래스입니다.
  • invoke() 메서드: Reflection으로 얻어온 Method 객체를 받아, 특정 조건(여기서는 @Transactional 어노테이션 유무)을 만족하면 메서드 실행 전후에 공통 코드를 출력하고, 실제 메서드(m.invoke(obj, arg))를 호출합니다.
  • Pattern, matches(): (예제에서는 invoke 조건문에서 주석 처리되었지만) 메서드 이름이 특정 패턴("a"로 시작)과 일치하는지 확인하여 Advice 적용 대상을 선정하는 또 다른 방법(Pointcut 시뮬레이션)을 보여줍니다.
• AopMain.java: Reflection을 사용하여 MyClass의 객체를 생성하고, 모든 메서드를 순회하며 MyAdvice의 invoke 메서드를 통해 호출합니다.

 

// AopMain.java (일부)
Class myClass = Class.forName("com.ABC.sbtch3.AOP.MyClass");
Object o = myClass.newInstance();
MyAdvice myAdvice = new MyAdvice();
for(Method m : myClass.getDeclaredMethods()){
    myAdvice.invoke(m, o, null); // 각 메서드를 Advice를 통해 호출
}

// MyAdvice.java (일부)
class MyAdvice {
    // ... Pattern p, matches() ...

    void invoke(Method m, Object obj, Object... arg) throws Exception {
        // @Transactional 어노테이션이 붙어있는 메서드에만 전/후 부가기능 적용 (Pointcut 역할)
        if(m.getAnnotation(Transactional.class)!= null) {
            System.out.println("[before]{"); // 공통 부가 기능 (Advice)
        }
        m.invoke(obj, arg); // 타겟 메서드(핵심 로직) 호출
        if(m.getAnnotation(Transactional.class)!= null) {
            System.out.println("}[after]"); // 공통 부가 기능 (Advice)
        }
    }
}

// MyClass.java (일부)
class MyClass {
    @Transactional // 부가 기능 적용 대상임을 표시
    void aaa() { System.out.println("aaa() is called"); }
    void aaa2() { System.out.println("aaa2() is called"); }
    void bbb() { System.out.println("bbb() is called"); }
}

코드 부연 설명:

• invoke(Method m, Object obj, Object... arg): Reflection의 Method.invoke()를 사용하여 실제 타겟 객체(obj)의 메서드(m)를 호출합니다. 이 호출 전후에 부가 기능을 삽입함으로써 AOP의 'Around Advice'와 유사한 동작을 흉내 냅니다.
• if(m.getAnnotation(Transactional.class)!= null): 이 조건문이 Pointcut (부가 기능을 적용할 대상을 선별하는 조건)의 역할을 합니다. 여기서는 @Transactional 어노테이션이 붙은 메서드만 대상으로 삼습니다. 실제 트랜잭션 처리는 없지만, 트랜잭션 시작/종료 로직이 이러한 형태로 적용될 수 있음을 보여줍니다. 트랜잭션 처리는 대표적인 횡단 관심사(Cross-Cutting Concern) 이므로 AOP 적용에 매우 적합합니다.
• Pattern, matches(): 만약 이름 기반으로 대상을 선정하고 싶다면 matches(m)와 같은 조건을 사용할 수 있습니다. Pattern.compile("a.*")은 'a'로 시작하는 모든 메서드 이름을 의미합니다.

수동 구현의 한계:

• 복잡성: 모든 객체와 메서드에 대해 Reflection 코드를 작성하고 적용하는 것은 매우 번거롭습니다.
• 성능 저하: Reflection API는 일반적인 메서드 호출보다 성능이 느립니다.
• 오류 가능성: 문자열 기반의 클래스/메서드 이름 사용, 타입 체크의 어려움 등으로 런타임 오류 발생 가능성이 높습니다.
• 제한적인 기능: Pointcut 표현, 다양한 Advice 타입(Before, After 등) 지원 등이 미흡합니다.
• 프록시 미사용: 실제 객체를 직접 호출하므로, Spring AOP처럼 프록시를 통한 유연한 위빙(Weaving)이 어렵습니다.

 

🔸 (2) AOP 자동 구현 (Spring AOP)

Spring Framework는 AspectJ 라이브러리와의 통합을 통해 훨씬 강력하고 편리한 AOP 기능을 제공합니다. 개발자는 복잡한 Reflection 코드 대신, 어노테이션과 설정으로 AOP를 구현할 수 있습니다. Spring AOP는 기본적으로 프록시(Proxy) 기반으로 동작합니다.

예제 코드 살펴보기:

• MyMath.java: 핵심 비즈니스 로직(덧셈, 뺄셈, 곱셈)을 가진 타겟 클래스입니다. AOP 관련 코드가 전혀 없습니다. (@Component로 스프링 빈으로 등록)
• LoggingAdvice.java: 부가 기능(로그 출력)을 담당하는 Aspect 클래스입니다.
  • @Aspect: 이 클래스가 Aspect임을 선언합니다.
  • @Component: Spring이 이 Aspect를 빈으로 관리하도록 합니다.
  • @Around: Advice의 종류를 지정합니다. (타겟 메서드 실행 전후 및 예외 처리 등 포괄적 제어 가능)
  • "execution(* com.ABC.sbtch3.AOP.MyMath.add*(..))": Pointcut 표현식입니다. com.ABC.sbtch3.AOP 패키지의 MyMath 클래스에 있는 이름이 add로 시작하는 모든 메서드(리턴 타입(*), 파라미터(..) 무관)를 대상으로 지정합니다.
  • ProceedingJoinPoint pjp: 현재 Advice가 적용된 Join Point(메서드)에 대한 정보를 담고 있으며, pjp.proceed()를 통해 실제 타겟 메서드를 호출할 수 있습니다.
• Config.java: Spring 설정 클래스입니다.
  • @EnableAspectJAutoProxy: 핵심 설정! 이 어노테이션이 있어야 Spring이 @Aspect 빈을 찾아서 Pointcut에 매칭되는 타겟 객체에 대한 프록시(Proxy) 를 생성하고, Advice를 적용(Weaving)합니다. 이게 없으면 AOP가 전혀 동작하지 않습니다.
  • @ComponentScan: @Component, @Aspect 등이 붙은 클래스를 스캔하여 빈으로 등록합니다.
• AopMain2.java: Spring 컨텍스트를 실행하고, MyMath 빈을 가져와 메서드를 호출합니다.

Java

 

// Config.java (일부)
@EnableAspectJAutoProxy // <<-- 이게 있어야 AOP가 활성화되고 프록시가 생성됨!
@ComponentScan
@Configuration
class Config { }

// LoggingAdvice.java (일부)
@Component // Spring Bean으로 등록
@Aspect    // Aspect 클래스임을 선언
class LoggingAdvice {
    // Around Advice + Pointcut 설정
    @Around("execution(* com.ABC.sbtch3.AOP.MyMath.add*(..))")
    public Object methodClassLog(ProceedingJoinPoint pjp) throws Throwable {
        // 타겟 메서드 시작 전 부가 기능
        System.out.println("<<[start]" + pjp.getSignature().getName() + Arrays.toString(pjp.getArgs()));

        Object result = pjp.proceed(); // <<-- 타겟 메서드(핵심 로직) 호출

        // 타겟 메서드 종료 후 부가 기능
        System.out.println("[end]>>" + ... + "ms");
        return result;
    }
}

// MyMath.java (일부) - 타겟 클래스
@Component
class MyMath {
    int add(int a, int b) { /*...*/ }
    int add(int a, int b, int c) { /*...*/ }
    int multiply(int a, int b) { /*...*/ }
}

// AopMain2.java (일부)
ApplicationContext ac =  SpringApplication.run(Config.class);
MyMath mm = ac.getBean("myMath", MyMath.class); // <<-- 실제로는 MyMath의 프록시 객체가 반환됨
mm.add(3,5);        // -> LoggingAdvice 적용됨
mm.multiply(3,5);   // -> LoggingAdvice 적용 안 됨 (Pointcut 불일치)

코드 부연 설명 및 어노테이션 역할:

• @EnableAspectJAutoProxy: Spring에게 AspectJ 기반의 AOP 처리를 활성화하라고 지시합니다. 이 어노테이션이 없으면 Spring은 @Aspect가 붙은 빈을 발견해도 무시하고 프록시를 생성하지 않아 AOP가 적용되지 않습니다. 반드시 필요합니다.
• @Aspect: LoggingAdvice 클래스가 단순한 빈이 아니라, Advice와 Pointcut을 담고 있는 특별한 Aspect 모듈임을 Spring에게 알려줍니다. @EnableAspectJAutoProxy는 @Aspect가 붙은 빈을 찾아 처리합니다.
• @Around: 여러 Advice 타입 중 하나로, 타겟 메서드 호출 전체를 감쌀 수 있습니다. 즉, 메서드 호출 전, 후, 예외 발생 시 등 모든 시점에 개입하여 부가 기능을 적용하고, 심지어 타겟 메서드의 반환 값을 조작하거나 호출 자체를 막을 수도 있습니다. (pjp.proceed() 호출 여부)
• execution(...) (Pointcut): Advice를 어디에 적용할지 결정하는 표현식입니다. AspectJ Pointcut 표현식 문법을 사용하여 매우 정교하게 적용 대상을 지정할 수 있습니다. (예: 특정 패키지 하위, 특정 어노테이션이 붙은 메서드, 특정 이름 패턴 등)
• ProceedingJoinPoint pjp: @Around Advice 메서드의 필수 파라미터입니다. 현재 Advice가 적용된 대상 메서드(Join Point)에 대한 정보(메서드 시그니처, 파라미터 등)를 얻고, pjp.proceed()를 호출하여 실제 타겟 메서드의 실행을 제어할 수 있습니다.
• 프록시(Proxy) 동작 원리: @EnableAspectJAutoProxy가 활성화되면, Spring은 Pointcut에 매칭되는 메서드를 가진 빈(여기서는 MyMath 빈)을 생성할 때, 직접 MyMath 객체를 빈으로 등록하는 대신 프록시 객체를 생성하여 빈으로 등록합니다. 이 프록시 객체는 MyMath와 동일한 인터페이스(또는 상속 구조)를 가지며, 내부에 실제 MyMath 객체(Target)를 참조합니다. 클라이언트(AopMain2)가 프록시 객체의 메서드(add())를 호출하면, 프록시는 먼저 Aspect(LoggingAdvice)의 Advice를 실행하고, Advice 내부에서 pjp.proceed()가 호출될 때 실제 MyMath 객체의 add() 메서드를 실행합니다. multiply()처럼 Pointcut에 해당하지 않는 메서드는 Advice 적용 없이 바로 타겟 객체의 메서드가 호출됩니다.

---

※ 비교 분석: 수동 AOP vs 자동 AOP

항목수동 AOP (Reflection)자동 AOP (Spring AOP + AspectJ)

 

구현 복잡도	높음 (반복적인 Reflection 코드)	낮음 (어노테이션, 설정 기반)
성능	낮음 (Reflection 오버헤드)	상대적으로 우수 (프록시 오버헤드, 최적화)
기능/유연성	제한적 (기본적인 Around 흉내)	강력함 (다양한 Advice, 정교한 Pointcut)
코드 결합도	높음 (Advice 코드가 타겟 호출 로직과 결합)	낮음 (Target 코드는 AOP 모르게 작성 가능)

• 프레임워크 통합 | 어려움 | 쉬움 (Spring 컨텍스트와 완벽 통합) |
• 프록시 사용 | 사용 안 함 (직접 호출 제어) | 사용함 (Dynamic Proxy 또는 CGLIB) |
• 표준/관례 | 비표준적, 학습용 | Spring 표준, 실무에서 널리 사용 |

---

결론

AOP는 애플리케이션의 공통 관심사를 효과적으로 분리하고 모듈화하여 코드의 중복을 줄이고 유지보수성을 높이는 강력한 패러다임입니다. 수동 구현 방식(Reflection)은 AOP의 기본 원리를 이해하는 데 도움이 될 수 있지만, 실제 애플리케이션 개발에는 성능, 복잡성, 기능 제한 등의 한계가 명확합니다.

반면, Spring AOP와 AspectJ를 활용한 자동 구현 방식은 @Aspect, @EnableAspectJAutoProxy 등의 어노테이션과 설정을 통해 훨씬 간결하고 강력하며 효율적으로 AOP를 적용할 수 있게 해줍니다. 특히 프록시 기반으로 동작하여 타겟 코드의 변경 없이 부가 기능을 동적으로 위빙하는 능력은 Spring AOP의 핵심 장점입니다.

따라서 현대적인 Spring 기반 애플리케이션에서는 당연히 Spring AOP를 사용하여 로깅, 트랜잭션 관리, 보안 등 다양한 횡단 관심사를 처리하는 것이 표준적인 방법입니다.