📌 1. AOP(Aspect-Oriented Programming)란?

---

📎 AOP란?

AOP는 관점 지향 프로그래밍이라고 불린다. 어떤 로직을 기준으로 핵심적인 관점, 부가적인 관점으로 나누어서 보고 그 관점을 기준으로 각각 모듈화하겠다는 것이다. AOP에서 각 관점을 기준으로 로직을 모듈화한다는 것은 모드들을 부분적으로 나누어서 모듈화하겠다는 의미이다. 이때, 소스 상에서 비슷한 기능을 하는 부분(비슷한 메서드, 코드)이 있는데, 이것은 흩어진 관심사(Crosscutting Concerns)라 부른다.

아래 그림에서 각 박스안에 색칠되어 있는 부분이 흩어진 관심사이다. (각 클래스안에 공통적으로 사용하고 있는 메소드 혹은 코드) 이때 만약 노란색 기능을 수정해야 한다면 각각 클래스의 노란색 기능을 수정해주어야 하기 때문에 유지보수면에서 불리하다.

이것을 해결하는 방법이 AOP이다. 흩어진 관심사들을 모을때 AOP의 Aspect을 사용한다. 각 Concern별로 Aspect을 만들어주고, 어느 클래스에서 사용하는 지 입력해주는 방식이다. 아래의 그림이 Aspect로 모듈화 한 것을 보여준 것이다.
각 모듈에는 Advice와 Poincut이 들어있다. Advice란 해야할 일, 기능을 나타낸다. Pointcut이란 어디에 적용해야하는지를 나타내는 것이다. (A라는 클래스의 W라는 메서드) Target이라는 개념도 있는데, Target이란 각각 클래스를 나타내는 것이다. 즉, 적용이되는 대상을 뜻하는 용어이다.

📎 AOP 용어

👉 Aspect: 관점

👉 Advice: 핵심기능에 부여되는 부가기능 (위치 메서드에 적용될 부가 기능)

• Around (Advice): 대상 객체의 메서드 실행 전, 후 및 예외 발생 모두 실행한다.
• Before (Advice): 대상 객체의 메서드로, 메서드 호출전에 수행한다.
• After (Advice): 대상 객체의 메서드 실행도중 예외 발생 여부와 상관없이 메서드 실행 후 실행한다.
• AfterReturning (Advice): 대상 객체의 메서드가 실행 도중 예외없이 실행 성공한 경우에 실행한다.
• AfterThrowing (Advice): 대상 객체의 메서드가 실행 도중 예외가 발생한 경우에 실행한다.

👉 Pointcut: Aspect 적용 위치 지정자 (Advice)를 어디에 적용할지를 결정

👉 Advisor: Advice + Pointcut

👉 Joinpoint: Aspect가 적용한 지점

📎 AOP 구현 순서

1. pon.xml 파일에 AOP 관련 dependency 추가
2. AOP설정 xml 파일(servlet-context.xml)에 aop autoproxy 지시
3. target 메소드에 추가 할 Aspect 생성
4. 구현하기
   
   

📎 execution 명시자

execution(수식어패턴 리턴타입패턴 클래스이름패턴.메서드이름패턴())

각 패턴은 *을 이용하여 모든값을 표현할 수 있다.

👉 패키지

• com.spring.aop → com.spring.aop패키지를 타겟한다는 의미
• com.spring.aop.. → com.spring.aop로 시작하는 하위의 모든 패키지를 타겟한다는 의미

👉 리턴타입

• * → 모든 리턴 타입 타겟
• void > 리턴 타입이 void인 메서드만 타켓
• !void > 리턴 타입이 void가 아닌 메서드만 타겟

👉 매개 변수 지정

• (..) > 1개 이상의 모든 파라미터 타켓
• (*) > 1개의 파라미터만 타켓
• (*,*) > 2개의 파라미터만 타겟
• (String,*) > 2개의 파라미터중 첫번째 파라미터가 String타입만 타겟

👉 샘플 예시

• execution(void set*(..))
  리턴 타입이 void이고 메서드 이름이 set으로 시작하고 파라미터가 0개 이상인 메서드 타겟
• execution(* abc.*.*())
  abc패키지에 속한 파라미터가 없는 모든 메서드 타겟
• execution(* abc..*.*(..))
  abc패키지 및 하위 패키지에 있는 파라미터가 0개 이상인 메서드 타겟
• execution(Long com.spring.aop.Boss.work(..))
  리턴 타입인 Long인 com.spring.aop 패키지 안의 Boss클래스의 work 메서드 타겟
• execution (* get*(*))
  이름이 get으로 시작하고 파라미터가 한 개인 메서드 타겟
• execution(* get*(*,*))
  이름이 get으로 시작하고 파라미터가 2개인 메서드 타겟
• execution(* read*(Integer,..))
  메서드 이름이 read 로시작하고, 첫번째 파라미터 타입이 Integer이며 한개 이상의 파라미터를 갖는 메서드 타겟
  
  
  

📌 2. AOP 예시

---

📎 @Before

@Component
@Aspect					// AOP 사용 선언 어노테이션
public class Advice {

	private static final Logger logger = LoggerFactory.getLogger(Advice.class);
	
	@Pointcut("execution(void com.spring.aop.*.work())") // 중복되는 execution을 기술
	public void pointcut() {
		 // 특정한 의미가 없다.
	}
	
	// 메서드 호출 전
	//@Before("execution(void com.spring.aop.*.work())")
	@Before("pointcut()")
	public void before() {
		logger.info("AOP Before 메서드 호출 : 출근한다.");
	}
	
}

👉 com.spring.aop. 패키지 파일

package com.spring.aop;

import org.springframework.stereotype.Component;

//테스트 목적의 클래스1
@Component
public class Boss {

	public void work() {
		System.out.println("사장의 일을 한다.");
	}
	
	public void getWorkingTime() {
		try {
			Thread.sleep(300);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
	public void getInfo(String title , int salary) {
		System.out.println("\n===================");
		System.out.println("Boss클래스 getInfo메서드 호출");
		System.out.println("직급 : " + title + " / 급여 : " + salary);
		System.out.println("===================\n");
	}	

📎 @After

@Component
@Aspect					// AOP 사용 선언 어노테이션
public class Advice {

	private static final Logger logger = LoggerFactory.getLogger(Advice.class);
	
	@Pointcut("execution(void com.spring.aop.*.work())") // 중복되는 execution을 기술
	public void pointcut() {
		 // 특정한 의미가 없다.
	}
	
	// 메서드 호출 후
	//@After("execution(void com.spring.aop.*.work())")
	@After("pointcut()")
	public void after() {
		logger.info("AOP After 메서드 호출 : 퇴근한다.\n");
	}
	
}

📎 @Around

@Component
@Aspect					// AOP 사용 선언 어노테이션
public class Advice {

	private static final Logger logger = LoggerFactory.getLogger(Advice.class);
	
	@Pointcut("execution(void com.spring.aop.*.work())") // 중복되는 execution을 기술
	public void pointcut() {
		 // 특정한 의미가 없다.
	}
	
	// 메서드 호출 전후
	@Around("execution(void com.spring.aop.*.getWorkingTime())")
	public void around(ProceedingJoinPoint pjp) {
		
		logger.warn("===========================");
		// 메서드 호출 전
		long startTime = System.currentTimeMillis();
		
		// ProceedingJoinPoint 객체의 proceed()메서드로 타겟메서드를 호출한다.
		try {
			pjp.proceed();
		} catch (Throwable e) {
			e.printStackTrace();
		}
		
		// 메서드 호출 후
		long endTime = System.currentTimeMillis();
		
		logger.warn("업무 소요시간 : " + (endTime-startTime) + " 초");
		logger.warn("===========================\n");
		
	}
	
	
}

📎 @AfterReturning

@Component
@Aspect					// AOP 사용 선언 어노테이션
public class Advice {

	private static final Logger logger = LoggerFactory.getLogger(Advice.class);
	
	@Pointcut("execution(void com.spring.aop.*.work())") // 중복되는 execution을 기술
	public void pointcut() {
		 // 특정한 의미가 없다.
	}
	
	// 타겟 메서드가 성공적으로 실행한 후
	@AfterReturning("execution(void com.spring.aop.*.getInfo(..))")
	//JoinPoint객체를 통해서 타겟메서드로부터 전달되는 파라메타를 받을 수 있다.
	public void AfterReturning(JoinPoint jp) {
		logger.info(Arrays.toString(jp.getArgs())); // 메서드의 파라메타를 확인
		logger.info(jp.getKind());				   // 메서드의 종류 확인
		logger.info(jp.getSignature().getName());   // 메서드에 대한 설명
		logger.info(jp.getTarget().toString());     // 대상 객체를 반환
		logger.info(jp.getThis().toString());	   // 프록시 객체를 반환
		logger.info("");
	}
	
}

📎 @AfterThrowing

@Component
@Aspect					// AOP 사용 선언 어노테이션
public class Advice {

	private static final Logger logger = LoggerFactory.getLogger(Advice.class);
	
	@Pointcut("execution(void com.spring.aop.*.work())") // 중복되는 execution을 기술
	public void pointcut() {
		 // 특정한 의미가 없다.
	}
	
	// 타겟 메서드에서 에러가 발생한 후
	@AfterThrowing("execution(void com.spring.aop.Employee.getError())")
	public void AfterThrowing(){
		logger.info("AOP AfterThrowing메서드 호출\n");
	}
	
	
}

📖 참고

• https://jojoldu.tistory.com/71