AOP란?

이규정·2025년 2월 27일

✅ Spring AOP

Spring AOP는 관점 지향 프로그래밍 (Aspect-Oriented Programming) 을 적용하여 핵심 비즈니스 로직과 공통 관심사(로깅, 보안, 트랜잭션 관리 등)를 분리할 수 있도록 해줍니다.

🔹 AOP의 핵심 개념

Spring AOP는 아래 5가지 핵심 개념으로 구성됩니다.

개념	설명
JoinPoint (조인포인트)	Advice가 실행될 수 있는 특정 지점 (예: 메서드 실행)
Pointcut (포인트컷)	어떤 JoinPoint에서 Advice를 적용할지 결정하는 필터 역할
Advice (어드바이스)	JoinPoint에서 실행할 코드 (실제 부가 기능)
Aspect (애스펙트)	여러 Advice와 Pointcut을 하나로 묶은 단위
Weaving (위빙)	Aspect를 대상 객체에 적용하는 과정

🔹 AOP의 전체 흐름

1️⃣ Spring 컨테이너가 빈을 생성

→ 애플리케이션이 실행되면 Spring이 Bean 객체를 생성.

2️⃣ AOP 프록시가 적용될 대상 객체를 감지

→ @Aspect를 사용하여 설정한 클래스들을 Spring이 스캔.

3️⃣ Pointcut에 해당하는 JoinPoint를 탐색

→ execution(* com.example.service..*(..)) 와 같은 Pointcut을 분석.

4️⃣ Advice를 JoinPoint에서 실행

→ JoinPoint에 도달하면 해당하는 Advice가 실행됨.

5️⃣ Weaving을 통해 프록시 객체 생성 및 적용

→ 원래 객체 대신 AOP 프록시 객체가 동작하여 부가 기능을 실행.

🔹 AOP의 동작 구조 (그림으로 표현)

┌──────────────────────────────────────────┐
│        @Aspect (LoggingAspect)           │
│   ┌────────────────────────────────┐    │
│   │ @Before / @After / @Around     │    │
│   │ 특정 메서드 실행 전/후/주변 실행 │    │
│   └────────────────────────────────┘    │
└──────────────────────────────────────────┘
                │
                ▼
┌──────────────────────────────────────────┐
│         Pointcut (포인트컷)                │
│ "execution(* com.example.service..*(..))" │
│ 실행될 메서드 선택 필터 역할               │
└──────────────────────────────────────────┘
                │
                ▼
┌──────────────────────────────────────────┐
│         JoinPoint (조인포인트)             │
│ 특정 메서드 실행 (예: getUser())           │
└──────────────────────────────────────────┘
                │
                ▼
┌──────────────────────────────────────────┐
│       Target Object (대상 객체)            │
│ 원래 실행될 서비스 객체 (예: UserService) │
└──────────────────────────────────────────┘

🔹 Advice 종류별 동작

Advice 유형	실행 시점	사용 예제
`@Before`	메서드 실행 전	`@Before("execution(* com.example.service..*(..))")`
`@AfterReturning`	메서드 실행 후 (정상 실행 시)	`@AfterReturning(pointcut = "...", returning = "result")`
`@AfterThrowing`	예외 발생 시	`@AfterThrowing(pointcut = "...", throwing = "ex")`
`@After`	메서드 실행 후 (성공/실패 관계없이)	`@After("execution(* ... )")`
`@Around`	메서드 실행 전후 (ProceedingJoinPoint 사용)	`@Around("execution(* ... )")`

🔹 Spring AOP의 핵심 구성 요소

Spring AOP는 다음 5가지 핵심 개념으로 구성됩니다.

개념	설명
Aspect	여러 Advice와 Pointcut을 포함하는 AOP의 단위 (ex: LoggingAspect)
Advice	특정 JoinPoint에서 실행될 코드 (ex: @Before, @After, @Around)
JoinPoint	AOP가 적용될 수 있는 실행 지점 (ex: 메서드 실행, 예외 발생)
Pointcut	어떤 JoinPoint에서 Advice를 실행할지 결정하는 표현식
Weaving	Advice를 실제 코드에 적용하는 과정

🔹 Spring AOP의 동작 과정

1️⃣ 클라이언트가 컨트롤러나 서비스 메서드를 호출

2️⃣ Pointcut이 해당 메서드를 가로챌지 확인

3️⃣ Pointcut이 일치하면 JoinPoint에서 Advice(로깅, 트랜잭션 등) 실행

4️⃣ 원래 메서드 실행 (proceed())

5️⃣ Advice가 응답 후 작업 수행 (ex: 실행 시간 로깅)

6️⃣ 최종 응답 반환

📌 개념 흐름을 쉽게 이해할 수 있도록 다이어그램으로 표현하면:

Client → Service Method (JoinPoint) → Pointcut 체크 → Advice 실행 → Proceed() 실행 → 응답 반환

🔹 Spring AOP 구조 예제

아래 예제는 모든 @Service 메서드 실행 전에 로그를 출력하는 AOP 구조를 보여줍니다.

1️⃣ Aspect 클래스 (LoggingAspect)

@Aspect
@Component
@Slf4j
public class LoggingAspect {

    // ✅ 서비스 계층 모든 메서드 실행 전에 로깅
    @Before("execution(* com.example.service..*(..))")
    public void logBeforeMethod(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName(); // 실행된 메서드명
        String className = joinPoint.getTarget().getClass().getSimpleName(); // 실행된 클래스명
        log.info("[AOP] {}.{}() 실행됨", className, methodName);
    }
}

2️⃣ Pointcut 표현식 해석

@Before("execution(* com.example.service..*(..))")

execution( → 메서드 실행 시 적용
**** → 모든 반환 타입 적용 (void, String, int 등)
com.example.service.. → service 패키지 및 하위 패키지 포함
**** → 모든 메서드 이름 (getUser(), saveUser() 등)
(..) → 모든 매개변수 허용 (getUser(Long id), saveUser(User user) 등)

✅ 즉, com.example.service 아래 모든 서비스 메서드 실행 전에 Advice가 실행됩니다.

🔹 Spring AOP의 다양한 Advice 종류

Spring AOP에서는 Advice(조언) 을 여러 방식으로 적용할 수 있습니다.

✅ 1️⃣ `@Before` (메서드 실행 전에 실행)

@Before("execution(* com.example.service.UserService.*(..))")
public void beforeAdvice(JoinPoint joinPoint) {
    log.info("[AOP] {} 메서드 실행 전에 실행됨", joinPoint.getSignature().getName());
}

📌 예제 실행 결과

[AOP] getUser() 메서드 실행 전에 실행됨

✅ 2️⃣ `@AfterReturning` (메서드 정상 실행 후 실행)

@AfterReturning(pointcut = "execution(* com.example.service.UserService.*(..))", returning = "result")
public void afterReturningAdvice(JoinPoint joinPoint, Object result) {
    log.info("[AOP] {} 메서드 실행 완료 - 결과: {}", joinPoint.getSignature().getName(), result);
}

📌 예제 실행 결과

[AOP] getUser() 메서드 실행 완료 - 결과: User{id=1, name='John'}

✅ 3️⃣ `@AfterThrowing` (예외 발생 시 실행)

@AfterThrowing(pointcut = "execution(* com.example.service.UserService.*(..))", throwing = "ex")
public void afterThrowingAdvice(JoinPoint joinPoint, Exception ex) {
    log.error("[AOP] {} 메서드 실행 중 예외 발생 - {}", joinPoint.getSignature().getName(), ex.getMessage());
}

📌 예제 실행 결과

[AOP] getUser() 메서드 실행 중 예외 발생 - 사용자 ID가 존재하지 않습니다.

✅ 4️⃣ `@After` (메서드 실행 후 무조건 실행)

@After("execution(* com.example.service.UserService.*(..))")
public void afterAdvice(JoinPoint joinPoint) {
    log.info("[AOP] {} 메서드 실행 후 실행됨", joinPoint.getSignature().getName());
}

📌 예제 실행 결과

[AOP] getUser() 메서드 실행 후 실행됨

✅ 5️⃣ `@Around` (메서드 실행 전/후 모두 감싸서 실행)

@Around는 가장 강력한 Advice로, 메서드 실행 전후에 로직을 추가하고, 실행 시간을 측정하거나 데이터를 변환할 수 있습니다.

@Around("execution(* com.example.service.UserService.*(..))")
public Object aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {
    long startTime = System.currentTimeMillis(); // 시작 시간
    log.info("[AOP] {} 메서드 실행 시작", joinPoint.getSignature().getName());

    Object result = joinPoint.proceed(); // 원래 메서드 실행

    long duration = System.currentTimeMillis() - startTime; // 실행 시간 계산
    log.info("[AOP] {} 메서드 실행 완료 - 실행 시간: {}ms", joinPoint.getSignature().getName(), duration);

    return result;
}

📌 예제 실행 결과

[AOP] getUser() 메서드 실행 시작
[AOP] getUser() 메서드 실행 완료 - 실행 시간: 145ms

✅ Spring AOP 정리

개념	설명
Aspect	여러 Advice와 Pointcut을 포함하는 AOP의 단위 (ex: LoggingAspect)
Advice	특정 JoinPoint에서 실행될 코드 (ex: @Before, @After, @Around)
JoinPoint	AOP가 적용될 수 있는 실행 지점 (ex: 메서드 실행, 예외 발생)
Pointcut	어떤 JoinPoint에서 Advice를 실행할지 결정하는 표현식
Weaving	Advice를 실제 코드에 적용하는 과정

✅ AOP를 언제 사용할까?

✅ 반복적으로 사용되는 공통 로직을 분리하고 싶을 때

예: 로깅, 트랜잭션 관리, 보안 검증, 성능 모니터링

✅ 비즈니스 로직과 부가 기능(공통 관심사)을 분리하고 싶을 때

예: 비즈니스 코드에 로그 코드가 섞이지 않도록 AOP 적용

✅ 클린한 코드 유지하고 싶을 때

예: service 코드에서 로깅/예외처리 등을 없애고 핵심 로직만 유지

✅ 결론

Spring AOP는 로깅, 보안, 트랜잭션 관리 등을 코드와 분리하는 강력한 도구
@Before, @AfterReturning, @Around 등 다양한 Advice를 활용 가능
Aspect를 활용하면 코드 중복을 최소화하고 유지보수를 쉽게 할 수 있음

참고

https://leeeeeyeon-dev.tistory.com/51

http://velog.io/@dhk22/Spring-AOP-%EA%B0%84%EB%8B%A8%ED%95%9C-AOP-%EC%A0%81%EC%9A%A9-%EC%98%88%EC%A0%9C-Logging

https://passionfruit200.tistory.com/981

https://f-lab.kr/insight/spring-aop-logging-validation-20240519

이규정

반갑습니다. 백엔드 개발자가 되기 위해 노력중입니다.

이전 포스트

[트러블 슈팅] AOP에서 사용된 요청/응답 값이 이후 단계에서 사용되지 못하는 문제

다음 포스트

AOP란?

✅ Spring AOP

🔹 AOP의 핵심 개념

🔹 AOP의 전체 흐름

🔹 AOP의 동작 구조 (그림으로 표현)

🔹 Advice 종류별 동작

🔹 Spring AOP의 핵심 구성 요소

🔹 Spring AOP의 동작 과정

🔹 Spring AOP 구조 예제

1️⃣ Aspect 클래스 (LoggingAspect)

2️⃣ Pointcut 표현식 해석

🔹 Spring AOP의 다양한 Advice 종류

✅ 1️⃣ `@Before` (메서드 실행 전에 실행)

✅ 2️⃣ `@AfterReturning` (메서드 정상 실행 후 실행)

✅ 3️⃣ `@AfterThrowing` (예외 발생 시 실행)

✅ 4️⃣ `@After` (메서드 실행 후 무조건 실행)

✅ 5️⃣ `@Around` (메서드 실행 전/후 모두 감싸서 실행)

✅ Spring AOP 정리

✅ AOP를 언제 사용할까?

✅ 결론

참고

[트러블 슈팅] AOP에서 사용된 요청/응답 값이 이후 단계에서 사용되지 못하는 문제

[트러블 슈팅] 기존 엔티티의 부속 엔티티를 재활용하지 못하는 문제.

0개의 댓글

관련 채용 정보

AOP란?

✅ Spring AOP

🔹 AOP의 핵심 개념

🔹 AOP의 전체 흐름

🔹 AOP의 동작 구조 (그림으로 표현)

🔹 Advice 종류별 동작

🔹 Spring AOP의 핵심 구성 요소

🔹 Spring AOP의 동작 과정

🔹 Spring AOP 구조 예제

1️⃣ Aspect 클래스 (LoggingAspect)

2️⃣ Pointcut 표현식 해석

🔹 Spring AOP의 다양한 Advice 종류

✅ 1️⃣ @Before (메서드 실행 전에 실행)

✅ 2️⃣ @AfterReturning (메서드 정상 실행 후 실행)

✅ 3️⃣ @AfterThrowing (예외 발생 시 실행)

✅ 4️⃣ @After (메서드 실행 후 무조건 실행)

✅ 5️⃣ @Around (메서드 실행 전/후 모두 감싸서 실행)

✅ Spring AOP 정리

✅ AOP를 언제 사용할까?

✅ 결론

참고

[트러블 슈팅] AOP에서 사용된 요청/응답 값이 이후 단계에서 사용되지 못하는 문제

[트러블 슈팅] 기존 엔티티의 부속 엔티티를 재활용하지 못하는 문제.

0개의 댓글

관련 채용 정보

✅ 1️⃣ `@Before` (메서드 실행 전에 실행)

✅ 2️⃣ `@AfterReturning` (메서드 정상 실행 후 실행)

✅ 3️⃣ `@AfterThrowing` (예외 발생 시 실행)

✅ 4️⃣ `@After` (메서드 실행 후 무조건 실행)

✅ 5️⃣ `@Around` (메서드 실행 전/후 모두 감싸서 실행)