[SPRING] AOP

 

Spring AOP

 

AOP는 Aspect Oriented Programming의 약자로 관점 지향 프로그래밍이라고 불린다. 관점 지향은 어떤 로직을 기준으로 핵심적인 관점, 부가적인 관점으로 나누어서 보고 그 관점을 기준으로 모듈화 하겠다는 것이다.

 

예를 들어 핵심적인 관점은 비즈니스 로직이 될 수 있고, 부가적인 관점은 핵심 로직을 실행하기 위해 행해지는 데이터베이스 연결, 로깅, 파일 입출력 등이 될 수 있다. 

 

 

AOP는 흩어진 관심사(Crosscutting Concerns)를 모듈화 할 수 있는 프로그래밍 기법이다

 

[그림 1]과 같이 클래스 A, B, C에서 공통적으로 나타나는 색깔 블록은 중복되는 메서드, 필드, 코드 등이다.

 

 

 

이때 예를 들어 클래스 A의 주황색 블록 부분을 수정해야 한다면 클래스 B, C의 주황색 부분도 일일이 찾아 수정해야 한다. 이런 식으로 소스 코드상에서 계속 반복해서 사용되는 부분들을 흩어진 관심사(Crosscutting Concerns)라고 한다.  

결국 AOP에서 각 관점을 기준으로 로직을 모듈화한다는 것은 흩어진 관심사를 모듈화하겠다는 의미다

 

• 스프링에서 제공하는 스프링 AOP는 프락시 기반의 AOP 구현체이다.
• 프록시 객체를 사용하는 것은 접근 제어 및 부가 기능을 추가하기 위해서이다.
• 스프링 AOP는 스프링 Bean에만 적용할 수 있다.
• 모든 AOP 기능을 제공하는 것이 목적이 아닌, 중복 코드, 프록시 클래스 작성의 번거로움 등 흔한 문제를 해결하기 위한 솔루션을 제공하는 것이 목적이다.
• 스프링 AOP는 순수 자바로 구현되었기 때문에 특별한 컴파일 과정이 필요하지 않다.

 

 

프록시 패턴 ( Proxy 패턴 )

[그림 2] Proxy 패턴

 

 프록시 패턴에서는 interface가 존재하고 Client는 이 interface 타입으로 Proxy 객체를 사용한다. Proxy 객체는 기존의 타겟 객체(Real Subject)를 참조한다. Proxy 객체와 기존의 타겟 객체의 타입은 같고, Proxy는 원래 할 일을 가지고 있는 Real Subject를 감싸서 Client의 요청을 처리한다. 

 

//Interface
public interface ProxyInterface {
    void SayHello();
}

//Proxy
public class Proxy implements ProxyInterface{

    ProxyInterface realsubject;

    //실제 객체를 생성자로 넘겨 받음
    public Proxy(ProxyInterface realsubject) {
        this.realsubject = realsubject;
    }

    //실제 객체 동작을 포함함
    @Override
    public void SayHello() {
        System.out.println("Proxy Hello");
        realsubject.SayHello();
    }
}

//Real Subject
public class Real implements ProxyInterface{
    @Override
    public void SayHello() {
        System.out.println("Real Hello");
    }
}

 

 

 

---

 

 

AOP 관련 용어

 

• Aspect : 흩어진 관심사를 모듈화 한 것. 
• Target : Aspect를 적용하는 곳. 클래스, 메서드 등..
• Advice : 실질적으로 어떤 일을 해야 할 지에 대한 것, 실질적인 부가기능을 담은 구현체
  • before, after, after-returning, after-throwing, around
• Join Point : Advice가 적용될 위치 혹은 끼어들 수 있는 시점. 메서드 진입 시점, 생성자 호줄 시점, 필드에서 꺼내올 시점 등 끼어들 시점을 의미. 참고로 스프링에서 Join Point는 언제나 메서드 실행 시점을 의미 한다.
• Point Cut : 어드바이스를 적용할 타겟의 메서드를 선별하는 정규표현식

 

AOP 적용 방법

 

1. 컴파일 타임 적용

 :  컴파일 시점에 바이트 코드를 조작하여 AOP가 적용된 바이트 코드를 생성하는 방법.

 

2. 로드 타임 적용

 :  순수하게 컴파일한 뒤, 클래스를 로딩하는 시점에 클래스 정보를 변경하는 방법

 

3. 런타임 적용

: 스프링 AOP가 주로 사용하는 방법.A라는 클래스 타입의 Bean을 만들 때 A 타입의 Proxy Bean을 만들어 Proxy Bean이 Aspect 코드를 추가하여 동작하는 방법.

 

 

Pointcut 표현식 결합

포인트컷 표현식은 And, or, not(&&, ||, !)을 사용하여 결합할 수 있다.

이름으로 pointcut 표현식을 참조할 수도 있다.

 

// (1)
@Pointcut("execution(public * *(..))")
private void anyPublicOperation() {} // (1)

// (2)
@Pointcut("within(com.xyz.myapp.trading..*)")
private void inTrading() {} // (2)

// (3)
@Pointcut("anyPublicOperation() && inTrading()")
private void tradingOperation() {} // (3)

 

(1) : public + 모든 (*)리턴타입 + *(..)모든 메소드

(2) : com.xyz.my.app.trading..* 밑에 모든 메소드

(3) : (1) + (2)

 

 

여러 가지 pointcut 표현식 사용 예시

execution은 메서드 실행 시점을 지정합니다. 이는 가장 일반적으로 사용되는 Pointcut 표현식입니다.

 

 

execution(* com.example.service.*.*(..))
:  com.example.service 패키지의 모든 클래스에서 모든 메서드를 선택합니다.

 

• *: 리턴 타입을 나타냅니다.
• com.example.service: 패키지명을 나타냅니다.
• *: 클래스명을 나타냅니다.
• *: 메서드명을 나타냅니다.
• ..: 메서드 인자를 나타냅니다. (0개 이상)

execution(* com..*(..))
: com 패키지와 그 하위 패키지에 있는 모든 클래스의 모든 메서드를 선택합니다.

 

• *: 리턴 타입을 나타냅니다.
• com..*: com 패키지와 하위 패키지에 있는 모든 클래스를 나타냅니다.
• *: 메서드명을 나타냅니다.
• (..): 메서드 인자를 나타냅니다. (0개 이상)

 

 

within은 특정 패키지, 클래스, 인터페이스 내의 모든 메서드를 선택합니다.

예를 들어, within(com.example.service.*)는 com.example.service 패키지의 모든 클래스의 모든 메서드를 선택합니다.

 

args는 특정 타입의 인자를 갖는 메서드를 선택합니다.

예를 들어, execution(* *(Long, ..))는 첫 번째 파라미터로 Long 타입을 받는 모든 메서드를 선택합니다.

 

annotation은 특정 어노테이션이 지정된 메서드를 선택합니다.

예를 들어, @annotation(org.springframework.transaction.annotation.Transactional)은 @Transactional 어노테이션이 지정된 모든 메서드를 선택합니다.

 

// 모든 공개 메서드 실행
execution(public * *(..))

// set 다음 이름으로 시작하는 모든 메서드 실행
execution(* set*(..))

// AccountService 인터페이스에 의해 정의된 모든 메서드의 실행
execution(* com.xyz.service.AccountService.*(..))

// service 패키지에 정의된 메서드 실행
execution(* com.xyz.service.*.*(..))

// 서비스 패키지 또는 해당 하위 패키지 중 하나에 정의된 메서드 실행
execution(* com.xyz.service..*.*(..))

// 서비스 패키지 내의 모든 조인 포인트
within(com.xyz.service.*)

// 서비스 패키지 또는 하위 패키지 중 하나 내의 모든 조인 포인트
within(com.xyz.service..*)

// AccountService 프록시가 인터페이스를 구현하는 모든 조인 포인트
this(com.xyz.service.AccountService)

// AccountService 대상 객체가 인터페이스를 구현하는 모든 조인 포인트
target(com.xyz.service.AccountService)

// 단일 매개변수를 사용하고 런타임에 전달된 인수가 Serializable과 같은 모든 조인 포인트
args(java.io.Serializable)

// 대상 객체에 @Transactional 애너테이션이 있는 모든 조인 포인트
@target(org.springframework.transaction.annotation.Transactional)

// 실행 메서드에 @Transactional 애너테이션이 있는 조인 포인트
@annotation(org.springframework.transaction.annotation.Transactional)

// 단일 매개 변수를 사용하고 전달된 인수의 런타임 유형이 @Classified 애너테이션을 갖는 조인 포인트
@args(com.xyz.security.Classified)

// tradeService 라는 이름을 가진 스프링 빈의 모든 조인 포인트
bean(tradeService)

// 와일드 표현식 *Service 라는 이름을 가진 스프링 빈의 모든 조인 포인트
bean(*Service)

 

 

Advice

 

 

@Before : Advice를 메서드가 실행되기 전에 실행합니다.

 

@Before("execution(* com.example.service.*.*(..))")
public void beforeMethodExecution() {
    // 메서드 실행 전에 실행될 로직
}

 

@After : Advice를 메서드가 실행된 후에 실행합니다. 예외 발생 여부와 관계없이 실행됩니다.

• Advice를 메서드가 실행된 후에 실행합니다.
• 예외 발생 여부와 관계없이 항상 실행됩니다.
• 메서드가 정상적으로 실행되더라도 예외가 발생하더라도 모두 실행됩니다.

@After("execution(* com.example.service.*.*(..))")
public void afterMethodExecution() {
    // 메서드 실행 후에 실행될 로직
}

 

@Around : Advice를 메서드 실행 전후에 실행합니다. 메서드 호출을 직접 제어할 수 있습니다.

• 예외 발생 여부와 관계없이 항상 실행됩니다.

@Around("execution(* com.example.service.*.*(..))")
public Object aroundMethodExecution(ProceedingJoinPoint joinPoint) throws Throwable {
    System.out.println("Before method execution...");
    Object result = joinPoint.proceed(); // 메서드 호출
    System.out.println("After method execution...");
    return result;
}

 

@AfterReturning : Advice를 메서드가 정상적으로 반환된 후에 실행합니다.

• Advice를 메서드가 정상적으로 반환된 후에 실행합니다.
• 예외가 발생하지 않고 메서드가 정상적으로 반환될 때만 실행됩니다.
• 메서드 실행 후 반환된 값을 파라미터로 받을 수 있습니다.

@AfterReturning(pointcut = "execution(* com.example.service.*.*(..))", returning = "result")
public void afterReturningMethodExecution(Object result) {
    // 메서드가 정상적으로 반환된 후에 실행될 로직
}

 

@AfterThrowing : Advice를 메서드에서 예외가 발생한 후에 실행합니다.

• Advice를 메서드에서 예외가 발생한 후에 실행합니다.
• 메서드가 예외를 던지고 종료될 때 실행됩니다.
• 예외가 발생하면 해당 예외 객체를 파라미터로 받을 수 있습니다

@AfterThrowing(pointcut = "execution(* com.example.service.*.*(..))", throwing = "ex")
public void afterThrowingMethodExecution(Exception ex) {
    // 메서드에서 예외가 발생한 후에 실행될 로직
}

 

 

설정

 

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

 

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

 

 

Spring

<?xml version="1.0" encoding="UTF-8"?>
<beans:beans>
	<aop:aspectj-autoproxy/> 
</beans:beans>

 

 

SpringBoot

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LoggingAspect {
    @Before("execution(* com.example..*.*(..))")
    public void beforeMethodExecution() {
        System.out.println("Before executing a method...");
    }
}

 

 

 

 

---

 

https://code-lab1.tistory.com/193