이번 게시물에서는 Spring의 AOP(Aspect-Oriented 프로그래밍)의 내부 메커니즘에 대해 설명하겠습니다. AOP가 종종 "마법"의 형태로 간주되는 로깅과 같은 기능을 달성하는 방법을 이해하는 데 중점을 둘 것입니다. 핵심 Java 구현을 살펴봄으로써 우리는 이것이 진정한 마술이 아닌 Java의 반사, 프록시 패턴 및 주석에 관한 모든 것을 알게 될 것입니다.
이들은 모두 java.lang.reflect,java.lang.annotation 및 javassist.util.proxy 패키지의 일부입니다.
Spring AOP의 핵심에는 프록시 객체, 메소드 인터셉터 및 리플렉션 개념이 있습니다. 이 패턴의 핵심 플레이어는 MethodHandler(또는 호출 핸들러)입니다. 이 핸들러는 메소드 호출을 가로채서 프록시 객체의 동작을 제어합니다. 프록시에서 메서드가 호출되면 핸들러를 통해 전달되며, 여기서 주석은 리플렉션을 통해 검사될 수 있습니다. 적용된 주석을 기반으로 예외 전, 후 또는 발생 시 필요한 로직(예: 로깅)을 실행할 수 있습니다.
예: 특정 메소드 실행 전후에 로깅을 추가한다고 가정해 보겠습니다. 모든 곳에서 로깅을 하드 코딩하는 대신 @BeforeMethod 및 @AfterMethod를 사용하여 메소드에 주석을 달 수 있습니다. 우리 핸들러는 이 주석에 대한 메소드를 검사하고 적절한 로깅 로직을 동적으로 추가합니다.
다음은 우리 예에서 컨트롤러와 서비스가 어떻게 보이는지 클래스입니다.
WorkerController.java
package edu.pk.poc.aop.controller;
import edu.pk.poc.aop.annotation.AfterMethod;
import edu.pk.poc.aop.annotation.All;
import edu.pk.poc.aop.annotation.BeforeMethod;
import edu.pk.poc.aop.helper.ProxyFactory;
import edu.pk.poc.aop.service.Worker;
import edu.pk.poc.aop.service.WorkerService;
import edu.pk.poc.aop.service.WorkerServiceImpl;
public class WorkerController {
WorkerService workerService = ProxyFactory.createProxy(WorkerServiceImpl.class);
/**
* This Method 1s annotated with @BeforeMethod and @AfterMethod, So the log statements
* will be generated before and after method call.
*/
@BeforeMethod
@AfterMethod
public void engageFullTimeWorker() throws Exception {
Worker fullTimeWorker = new Worker();
fullTimeWorker.setName("FullTime-Worker");
fullTimeWorker.setPartTime(false);
fullTimeWorker.setDuration(9);
workerService.doWork(fullTimeWorker);
}
/**
* This Method is annotated with @All, So the log statements will be generated before and after method call
* along with exception if raised.
*/
@All
public void engagePartTimeWorker() throws Exception {
Worker partTimeWorker = new Worker();
partTimeWorker.setName("PartTime-Worker");
partTimeWorker.setPartTime(true);
partTimeWorker.setDuration(4);
workerService.doWork(partTimeWorker);
}
}
WorkerServiceImpl.java
package edu.pk.poc.aop.service;
import edu.pk.poc.aop.annotation.AfterMethod;
public class WorkerServiceImpl implements WorkerService {
/**
* Here this method is annotated with only @AfterMethod, So only log statement
* will be generated after method call
*/
@AfterMethod
@Override
public void doWork(Worker worker) throws Exception {
if (worker.isPartTime()) {
throw new Exception("Part time workers are not permitted to work.");
}
System.out.print("A full time worker is working for " + worker.getDuration() + " hours :: ");
for (int i = 1; i < worker.getDuration(); i++) {
System.out.print("* ");
}
System.out.println();
}
}
Main.java 테스트 클래스
package edu.pk.poc.aop.test;
import edu.pk.poc.aop.controller.WorkerController;
import edu.pk.poc.aop.helper.ProxyFactory;
import edu.pk.util.Logger;
public class Main {
public static void main(String[] args) {
WorkerController controller = ProxyFactory.createProxy(WorkerController.class);
Logger logger = new Logger();
try {
System.out.println("Testing @BeforeMethod and @AfterMethod");
System.out.println("-----------------------------------------");
controller.engageFullTimeWorker();
System.out.println("Testing @All");
System.out.println("-----------------------------------------");
controller.engagePartTimeWorker();
} catch (Exception e) {
logger.error("Exception caught in Main class");
}
}
}
출력
Testing @BeforeMethod and @AfterMethod ----------------------------------------- >>> Entering into edu.pk.poc.aop.controller.WorkerController.engageFullTimeWorker() A full time worker is working for 9 hours :: * * * * * * * * >>> Exiting from edu.pk.poc.aop.service.WorkerServiceImpl.doWork() >>> Exiting from edu.pk.poc.aop.controller.WorkerController.engageFullTimeWorker() Testing @All ----------------------------------------- >>> Entering into edu.pk.poc.aop.controller.WorkerController.engagePartTimeWorker() >>> Exception in edu.pk.poc.aop.controller.WorkerController.engagePartTimeWorker() Exception caught in Main class
프록시 객체에서 메서드가 호출되면 리플렉션을 사용하여 대상 메서드의 모든 주석을 검사하는 핸들러가 호출을 가로챕니다. 이러한 주석을 기반으로 핸들러는 메소드 시작/종료를 기록할지, 예외를 기록할지, 아니면 로깅을 모두 건너뛸지를 결정합니다.
시각화하는 방법은 다음과 같습니다.
주석 정의
package edu.pk.poc.aop.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface AfterMethod {
}
package edu.pk.poc.aop.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface BeforeMethod {
}
package edu.pk.poc.aop.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface All {
}
프록시 팩토리 정의
package edu.pk.poc.aop.helper;
/**
* The {@code ProxyFactory} class is responsible for creating proxy objects using the Javassist library.
* It allows for dynamic generation of proxies for classes or interfaces, with support for method interception.
*/
public class ProxyFactory {
/**
* A Javassist ProxyFactory instance used to generate proxy classes.
*/
private static final javassist.util.proxy.ProxyFactory factory = new javassist.util.proxy.ProxyFactory();
/**
* Creates a proxy object for the given class or interface.
* If the class is an interface, the proxy implements the interface.
* If it's a concrete class, the proxy extends the class.
*
* @param <T> the type of the class or interface for which the proxy is to be created
* @param klass the {@code Class} object representing the class or interface to proxy
* @return a proxy instance of the specified class or interface, or {@code null} if proxy creation fails
*/
public static <T> T createProxy(Class<T> klass) {
if (klass.isInterface())
factory.setInterfaces(new Class[]{klass});
else
factory.setSuperclass(klass);
try {
return (T) factory.create(new Class<?>[0], new Object[0], new AOPLoggingMethodHandler());
} catch (Exception e) {
System.err.println(e.getMessage());
}
return null;
}
}
MethodHandler 정의
package edu.pk.poc.aop.helper;
import edu.pk.poc.aop.annotation.AfterMethod;
import edu.pk.poc.aop.annotation.All;
import edu.pk.poc.aop.annotation.BeforeMethod;
import edu.pk.poc.aop.annotation.OnException;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import edu.pk.util.Logger;
import javassist.util.proxy.MethodHandler;
public class AOPLoggingMethodHandler implements MethodHandler {
private static final Logger logger = new Logger();
public Object invoke(Object self, Method thisMethod, Method proceed, Object[] args) throws Throwable {
if (proceed != null) { // Concrete Method
Object result = null;
String className = resolveClassName(self);
try {
if (isAnnotationPresent(thisMethod, BeforeMethod.class) || isAnnotationPresent(thisMethod, All.class)) {
logger.info(">>> Entering into " + className + "." + thisMethod.getName() + "()");
}
result = proceed.invoke(self, args);
if (isAnnotationPresent(thisMethod, AfterMethod.class) || isAnnotationPresent(thisMethod, All.class)) {
logger.info(">>> Exiting from " + className + "." + thisMethod.getName() + "()");
}
} catch (Throwable t) {
if (isAnnotationPresent(thisMethod, OnException.class) || isAnnotationPresent(thisMethod, All.class)) {
logger.error(">>> Exception in " + className + "." + thisMethod.getName() + "()");
}
throw t;
}
return result;
}
throw new RuntimeException("Method is Abstract");
}
private boolean isAnnotationPresent(Method method, Class klass) {
Annotation[] declaredAnnotationsByType = method.getAnnotationsByType(klass);
return declaredAnnotationsByType != null && declaredAnnotationsByType.length > 0;
}
private String resolveClassName(Object self) {
String className = self.getClass().getName();
if (className.contains("_$$")) {
className = className.substring(0, className.indexOf("_$$"));
}
return className;
}
}
Spring AOP는 다양한 문제를 해결하는 강력한 도구이지만 혁신적인 작업을 수행하지는 않습니다. 이는 언어 자체에서 사용할 수 있는 리플렉션 및 프록시와 같은 핵심 Java 개념을 기반으로 구축되었습니다. 이를 이해하면 Spring이 개발자 편의를 위해 이러한 하위 수준 메커니즘을 어떻게 단순화하는지 더 잘 이해할 수 있습니다.
위 내용은 Spring AOP의 내부 작동 방식 공개의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!
![[웹 프런트엔드] Node.js 빠른 시작](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
