AOP (Aspect Oriented Programming)

최동민·2022년 11월 18일
실전에 부딪히며 공부하는 개발
0

실전에 부딪히며 공부하는 개발

목록 보기
20/53

AOP

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

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

AOP에서 각 관점을 기준으로 로직을 모듈화한다는 것은 코드들을 부분적으로 나누어서 모듈화하겠다는 의미이다. 이때, 소스 코드 상에서 다른 부분에 계속 반복해서 쓰는 코드들을 발견할 수 있는데 이것을 흩어진 관심사 (Crosscutting Concerns)라 부른다.

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

AOP 주요 개념

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

스프링 AOP 특징

  • 프록시 패턴 기반의 AOP 구현체, 프록시 객체를 쓰는 이유는 접근 제어 및 부가기능을 추가하기 위해서임
  • 스프링 빈에만 AOP를 적용 가능
  • 모든 AOP 기능을 제공하는 것이 아닌 스프링 IOC와 연동하여 엔터프라이즈 애플리케이션에서 가장 흔한 문제 (중복코드, 프록시 클래스 작성의 번거로움, 객체들 간 관계 복잡도 증가 등)에 대한 해결책을 지원하는 것이 목적

예시

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

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

AOP를 사용하지 않는 기본 적인 시간 측정 Bean(ExampleService)구현

  • 인터페이스 구현
public interface ExampleService { 
		public void start();
		public void process();
		public void end(); 
}
  • 인터페이스 구현체 구현
package io.security.corespringsecurity.aopsecurity;

import org.springframework.stereotype.Component;
import org.springframework.util.StopWatch;

@Component
public class ExampleServiceImpl implements ExampleService {
    @Override
    public void start() {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        try{
            Thread.sleep(1000);
            System.out.println("start");
        }catch(Exception e){
            e.printStackTrace();
        }
        stopWatch.stop();
        System.out.println(stopWatch.prettyPrint());
    }

    @Override
    public void process() {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        try{
            Thread.sleep(1000);
            System.out.println("processing");
        }catch(Exception e){
            e.printStackTrace();
        }
        stopWatch.stop();
        System.out.println(stopWatch.prettyPrint());
    }

    @Override
    public void end() {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        try{
            Thread.sleep(1000);
            System.out.println("ended");
        }catch(Exception e){
            e.printStackTrace();
        }
        stopWatch.stop();
        System.out.println(stopWatch.prettyPrint());
    }
}
  • 테스트 코드 작성
package io.security.corespringsecurity.aopsecurity;

import org.junit.jupiter.api.Test;

class ExampleServiceImplTest {
    @Test
    public void exampleTest() throws Exception {
        ExampleService service = new ExampleServiceImpl();
        service.start();
        service.process();
        service.end();
    }
}
  • 실행 결과

  • 공통 모듈분석
    ⇒ 위 코드(ExampleServiceImpl)를 보면 StopWatch 를 이용해 성능측정을 하는부분이 start, process , end 메서드에 모두 포함된다.
    그렇기 때문에 해당 코드는 공통모듈로 묶어서 정의할 수 있다.

AOP를 이용해 시간측정 Bean(ExampleService) 개선 - Execution expression

package io.security.corespringsecurity.aopsecurity;

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

@Component
@Aspect
public class PerfAspect {
		// io.security.corespringsecurity.aopsecurity.ExampleService 클래스내의 모든 메서드에 공통 모듈을 적용한다. 
    @Around(value = "execution(* io.security.corespringsecurity.aopsecurity.ExampleService.*(..))")
    public Object logPerf(ProceedingJoinPoint pjp) throws Throwable {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        Object retVal = pjp.proceed();
        stopWatch.stop();
        System.out.println(stopWatch.prettyPrint());
        return retVal;
    }
}
  • 기존 코드 수정
package io.security.corespringsecurity.aopsecurity;

import org.springframework.stereotype.Component;
import org.springframework.util.StopWatch;

@Component
public class ExampleServiceImpl implements ExampleService {
    @Override
    public void start() {
        try {
            Thread.sleep(1000);
            System.out.println("start");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public void process() {
        try {
            Thread.sleep(1000);
            System.out.println("processing");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public void end() {
        try {
            Thread.sleep(1000);
            System.out.println("ended");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
  • 테스트 코드 작성
package io.security.corespringsecurity.aopsecurity;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class ExampleServiceImplTest {

    @Autowired
    ExampleService service;

    @Test
    public void exampleTest() throws Exception {
        service.start();
        service.process();
        service.end();
    }
}

기존과 차이점이 있다면, @Aspect 를 적용하기위해 @SpringBootTest 어노테이션을 추가해서 해당 @Aspect를 등록해주고 ExampleService도 DI(의존관계 주입(Dependency Injection))해주었다.

참고: Advice 정의(@Aspect)시 Point cut시점을 정의할 수 있는데 위 예제는 @Around로 정의되었지만
@Before나 @After와같은 어노테이션도 존재한다.

AOP를 이용해 시간측정 Bean(ExampleService) 개선 - Annotation

⇒ 구현체의 특정 메서드들만 부가기능을 부여하려면 기존 Execution expression 방식을 쓰면 표현식을 다 작성해줘야 한다.
그렇기에 Annotation을 이용하여 조금 더 편하게 적용해보자.

  • 어노테이션(Annotation) 구현
package io.security.corespringsecurity.aopsecurity;

import java.lang.annotation.*;

@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.CLASS)
public @interface PerfLogging {
}
  • Aspect 클래스 수정(Execution Expression → Annotation)
package io.security.corespringsecurity.aopsecurity;

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

@Component
@Aspect
public class PerfAspect {

    @Around("@annotation(PerfLogging)")
    public Object logPerf(ProceedingJoinPoint pjp) throws Throwable {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        Object retVal = pjp.proceed();
        stopWatch.stop();
        System.out.println(stopWatch.prettyPrint());
        return retVal;
    }
}
  • 구현체(ExampleServiceImpl)에 어노테이션 추가
package io.security.corespringsecurity.aopsecurity;

import org.springframework.stereotype.Component;
import org.springframework.util.StopWatch;

@Component
public class ExampleServiceImpl implements ExampleService {
    @PerfLogging
    @Override
    public void start() {
        try {
            Thread.sleep(1000);
            System.out.println("start");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    @PerfLogging
    @Override
    public void process() {
        try {
            Thread.sleep(1000);
            System.out.println("processing");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public void end() {
        try {
            Thread.sleep(1000);
            System.out.println("ended");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
  • 실행 결과

  • 어노테이션을 붙히지 않은 end메서드에서는 성능 측정 기능이 부여되지 않은걸 확인 가능합니다.

AOP를 이용해 시간측정 Bean(ExampleService) 개선 - Bean

Bean을 통한 기능 부여도 가능합니다. 

package io.security.corespringsecurity.aopsecurity;

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

@Component
@Aspect
public class PerfAspect {

    @Around("bean(exampleServiceImpl)")
    public Object logPerf(ProceedingJoinPoint pjp) throws Throwable {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        Object retVal = pjp.proceed();
        stopWatch.stop();
        System.out.println(stopWatch.prettyPrint());
        return retVal;
    }
}

AOP 적용 전/후 의존관계 비교

  • AOP 적용 전 의존관계

  • helloController는 memberService의 기능들을 사용하며 의존관계가 수립됩니다.

  • 컨트롤러에서는 memberService의 실제 객체(Real Subject)에 바로 접근하여 로직을 수행시킵니다.

  • memberService 에서는 공통적인 기능들을 추가하려면 각각의 메서드마다 기능들을 추가/수정/삭제 해야합니다.

  • AOP 적용 후 의존관계

  • helloController와 memberService 간에 프록시 객체인 memberServiceProxy가 추가되었습니다.

  • helloController 는 이제 실제객체(Real Subject)에 바로 접근하지 않고 프록시 객체를 거쳐 프록시 객체에서 실제 객체에 접근하여 로직을 수행합니다.

  • AOP 적용 전 전체 그림

  • Client가 Request를 하였을 때 스프링 컨테이너 내부의 의존관계를 보여줍니다.
  • helloController 가 memberService 에 메서드를 호출해 비즈니스 로직을 수행하고 memberService에서는 - memberRepository 를 호출하여 레파지토리에서는 DB에 접근해 데이터를 조회/수정/삭제 합니다.
  • 모두 실제 객체에 바로바로 접근합니다.

  • 모든 객체들에게 프록시객체가 생성되었고 의존관계도 프록시 객체를 통하여 이뤄집니다.
  • 각각 객체의 기능들을 수행하려 메서드를 호출하면 요청을 프록시 객체가 전달받아서 전처리/후처리 등 추가적인 작업을 수행하면서
  • 실제 객체(Real Subject)에 로직을 수행합니다.
profile
최동민
코드를 두드리면 문이 열린다
이전 포스트

싱글톤(Singleton) 패턴

다음 포스트

객체 지향 프로그래밍 OOP ( Object Oriented Programing )

0개의 댓글