[Spring] AOP (Aspect Oriented Programming)

AOP가 필요한 이유

@Service
public class OrderService {
	
    @Autowired
    private OrderRepository orderRepository;
    
    public Order placeOrder(OrderRequest request) {
    	// 1. 로깅
        log.debug("주문 요청 : {}" , request);
        long start = System.currentTimeMilis();
        
        // 2. 권한 체크
        if (!SecutiryContext.hasRole("USER")) {
        	throw new AccessDeniedException("권한 없음");
        }
        
        Connection con = null;
        
        try {
        	// 3. 리소스 획득 & 트랜잭션 시작
            con = dataSource.getConnection();
            con.setAutoCommit(false);
            
            // 4. 핵심 로직
            Order order = orderRepository.save(con, request);
            
            // 5. 트랜잭션 커밋
            con.commit();
            return order;
        } catch (Exception e)) {
        	// 6. 예외 처리 & 롤백
            con.rollback();
            throw new OrderException(e);
        } finally {
        	// 7. 리소스 반환
            con.close();
            // 8. 성능 측정 로길
            log.debug("소요 시간 : {}ms", System.currentTimeMilis() - start);
        }
    }
}

이 메서드에서 비즈니스 로직은 "Order order = orderRepository.save(con, request)" 한 줄입니다.

나머지 코드는 부가 코드이며, cancelOrder( ), updateOrder( )...등을 만들면 중복으로 동일한 부가코드가 반복됩니다. 

 

여러 메서드를 가로지르며 반복되는 부가 로직을 횡단 관심사("Crossing-cutting Concern") 라고 부릅니다.

대표적으로 "로깅, 성능, 보안, 암호화, 일관적인 예외 처리, 트랜잭션 처리" 등이 해당됩니다. 

 

AOP

 

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

 

AOP는 부가 로직들을 비즈니스 코드에서 완전히 분리해 "관점(Aspect)"라는 별도 모듈로 관리합니다.

 

@Service
public class OrderService {
	
    @Autowired
    private OrderRepository orderRepository;
    
    public Order placeOrder(OrderRepository request) {
    	return orderRepository.save(request);
    }
}

AOP를 적용하면 위와 같이 코드를 작성할 수 있습니다. 

로깅, 성능, 권한 체크, 트랜잭션은 별도의 Aspect에서 처리하고, 개발자는 비즈니스 로직만을 작성합니다.

 

AOP 핵심 용어

용어	의미
Target	AOP가 적용될 대상 빈, 핵심 로직을 가진 객체(예: OrderService)
Aspect	모듈화된 횡단 관심사. 하나 이상의 Advice로 구성
Advice	횡단 관심 코드를 담은 실제 메서드. 언제 실행될지에 따라 5종류(@Before, @After, @AfterReturning, @AfterThrowing, @Around)로 구분
Join Point	Advice가 적용 가능한 지점. Spring AOP에서는 "메서드 실행" 시점만 가
Pointcut	Join Point중에서 "어디에" Advice를 적용할지 결정하는 필터 표현식
Weaving	Aspect를 실제 비즈니스 코드에 적용하는 행

 

Spring AOP의 동작 원리 - "Proxy"

 Spring은 AOP를 구현하기 위해 타깃 빈을 그대로 노출하지 않고, 타깃을 감싼 프록시 객체를 빈으로 등록합니다.

기본적인 동작은 CGLib 라이브러리를 활용해 타깃 클래스를 상속한 프록시 클래스를 런타임에 만들어내는 방식으로 동작합니다. 

[빈 설정 분석] -> [빈 생성] -> [Pointcut 기반 AOP 적용 검토] ->
[Proxy 생성] -> [노출 대상을 target에서 proxy로 교체]

 

applicationContext.getBean(OrderService.class)를 호출할 경우, 

실제로는 OrderService$$SpringCGLIB$$0 같은 이름의 프록시 객체가 반환됩니다. 이 프록시는 OrderService를 상속하고, 메서드 호출이 들어오면 부가 로직을 먼저 처리한 뒤, super.placeOrder(...)로 실제 타깃 메서드를 호출합니다.

클라이언트 -> [프록시 객체] -> 부가 로직 처리 ->
[타깃 객체.placeOrder()] -> 결과 반환

 

Pointcut 작성

Pointcut은 "어떤 메서드에서 Advice를 적용할지"를 골라내는 표현식입니다. 

지정자	설명
execution	메서드나 시그니처 기반으로 정교한 매칭
within	클래스 또는 패키지 단위로 매칭
bean	빈 이름 기반으로 매칭
@within	클래스에 붙은 애너테이션 기준 매칭
@annotation	메서드에 붙은 애너테잇녀 기준 매칭

 

• execution 표현 문법식

execution(수정자 리턴타입 패키지.클래스.메서드명(파라미터))

- * : 임의의 한 단어

- .. : 0개 이상(패키지 경로면 하위 전체, 파라미터면 개수 무관)

- ! : 부정

 

예시 )

// com.example.order 패키지의 모든 메서드
"execution(* com.example.order..*(..))"

// public 리턴타입 무관, 이름이 find로 시작하는 모든 메서드
"execution(public * find*(..))"

// String을 반환하고 파라미터가 정확히 1개인 모든 메서드
"execution(String *(*))"

// 리턴타입이 List<User>인 메서드
"execution(java.util.List<com.example.User> *(..))"

// 여러 pointcut 조합
"execution(* com.example.service..*(..)) || execution(* com.example.api..*(..))"

 

매번 표현식을 반복하면 지저분해지므로, @Pointcut으로 이름을 붙여 재사용할 수 있습니다.

@Aspect
@Component
public class CommonPointcuts {
	@Pointcut("execution(* com.example.service..*(..))")
    public void serviceLayer() {}
    
    @Pointcut("@annotation(com.example.annotation.Loggable)")
    public void loggableMethods() {}
}

//----------------------------------------------------------------------

@Before("com.example.aop.CommonPointcuts.serviceLayer()")
public void doLogic(JoinPoint jp) { ... }

 

Advice

Advice는 Join Point에서 advice가 실행되는 시점에 따라 5가지로 나뉩니다.

애너테이션	실행 시점
@Before	타깃 메서드 호출 전
@After	타깃 메서드 종료 후(성공 / 예외와 무관, finally 처럼 동작)(
@AfterReturning	타깃 메서드가 정상 리턴한 경우만
@AfterThrowing	타깃 메서드가 예외를 던진 경우만
@Around	타깃 메서드 호출을 직접 제어

 

* 공용 비즈니스 로직 *

@Service
public class ProductService {

    public Product findById(Long id) {
        if (id < 0) throw new IllegalArgumentException("음수 ID");
        return new Product(id, "노트북", 1500000);
    }

    public Product updatePrice(Long id, int newPrice) {
        return new Product(id, "노트북", newPrice);
    }
}

아래 예제들에서 공통적으로 사용할 비즈니스 코드 예시입니다.

 

@Before - 메서드 실행 전

• annotation

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementTYpe.METHOD)
public @interface Before{
	String value();
}

• 예시

@Aspect
@Component
@Slf4j
public class LoggingAspect {
	
    @Before("execution(* com.example.service.ProductService.*(..))")
    public void logBefore(JoinPoint joinPoint) {
    	String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        
        log.info("[호출 전] {} 메서드, 인자: {}", methodName, Arrays.toString(args));
    }
}

• 특징 : 인자를 조회, 조작할 수 있습니다. 완전히 다른 객체로 교체는 불가능하고, 객체의 속성만 변경 가능합니다. 또한 Advice 내부에서 예외가 발생하면 타깃 메서드는 실행되지 않습니다.
• JointPoint.getArgs()로 배열을 꺼내는 대신, Pointcut에 args()를 적으면 메서드 파라미터로 직접 받을 수 있습니다.

@Before("execution(* com.example.service.ProductService.findById(..)) && args(id)")
public void logId(Long id) {
    log.info("조회 요청 ID: {}", id);
}

 

@AfterReturning - 정상 리턴 시

• annotation

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @Interface AfterReturning {
	String value() default "";     // pointcut의 alias
    String pointcut() default "";
    String running() default "";   // target의 return 값 할당
}

• 예시

@AfterReturning(
	pointcut = "execution(* com.example.service.ProductService.findById(..))",
    returning = "result"
)
public void logResult(JoinPoint joinPoint, Product result) {
	log.info("[정상 반환] 메서드 : {}, 결과 : {}",
    	joinPoint.getSignature().getName(), result);
}

• returning :
  • target이 반환한 값을 저장할 변수명
  • advice method의 파라미터 이름과 일치해야 함
• 특징 : 반환받은 return 값 조작 가능
  • 완전 대체 x, 객체의 경우 속성 변경 가능

 

@AfterThrowing - 예외 발생 시

• annotation

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface AfterThrowing {
	String value() default "";
    String pointcut() default "";
    String throwing() default "";
}

• 예시

@AfterThrowing(
	pointcut = "execution(* com.ssafy.service.ProductService.*(..))",
    throwing = "ex"
)
public void logException(JoinPoint joinPoint, Exception ex) {
    log.error("[예외 발생] 메서드: {}, 예외: {}", 
        joinPoint.getSignature().getName(), ex.getMessage());
}

• throwing :
  • target이 던진 예외를 저장할 변수명
  • advice method의 파라미터 이름과 일치해야 함
• 특징 : 예외가 던져진 것이 아니고, 참조만 전달
  • 부가적인 작업 수행을 위함. 
  • try ~ catch 로 처리 불가

 

@After - 무조건 실행

• annotation

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface After {
	String value() default "";
}

• 예시

@After("execution(* com.example.service.ProductService.*(..))")
public void logAfter(JoinPoint joinPoint) {
    log.info("[종료] {} 메서드 종료 (성공/실패 무관)", 
        joinPoint.getSignature().getName());
}

• try-catch-finally의 finally 블록과 동일하게 동작.
• 정상 리턴이든 예외던 상관 없이 무조건 실행됨 (리소스 정리 같은 작업에 적합)

 

@Around

• annotatio

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @Interface Around {
	String value();
}

• 예시

@Around("execution(* com.example.service.ProductService.*(..))")
public Object measurePerformance(ProceedingJoinPoint pjp) throws Throwable {
    String methodName = pjp.getSignature().getName();
    long start = System.currentTimeMillis();

    try {
        // 실제 타깃 메서드 호출
        Object result = pjp.proceed();
        
        long elapsed = System.currentTimeMillis() - start;
        log.info("[성능] {} 완료, 소요시간: {}ms", methodName, elapsed);
        return result;
    } catch (Throwable t) {
        log.error("[성능] {} 실패", methodName);
        throw t;
    }
}

• @Around 는 타깃 메서드 호출 자체를 직접 제어합니다.
• 다른 Advice들과 달리 파라미터와 리턴 값을 완전히 교체 가능합니다.

 

정리

AOP는 "비즈니스 로직과 부가 로직의 분리" 라는 아이디어에서 시작해 아래의 세 가지를 제공합니다.

• Pointcut으로 "어디에" 적용할지 표현
• Advice로 "언제, 무엇을" 할지 정의하고
• 프록시가 런타임에 이 둘을 비즈니스 코드에 엮어줌