[Spring] Spring AOP 기초 및 예제

🔻Spring AOP

• AOP : Aspect Oriented Programming
• 관점 지향 프로그래밍
• 관점(=관심사)는 업무 구현시 주업무가 아닌 나머지 보조 업무를 의미한다.
• 횡단 관심사를 별도의 모듈로 분리하여 코드의 재사용성과 유지보수성을 향상시킨다.
• Spring AOP는 주로 어노테이션 또는 XML 설정을 통해 관심사를 정의하고, 이를 핵심 로직에 적용하여 횡단 관심사를 처리한다.

 

※기존 방식과 AOP 방식 비교

기존 방식

• 게시판 글쓰기의 add.do 파일
• 주업무 : 글쓰기 기능 
• 보조업무 : 권한 체크
• 주업무와 보조업무를 한 파일에서 구현했다.
• 어디까지 주업무고 보조업무인지 코드 관리가 불편하다는 단점이 있다.

AOP 방식

• 주업무와 보조업무를 분리시켜서 따로 구현한다.
• 스프링을 통해서 주업무와 보조업무를 다시 결합 후 동작한다.

 

Spring AOP 용어

1. Core Concern

• 비즈니스 코드, 주업무
• 어플리케이션의 핵심 목적을 달성하기 위한 주요 기능들을 포함하며, 주로 개발자가 직접 코드로 작성하는 부분

 

2. Cross-cutting Concern

• 보조업무
• 주로 로깅, 트랜잭션 관리, 보안 등과 같이 여러 모듈에서 공통으로 필요한 부분을 포함한다.
• AOP는 횡단 관심사를 모듈화하고 코드의 재사용성을 높이기 위한 목적으로 도입되었다. AOP는 핵심 관심사와 횡단 관심사를 분리하여 개발자가 핵심 로직에만 집중할 수 있도록 도와준다.

 

 

 

3. Target

• 비즈니스 업무를 소유한 객체
•  주요 기능이나 비즈니스 로직을 담당하는 객체로, AOP에서는 보조 업무가 적용되는 대상이 된다.

 

4. Proxy

• Target을 감싸는 대리 객체
• AOP에서는 주로 보조 업무를 적용하기 위한 용도로 사용된다.
• 클라이언트가 실제 Target이 아닌 Proxy에 접근하게 되면, Proxy는 필요한 보조 업무를 처리한 후에 실제 Target에게 제어를 전달한다.

 

5. JoinPoint

• Target이 가진 주업무(메서드)
• AOP에서는 이 JoinPoint에 보조 업무(Advice)를 적용하여 횡단 관심사를 처리한다.

 

6. Pointcut

• 보조업무와 특정 JoinPoint를 연결하는 작업
• 어떤 메서드를 언제 실행할지를 결정하는데 사용된다.
• Pointcut은 정규 표현식 또는 패턴을 통해 JoinPoint를 선택한다.

 

7. Aspect

• 보조업무를 구현하는 객체
• Aspect는 Pointcut과 Advice를 결합하여 실제로 어떤 보조 업무를 수행할지를 정의한다. 보조 업무는 주로 횡단 관심사를 처리하는데 사용된다.

 

8. Advice

• 주업무가 시행되는 어느 시점에 보조업무를 실행할지 정의하는 것
• Before Advice: 주업무 실행 전에 보조 업무를 실행한다.
• After Advice: 주업무 실행 후에 보조 업무를 실행한다.
• Around Advice: 주업무를 감싸서 전/후에 보조 업무를 실행하며, 주업무를 직접 실행 여부를 결정할 수 있다.
• After-returning Advice: 주업무가 정상적으로 실행된 후에 보조 업무를 실행한다.
• After-throwing Advice: 주업무에서 예외가 발생한 경우에 보조 업무를 실행한다.

---

🔻Spring AOP 구현

• com.test.spring.aop1 패키지 생성
• 하위 파일 생성
  • Main.java
  • Memo.java (I) : 메인 업무 객체(인터페이스)
  • MemoImpl.java(C) : 메인 업무 객체(클래스)
  • Logger.java(C) : 보조 업무 객체(클래스)
  • memo.xml : 스프링 설정 파일

 

계층과 계층 사이의 관계

서블릿 계층과 계층 사이의 관계를 클래스로 만들어 이어줬다. (DAO <-> Controller <-> View)

Spring에서 계층 사이의 관계를 인터페이스로 만든다. 

 

Main.java

메모 등록, 조회, 수정, 삭제를 호출한다.

package com.test.spring.aop1;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {
	public static void main(String[] args) {
		
		ApplicationContext context = new ClassPathXmlApplicationContext("com/test/spring/aop1/memo.xml");
		
		Memo memo = (Memo)context.getBean("memo");	//new MemoImpl()와 동일한 역할
		
		memo.add("스프링 AOP");
		
		try {
			String txt = memo.read(15);
			System.out.println(txt);
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		memo.edit(5, "수정합니다.");
		
		memo.del(5);
		
		
	}
}

 

 

주업무 객체 생성

주업무 객체인 memo를 직접생성하면 스프링 환경을 제공받지 못한다. 그러므로 스프링을 통해 생성하여 스프링의 기능을 활용할 수 있도록 한다. 

ApplicationContext context = new ClassPathXmlApplicationContext("com/test/spring/aop1/memo.xml");

 

ApplicationContext 인터페이스
ApplicationContext는 Spring 컨테이너를 나타내는 인터페이스이다. Spring 애플리케이션에서 빈(Bean)들을 생성하고 관리한다.

 

ClassPathXmlApplicationContext 클래스

XML 형식의 설정 파일을 이용하여 Spring ApplicationContext를 생성하는 구현체 중 하나이다. 지정된 클래스 패스에서 XML 설정 파일을 찾아 읽어들여 ApplicationContext를 초기화한다.

ClassPathXmlApplicationContext는 클래스 패스 상에서 지정된 경로에서 XML 설정 파일을 찾아 사용한다.

 

 

Bean 가져오기

Memo memo = (Memo)context.getBean("memo");

 

context는 앞서 생성한 ApplicationContext으로 getBean 메서드를 사용하여 ApplicationContext에서 빈을 가져온다.
"memo"는 가져오고자 하는 빈의 이름이며, 이는 XML 설정 파일에서 해당 빈의 <bean> 태그의 id 속성에 지정된 값과 일치해야 한다.

 

 

 

Memo.java

메모 쓰기, 읽기, 수정, 삭제하기를 선언한다.

package com.test.spring.aop1;

public interface Memo {
	//메모 쓰기
	void add(String memo);
	
	//메모 읽기
	String read(int seq);
	
	//메모 수정
	boolean edit(int seq, String memo);
	
	//메모 삭제
	boolean del(int seq);
}

 

 

MemoImpl.java

주업무(메모 쓰기, 읽기, 수정, 삭제)를 구현한다.

package com.test.spring.aop1;

public class MemoImpl implements Memo{
	@Override
	public void add(String memo) {
		System.out.println("메모 쓰기: " + memo);
	}

	@Override
	public String read(int seq) throws Exception{
		if (seq < 10) {
			System.out.println("메모 읽기");
		} else {
			throw new Exception("존재하지 않는 메모");
		}
		return "메모 읽기 완료";
	}

	@Override
	public boolean edit(int seq, String memo) {
		System.out.println("메모 수정: " + memo);
		return false;
	}

	@Override
	public boolean del(int seq) {
		System.out.println(seq + "번 메모 삭제 완료");
		return false;
	}
}

 

 

Logger.java

보조업무(로그 기록)를 구현한다. 보조업무의 타이밍은 memo.xml 파일에서 관리한다.

package com.test.spring.aop1;

import java.util.Calendar;
import org.aspectj.lang.ProceedingJoinPoint;

public class Logger {
	public void log() {
		Calendar now = Calendar.getInstance();
		System.out.printf("[LOG][%tF %tT] 로그를 기록합니다.\n", now, now);
	}

	public void time(ProceedingJoinPoint jp) {
		//주업무를 실행하는 소요시간
		long begin = System.nanoTime();
		System.out.println("[LOG] 기록을 시작합니다.");
		
		//주업무 실행 > aop의 around와 사용
		//주업무 객체의 가상 객체 참조
		try {
			jp.proceed();	//주업무 객체의 주업무 메소드를 의미한다. xml에서 지정한다.
		} catch (Throwable e) {
			e.printStackTrace();
		}
		
		long end = System.nanoTime();
		System.out.println("[LOG] 기록을 종료합니다.");
		
		System.out.printf("[LOG] 쇼요 시간 %,dns\n", end-begin);
	}
	
	public void history(String memo) {
		System.out.println("[LOG] 읽기 기록 > " + memo);
	}
	
	public void check(Exception e) {
		//예외처리가 아닌 에러메시지만 출력하는 역할
		System.out.println("[LOG]예외 발생: " + e.getMessage());
	}
}

 

 

AOP 작성하기

#AOP를 사용하기 위한 환경설정

 

1. Namespace

xml 파일 우클릭 - Spring - Add as  Bean Configuration

 

 

xml 화면 하단에 여러개의 탭이 생겼다.

 

 

'Namespaces' 탭에서 aop 체크를 하고 파일을 저장한다.

 

 

2. jar 설치

pom.xml에 아래 코드를 추가한다.

		<!-- AOP -->
		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjrt</artifactId>
			<version>${org.aspectj-version}</version>
		</dependency>
		
		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjweaver</artifactId>
			<version>${org.aspectj-version}</version>
		</dependency>

 

 

jar 파일 추가된 모습

 

 

 

memo.xml

 

1. 주업무 객체 및 보조 업무 객체 정의

<!-- 주업무 객체 -->
<bean id="memo" class="com.test.spring.aop1.MemoImpl"></bean>
	
<!-- 보조 업무 객체 -->
<bean id="logger" class="com.test.spring.aop1.Logger"></bean>

 

주업무 객체( MemoImpl)와 보조업무 객체(Logger) 결합하는 것이 memo.xml의 업무이다.

결합하기 위해 객체를 인지하는 단계를 먼저 거쳐야하는데 <bean> 으로 선언하면 스프링이 특정 객체(클래스)를 인지할 수 있다.

 

 

2. AOP 설정

<aop:config>
    <aop:aspect id="loggerAspect" ref="logger">
        <!-- Aspect 내용이 이어질 부분 -->
    </aop:aspect>
</aop:config>

 

주업무 객체와 보조업무 객체 결합을 AOP가 담당한다.

aop 태그를 사용하여 AOP 설정한다.

aspect 는 보조업무를 담당하는 객체로써  loggerAspect라는 이름의 Aspect를 정의하고, 이 Aspect에 보조 업무를 구현한 logger 빈을 참조한다.

 

aspect : 보조업무 담당 객체

 

3. Pointcut 정의

1) PointCut 지정하기

• 주업무 객체 지정 및 메서드를 찾는다. 주업무 사이에서 보조업무가 실행하는 시점을 정한다.
• ex) MemoImpl.add 메서드,  MemoImpl.read 메서드

2) AspectJ 표현식을 사용하여 찾는다.

• AspectJ 표현식은 독립적인 표현식으로 Spring에서 가져다 사용하는 것이다.
• execution() 지시자
• within() 지시자

3) execution()

• execution([접근지정자] 반환형 [클래스].메서드(인자))

4) 와일드 카드 존재

• * : 접근지정자, 반환형, 패키지, 클래스, 메서드에서 사용가능하다.
• .. : 인자 리스트에만 사용가능하다.

<!-- 메모 쓰기 -->
<aop:pointcut expression="execution(public void com.test.spring.aop1.MemoImpl.add(String))" id="p1"/>

<!-- 메모 읽기 -->
<aop:pointcut expression="execution(public String com.test.spring.aop1.MemoImpl.read(int))" id="p2"/> 

<!-- 주업무와 보조업무가 같은 패키지 내에 있다면 패키지와 클래스 이름을 생략할 수 있다. -->
<aop:pointcut expression="execution(public void add(String))" id="p4"/>

<!-- 와일드 카드를 사용해서 모든 메서드(CRUD)를 찾는다. -->
<aop:pointcut expression="execution(* com.test.spring.aop1.MemoImpl.*(..))" id="p5"/>

<!-- a로 시작하는 모든 메서드 -->
<aop:pointcut expression="execution(* com.test.spring.aop1.MemoImpl.a*(..))" id="p6"/>

<!-- a로 끝나는 모든 메서드 -->
<aop:pointcut expression="execution(* com.test.spring.aop1.MemoImpl.*a(..))" id="p7"/>

 

<aop:pointcut> 태그를 사용하여 Pointcut을 정의한다. Pointcut은 어떤 메서드에 어떤 Advice를 적용할지를 결정하는데 사용된다.

 

 

4. Advice 적용

• Advice는 주업무가 시행되는 어느 시점에 보조업무를 실행할지 정의하는 것이다.
• 보조업무 객체의 메소드명과 + 포인트컷의 id 로 지정한다.
• 5종류 Advice 중 하나를 설정한다.
  • Before Advice: 주업무 실행 전에 보조 업무를 실행한다.
  • After Advice: 주업무 실행 후에 보조 업무를 실행한다.
  • Around Advice: 주업무를 감싸서 전/후에 보조 업무를 실행하며, 주업무를 직접 실행 여부를 결정할 수 있다.
  • After-returning Advice: 주업무가 정상적으로 실행된 후에 보조 업무를 실행한다.
  • After-throwing Advice: 주업무에서 예외가 발생한 경우에 보조 업무를 실행한다.

 

<aop: 'advice'> 태그를 사용하여 적용한다.

after

<aop:after method="log" pointcut-ref="p1"/>

보조업무의 log 메서드를 PointCut p1 뒤에 실행하겠다는 의미이다.

 

before

<aop:before method="log" pointcut-ref="p1"/>

보조업무의 log 메서드를 PointCut p1 전에 실행하겠다는 의미이다.

 

 

around

<aop:around method="time" pointcut-ref="p5"/>

 

보조업무의 time 메서드를 PointCut p5 앞, 뒤에 실행하겠다는 의미이다.

 

around를 사용할 때 보조업무 메서드에 주업무 객체의 가상 객체 참조하여 사용한다.

try {
	jp.proceed();	//주업무 객체의 주업무 메소드를 의미한다. xml에서 지정한다.
} catch (Throwable e) {
	e.printStackTrace();
}

 

around는 보조업무가 주업무를 감싸는 경우가 많지않아 사용빈도가 낮다.

 

 

after-returning

<aop:after-returning method="history" pointcut-ref="p2" returning="memo"/>

 

p2 Pointcut에서 메서드가 정상적으로 실행된 후에, "history"라는 이름의 메서드를 호출하면서 해당 메서드에 반환된 Memo 객체를 전달한다.

 

after-throwing

<aop:after-throwing method="check" pointcut-ref="p2" throwing="e"/>

 

 

p2 Pointcut에서 메서드가 예외를 던질 때, "check"라는 이름의 메서드를 호출하면서 해당 메서드에 발생한 예외 객체를 전달한다.

 

 

전체 memo.xml

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">

	
	<!-- 주업무 객체 -->
	<bean id="memo" class="com.test.spring.aop1.MemoImpl"></bean>
	
	<!-- 보조 업무 객체 -->
	<bean id="logger" class="com.test.spring.aop1.Logger"></bean>

	<!-- 주업무 객체와 보조업무 객체 결합을 AOP가 담당한다.-->
	<aop:config>
		
		<aop:aspect id="loggerAspect" ref="logger">
	
			<!-- 메모 쓰기 -->
	 		<aop:pointcut expression="execution(public void com.test.spring.aop1.MemoImpl.add(String))" id="p1"/>
	 		
	 		<!-- 메모 읽기 -->
	 		<aop:pointcut expression="execution(public String com.test.spring.aop1.MemoImpl.read(int))" id="p2"/> 
	 		
	 		<!-- 메모 쓰기 + 읽기 (단, 표현식이 복잡해지기에 잘 사용하지 않는다)-->
	 		<aop:pointcut expression="execution(public String com.test.spring.aop1.MemoImpl.read(int)) 
	 								|| execution(public void com.test.spring.aop1.MemoImpl.add(String))" id="p3"/>
	 		
	 		
	 		<!-- 주업무와 보조업무가 같은 패키지 내에 있다면 패키지와 클래스 이름을 생략할 수 있다. -->
	 		<aop:pointcut expression="execution(public void add(String))" id="p4"/>
	 		
	 		<!-- 와일드 카드를 사용해서 모든 메서드(CRUD)를 찾는다. -->
	 		<aop:pointcut expression="execution(* com.test.spring.aop1.MemoImpl.*(..))" id="p5"/>
	 		
	 		<!-- a로 시작하는 모든 메서드 -->
	 		<aop:pointcut expression="execution(* com.test.spring.aop1.MemoImpl.a*(..))" id="p6"/>
	 		
	 		<!-- a로 끝나는 모든 메서드 -->
	 		<aop:pointcut expression="execution(* com.test.spring.aop1.MemoImpl.*a(..))" id="p7"/>
	 		
	 		<!-- <aop:after method="log" pointcut-ref="p1"/> -->
	 		<!-- <aop:before method="log" pointcut-ref="p1"/> -->
	 		
	 		<!-- 
	 		<aop:after method="log" pointcut-ref="p1"/>
	 		<aop:after method="log" pointcut-ref="p2"/>
	 		 -->
	 		
	 		<!-- <aop:after method="log" pointcut-ref="p3"/> -->
	 		<!-- <aop:after method="log" pointcut-ref="p4"/> -->
	 		<!-- <aop:after method="log" pointcut-ref="p5"/> -->
	 		
	 		<!-- around는 사용하기 힘들어서 또는 보조업무가 주업무를 감싸는 경우가 많지않아 사용빈도가 낮다 -->
	 		<!-- <aop:around method="time" pointcut-ref="p5"/> -->
	 		
	 		<!-- returning은 매개변수 이름을 참조한다. -->
	 		<!-- <aop:after-returning method="history" pointcut-ref="p2" returning="memo"/> -->
	 		
	 		<aop:after-throwing method="check" pointcut-ref="p2" throwing="e"/>
	 		
	 	</aop:aspect>
	</aop:config>
</beans>