AOP(Aspect-Oriented Programming)란? 예시 포함

 

1. AOP(Aspect-Oriented Programming)란?

 

  AOP(Aspect-Oriented Programming)는 프로그래밍 패러다임 중 하나로, 관심사의 분리(Concern Separation)를 위해 사용되는 기술이다. AOP는 애플리케이션의 핵심 비즈니스 로직과 관련 없는 부가적인 기능들을 모듈화하여 코드의 중복을 줄이고 유지보수성을 향상시키는 데에 주로 활용된다. AOP에서는 다양한 관점(Aspect)을 정의하고, 이러한 관점들을 핵심 로직에 적용하는 방식으로 동작한다.

 

   Spring에서는 일반적으로 사용하는 클래스(Service, Dao 등)에서 중복되는 공통 코드 부분(commit, rollback, log처리)을 별도의 영역으로 분리해 내고, 코드가 시행 되기 전이나 이 후의 시점에 해당 코드를 붙여 넣음으로써 소스 코드의 중복을 줄이고, 필요할 때 마마다 가져다 쓸 수 있게 객체화 하는 기술을 말한다.

 

 

 

 

 

 

2. Spring AOP의 핵심 용어

 

 

* Aspect란? : Advice + Pointcut = Aspect

실제로 동작 코드를 의미하는 Advice와 작성한 Advice가 실제로 적용된 메소드인 Pointcut을 합친 개념으로 부가기능(로깅, 보안, 트랜잭션 등)을 나타내는 공통 관심사에 대한 추상적인 명칭. (여러 객체에 공통으로 적용되는 부가기능을 작성한 클래스 나타냄) AOP 개념을 적용하면 핵심기능 코드 사이에 끼어있는 부가기능을 독립적인 요소로 구분해 낼 수 있고, 이렇게 구분된 부가기능 Aspect는 런타임 시에 필요한 위치에 동적으로 참여하게 할 수 있다.

 

 

 

 

3.Spring AOP의 구조

 

 

 

 

 

 

4. Spring AOP의 구현 방식

1) XML 기반의 AOP 네임스페이스를 통한 AOP 구현

• 부가기능을 제공하는 Advice 클래스를 작성한다.
• XML 설정 파일에 <aop:config>를 이용해서 Aspect를 설정한다.

 

2) @Aspect를 정의하는 태그

• @Aspect 어노테이션을 이용해서 부가기능을 제공하는 Aspect 클래스를 작성한다.
• 이 때, Aspect 클래스는 어드바이스를 구현하는 메소드와 포인트컷을 포함한다.
• dispachter-servlet으로 지정된 XML 설정 파일에 <aop:aspect-autoproxy/>를 설정한다.

servlet-context.xml에 설정된 모습

 

 

5. Spring AOP의 Advice와 annotation

 

 

 

 

6. 실제 적용 예시

 

** 전체 구조

 

1) 포인트컷 설정하기

 

 

 

 

 

2) Before Aspect 예시 

• 아래 예시는 JoinPoint 인터페이스를 사용해서 웹 페이지에 접속한 사람의 ip주소를 출력해주는 메서드를 Before방식으로 구현한 것이다.
• JointPoint 인터페이스는 advice가 적용되는 동안 Target Object의 정보, 전달되는 매개변수, 메서드, 반환값, 예외 등을 얻을 수 있는 메서드를 제공한다.
• @Before("CommonPointcut.implPointcut()") : 모든 ServiceImple 클래스에 접근하기 전에 사용자의 log로 남기는 메서드 실행

 

import java.util.Arrays;

import javax.servlet.http.HttpServletRequest;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import edu.kh.comm.member.model.vo.Member;

@Component
@Aspect
public class BeforeAspect {
	
	private Logger logger = LoggerFactory.getLogger(BeforeAspect.class);
	

	@Before("CommonPointcut.implPointcut()")
	public void serviceStart(JoinPoint jp) { //메서드 시그니처
		
		String str = "----------------------------------------------\n";
		
		
		String className = jp.getTarget().getClass().getSimpleName();
		String methodName = jp.getSignature().getName();
		
		String param = Arrays.toString( jp.getArgs() );
		
		str += "Start : " + className + " - " + methodName + "\n";
		// Start : MemberServiceImpl - login
		
		str += "Parameter : " + param + "\n";
		
		try {
			//HttpServletRequest를 이용해서 ip 얻어오기

			
			HttpServletRequest req = ((ServletRequestAttributes) RequestContextHolder.currentRequestAttributes()).getRequest();
			
			Member loginMember = (Member) req.getSession().getAttribute("loginMember");
			
			//ip.xxx.xxx.xxx.xxx(email : test01@naver.com)
			str += "ip : " + getRemoteAddr(req);
			
			if(loginMember != null) {// 로그인 상태인 경우
				str += "(email : " + loginMember.getMemberEmail() + ")";
				
			}
			
		}catch(Exception e) {
			str+="[스케줄러 동작]";
		}
		logger.info(str);
		
		
	}
	
	//pc  / 브라우저 / os가 각자 달라도
	//ip 주소를 얻어오는 메서드
	
	public static String getRemoteAddr(HttpServletRequest request) {

        String ip = null;

        ip = request.getHeader("X-Forwarded-For");

        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) { 
            ip = request.getHeader("Proxy-Client-IP"); 
        } 

        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) { 
            ip = request.getHeader("WL-Proxy-Client-IP"); 
        } 

        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) { 
            ip = request.getHeader("HTTP_CLIENT_IP"); 
        } 

        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) { 
            ip = request.getHeader("HTTP_X_FORWARDED_FOR"); 
        }

        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) { 
            ip = request.getHeader("X-Real-IP"); 
        }

        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) { 
            ip = request.getHeader("X-RealIP"); 
        }

        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) { 
            ip = request.getHeader("REMOTE_ADDR");
        }

        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) { 
            ip = request.getRemoteAddr(); 
        }

		return ip;
	}

}

 

콘솔에 찍힌 결과

 

 

 

 

 

 

 

3)After Aspect 예시 

• @After("CommonPointcut.implPointcut()") : ServeImple이 끝난뒤  실행된다.

import java.util.Arrays;

@Component
@Aspect
@Order(1)
public class AfterAspect {

	private Logger logger = LoggerFactory.getLogger(AfterAspect.class);
	

	@After("CommonPointcut.implPointcut()")
	public void serviceEnd(JoinPoint jp) {
		
	
		String className = jp.getTarget().getClass().getSimpleName();
	
		String methodName = jp.getSignature().getName();
	
		String str = "End : " + className + " - " + methodName + "\n";
		// Start : MemberServiceImpl - login
		
		
		 str += "----------------------------------------------\n";
		 
		 logger.info(str);
		
	}
}

 

 

 

4) Around Aspect

• @Arount : 전처리(@Before)와 후처리(@After)를 한 번에 작성할 수 있는 advice이다.
• 아래의 메서드는 메서드 처리 소요 시간을 알려주는 메서드이다.
• ProceedingJointPoint 인터페이스 : 주로 Around 어드바이스에서 활용되며 핵심로직의 호출을 제어하고 추가적인 처리를 수행하는데 사용된다.
• proceed() :  Around 어드바이스에서 핵심 로직의 호출을 진행하는 메서드. 이 메서드를 호출하여 로직을 실행하고 Around 어드바이스 내에서 원하는 타이밍에 호출을 중단하거나 추가적인 처리를 진행할 수 있다. 따라서 핵심 로직을 실행하는 proceed()이전에 전처리 내용을 쓰고 이후에 후처리 내용을 쓰면 된다.
• 아래에서는 1970/01/01 오전 9시(한국 OS 기준) 부터  지금까지 지난 시간을 ms단위로 나타낸 값을 출력하는 System.currentTimeMillis() 을 이용하여 서비스 시작전(@Before)와 서비스가 끝난후 (@After)의 시간 차이를 얻어내 프로그램 실행 시간을 얻어내는 Aspect를 구현하고 있다.

@Component
@Aspect
@Order(3)
public class AroundAspect {

	private Logger logger = LoggerFactory.getLogger(AroundAspect.class);
	
	// @Around : 전처리(@Before)와 후처리(@After)를 한 번에 작성 가능한 advice
	@Around("CommonPointcut.implPointcut()")
	public Object runningTime(ProceedingJoinPoint jp) throws Throwable {
		//메서드 소요 시간을 알려주는 메서드
		//ProceedingJoinPoint 인터페이서 : 전/후 처리 기능, 값을 얻어올 수 있는 메서드 제공
		
		// proceed() 메소드 호출 전  : @Before advice 작성
		// proceed() 메소드 호출 후  : @After advice 작성
		// 메소드 마지막에 proceed()의 반환값을 리턴해야함.
		
		// System.currentTimeMillis() : 
		//	1970/01/01 오전 9시(한국 OS 기준) 부터 
		//  지금까지 지난 시간을 ms단위로 나타낸 값
		
		long startMs = System.currentTimeMillis();
		
		Object obj = jp.proceed();// 전후 처리를 나누는 기준. 이보다 위가 befor, 뒤가 after
		
		long endMs = System.currentTimeMillis();
		
		logger.info("Running Time : " + (endMs-startMs) + "ms");
		
		return obj;
		
		
		
	}
}

 

 

 

 

 

5)AfterReturning Aspect 예시 

• @After는 반환값을 얻어올 수 없다.
• @AfterReturning는 기존 @After에 반환값 얻어오는 기능을 제공한다.
•  returning="returnObj" : 반환 값을 저장할 매개변수를 지정

@Component
@Aspect
@Order(5) // 큰 숫자 순으로 먼저 실행
public class AfterReturningAspect {
	
	private Logger logger = LoggerFactory.getLogger(AfterReturningAspect.class);
	
	@AfterReturning(pointcut = "CommonPointcut.implPointcut()", returning="returnObj")
	public void serviceReutrnValue(Object returnObj ) {
		
		
		logger.info("return Value: " + returnObj);
	}
}

AfterReturning의 Advice가 실행되어 @After의 "End: ..." 위에 return Value가 출력되었다.

 

 

 

 

 

6)AfterThrowing Aspect 예시 

 

• @AfterThrowing : 기존 @After + Throwing된 예외 얻어오기
• throwing="exceptionObj" : 던저진 예외를 저장할 매개변수를 지정

 

@Component
@Aspect
public class AfterThrowingAspect {
	
	private Logger logger = LoggerFactory.getLogger(AfterThrowingAspect.class);
	

	@AfterThrowing(pointcut = "CommonPointcut.implPointcut()", throwing="exceptionObj")
	public void serviceReutrnValue(Exception exceptionObj ) {
		
		String str = "<<exception>> : " + exceptionObj.getStackTrace()[0];
		
		str += " - " + exceptionObj.getMessage();
		
		logger.error(str);
		
	}
}

 

게시글을 상세조회하는 sql에 세미콜론(;)을 추가해서 오류를 발생시켰다.

콘솔에 찍힌 예외