🌈 [Section2] 20. AOP (Aspect-Oriented Programming)

📕 오늘 배운 내용!

• AOP (Aspect-Oriented Programming)
• AOP 용어
• AOP 프록시

---

✏️ 애플리케이션 로직

1. 핵심 관심사 (Core Concerns)
( 핵심 기능 )

• 객체가 제공하는 고유의 기능

Ex. 업무 로직

2. 횡단 관심사 (CROSS-CUTTING CONCERNS)

• 핵심 기능을 보조하기 위해 여러 클래스에 걸쳐 공통으로 사용되는 부가적인 기능
  ➜ 중복 코드 생김 ( AOP 방식으로 해결 )

• 핵심기능과 함께 사용 ( 단독 X )

Ex. 로깅, 보안, 트랜잭션, 로그 추적 로직 등

Ex. orderService라는 하나의 객체에 핵심기능인 주문 로직과 부가기능인 로그 추적 로직이 합쳐져서 하나의 로직을 완성하게 됨

---

✏️ 객체 지향 프로그래밍 (Object Oriented Programming)

• OOP의 핵심은 공통된 목적을 띈 데이터와 동작을 묶어 하나의 객체로 정의하는 것

• 기능을 재사용할 수 있는 것이 큰 장점

• 관심사 분리 (Separation of Concerns, SoC)의 디자인 원칙을 준수해야함

• OOP 모듈화의 핵심 단위 ➜ 클래스

✔️ OOP의 문제점

비즈니스 클래스에 횡단 관심사와 핵심 관심사가 공존하게 되는데,
이 때 메소드 복잡도가 증가하여 비즈니스 코드 파악이 어렵고,
부가 기능의 불특정 다수 메소드가 반복적으로 구현되어 횡단 관심사의 모듈화가 어려움

➜ OOP의 관심사 분리에 대한 한계를 해결하고자 AOP 등장

---

✏️ AOP (Aspect-Oriented Programming)

• 기존과 다른 프로그램 구조 사고 방식을 제공함으로써 객체 지향 프로그래밍(OOP)의 부족한 부분을 보완하는 것

• 여러 유형과 객체 간에 발생하는 문제의 모듈화를 가능하게 함

• AOP의 모듈화의 핵심 단위 ➜ 관점 (Aspect)
  ( OOP의 모듈화의 핵심 단위 ➜ 클래스 (class) )

✔️ Aspect

• 여러 객체에 공통으로 적용되는 기능 ( 공통 기능 = 횡단 관심사 )
• Aspect = 어드바이스(Advice) + 포인트컷(PointCut)
  ( 부가 기능을 정의한 코드인 어드바이스(Advice)와 어드바이스를 어디에 적용할지 결정하는 포인트컷(PointCut)을 합친 개념 )

---

✏️ Spring AOP의 구현 방식

1. XML 기반의 POJO 클래스를 이용한 AOP 구현

• 부가기능을 제공하는 Advice 클래스를 작성

• XML 설정 파일에 <aop:config>를 이용해서 애스펙트를 설정
  (즉, 어드바이스와 포인트컷을 설정함)

2. @Aspect 애너테이션을 이용한 AOP 구현

• @Aspect 애너테이션을 이용해서 부가기능을 제공하는 Aspect 클래스를 작성

• 이 때, Aspect 클래스는 어드바이스를 구현하는 메서드와 포인트컷을 포함

• XML 설정 파일에 <aop:aspectj-autoproxy />를 설정

---

✏️ 조인 포인트 (Join Point)

• 애플리케이션의 실행 흐름에서의 AOP를 적용할 수 있는 모든 특정 지점

• 스프링 컨테이너가 관리할 수 있는 스프링 빈에만 AOP 적용 가능

• 항상 메서드 레벨에만 AOP 적용 가능
  ( 스프링 AOP가 프록시 방식 사용하기 때문 )
  ( 프록시 방식 = 런타임 중일 때, 스프링 컨테이너가 빈을 생성하면서, 요청을 프록시 객체가 대신 가로채서 찐 객체에 넣어주는 것 )

• 애플리케이션에 새로운 동작을 추가하기 위해, 이 조인 포인트에 관심코드(Aspect Code) 추가함

• 횡단 관심사는 조인포인트 전/후에 AOP에 의해 자동으로 추가됨

• 어드바이스 적용이 필요한 곳은 애플리케이션 내에 메서드를 가짐

• JointPoint 메소드는 기본적으로 어드바이스 메소드에 매개변수로 선언만 하면 됨

✔ JointPoint 인터페이스의 주요 기능

• JoinPoint.getArgs()
  ➜ JoinPoint에 전달된 인자를 배열로 반환

• JoinPoint.getThis()
  ➜ AOP 프록시 객체를 반환

• JoinPoint.getTarget()
  ➜ AOP가 적용된 대상 객체를 반환
  ( 클라이언트가 호출한 비즈니스 메소드를 포함하는 비즈니스 객체를 반환 )

• JoinPoint.getSignature()
  ➜ 조언되는 메서드에 대한 설명을 반환
  ( 클라이언트가 호출한 메소드의 시그니처(리턴타입, 이름, 매개변수) 정보가 저장된 Signature 객체를 반환 )

  • Signature가 제공하는 메서드
    ( 객체가 선언하는 모든 연산에서, 연산의 이름, 매개변수로 받아들이는 객체들을 시그니처라고 함 )

    • String getName()
      ➜ 클라이언트가 호출한 메소드 이름을 반환

    • String toLongString()
      ➜ 클라이언트가 호출한 메소드의 리턴타입, 이름, 매개변수를 패키지 경로까지 포함해서 반환

    • String toShortString()
      ➜ 클라이언트가 호출한 메소드 시그니처를 축약한 문자열로 반환

    • JoinPoint.toString()
      ➜ 조언되는 방법에 대한 유용한 설명을 인쇄

✔ ProceedingJoinPoint 인터페이스의 주요 기능

• proceed()
  ➜ 다음 어드바이스나 타켓을 호출

---

✏️ 어드바이스 (Advice)

• 특정 조인포인트(Join Point)에서 수행될 부가기능을 정리한 코드

• 핵심 코드(Target)에 Aspect를 언제 적용할지 정의

• 시스템 전체 Aspect에 API 호출 제공

• 메소드 호출 전 상세 정보 및 모든 메소드 로그를 남기기 위해, 로거(Logger)는 조인포인트(메소드 시작 전 포인트)를 선택

  ✔️ 로거 (Logger)
  일련의 데이터를 로그 파일로 기록하는 소프트웨어

• 순서를 보장하지 않음

  • 순서를 지정하려면 @Aspect 적용 단위로 org.springframework.core.annotation.@Order 애너테이션을 적용해야함

  • 어드바이스(Advice) 단위가 아닌 클래스 단위로 적용 가능

  • 하나의 애스팩트(Aspect)에 여러 어드바이스(Advice)가 존재한다면 순서 보장 X
    ➜ 애스팩트(Aspect)를 클래스별로 분리해야함

✔ Advice 종류

✔️ Before

• 조인 포인트 이전에 실행

• 타겟 메서드가 실행되기 전에 처리해야할 필요가 있는 부가기능을 호출 전에 공통기능 실행

• Before Advice 구현한 메서드는 일반적으로 리턴타입이 void
  ( But, 리턴 값을 갖더라도 실제 Advice 적용 과정에는 영향 X )

• 작업 흐름 변경 불가

• 메서드 종료 시, 자동으로 다음 타겟 호출
  ( 주의점 : 메서드에서 예외를 발생시킬 경우, 대상 객체의 메서드 호출 안됨 )

✔️ After returning

• 조인포인트가 정상 완료된 후 실행
  ( 메서드 실행이 예외없이 정상적으로 반환된 이후 공통 기능을 실행 )

• < returning 속성에 사용된 이름 = 어드바이스 메서드의 매개변수 이름 > 이어야함

• returning 절에 지정된 타입의 값을 반환하는 메서드만 대상을 실행

✔️ After throwing

• 메서드 실행이 예외를 던져 종료될 경우에 실행
  ( 메서드를 실행하는 도중 예외가 발생한 경우 공통 기능을 실행 )

• < throwing 속성에 사용된 이름 = 어드바이스 메서드의 매개변수 이름 > 이어야함

• throwing 절에 지정된 타입과 맞은 예외를 대상으로 실행

✔️ After (finally)

• 조인 포인트의 동작과는 상관없이 메서드 실행 후 공통 기능 실행
  ( 실행 결과가 정상, 예외와는 상관 X )
  ( 예외 동작의 finally를 생각하면 됨 )

• 보통 리소스 해제하는데 사용

✔️ Around

• 메서드 호출 전/후, 예외 발생 시점에 공통 기능 실행
  Ex. 조인 포인트 실행 여부 선택, 반환 값 변환, 예외 변환 등

• 가장 강력한 어드바이스

  • 조인 포인트 실행 여부 선택 - joinPoint.proceed()
  • 전달 값 변환 - joinPoint.proceed(args[])
  • 반환 값 변환
  • 예외 변환
  • try ~ catch ~ finally 가 들어가는 구문 처리 ( 예외 처리 구문 )

• 어드바이스의 첫 번째 파라미터는 ProceedingJoinPoint 사용해야함

• proceed()를 통해 대상 실행하고 여러번 실행 가능

  💡 사실 @Around만 있어도 모든 기능 수행 가능
  But, 고려해야할 사항이 있을 때 정상적으로 작동이 되지 않는 경우 있음
  ⠀
  @Before / @After 과 같은 어드바이스는 기능은 적지만 코드도 단순하고, 원하는 대로 작동하며 각각이 애너테이션만 봐도 어떤 일을 하는지 명확하게 파악 가능
  ⠀
  ➜ 좋은 설계는 @Around만 사용하는 것보다 제약을 가지더라도 문제 자체가 발생하지 않고 역할을 명확하게 하여 실수를 사전에 방지하는 것임

---

✏️ 포인트컷 (Pointcut)

• 조인포인트(Join Point)에서 어드바이스(Advice)가 적용될 위치를 선별하는 기능
  ( 애플리케이션 실행 흐름에서 AOP를 적용할 수 있는 모든 포인트에서 수행될 부가기능 코드의 위치를 선별하는 기능 )

• 관심 조인포인트를 결정 ➜ 어드바이스가 실행되는 시기 제어 가능

• 메서드 실행 지점만 포인트컷으로 선별 가능

• AspectJ 표현식을 사용해서 지정
  ( &&, ||, ! 를 사용하여 결합 가능 )

  💡 build.gradle 파일의 dependencies에 implementation 'org.springframework.boot:spring-boot-starter-aop' 추가해야 AspectJ 라이브러리 사용 가능 !

포인트컷 지시자 종류

• execution
  ➜ 메서드 실행 조인트 포인트 매칭
  ➜ 스프링 AOP에서 가장 많이 사용, 기능도 복잡

• within
  ➜ 특정 타입 내의 조인 포인트 매칭

• args
  ➜ 인자가 주어진 타입의 인스턴스인 조인 포인트

• this
  ➜ 스프링 빈 객체(스프링 AOP 프록시)를 대상으로 하는 조인 포인트

• target
  ➜ Target 객체(스프링 AOP 프록시가 가르키는 실제 대상)를 대상으로 하는 조인 포인트

• @target
  ➜ 실행 객체의 클래스에 주어진 타입의 애너테이션이 있는 조인 포인트

• @within
  ➜ 주어진 애너테이션이 있는 타입 내 조인 포인트

• @annotation
  ➜ 메서드가 주어니 애너테이션을 가지고 있는 조인 포인트를 매칭

• @args
  ➜ 전달된 실제 인수의 런타임 타입이 주어진 타입의 애너테이션을 갖는 조인 포인트

• bean
  ➜ 스프링 전용 포인트컷 지시자
  ➜ 빈의 이름으로 포인트컷을 지정
  ⠀
  ❗ execution을 가장 많이 사용하고 나머지는 자주 사용하지 않음 !

✔ 포인트컷 표현식

(..) ➜ 모든 매개변수
*(..) ➜ 모든 메서드 선택
(*) ➜ 반드시 1개의 매개변수를 가지는 메소드만 선택

• 모든 공개 메서드 실행
  ➜ execution(public * *(..))
  ⠀
• set 다음 이름으로 시작하는 모든 메서드 실행
  ( 메서드명이 set~~으로 시작하는 모든 메서드 )
  ➜ execution(* set*(..))
  ⠀
• AccountService 인터페이스에 의해 정의된 모든 메소드의 실행
  ➜ execution(* com.xyz.service.AccountService.*(..))
  ( 파일 위치가 com.xyz.service 패키지의 AccountService 인터페이스인 것 )
  ⠀
• service 패키지에 정의된 메서드 실행
  ➜ execution(* com.xyz.service.*.*(..))
  ( 파일 위치가 com.xyz.service 패키지 )
  ⠀
• service 패키지 또는 해당 하위 패키지 중 하나에 정의된 메서드 실행
  ➜ execution(* com.xyz.service..*.*(..))
  ⠀
• service 패키지 내의 모든 조인 포인트
  (Spring AOP에서만 메서드 실행)
  ➜ within(com.xyz.service.*)
  ⠀
• service 패키지 또는 하위 패키지 중 하나 내의 모든 조인 포인트
  (Spring AOP에서만 메서드 실행)
  ➜ within(com.xyz.service..*)
  ⠀
• AccountService 프록시가 인터페이스를 구현하는 모든 조인 포인트
  (Spring AOP에서만 메서드 실행)
  ➜ this(com.xyz.service.AccountService)
  ⠀
• AccountService 대상 객체가 인터페이스를 구현하는 모든 조인 포인트
  (Spring AOP에서만 메서드 실행)
  ➜ target(com.xyz.service.AccountService)
  ⠀
• 단일 매개변수를 사용하고 런타임에 전달된 인수가 Serializable과 같은 모든 조인 포인트
  (Spring AOP에서만 메소드 실행)
  ➜ args(java.io.Serializable)
  ⠀
• 대상 객체에 @Transactional 애너테이션이 있는 모든 조인 포인트
  (Spring AOP에서만 메서드 실행)
  ➜ @target(org.springframework.transaction.annotation.Transactional)
  ⠀
• 실행 메서드에 @Transactional 애너테이션이 있는 조인 포인트
  (Spring AOP에서만 메서드 실행)
  ➜ @annotation(org.springframework.transaction.annotation.Transactional)
  ⠀
• 단일 매개 변수를 사용하고 전달된 인수의 런타임 유형이 @Classified 애너테이션을 갖는 조인 포인트
  (Spring AOP에서만 메서드 실행)
  ➜ @args(com.xyz.security.Classified)
  ⠀
• memberService 라는 이름의 스프링 빈의 모든 조인 포인트
  (Spring AOP에서만 메서드 실행)
  ➜ bean(memberService)
  ⠀
• 와일드 표현식 *Service 라는 이름을 가진 스프링 빈의 모든 조인 포인트
  ( ~~Service로 끝나는 이름의 빈들 )
  ➜ bean(*Service)

---

✏️ 어드바이저 (Advisor)

• 하나의 어드바이스(Advice) + 하나의 포인트컷(Pointcut) 으로 구성
  ( 수행 코드(부가기능) + 그 코드의 위치 선별 기능 )

• 스프링 AOP에서만 사용되는 특별한 용어

---

✏️ 타겟 (Target)

• 핵심 기능을 담고있는 모듈
  ( 부가기능(Advice)이 적용될 객체 )

• 포인트컷(Pointcut)으로 어느 타겟에 들어갈지 결정됨
  ( 위치 선별 기능으로 결정 )

---

✏️ 위빙 (Weaving)

• 포인트컷(Pointcut)으로 결정한 타겟(Target)의 조인포인트(Join Point)에 어드바이스(Advice)를 적용하는 것
  ( 위치 선별 기능으로 결정한 핵심 기능 모듈의 AOP 적용 가능 포인트에 부가기능 코드를 적용하는 것 )

➜ 프록시 방식을 통해서 AOP가 구현되는 과정

• 컴파일 타임
  ➜ .java 파일 -> .class 파일로 컴파일되는 시점에 Aspect가 삽입된
  ➜ 스프링 AOP에서는 사용 불가 / AspectJ 사용할 때 사용
  ⠀
• 클래스 로드 타임
  ➜ 컴파일 이후에 메모리에 올라가는 시점에 AOP가 적용
  ➜ 스프링 AOP에서는 사용 불가 / AspectJ 사용할 때 사용
  ⠀
• 런타임(실행중일 때) == 프록시 방식
  ➜ 스프링 컨테이너가 객체를 생성할 때 프록시 객체를 자동으로 생성하고 원본 객체 대신 프록시 빈으로 등록
  (IoC를 통해서)
  스프링 컨테이너가 빈을 생성할 때 이 요청을 프록시 객체가 가로채서 @Aspect가 되어있는 객체들을 싹 모아서 찐 객체에 넣어줌

---

✏️ AOP 프록시 (proxy)

• AOP 기능 구현을 위해 만든 프록시 객체

  ✔️ 프록시 (Proxy)

  • '대리' 라는 의미
  • 다른 무언가와 이어지는 인터페이스 역할을 하는 클래스
  • 타겟을 감싸서 요청을 대신 받아주는 랩핑 클래스
    ( Spring에서는 Proxy를 이용해 OOP의 5대 원칙 중 하나인 OCP 적용 )
  • 프록시 객체 = 핵심 기능 외에 공통적인 기능을 담은 객체
    ( 어드바이스를 타겟 객체에 적용하면서 생성되는 객체 )
    ➜ 원래 객체를 감싸서 client의 요청을 대신 처리함

Ex. 같은 인터페이스를 구현하고 있는 실제 요청 처리 객체와 프록시 객체를 만들고, 프록시 객체가 대신하여 실제 요청 처리를 가짐

• 스프링에서 생성하는 AOP 프록시는 JDK 동적 프록시 or CGLIB 프록시임

✔ IoC 컨테이너와 AOP Proxy의 관계

Spring AOP는 Proxy의 메커니즘을 기반으로 AOP Proxy를 제공하고 있음 !

위 그림처럼 Spring AOP는 사용자의 특정 호출 시점에 IoC 컨테이너에 의해 AOP를 할 수 있는 Proxy Bean을 생성해줌

동적으로 생성된 Proxy Bean은 핵심기능 모듈(Target)의 메소드가 호출되는 시점에, 부가기능을 추가할 메소드를 자체적으로 판단하고 가로채어 부가기능을 주입함

➜ 호출 시점에 동적으로 위빙을 한다고 하여 런타임 위빙(Runtime Weaving)이라고 함

따라서 Spring AOP는 런타임 위빙의 방식을 기반으로 하고 있고,

Spring에선 런타임 위빙을 할 수 있도록 상황에 따라 JDK Dynamic Proxy 방식와 CGLIB 방식을 통해 Proxy Bean을 생성을 해줌

✔ 두 AOP Proxy는 어떤 상황에서 생성될까?

Spring은 AOP Proxy를 생성하는 과정에서 자체 검증 로직을 통해 타깃의 인터페이스 유무를 판단함

이 때 인터페이스의 유무에 따라,

타겟(Target)이 하나 이상의 인터페이스를 구현하고 있는 클래스라면 ➜ JDK Dynamic Proxy 방식으로,
( But, 기본적으로 Spring은 인터페이스를 구현하는 것을 추천 )

인터페이스를 구현하지 않은 클래스라면 ➜ CGLIB의 방식으로 AOP 프록시를 생성

[참고] https://gmoon92.github.io/spring/aop/2019/04/20/jdk-dynamic-proxy-and-cglib.html

---

❗ 💬 정리 !!

프로그래밍 할 때, 더 좋은 객체지향을 하고 반복적인 작업을 통일해 한번에 하여 효율성을 높이기 위해 AOP (Aspect Oriented Programming) 기법을 사용한다.

이 AOP는 프로젝트 내의 여러 객체에 공통으로 적용되는 기능(Aspect)들만 기능별로 따로 묶어, 프록시 객체를 만들어서 한번에 처리하는 기법이다.

이 때 따로 묶은 Aspect들은 그 기능을 어디에(어느 타겟에) 적용할 지 써줘야하는데
( 타겟 - 따로 묶은 공통 기능들을 넣어줄 핵심 기능 )

이는 포인트컷을 활용하여 그 기능을 어느 위치에 넣을 건지 정해줄 수 있고,

어드바이스를 활용하여 언제 넣을 건지 정해줄 수 있다.
( Ex. 메서드 호출 전, 필드값 변경 후 등 )

여기서, AOP가 적용될 수 있는 모든 지점을 조인포인트라고 하고,
그러므로 AOP가 적용될 수 있는 지점 == 포인트컷을 넣을 지점이 되기 때문에

즉, 포인트컷을 활용할 수 있는 모든 지점을 조인포인트라고 할 수 있다.

[참고] https://pangtrue.tistory.com/m/80

---

💬 궁금했던 점 !

Q1 ) AOP 개념을 적용할 때, Proxy 객체가 요청을 대신 가로채서 처리한다고 했는데, 왜 바로 원래 객체에 넣지 않고 Proxy 객체를 통해 넣어주는 걸까?
⠀
Answer1 )
먼저 Proxy 객체는 원래 객체를 감싸는 형태로 만들어지는데, 이 Proxy 패턴을 사용하는 이유는 접근을 제어하고 싶거나, 부가기능을 추가할 때 사용됨.
즉, Proxy 객체를 사용한다면 공통 로직과 비즈니스 로직이 분리되어 역할 분리가 되고 코드도 깔끔해지기 때문에 Proxy 객체를 사용하는 것이 더 효율적인 것.
⠀
예를 들어, Service라는 상위 인터페이스가 있고, 이를 구현한 MemberSevice라는 하위 인터페이스가 있다고 가정했을 때,
이 코드를 실행시키는 main()이 client라고 볼 수 있고, MemberService가 원래 객체라고 볼 수 있다.
이 때 원래 객체인 MemberService의 메서드들에 동일한 기능을 하는 코드를 넣고 싶을 경우, 각각의 메서드에 넣어주는 것은 효율성이 떨어진다.
따라서 이 경우 Proxy 패턴을 사용한다.
Proxy 객체는 원래 객체 MemberService와 같은 상위 인터페이스 Service를 구현해줘야 한다.
그리고 이 Proxy 객체 안에 원래 객체 MemberService를 주입받아서 그 안의 메서드들을 위임받아 사용하고, 원하는 추가 코드를 Proxy 객체에 넣어주면 된다.
⠀

[참고] https://velog.io/@max9106/Spring-%ED%94%84%EB%A1%9D%EC%8B%9C-AOP-xwk5zy57ee

Q2 ) JoinPoint는 AOP를 적용할 수 있는 모든 특정 지점이고, Pointcut은 조인포인트에서 어드바이스가 적용될 위치를 선별하는 기능인데,
그렇다면 Pointcut은 결국 어드바이스가 적용될 위치 즉, AOP가 적용될 수 있는 위치를 선별하는 기능이라고 생각하여
JoinPoint 와 Pointcut의 차이점이 너무 했갈렸다.
⠀
Answer2 )
JoinPoint가 Advice가 적용될 수 있는 모든 위치들(AOP 적용 지점에 대한 메타적인 정보)이고,
Pointcut은 좀 더 구체적인 적용 지점으로 특정 메소드에 어디에 어드바이스가 적용될 수 있는 지에 대한 정보이다.
⠀
예를 들어서 MemberService의 hello()라는 메소드 실행 전,후에 hello와 bye를 출력하는 일을 한다고 가정할 때,
MemberService 빈 = Target
"hello() 메소드 실행 전,후" = 포인트컷
"메소드 실행 전,후" = 조인포인트
"hello랑 bye를 출력하는 일" = Advice
인 것이다.

Q3 ) AnnotationConfigApplicationContext와 ApplicationContext의 차이와 /
밑의 코드에서 AnnotationConfigApplicationContext로만 정의해도 되는데 ApplicationContext로 만드는 이유가 궁금했다.

AnnotationConfigApplicationContext acac = new AnnotationConfigApplicationContext(AppConfig.class);
⠀
ApplicationContext ac = new AnnotationConfigApplicationContext(AppConfig.class);

Answer3 )

이 위 표를 보고 상위 하위 관계라는 건 알았는데 이 이후로는 이해가 가지 않아 찾아보았는데, 나와 같은 궁금증을 가진 사람이 있었다.

그리고 이 하위 인터페이스를 사용하게 되면 그 구현체가 수정되어 다른 하위 인터페이스로 바뀌어도 결국엔 그것도 저 상위 인터페이스를 구현하고 있기 때문에,
상위 인터페이스의 기능(메서드)이 변하지 않는 이상 상위 인터페이스를 구현한 기능들은 변경할 일이 없어져서
나중에 구현체를 수정하더라도 그 구현체만의 메서드만 수정하면 되기 때문에 좀 더 수정할 일이 적어진다 !
⠀
또 추가적으로, 상위 인터페이스인 ApplicationContext를 통해 스프링 컨테이너 형식을 저장하면 getBeanDefinition() 메서드가 사용이 안되니 주의하자 !

---

🌈 느낀점

오늘 실습을 하면서 직접 코드를 치고 어떤 상황에서 쓰이는지 좀 더 잘 이해가 됐다!!
역시 직접 많이 쳐봐야하나보다
실습 내용은 Project 폴더 내의 aop !!