Coding/SPRING

[Spring] AOP(Aspect Oriented Programming)=Part.1

Soocong 2022. 4. 7. 15:01

AOP(Aspect Oriented Programming) 란?

관점 지향 프로그래밍 이라고 불린다. 관점 지향은 쉽게 말해 어떤 로직을 기준으로 핵심적인 관점, 부가적인 관점으로 나누어서 보고 그 관점을 기준으로 각각 모듈화하겠다는 것이다. 여기서 모듈화란 어떤 공통된 로직이나 기능을 하나의 단위로 묶는 것을 말한다.

- 여러 객체에 공통으로 적용할 수 있는 기능을 분리해서 재사용성을 높여주는 프로그래밍 기법

- AOP는 핵심기능과 공통 기능의 구현을 분리함으로써 핵심 기능을 구현한 코드의 수정없이 공통 기능을 적용할 수 있게 만들어준다.

- Aspect라는 말은 구분되는 기능이나 요소를 의미한다.

=> 즉, 핵심 기능의 코드를 수정하지 않으면서 공통기능의 구현을 추가하는 것

방법 1) 컴파일 시점에 코드에 공통기능을 삽입하는 방법

방법 2) 클래스 로딩 시점에 바이트 코드에 공통 기능을 삽입하는 방법

방법 3) 런타임에 프록시 객체를 생성해서 공통 기능을 삽입하는 방법

위와 같이 흩어진 관심사를 Aspect로 모듈화하고 핵심적인 비즈니스 로직에서 분리하여 재사용하겠다는 것이 AOP의 취지다.

Aspect?

- Aspect라는 말은 구분되는 기능이나 요소를 의미

- 부가 기능을 정의한 코드인 어드바이스(Advice)와 어디바이스를 어디에 적용할지를 결정하는 포인트 컷(PointCut)을 합친 개념이다.

Advice+PointCut = Aspect

- AOP 개념을 적용하면 핵심기능 코드 사이에 침투된 부가기능을 독립적인 애스펙트로 구분해 낼 수 있다.

- 구분된 부가기능 애스펙트를 런타임 시에 필요한 위치에 동적으로 참여하게 할 수 있다.

방법 1) 컴파일 시점에 코드에 공통기능을 삽입하는 방법

방법 2) 클래스 로딩 시점에 바이트 코드에 공통 기능을 삽입하는 방법

방법 3) 런타임에 프록시 객체를 생성해서 공통 기능을 삽입하는 방법

AOP 주요 개념

용어	의미
Aspect	위에서 설명한 흩어진 관심사를 모듈화 한 것. 주로 부가기능을 모듈화함.
Weavinhg	Advice를 핵심 로직 코드에 적용하는 것.
Target	Aspect를 적용하는 곳 (클래스, 메서드 .. )
Advice	실질적으로 어떤 일을 해야할 지에 대한 것, 실질적인 부가기능을 담은 구현체
JointPoint	Advice를 적용 가능한 지점. 메서드 호출, 필드 값 변경 등이 Joinpoint에 해당한다. 스프링은 프록시를 이용해서 AOP를 구현하기 때문에 메서드 호출에 대한 Joinpoint만 지원한다.Advice가 적용될 위치, 끼어들 수 있는 지점. 메서드 진입 지점, 생성자 호출 시점, 필드에서 값을 꺼내올 때 등 다양한 시점에 적용가능
PointCut	JointPoint의 상세한 스펙을 정의한 것. 'A란 메서드의 진입 시점에 호출할 것'과 같이 더욱 구체적으로 Advice가 실행될 지점을 정할 수 있음

| 스프링 AOP : @AOP

스프링 @AOP를 사용하기 위해서는 다음과 같은 의존성을 추가해야 한다.

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

다음에는 아래와 같이 @Aspect 어노테이션을 붙여 이 클래스가 Aspect를 나타내는 클래스라는 것을 명시하고 @Component를 붙여 스프링 빈으로 등록한다.

@Component
@Aspect
public class PerfAspect {

@Around("execution(* com.saelobi..*.EventService.*(..))")
public Object logPerf(ProceedingJoinPoint pjp) throws Throwable{
long begin = System.currentTimeMillis();
Object retVal = pjp.proceed(); // 메서드 호출 자체를 감쌈
System.out.println(System.currentTimeMillis() - begin);
return retVal;
}
}

@Around 어노테이션은 타겟 메서드를 감싸서 특정 Advice를 실행한다는 의미이다. 위 코드의 Advice는 타겟 메서드가 실행된 시간을 측정하기 위한 로직을 구현하였다. 추가적으로 execution(* com.saelobi..*.EventService.*(..))가 의미하는 바는 com.saelobi 아래의 패키지 경로의 EventService 객체의 모든 메서드에 이 Aspect를 적용하겠다는 의미다.

public interface EventService {

    void createEvent();

    void publishEvent();

    void deleteEvent();
}

@Component
public class SimpleEventService implements EventService {

    @Override
    public void createEvent() {
        try {
            Thread.sleep(1000);
        } catch(InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Created an event");
    }

    @Override
    public void publishEvent() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e){
            e.printStackTrace();;
        }
        System.out.println("Published an event");
    }

    public void deleteEvent() {
        System.out.println("Delete an event");
    }
}

@Service
public class AppRunner implements ApplicationRunner {

    @Autowired
    EventService eventService;

    @Override
    public void run(ApplicationArguments args) throws Exception {
        eventService.createEvent();
        eventService.publishEvent();
        eventService.deleteEvent();
    }
}

Created an event
1003
Published an event
1000
Delete an event
0

또한 경로지정 방식말고 특정 어노테이션이 붙은 포인트에 해당 Aspect를 실행할 수 있는 기능도 제공한다.

@Component
@Aspect
public class PerfAspect {

@Around("@annotation(PerLogging)")
public Object logPerf(ProceedingJoinPoint pjp) throws Throwable{
long begin = System.currentTimeMillis();
Object retVal = pjp.proceed(); // 메서드 호출 자체를 감쌈
System.out.println(System.currentTimeMillis() - begin);
return retVal;
}
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.CLASS)
public @interface PerLogging {
}

@Component
public class SimpleEventService implements EventService {

    @PerLogging
    @Override
    public void createEvent() {
        try {
            Thread.sleep(1000);
        } catch(InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Created an event");
    }

    @Override
    public void publishEvent() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e){
            e.printStackTrace();;
        }
        System.out.println("Published an event");
    }

    @PerLogging
    @Override
    public void deleteEvent() {
        System.out.println("Delete an event");
    }
}

Created an event
1003
Published an event
Delete an event
0

위 출력 결과에서 @PerLogging 어노테이션이 붙은 메서드만 Aspect가 적용된 것을 볼 수 있다.

마찬가지로 스프링 빈의 모든 메서드에 적용할 수 있는 기능도 제공한다.

@Component
@Aspect
public class PerfAspect {

@Around("bean(simpleEventService)")
public Object logPerf(ProceedingJoinPoint pjp) throws Throwable{
long begin = System.currentTimeMillis();
Object retVal = pjp.proceed(); // 메서드 호출 자체를 감쌈
System.out.println(System.currentTimeMillis() - begin);
return retVal;
}
}

@Component
public class SimpleEventService implements EventService {

    @Override
    public void createEvent() {
        try {
            Thread.sleep(1000);
        } catch(InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Created an event");
    }

    @Override
    public void publishEvent() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e){
            e.printStackTrace();;
        }
        System.out.println("Published an event");
    }
    
    @Override
    public void deleteEvent() {
        System.out.println("Delete an event");
    }
}

@Service
public class AppRunner implements ApplicationRunner {

    @Autowired
    EventService eventService;

    @Override
    public void run(ApplicationArguments args) throws Exception {
        eventService.createEvent();
        eventService.publishEvent();
        eventService.deleteEvent();
    } }

Created an event
1002
Published an event
1001
Delete an event
0

위 출력결과로 SimpleEventService의 모든 메서드에 해당 Aspect가 추가된 것을 알 수 있다.

.xml 파일 생성할때 꼭 체크해주기

[Interface]Person.java

package com.java.aop01;

public interface Person {
	public void awake();
	
	public void work();
	
	public void sleep();
	
}

Baby.java

package com.java.aop01;

public class Baby implements Person {

	@Override
	public void awake() {
		System.out.println("일어난다.");
	}

	@Override
	public void work() {
		System.out.println("유치원에 간다.");
	}

	@Override
	public void sleep() {
		System.out.println("잠을잔다.");	
	}
}

Mama.java

package com.java.aop01;

public class Mama implements Person {

	@Override
	public void awake() {
		System.out.println("일어난다.");
	}

	@Override
	public void work() {
		System.out.println("집안일 한다.");	
	}

	@Override
	public void sleep() {
		System.out.println("잠을잔다.");
	}

}

Papa.java

package com.java.aop01;

public class Papa implements Person {

	@Override
	public void awake() {
		System.out.println("일어난다.");
	}

	@Override
	public void work() {
		System.out.println("회사간다.");
	}

	@Override
	public void sleep() {
		System.out.println("잠을잔다.");
	}
}

appCTX.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"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

	<bean id="baby" class="com.java.aop01.Baby"/>
	<bean id="papa" class="com.java.aop01.Papa"/>
	<bean id="mama" class="com.java.aop01.Mama"/>
</beans>

MainClass.java

package com.java.aop01;

import org.springframework.context.support.GenericXmlApplicationContext;

public class MainClass {

	public static void main(String[] args) {
		GenericXmlApplicationContext ctx = new GenericXmlApplicationContext("classpath:com/java/aop01/appCTX.xml");
		
		//아빠
		//Papa로 객체 생성해도 되지만, 인터페이스기반이므로 Person으로 객체 생성
		Person papa = (Person)ctx.getBean("papa");
		papa.awake();
		papa.work();
		papa.sleep();
		System.out.println();
		
		//엄마
		Person mama = (Person)ctx.getBean("mama");
		mama.awake();
		mama.work();
		mama.sleep();
		System.out.println();
		
		//아기
		Person baby = (Person)ctx.getBean("baby");
		baby.awake();
		baby.work();
		baby.sleep();

		ctx.close();
	}
}

공통함수를 aspect 를 사용해서 작성

[Interface]Person.java

package com.java.aop01;

public interface Person {

	public void work();
}

Baby.java

package com.java.aop02;

public class Baby implements Person {

	@Override
	public void work() {
		System.out.println("유치원 등교");
	}
}

Mama.java

package com.java.aop02;

public class Mom implements Person {

	@Override
	public void work() {
		System.out.println("집안일");
	}
}

Papa.java

package com.java.aop02;

public class Papa implements Person {

	@Override
	public void work() {
		System.out.println("회사를 간다.");
	}
}

PASpect.java

package com.java.aop02;

import org.aspectj.lang.JoinPoint;

public class PASpect {		// 공통클래스	: aspect 라고 부른다.
	public void awake(JoinPoint joinPoint) {	// 공통함수	: advice 라고 부른다.
		// joinPoint의 역할은 핵심코드를 가져온다. 
		System.out.println("일어난다.");
	}
	
	public void sleep(JoinPoint joinPoint) {	// 공통함수
		System.out.println("일어난다.");
	}
}

appCTX.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-3.1.xsd">
	
	<!-- 핵심코드  -->
	<bean id="baby" class="com.java.aop02.Baby"/>
	<bean id="papa" class="com.java.aop02.Papa"/>
	<bean id="mama" class="com.java.aop02.Mama"/>
	
	<!-- 공통코드 -->
	<bean id="pAspect" class="com.java.aop02.PASpect"/>
	
	<!-- AOP -->
	<aop:config>
		<!-- 공통클래스  -->
		<aop:aspect id="exAspect" ref="pAspect"> 
			<!--핵심클래스 -->
			<aop:pointcut id="publicM" expression="within(com.java.aop02.*)" />
			
			<aop:before method="awake" pointcut-ref="publicM"/>
			<aop:after method="sleep" pointcut-ref="publicM"/> 
		</aop:aspect>
	</aop:config>
</beans>

MainClass.java

package com.java.aop02;

import org.springframework.context.support.GenericXmlApplicationContext;

public class MainClass {

	public static void main(String[] args) {
		GenericXmlApplicationContext ctx = new GenericXmlApplicationContext("classpath:com/java/aop02/appCTX.xml");
		
		//아빠
		//Papa로 객체 생성해도 되지만, 인터페이스기반이므로 Person으로 객체 생성
		Person papa = (Person)ctx.getBean("papa");
		papa.work();
		System.out.println();
		
		//엄마
		Person mama = (Person)ctx.getBean("mama");
		mama.work();
		System.out.println();
		
		//아기
		Person baby = (Person)ctx.getBean("baby");
		baby.work();
		ctx.close();
	}
}

프록시 기반 AOP

스프링 AOP 특징

스프링 AOP의 특징에 대해서 알아보자.

프록시 기반의 AOP 구현체이다. 프록시 객체를 사용하는 이유는 접근 제어 및 부가 기능을 추가하기 위해서이다.
스프링 빈에만 AOP를 적용할 수 있다.
모든 AOP 기능을 제공하는 것이 목적이 아니라, 스프링 IoC와 연동하여 엔터프라이즈 애플리케이션에서 가장 흔한 문제(중복코드, 프록시 클래스 작성의 번거로움, 객체 간 관계 복잡도 증가 등등…)를 해결하기 위한 솔루션을 제공하는 것이 목적.

프록시 패턴

프록시 패턴에는 interface가 존재하고 Client는 이 interface 타입으로 Proxy 객체를 사용하게 된다.

Proxy 객체는 기존의 타겟 객체(Real Subject)를 참조하고 있다.

Proxy 객체와 Real Subject의 타입은 같고, Proxy는 원래 해야 할 일을 가지고 있는 Real Subject를 감싸서 Client의 요청을 처리한다.

왜? 이렇게 해서 패턴을 사용하는 걸까?

그 이유는 기존 코드의 변경 없이 접근 제어 또는 부가 기능 추가를 위해서다.

▶ AppRunner.java

package me.gracenam.demospring51;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;

@Component
public class AppRunner implements ApplicationRunner {

    @Autowired
    EventService eventService;

    @Override
    public void run(ApplicationArguments args) throws Exception {
        eventService.createEvent();
        eventService.publishEvent();
    }

}

▶ EventService.java

package me.gracenam.demospring51;

public interface EventService {

    void createEvent();

    void publishEvent();

}

▶ SimpleEventService.java

package me.gracenam.demospring51;

import org.springframework.stereotype.Service;

@Service
public class SimpleEventService implements EventService {

    @Override
    public void createEvent() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Created an event");
    }

    @Override
    public void publishEvent() {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Published an event");
    }

}

AppRunner는 Client, EventService는 Subject, SimpleEventService는 Real Subject라고 할 수 있다.

EventService 인터페이스를 상속받은 SimpleEventService에 실질적인 동작 코드가 작성되어 있고 AppRunner를 통해서 실행이 된다.

이제 Proxy로 SimpleEventService(Real Subject)와 AppRunner(Client)를 건들이지 않고 성능을 테스트할 수 있는 기능을 추가해보자.

package me.gracenam.demospring51;

import org.springframework.stereotype.Service;

@Service
public class SimpleEventService implements EventService {

    @Override
    public void createEvent() {
        long begin = System.currentTimeMillis();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Created an event");

        System.out.println(System.currentTimeMillis() - begin);
    }

    @Override
    public void publishEvent() {
        long begin = System.currentTimeMillis();

        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Published an event");

        System.out.println(System.currentTimeMillis() - begin);
    }

    public void deleteEvent() {
        System.out.println("Delete an event");
    }

}

package me.gracenam.demospring51;

public interface EventService {

    void createEvent();

    void publishEvent();

    void deleteEvent();

}

package me.gracenam.demospring51;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;

@Component
public class AppRunner implements ApplicationRunner {

    @Autowired
    EventService eventService;

    @Override
    public void run(ApplicationArguments args) throws Exception {
        eventService.createEvent();
        eventService.publishEvent();
        eventService.deleteEvent();
    }

}

먼저, 프로그램의 성능을 테스트 하는 코드를 추가했다. 시작 시간과 종료 시간을 구해서 동작하는데 걸리는 시간을 출력하도록 했는데, 두 개만 측정하고 하나는 측정하지 않도록 했다. 위 코드처럼 작성할 경우에는 기존의 코드를 건드리게 된다.

기존의 코드를 건드리지 않고 하는 방법이 바로 프록시 패턴을 사용하는 것이다.

package me.gracenam.demospring51;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Service;

@Primary
@Service
public class ProxySEService implements EventService {

    @Autowired
    SimpleEventService simpleEventService;

    @Override
    public void createEvent() {
        long begin = System.currentTimeMillis();
        simpleEventService.createEvent();
        System.out.println(System.currentTimeMillis() - begin);
    }

    @Override
    public void publishEvent() {
        long begin = System.currentTimeMillis();
        simpleEventService.publishEvent();
        System.out.println(System.currentTimeMillis() - begin);
    }

    @Override
    public void deleteEvent() {
        simpleEventService.deleteEvent();
    }
}

@Primary는 같은 타입의 빈이 여러가지일 때 그 중 하나를 선택하여 사용하는 애노테이션이다.

@Autowired는 이론적으로 인터페이스 타입의 빈을 받는 것이 추천된다. 하지만 여기서 Proxy의 경우 Real Subject의 빈을 주입받아서 사용해야하기 떄문에 해당 타입인 SimpleEventService를 명시해주면 주입받아 사용할 수 있다. 또는 EventService 타입을 받지만 빈의 이름(simpleEventService)에 기반해서 주입받아도 상관은 없다.

성능을 테스트하고 싶은 두 개에만 코드를 추가했다. 이렇게 코드를 완성하면 Proxy가 Real Subject를 가지고 있고, Real Subject에 일을 위임해서 대신 처리하고, 부가적인 기능들은 가지고 있다.

Client는 @Autowired로 EventService를 주입받지만 @Primary로 등록된 빈을 가져다 쓰게 될 것이다.

실행해보면 마찬가지로 실행된 시간이 찍히는 것을 확인할 수 있다.

이렇게 Proxy를 사용해서 만들면 원래의 Client와 Real Subject의 코드를 건드리지 않고 부가기능을 추가할 수 있었다. 하지만 Proxy에 중복코드가 생기고, Proxy 클래스를 만드는데 생기는 비용과 수고가 발생한다는 문제가 있다.

만일 Proxy를 여러 클래스, 여러 메소드에 적용시켜야 한다고 생각해보자. 매번 프록시 클래스를 작성해야하고, 또 작성한 프록시 클래스 내에서 중복이 발생할 것이다.

위 예제에서는 Proxy를 클래스로 만들어서 사용했지만, 동적으로 Proxy 객체를 만드는 방법이 있다. 여기서 동적이란, 런타임, 즉 애플리케이션이 동작하는 중에 동적으로 어떤 객체의 Proxy 객체를 만드는 것을 말한다.

스프링 IoC 컨테이너가 제공하는 기반 시설과 Dynamic 프록시를 사용해서 여러 복잡한 문제(중복 코드, 매번 Proxy를 생성 등등)를 해결할 수 있다. 이것이 바로 Spring AOP이다.

@AOP

스프링 애노테이션 기반의 AOP를 살펴보자.

먼저, @AOP를 사용하기 위해서 의존성을 추가한다.

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

이제 Aspect를 나타내는 클래스를 생성한다.

package me.gracenam.demospring51;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class PerfAspect {

    @Around("execution(* me.gracenam..*.EventService.*(..))")
    public Object logPerf(ProceedingJoinPoint pjp) throws Throwable {
        long begin = System.currentTimeMillis();
        Object retVal = pjp.proceed();
        System.out.println(System.currentTimeMillis() - begin);
        return retVal;
    }

}

@Aspect 애노테이션으로 이 클래스가 Aspect 클래스임을 알려준다. @Component 애노테이션을 사용해서 빈으로 등록하는데 이는 애노테이션 기반의 스프링 IoC를 사용하기 때문에 Component Scan을 통해서 빈 등록을 하기 때문이다.

두 가지 정보가 필요한데 해야할 일과 어디에 적용할 것인가이다. 해야할 일은 Advice, 어디에 적용할 것인가는 Point Cut에 해당하고 이 두 가지를 정의해야 한다.

ProceedingJoinPoint, PJP는 Advice가 적용되는 대상이다. 즉, Advice가 적용되는 createEvent, publishEvent와 같은 메서드 자체라고 보면 된다. method invocation과 비슷한 개념이다.

시간을 측정하고 걸린 시간을 출력해주는 기능을 추가하면 Advice가 완성이 된다. 완성된 Advice는 Around Advice라고 해서 @Around 애노테이션을 붙여준다. 그리고 value에 Point Cut 이름을 주거나 직접 정의할 수도 있다.

execution은 Point Cut 표현식인데 이 표현식을 사용해서 어디에 적용할 지를 정의할 수 있다. * me.gracenam..*.EventService.*(..)는 me.gracenam 패키지 밑에 있는 모든 클래스 중 EventService에 있는 모든 메소드에 Advice를 적용하라고 정의한 것이다. 만일 EventService를 *로 변경하면 여러 클래스에 적용할 수 있다.

하지만 이렇게 할 경우에는 적용하고 싶지 않은 메서드에도 적용이 될 수 있다. 그럴 땐 execution을 사용하는 대신 애노테이션으로 적용하면 원하는 곳에만 적용할 수 있다.

package me.gracenam.demospring51;

import java.lang.annotation.*;

@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.CLASS)
public @interface PerfLogging {
}

package me.gracenam.demospring51;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class PerfAspect {

    @Around("@annotation(PerfLogging)")
    public Object logPerf(ProceedingJoinPoint pjp) throws Throwable {
        long begin = System.currentTimeMillis();
        Object retVal = pjp.proceed();
        System.out.println(System.currentTimeMillis() - begin);
        return retVal;
    }

}

package me.gracenam.demospring51;

import org.springframework.stereotype.Service;

@Service
public class SimpleEventService implements EventService {

    @PerfLogging
    @Override
    public void createEvent() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Created an event");
    }

    @PerfLogging
    @Override
    public void publishEvent() {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Published an event");
    }

    public void deleteEvent() {
        System.out.println("Delete an event");
    }

}

애노테이션을 만들 때 한 가지 주의해야 할 점은 RetentionPolicy를 Class 이상으로 주어야 한다. 이 RetentionPolicy라는 것은 기본 값이 Class인데 이 애노테이션 정보를 얼마나 유지할 것인가를 말하는 것이다. 즉, 기본 값이 Class라는 것은 ‘.class 파일까지 유지하겠다’라는 말이다.

Aspect에서는 execution 대신 @annotation이라는 표현식으로 PerfLogging이라는 애노테이션이 달린 곳에 적용되도록 지정했다.

그 외

예제에서는 @Around를 통해서 타겟 메서드의 Aspect 실행 시점을 지정했지만 다른 어노테이션들도 있다.

@Before (이전) : 어드바이스 타겟 메소드가 호출되기 전에 어드바이스 기능을 수행
@After (이후) : 타겟 메소드의 결과에 관계없이(즉 성공, 예외 관계없이) 타겟 메소드가 완료 되면 어드바이스 기능을 수행
@AfterReturning (정상적 반환 이후)타겟 메소드가 성공적으로 결과값을 반환 후에 어드바이스 기능을 수행
@AfterThrowing (예외 발생 이후) : 타겟 메소드가 수행 중 예외를 던지게 되면 어드바이스 기능을 수행
@Around (메소드 실행 전후) : 어드바이스가 타겟 메소드를 감싸서 타겟 메소드 호출전과 후에 어드바이스 기능을 수행